From 1d5e55d9b6a8b30d5012b0e607b71dfbdc7dda9a Mon Sep 17 00:00:00 2001 From: Egon Elbre Date: Thu, 17 Jul 2014 13:14:50 +0300 Subject: [PATCH] Fix: UDP serving on windows, UDP serving test paniced Also, replaced t.Error/t.Fail with t.Fatal in some places. --- server_test.go | 36 +++++++++++++++++++++--------------- udp.go | 18 ------------------ udp_linux.go | 18 ++++++++++++++++++ udp_other.go | 8 ++++---- udp_windows.go | 38 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 81 insertions(+), 37 deletions(-) create mode 100644 udp_windows.go diff --git a/server_test.go b/server_test.go index 3c2e7e47..a3fc8cf9 100644 --- a/server_test.go +++ b/server_test.go @@ -44,27 +44,36 @@ func TestServing(t *testing.T) { time.Sleep(4e8) c := new(Client) m := new(Msg) + m.SetQuestion("miek.nl.", TypeTXT) - r, _, _ := c.Exchange(m, "127.0.0.1:8053") + r, _, err := c.Exchange(m, "127.0.0.1:8053") + if err != nil { + t.Fatal("Failed to exchange miek.nl", err) + } txt := r.Extra[0].(*TXT).Txt[0] if txt != "Hello world" { - t.Log("Unexpected result for miek.nl", txt, "!= Hello world") - t.Fail() + t.Fatal("Unexpected result for miek.nl", txt, "!= Hello world") } + m.SetQuestion("example.com.", TypeTXT) - r, _, _ = c.Exchange(m, "127.0.0.1:8053") + r, _, err = c.Exchange(m, "127.0.0.1:8053") + if err != nil { + t.Fatal("Failed to exchange example.com", err) + } txt = r.Extra[0].(*TXT).Txt[0] if txt != "Hello example" { - t.Log("Unexpected result for example.com", txt, "!= Hello example") - t.Fail() + t.Fatal("Unexpected result for example.com", txt, "!= Hello example") } + // Test Mixes cased as noticed by Ask. m.SetQuestion("eXaMplE.cOm.", TypeTXT) - r, _, _ = c.Exchange(m, "127.0.0.1:8053") + r, _, err = c.Exchange(m, "127.0.0.1:8053") + if err != nil { + t.Fatal("Failed to exchange eXaMplE.cOm", err) + } txt = r.Extra[0].(*TXT).Txt[0] if txt != "Hello example" { - t.Log("Unexpected result for example.com", txt, "!= Hello example") - t.Fail() + t.Fatal("Unexpected result for example.com", txt, "!= Hello example") } } @@ -238,8 +247,7 @@ func TestServingLargeResponses(t *testing.T) { M.Unlock() _, _, err := c.Exchange(m, "127.0.0.1:10000") if err != nil { - t.Logf("Failed to exchange: %s", err.Error()) - t.Fail() + t.Fatalf("Failed to exchange: %s", err.Error()) } // This must fail M.Lock() @@ -247,14 +255,12 @@ func TestServingLargeResponses(t *testing.T) { M.Unlock() _, _, err = c.Exchange(m, "127.0.0.1:10000") if err == nil { - t.Logf("Failed to fail exchange, this should generate packet error") - t.Fail() + t.Fatalf("Failed to fail exchange, this should generate packet error") } // But this must work again c.UDPSize = 7000 _, _, err = c.Exchange(m, "127.0.0.1:10000") if err != nil { - t.Logf("Failed to exchange: %s", err.Error()) - t.Fail() + t.Fatalf("Failed to exchange: %s", err.Error()) } } diff --git a/udp.go b/udp.go index 9b426c74..432af818 100644 --- a/udp.go +++ b/udp.go @@ -38,21 +38,3 @@ func setUDPSocketOptions(conn *net.UDPConn) error { } return nil } - -// readFromSessionUDP acts just like net.UDPConn.ReadFrom(), but returns a session object instead of a -// net.UDPAddr. -func readFromSessionUDP(conn *net.UDPConn, b []byte) (int, *sessionUDP, error) { - oob := make([]byte, 40) - n, oobn, _, raddr, err := conn.ReadMsgUDP(b, oob) - if err != nil { - return n, nil, err - } - session := &sessionUDP{raddr, oob[:oobn]} - return n, session, err -} - -// writeToSessionUDP acts just like net.UDPConn.WritetTo(), but uses a *sessionUDP instead of a net.Addr. -func writeToSessionUDP(conn *net.UDPConn, b []byte, session *sessionUDP) (int, error) { - n, _, err := conn.WriteMsgUDP(b, session.context, session.raddr) - return n, err -} diff --git a/udp_linux.go b/udp_linux.go index aedc7663..2a4517f6 100644 --- a/udp_linux.go +++ b/udp_linux.go @@ -19,6 +19,24 @@ import ( "syscall" ) +// readFromSessionUDP acts just like net.UDPConn.ReadFrom(), but returns a session object instead of a +// net.UDPAddr. +func readFromSessionUDP(conn *net.UDPConn, b []byte) (int, *sessionUDP, error) { + oob := make([]byte, 40) + n, oobn, _, raddr, err := conn.ReadMsgUDP(b, oob) + if err != nil { + return n, nil, err + } + session := &sessionUDP{raddr, oob[:oobn]} + return n, session, err +} + +// writeToSessionUDP acts just like net.UDPConn.WritetTo(), but uses a *sessionUDP instead of a net.Addr. +func writeToSessionUDP(conn *net.UDPConn, b []byte, session *sessionUDP) (int, error) { + n, _, err := conn.WriteMsgUDP(b, session.context, session.raddr) + return n, err +} + // setUDPSocketOptions4 prepares the v4 socket for sessions. func setUDPSocketOptions4(conn *net.UDPConn) error { file, err := conn.File() diff --git a/udp_other.go b/udp_other.go index 65cfe642..2ec15216 100644 --- a/udp_other.go +++ b/udp_other.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// +build !linux +// +build !linux, !windows package dns @@ -15,7 +15,7 @@ import ( // We tried to adhire to some kind of naming scheme. -func setUDPSocketOptions4(conn *net.UDPConn) error { return nil } -func setUDPSocketOptions6(conn *net.UDPConn) error { return nil } -func getUDPSocketOptions6Only(conn *net.UDPConn) (bool, error) { return false, nil } +func setUDPSocketOptions4(conn *net.UDPConn) error { return nil } +func setUDPSocketOptions6(conn *net.UDPConn) error { return nil } +func getUDPSocketOptions6Only(conn *net.UDPConn) (bool, error) { return false, nil } func getUDPSocketName(conn *net.UDPConn) (syscall.Sockaddr, error) { return nil, nil } diff --git a/udp_windows.go b/udp_windows.go new file mode 100644 index 00000000..b492e66a --- /dev/null +++ b/udp_windows.go @@ -0,0 +1,38 @@ +// Copyright 2011 Miek Gieben. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build windows + +package dns + +import ( + "net" + "syscall" +) + +// readFromSessionUDP acts just like net.UDPConn.ReadFrom(), but returns a session object instead of a +// net.UDPAddr. +func readFromSessionUDP(conn *net.UDPConn, b []byte) (int, *sessionUDP, error) { + n, raddr, err := conn.ReadFrom(b) + if err != nil { + return n, nil, err + } + session := &sessionUDP{raddr.(*net.UDPAddr), nil} + return n, session, err +} + +// writeToSessionUDP acts just like net.UDPConn.WritetTo(), but uses a *sessionUDP instead of a net.Addr. +func writeToSessionUDP(conn *net.UDPConn, b []byte, session *sessionUDP) (int, error) { + n, err := conn.WriteTo(b, session.raddr) + return n, err +} + +// These do nothing. See udp_linux.go for an example of how to implement this. + +// We tried to adhire to some kind of naming scheme. + +func setUDPSocketOptions4(conn *net.UDPConn) error { return nil } +func setUDPSocketOptions6(conn *net.UDPConn) error { return nil } +func getUDPSocketOptions6Only(conn *net.UDPConn) (bool, error) { return false, nil } +func getUDPSocketName(conn *net.UDPConn) (syscall.Sockaddr, error) { return nil, nil }