awldns: return NODATA for AAAA queries on .awl names

The local-domain handler answered A, AAAA and ANY queries identically,
always emitting an A (IPv4) record. On IPv6-enabled networks clients such
as Windows' ping/getaddrinfo query AAAA first; a NOERROR response carrying
a mismatched A record (instead of NODATA) made them fail with "no such
host" without falling back to an A query.

Split the handler by qtype: A/ANY return the A record, AAAA returns NODATA
(NOERROR + empty answer) so clients fall back to A, and unknown names now
return a clean NXDOMAIN instead of NXDOMAIN plus an empty A record.

Full IPv6 support remains a separate task.

Fixes #150

Author: pymq

awldns/awldns.go

@@ -164,8 +164,13 @@ func (r *Resolver) dnsLocalDomainHandler(resp dns.ResponseWriter, req *dns.Msg)
 		hostnameLower := strings.ToLower(hostname)
 		mappedIP, found := cfg.directMapping[hostnameLower]
 
+		if !found {
+			m.SetRcode(req, dns.RcodeNameError)
+			continue
+		}
+
 		switch qtype {
-		case dns.TypeA, dns.TypeAAAA, dns.TypeANY:
+		case dns.TypeA, dns.TypeANY:
 			aRec := &dns.A{
 				Hdr: dns.RR_Header{
 					// we should return original name from the request as some clients expect that
@@ -174,14 +179,11 @@ func (r *Resolver) dnsLocalDomainHandler(resp dns.ResponseWriter, req *dns.Msg)
 					Class:  dns.ClassINET,
 					Ttl:    defaultTTLSeconds,
 				},
-			}
-			if found {
-				// TODO: support ipv6
-				aRec.A = net.ParseIP(mappedIP).To4()
-			} else {
-				m.SetRcode(req, dns.RcodeNameError)
+				A: net.ParseIP(mappedIP).To4(),
 			}
 			m.Answer = append(m.Answer, aRec)
+		case dns.TypeAAAA:
+			// TODO: support ipv6
 		}
 	}
 

awldns/awldns_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"net"
-	"runtime"
 	"testing"
 	"time"
 
@@ -57,15 +56,62 @@ func TestDNS(t *testing.T) {
 	assertAddr(name2+".awl", addr2)
 	assertAddr(name2Capitalized+".awl", addr2)
 
-	addrs, err := client.LookupHost(ctx, "unknown.awl")
+	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)
+	a.Equalf(true, dnsErr.IsNotFound, "actual error: %v", err)
+}
+
+// TestLocalDomainQueryTypes verifies the per-qtype behaviour of the .awl
+// handler at the DNS message level (which net.Resolver.LookupHost hides):
+//   - A     for a known name -> NOERROR + one A record
+//   - AAAA  for a known name -> NODATA (NOERROR + empty answer), so IPv6-first
+//     clients fall back to A instead of failing. Regression test for #150.
+//   - A/AAAA for an unknown name -> NXDOMAIN
+func TestLocalDomainQueryTypes(t *testing.T) {
+	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)
+
+	const knownIP = "127.0.0.66"
+	resolver.ReceiveConfiguration("", map[string]string{"admin": knownIP})
+
+	query := func(name string, qtype uint16) *dns.Msg {
+		m := new(dns.Msg)
+		m.SetQuestion(dns.CanonicalName(name), qtype)
+		client := &dns.Client{Net: "udp"}
+		resp, _, err := client.Exchange(m, addr)
+		a.NoError(err)
+		return resp
 	}
+
+	// A for a known name -> single A record
+	respA := query("admin.awl", dns.TypeA)
+	a.Equal(dns.RcodeSuccess, respA.Rcode)
+	a.Len(respA.Answer, 1)
+	aRec, ok := respA.Answer[0].(*dns.A)
+	a.True(ok, "expected an A record, got %T", respA.Answer[0])
+	a.Equal(knownIP, aRec.A.String())
+
+	// AAAA for a known name -> NODATA (NOERROR, empty answer)
+	respAAAA := query("admin.awl", dns.TypeAAAA)
+	a.Equal(dns.RcodeSuccess, respAAAA.Rcode)
+	a.Empty(respAAAA.Answer)
+
+	// unknown name -> NXDOMAIN for both A and AAAA
+	respUnknownA := query("nope.awl", dns.TypeA)
+	a.Equal(dns.RcodeNameError, respUnknownA.Rcode)
+	a.Empty(respUnknownA.Answer)
+
+	respUnknownAAAA := query("nope.awl", dns.TypeAAAA)
+	a.Equal(dns.RcodeNameError, respUnknownAAAA.Rcode)
+	a.Empty(respUnknownAAAA.Answer)
 }
 
 func NewResolverClient(address string) *net.Resolver {