Completely cover new nameserver code

Author: jsumners

challenge/dns01/nameserver.go

@@ -294,7 +294,10 @@ func sendDNSQuery(m *dns.Msg, ns string) (*dns.Msg, error) {
 	in, _, err := udp.Exchange(m, ns)
 
 	network = getNetwork("tcp")
-	if in != nil && in.Truncated {
+	// We can encounter a net.OpError if the nameserver is not listening
+	// on UDP at all, i.e. net.Dial could not make a connection.
+	_, isOpErr := err.(*net.OpError)
+	if (in != nil && in.Truncated) || isOpErr {
 		tcp := &dns.Client{Net: network, Timeout: dnsTimeout}
 		// If the TCP request succeeds, the err will reset to nil
 		in, _, err = tcp.Exchange(m, ns)

challenge/dns01/nameserver_test.go

@@ -1,6 +1,7 @@
 package dns01
 
 import (
+	"fmt"
 	getport "github.com/jsumners/go-getport"
 	"github.com/miekg/dns"
 	"net"
@@ -13,6 +14,10 @@ import (
 )
 
 type testDnsHandler struct{}
+type testDnsServer struct {
+	*dns.Server
+	getport.PortResult
+}
 
 func (handler *testDnsHandler) ServeDNS(writer dns.ResponseWriter, reply *dns.Msg) {
 	msg := dns.Msg{}
@@ -39,32 +44,45 @@ func (handler *testDnsHandler) ServeDNS(writer dns.ResponseWriter, reply *dns.Ms
 	writer.WriteMsg(&msg)
 }
 
-func getTestNameserver(t *testing.T, network string) *dns.Server {
+// getTestNameserver constructs a new DNS server on a local address, or set
+// of addresses, that responds to an `A` query for `example.com`.
+func getTestNameserver(t *testing.T, network string) testDnsServer {
 	server := &dns.Server{
 		Handler: new(testDnsHandler),
 		Net:     network,
 	}
+	testServer := testDnsServer{
+		Server: server,
+	}
 
 	var protocol getport.Protocol
+	var address string
 	switch network {
 	case "tcp":
 		protocol = getport.TCP
+		address = "0.0.0.0"
 	case "tcp4":
 		protocol = getport.TCP4
+		address = "127.0.0.1"
 	case "tcp6":
 		protocol = getport.TCP6
+		address = "::1"
 	case "udp":
 		protocol = getport.UDP
+		address = "0.0.0.0"
 	case "udp4":
 		protocol = getport.UDP4
+		address = "127.0.0.1"
 	case "udp6":
 		protocol = getport.UDP6
+		address = "::1"
 	}
-	portResult, portError := getport.GetPort(protocol, "127.0.0.1")
+	portResult, portError := getport.GetPort(protocol, address)
 	if portError != nil {
 		t.Error(portError)
-		return server
+		return testServer
 	}
+	testServer.PortResult = portResult
 	server.Addr = getport.PortResultToAddress(portResult)
 
 	waitLock := sync.Mutex{}
@@ -77,18 +95,52 @@ func getTestNameserver(t *testing.T, network string) *dns.Server {
 	}()
 
 	waitLock.Lock()
-	return server
+	return testServer
 }
 
 func TestSendDNSQuery(t *testing.T) {
 	t.Run("does udp4 only", func(t *testing.T) {
 		SetNetworkStack(IPv4Only)
 		nameserver := getTestNameserver(t, getNetwork("udp"))
-		defer nameserver.Shutdown()
+		defer nameserver.Server.Shutdown()
+
+		serverAddress := fmt.Sprintf("127.0.0.1:%d", nameserver.PortResult.Port)
+		recursiveNameservers = ParseNameservers([]string{serverAddress})
+		msg := createDNSMsg("example.com.", dns.TypeA, true)
+		result, queryError := sendDNSQuery(msg, serverAddress)
+		assert.NoError(t, queryError)
+		assert.Equal(t, result.Answer[0].(*dns.A).A.String(), "127.0.0.1")
+	})
+
+	t.Run("does udp6 only", func(t *testing.T) {
+		SetNetworkStack(IPv6Only)
+		nameserver := getTestNameserver(t, getNetwork("udp"))
+		defer nameserver.Server.Shutdown()
 
-		recursiveNameservers = ParseNameservers([]string{nameserver.Addr})
+		serverAddress := fmt.Sprintf("[::1]:%d", nameserver.PortResult.Port)
+		recursiveNameservers = ParseNameservers([]string{serverAddress})
 		msg := createDNSMsg("example.com.", dns.TypeA, true)
-		result, queryError := sendDNSQuery(msg, nameserver.Addr)
+		result, queryError := sendDNSQuery(msg, serverAddress)
+		assert.NoError(t, queryError)
+		assert.Equal(t, result.Answer[0].(*dns.A).A.String(), "127.0.0.1")
+	})
+
+	t.Run("does tcp4 and tcp6", func(t *testing.T) {
+		SetNetworkStack(DefaultNetworkStack)
+		nameserver := getTestNameserver(t, getNetwork("tcp"))
+		defer nameserver.Server.Shutdown()
+
+		serverAddress := fmt.Sprintf("[::1]:%d", nameserver.PortResult.Port)
+		recursiveNameservers = ParseNameservers([]string{serverAddress})
+		msg := createDNSMsg("example.com.", dns.TypeA, true)
+		result, queryError := sendDNSQuery(msg, serverAddress)
+		assert.NoError(t, queryError)
+		assert.Equal(t, result.Answer[0].(*dns.A).A.String(), "127.0.0.1")
+
+		serverAddress = fmt.Sprintf("127.0.0.1:%d", nameserver.PortResult.Port)
+		recursiveNameservers = ParseNameservers([]string{serverAddress})
+		msg = createDNSMsg("example.com.", dns.TypeA, true)
+		result, queryError = sendDNSQuery(msg, serverAddress)
 		assert.NoError(t, queryError)
 		assert.Equal(t, result.Answer[0].(*dns.A).A.String(), "127.0.0.1")
 	})