Merge pull request #80 from anywherelan/dns-case-insensitive

awldns: make hosts case-insensitive, add tests

Author: pymq

application.go

@@ -301,7 +301,10 @@ func NewDNSService(conf *config.Config, eventbus awlevent.Bus, ctx context.Conte
 
 func (a *DNSService) initDNS(interfaceName string) {
 	var err error
-	a.dnsResolver = awldns.NewResolver()
+	a.dnsResolver = awldns.NewResolver(awldns.DNSAddress)
+	a.upstreamDNS = awldns.DefaultUpstreamDNSAddress
+	a.refreshDNSConfig()
+
 	awlevent.WrapSubscriptionToCallback(a.ctx, func(_ interface{}) {
 		a.refreshDNSConfig()
 	}, a.eventbus, new(awlevent.KnownPeerChanged))

awldns/awldns.go

@@ -35,6 +35,8 @@ type Resolver struct {
 
 	udpServerWorking bool
 	tcpServerWorking bool
+
+	dnsAddress string
 }
 
 type config struct {
@@ -43,40 +45,39 @@ type config struct {
 	reverseMapping map[string]string
 }
 
-func NewResolver() *Resolver {
+func NewResolver(dnsAddress string) *Resolver {
 	r := &Resolver{
 		logger: log.Logger("awl/dns"),
 		udpClient: &dns.Client{
-			Net:            "udp",
-			SingleInflight: true,
+			Net: "udp",
 		},
 		tcpClient: &dns.Client{
-			Net:            "tcp",
-			SingleInflight: true,
+			Net: "tcp",
 		},
+		dnsAddress: dnsAddress,
 	}
-	r.cfg.Store(&config{upstreamDNS: "127.0.0.1:53"})
+	r.cfg.Store(&config{})
 
 	mux := dns.NewServeMux()
 	mux.HandleFunc(LocalDomain, r.dnsLocalDomainHandler)
 	mux.HandleFunc(strings.TrimPrefix(ptrV4Suffix, "."), r.ptrv4Handler)
 	mux.HandleFunc(".", r.dnsProxyHandler)
 
 	r.udpServer = &dns.Server{
-		Addr:    DNSAddress,
+		Addr:    dnsAddress,
 		Net:     "udp",
 		Handler: mux,
 		NotifyStartedFunc: func() {
-			r.logger.Infof("udp server has started on %s", DNSAddress)
+			r.logger.Infof("udp server has started on %s", dnsAddress)
 			r.udpServerWorking = true
 		},
 	}
 	r.tcpServer = &dns.Server{
-		Addr:    DNSAddress,
+		Addr:    dnsAddress,
 		Net:     "tcp",
 		Handler: mux,
 		NotifyStartedFunc: func() {
-			r.logger.Infof("tcp server has started on %s", DNSAddress)
+			r.logger.Infof("tcp server has started on %s", dnsAddress)
 			r.tcpServerWorking = true
 		},
 	}
@@ -127,7 +128,7 @@ func (r *Resolver) DNSAddress() string {
 		return ""
 	}
 
-	return DNSAddress
+	return r.dnsAddress
 }
 
 func (r *Resolver) Close() {
@@ -149,17 +150,18 @@ func (r *Resolver) dnsLocalDomainHandler(resp dns.ResponseWriter, req *dns.Msg)
 
 	m := new(dns.Msg)
 	m.SetReply(req)
-	m.Authoritative = true
 
 	for _, question := range req.Question {
 		hostname := question.Name
 		qtype := question.Qtype
-		mappedIP, found := cfg.directMapping[hostname]
+		hostnameLower := strings.ToLower(hostname)
+		mappedIP, found := cfg.directMapping[hostnameLower]
 
 		switch qtype {
 		case dns.TypeA, dns.TypeAAAA, dns.TypeANY:
 			aRec := &dns.A{
 				Hdr: dns.RR_Header{
+					// we should return original name from the request as some clients expect that
 					Name:   hostname,
 					Rrtype: dns.TypeA,
 					Class:  dns.ClassINET,
@@ -176,6 +178,8 @@ func (r *Resolver) dnsLocalDomainHandler(resp dns.ResponseWriter, req *dns.Msg)
 		}
 	}
 
+	processOwnResponse(req, resp, m)
+
 	_ = resp.WriteMsg(m)
 }
 
@@ -201,7 +205,6 @@ func (r *Resolver) ptrv4Handler(resp dns.ResponseWriter, req *dns.Msg) {
 
 	m := new(dns.Msg)
 	m.SetReply(req)
-	m.Authoritative = true
 
 	ptr := &dns.PTR{
 		Hdr: dns.RR_Header{
@@ -213,6 +216,9 @@ func (r *Resolver) ptrv4Handler(resp dns.ResponseWriter, req *dns.Msg) {
 		Ptr: mappedName,
 	}
 	m.Answer = append(m.Answer, ptr)
+
+	processOwnResponse(req, resp, m)
+
 	_ = resp.WriteMsg(m)
 }
 
@@ -244,6 +250,24 @@ func (r *Resolver) loadConfig() config {
 	return *cfg
 }
 
+func processOwnResponse(req *dns.Msg, respWriter dns.ResponseWriter, resp *dns.Msg) {
+	maxSize := dns.MinMsgSize
+	if respWriter.LocalAddr().Network() == "tcp" {
+		maxSize = dns.MaxMsgSize
+	} else {
+		if optRR := req.IsEdns0(); optRR != nil {
+			udpsize := int(optRR.UDPSize())
+			if udpsize > maxSize {
+				maxSize = udpsize
+			}
+		}
+	}
+	resp.Truncate(maxSize)
+
+	resp.Authoritative = true
+	resp.RecursionAvailable = true
+}
+
 func TrimDomainName(domain string) string {
 	domain = strings.TrimSpace(domain)
 	domain = strings.Map(func(r rune) rune {

awldns/awldns_test.go

@@ -0,0 +1,98 @@
+package awldns
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"runtime"
+	"testing"
+	"time"
+
+	"github.com/miekg/dns"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDNS(t *testing.T) {
+	ctx := context.Background()
+	a := require.New(t)
+	port := FindFreePort()
+	addr := fmt.Sprintf("127.0.0.1:%d", port)
+
+	resolver := NewResolver(addr)
+	defer resolver.Close()
+	// TODO: remove sleep. We need it because NewResolver starts servers in goroutines
+	time.Sleep(50 * time.Millisecond)
+
+	name1 := "peer_id"
+	name1Capitalized := "pEEr_Id"
+	addr1 := "123.4.5.6"
+	name2 := "laptop.office"
+	name2Capitalized := "LAPTOP.office"
+	addr2 := "10.66.0.2"
+
+	namesMapping := map[string]string{
+		name1: addr1,
+		name2: addr2,
+	}
+	resolver.ReceiveConfiguration("", namesMapping)
+
+	client := NewResolverClient(addr)
+
+	assertAddr := func(host, addr string) {
+		addrs, err := client.LookupHost(ctx, host)
+		a.NoError(err)
+		a.Len(addrs, 1)
+		a.Equal(addr, addrs[0])
+
+		hosts, err := client.LookupAddr(ctx, addr)
+		a.NoError(err)
+		a.Len(hosts, 1)
+		a.Equal(dns.CanonicalName(host), hosts[0])
+	}
+
+	assertAddr(name1+".awl", addr1)
+	assertAddr(name1+".AWL", addr1)
+	assertAddr(name1Capitalized+".awl", addr1)
+
+	assertAddr(name2+".awl", addr2)
+	assertAddr(name2Capitalized+".awl", addr2)
+
+	addrs, err := client.LookupHost(ctx, "unknown.awl")
+	a.Error(err)
+	a.Empty(addrs)
+	dnsErr := err.(*net.DNSError)
+	// TODO: investigate why macos and linux in CI return `lookup unknown.awl on 127.0.0.53:53: server misbehaving`
+	//  it should use only our resolver, but somehow it tries to use system resolver afterwards
+	if runtime.GOOS == "windows" {
+		a.Equalf(true, dnsErr.IsNotFound, "actual error: %v", err)
+	}
+}
+
+func NewResolverClient(address string) *net.Resolver {
+	dialer := &net.Dialer{Timeout: time.Second}
+	return &net.Resolver{
+		StrictErrors: true,
+		PreferGo:     true,
+		Dial: func(ctx context.Context, network, _ string) (net.Conn, error) {
+			return dialer.DialContext(ctx, network, address)
+		},
+	}
+}
+
+func FindFreePort() int {
+	l, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		panic(fmt.Sprintf("failed to listen on a port: %v", err))
+	}
+	defer l.Close()
+
+	port := l.Addr().(*net.TCPAddr).Port
+
+	u, err := net.ListenPacket("udp", l.Addr().String())
+	if err != nil {
+		panic(fmt.Sprintf("failed to listen on a udp port: %v", err))
+	}
+	defer u.Close()
+
+	return port
+}