feat: rework engine and CLI for dnstraverse parity
Port the traversal engine to the Ruby dnstraverse model so behaviour and output match dns.squish.net: - dns: single RD=0 query path (RD=1 only for upstream root discovery), per-run packet cache, EDNS0 512-fallback with warnings, UDP->TCP on truncation; fix --retries 0 and --root-server IP-literal handling; drop all hardcoded 127.0.0.1:53 resolvers - traverse: hierarchical per-branch InfoCache, 7-step response classification with the full 10-status vocabulary, bailiwick partitioning, strictly-deeper lame-referral rule, refid grammar with .0 resolve subtrees and childset digits, per-IP branching at 1/n weight, cache-based glue resolution with noglue/loop dead ends, CNAME restarts from the deepest cached zone, fast-mode memoization, probability aggregation with Ruby-identical stats keys (sums to 1.0) - output: byte-for-byte reference text format pinned by a golden test, reference CLI defaults, working --quiet/--show-X=false, TTY-aware colour, deduplicated deterministic JSON - web: adapt API/SPA to the new engine, SSE events carry refid/status, fix subscribe/snapshot duplicate-event race and a statusCls TDZ bug, align SPA type list with the backend - delete the old engine and dead code (net -4,350 lines) Verified against live runs of the reference Ruby engine across five domains (answers, NXDOMAIN, null MX, CNAME restart, glueless resolve) with no divergences beyond the documented typo fixes. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Gary Hansen
co-authored by
Claude Fable 5
Claude Fable 5
parent
af15c9c2d4
commit
d71c7fbef2
+335
-349
@@ -2,9 +2,10 @@ package dns
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"net"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/miekg/dns"
|
||||
)
|
||||
@@ -35,9 +36,8 @@ func TestRootServerAllIPs(t *testing.T) {
|
||||
|
||||
t.Run("no addresses", func(t *testing.T) {
|
||||
empty := RootServer{Name: "empty.root-servers.net."}
|
||||
ips := empty.AllIPs(false)
|
||||
if len(ips) != 0 {
|
||||
t.Errorf("expected 0 IPs, got %d", len(ips))
|
||||
if len(empty.AllIPs(false)) != 0 {
|
||||
t.Error("expected 0 IPs")
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -55,31 +55,317 @@ func TestDefaultRootDiscoveryConfig(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestNormalizeServerName(t *testing.T) {
|
||||
tests := []struct {
|
||||
input string
|
||||
want string
|
||||
}{
|
||||
{"a.root-servers.net.", "a.root-servers.net"},
|
||||
{"A.ROOT-SERVERS.NET.", "a.root-servers.net"},
|
||||
{"b.root-servers.net", "b.root-servers.net"},
|
||||
{"root-servers.net.", "root-servers.net"},
|
||||
// mockUpstream builds an ExchangeFunc that answers root discovery queries.
|
||||
// glue controls whether A records are put in the additional section of the
|
||||
// NS response.
|
||||
func mockUpstream(t *testing.T, roots map[string]string, glue bool) ExchangeFunc {
|
||||
t.Helper()
|
||||
return func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
if !msg.RecursionDesired {
|
||||
t.Error("root discovery must query the upstream resolver with RD=1")
|
||||
}
|
||||
q := msg.Question[0]
|
||||
m := new(dns.Msg)
|
||||
m.SetReply(msg)
|
||||
switch {
|
||||
case q.Name == "." && q.Qtype == dns.TypeNS:
|
||||
for name, ip := range roots {
|
||||
m.Answer = append(m.Answer, &dns.NS{
|
||||
Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: 300},
|
||||
Ns: name,
|
||||
})
|
||||
if glue {
|
||||
m.Extra = append(m.Extra, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
|
||||
A: net.ParseIP(ip),
|
||||
})
|
||||
}
|
||||
}
|
||||
case q.Qtype == dns.TypeA:
|
||||
if ip, ok := roots[q.Name]; ok {
|
||||
m.Answer = append(m.Answer, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: q.Name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
|
||||
A: net.ParseIP(ip),
|
||||
})
|
||||
}
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsIPLiteral(t *testing.T) {
|
||||
cfg := &RootDiscoveryConfig{
|
||||
Server: "192.203.230.10",
|
||||
Exchange: func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
t.Error("IP literal root must not trigger any lookup")
|
||||
return nil, errors.New("no network")
|
||||
},
|
||||
}
|
||||
servers, err := DiscoverRoots(context.Background(), cfg)
|
||||
if err != nil {
|
||||
t.Fatalf("DiscoverRoots: %v", err)
|
||||
}
|
||||
if len(servers) != 1 {
|
||||
t.Fatalf("expected 1 root, got %d", len(servers))
|
||||
}
|
||||
if servers[0].Name != "192.203.230.10" {
|
||||
t.Errorf("Name = %q, want the IP literal", servers[0].Name)
|
||||
}
|
||||
if len(servers[0].IPv4) != 1 || !servers[0].IPv4[0].Equal(net.ParseIP("192.203.230.10")) {
|
||||
t.Errorf("IPv4 = %v, want [192.203.230.10]", servers[0].IPv4)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsIPv6Literal(t *testing.T) {
|
||||
cfg := &RootDiscoveryConfig{Server: "2001:503:ba3e::2:30"}
|
||||
servers, err := DiscoverRoots(context.Background(), cfg)
|
||||
if err != nil {
|
||||
t.Fatalf("DiscoverRoots: %v", err)
|
||||
}
|
||||
if len(servers) != 1 || len(servers[0].IPv6) != 1 {
|
||||
t.Fatalf("expected 1 root with 1 IPv6 address, got %+v", servers)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsHostnameOverride(t *testing.T) {
|
||||
roots := map[string]string{"e.root-servers.net.": "192.203.230.10"}
|
||||
cfg := &RootDiscoveryConfig{
|
||||
Server: "e.root-servers.net",
|
||||
Resolver: "192.0.2.53:53",
|
||||
Exchange: mockUpstream(t, roots, false),
|
||||
}
|
||||
servers, err := DiscoverRoots(context.Background(), cfg)
|
||||
if err != nil {
|
||||
t.Fatalf("DiscoverRoots: %v", err)
|
||||
}
|
||||
if len(servers) != 1 {
|
||||
t.Fatalf("expected 1 root, got %d", len(servers))
|
||||
}
|
||||
if servers[0].Name != "e.root-servers.net" {
|
||||
t.Errorf("Name = %q", servers[0].Name)
|
||||
}
|
||||
if len(servers[0].IPv4) != 1 || !servers[0].IPv4[0].Equal(net.ParseIP("192.203.230.10")) {
|
||||
t.Errorf("IPv4 = %v", servers[0].IPv4)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsHostnameOverrideUnresolvable(t *testing.T) {
|
||||
cfg := &RootDiscoveryConfig{
|
||||
Server: "nonexistent.root-servers.net",
|
||||
Resolver: "192.0.2.53:53",
|
||||
Exchange: mockUpstream(t, map[string]string{}, false),
|
||||
}
|
||||
if _, err := DiscoverRoots(context.Background(), cfg); err == nil {
|
||||
t.Fatal("expected error for unresolvable root override")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsSingleFromGlue(t *testing.T) {
|
||||
roots := map[string]string{"a.root-servers.net.": "198.41.0.4"}
|
||||
var wireQueries int
|
||||
inner := mockUpstream(t, roots, true)
|
||||
cfg := &RootDiscoveryConfig{
|
||||
Resolver: "192.0.2.53:53",
|
||||
Exchange: func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
wireQueries++
|
||||
return inner(ctx, server, msg, useTCP)
|
||||
},
|
||||
}
|
||||
servers, err := DiscoverRoots(context.Background(), cfg)
|
||||
if err != nil {
|
||||
t.Fatalf("DiscoverRoots: %v", err)
|
||||
}
|
||||
if len(servers) != 1 {
|
||||
t.Fatalf("expected exactly one root, got %d", len(servers))
|
||||
}
|
||||
if len(servers[0].IPv4) == 0 {
|
||||
t.Error("expected glue A address")
|
||||
}
|
||||
if wireQueries != 1 {
|
||||
t.Errorf("glue should satisfy discovery in one query, got %d", wireQueries)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsSingleWithoutGlue(t *testing.T) {
|
||||
roots := map[string]string{"a.root-servers.net.": "198.41.0.4"}
|
||||
cfg := &RootDiscoveryConfig{
|
||||
Resolver: "192.0.2.53:53",
|
||||
Exchange: mockUpstream(t, roots, false),
|
||||
}
|
||||
servers, err := DiscoverRoots(context.Background(), cfg)
|
||||
if err != nil {
|
||||
t.Fatalf("DiscoverRoots: %v", err)
|
||||
}
|
||||
if len(servers) != 1 || len(servers[0].IPv4) != 1 {
|
||||
t.Fatalf("expected one root resolved via A lookup, got %+v", servers)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverAllRootsPerRootSet(t *testing.T) {
|
||||
roots := map[string]string{
|
||||
"a.mock-roots.test.": "192.0.2.1",
|
||||
"b.mock-roots.test.": "192.0.2.2",
|
||||
"c.mock-roots.test.": "192.0.2.3",
|
||||
}
|
||||
cfg := &RootDiscoveryConfig{
|
||||
AllRoots: true,
|
||||
Resolver: "192.0.2.53:53",
|
||||
Exchange: mockUpstream(t, roots, true),
|
||||
}
|
||||
servers, err := DiscoverRoots(context.Background(), cfg)
|
||||
if err != nil {
|
||||
t.Fatalf("DiscoverRoots: %v", err)
|
||||
}
|
||||
if len(servers) != 3 {
|
||||
t.Fatalf("expected 3 roots, got %d", len(servers))
|
||||
}
|
||||
seen := map[string]bool{}
|
||||
for _, rs := range servers {
|
||||
seen[rs.Name] = true
|
||||
want, ok := roots[rs.Name]
|
||||
if !ok {
|
||||
t.Errorf("unexpected root %q", rs.Name)
|
||||
continue
|
||||
}
|
||||
if len(rs.IPv4) != 1 || !rs.IPv4[0].Equal(net.ParseIP(want)) {
|
||||
t.Errorf("root %s IPv4 = %v, want [%s]", rs.Name, rs.IPv4, want)
|
||||
}
|
||||
}
|
||||
if len(seen) != 3 {
|
||||
t.Errorf("roots not distinct: %v", seen)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverAllRootsSkipsUnresolvable(t *testing.T) {
|
||||
// b has neither glue nor an A record: it must be skipped, like
|
||||
// find_all_roots in traverser.rb.
|
||||
roots := map[string]string{"a.mock-roots.test.": "192.0.2.1"}
|
||||
exchange := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
q := msg.Question[0]
|
||||
m := new(dns.Msg)
|
||||
m.SetReply(msg)
|
||||
switch {
|
||||
case q.Name == "." && q.Qtype == dns.TypeNS:
|
||||
for _, name := range []string{"a.mock-roots.test.", "b.mock-roots.test."} {
|
||||
m.Answer = append(m.Answer, &dns.NS{
|
||||
Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: 300},
|
||||
Ns: name,
|
||||
})
|
||||
}
|
||||
case q.Qtype == dns.TypeA:
|
||||
if ip, ok := roots[q.Name]; ok {
|
||||
m.Answer = append(m.Answer, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: q.Name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
|
||||
A: net.ParseIP(ip),
|
||||
})
|
||||
}
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
cfg := &RootDiscoveryConfig{
|
||||
AllRoots: true,
|
||||
Resolver: "192.0.2.53:53",
|
||||
Query: &QueryConfig{Retries: 1},
|
||||
Exchange: exchange,
|
||||
}
|
||||
servers, err := DiscoverRoots(context.Background(), cfg)
|
||||
if err != nil {
|
||||
t.Fatalf("DiscoverRoots: %v", err)
|
||||
}
|
||||
if len(servers) != 1 || servers[0].Name != "a.mock-roots.test." {
|
||||
t.Fatalf("expected only the resolvable root, got %+v", servers)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsFallsBackToHints(t *testing.T) {
|
||||
cfg := &RootDiscoveryConfig{
|
||||
Resolver: "192.0.2.53:53",
|
||||
Query: &QueryConfig{Retries: 1},
|
||||
Exchange: func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return nil, errors.New("upstream unreachable")
|
||||
},
|
||||
}
|
||||
servers, err := DiscoverRoots(context.Background(), cfg)
|
||||
if err != nil {
|
||||
t.Fatalf("expected hints fallback, got error: %v", err)
|
||||
}
|
||||
if len(servers) != 1 {
|
||||
t.Fatalf("single-root mode must fall back to one hint, got %d", len(servers))
|
||||
}
|
||||
if !strings.HasSuffix(servers[0].Name, ".root-servers.net.") {
|
||||
t.Errorf("expected an IANA hint, got %q", servers[0].Name)
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.input, func(t *testing.T) {
|
||||
got := normalizeServerName(tt.input)
|
||||
if got != tt.want {
|
||||
t.Errorf("normalizeServerName(%q) = %q, want %q", tt.input, got, tt.want)
|
||||
cfg.AllRoots = true
|
||||
servers, err = DiscoverRoots(context.Background(), cfg)
|
||||
if err != nil {
|
||||
t.Fatalf("expected hints fallback, got error: %v", err)
|
||||
}
|
||||
if len(servers) != len(RootHints) {
|
||||
t.Errorf("all-roots fallback should return all %d hints, got %d", len(RootHints), len(servers))
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsRetriesUpstream(t *testing.T) {
|
||||
roots := map[string]string{"a.root-servers.net.": "198.41.0.4"}
|
||||
inner := mockUpstream(t, roots, true)
|
||||
var calls int
|
||||
cfg := &RootDiscoveryConfig{
|
||||
Resolver: "192.0.2.53:53",
|
||||
Query: &QueryConfig{Retries: 2, RetryDelay: 1},
|
||||
Exchange: func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
calls++
|
||||
if calls == 1 {
|
||||
return nil, errors.New("transient failure")
|
||||
}
|
||||
})
|
||||
return inner(ctx, server, msg, useTCP)
|
||||
},
|
||||
}
|
||||
servers, err := DiscoverRoots(context.Background(), cfg)
|
||||
if err != nil {
|
||||
t.Fatalf("DiscoverRoots should retry: %v", err)
|
||||
}
|
||||
if len(servers) != 1 {
|
||||
t.Fatalf("expected 1 root after retry, got %d", len(servers))
|
||||
}
|
||||
if calls != 2 {
|
||||
t.Errorf("expected 2 attempts, got %d", calls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsTruncationTCPFallback(t *testing.T) {
|
||||
roots := map[string]string{"a.root-servers.net.": "198.41.0.4"}
|
||||
inner := mockUpstream(t, roots, true)
|
||||
var sawTCP bool
|
||||
cfg := &RootDiscoveryConfig{
|
||||
Resolver: "192.0.2.53:53",
|
||||
Query: &QueryConfig{Retries: 1, AllowTCP: true},
|
||||
Exchange: func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
if !useTCP {
|
||||
m := new(dns.Msg)
|
||||
m.SetReply(msg)
|
||||
m.Truncated = true
|
||||
return m, nil
|
||||
}
|
||||
sawTCP = true
|
||||
return inner(ctx, server, msg, useTCP)
|
||||
},
|
||||
}
|
||||
servers, err := DiscoverRoots(context.Background(), cfg)
|
||||
if err != nil {
|
||||
t.Fatalf("DiscoverRoots: %v", err)
|
||||
}
|
||||
if !sawTCP {
|
||||
t.Error("expected TCP fallback on truncated upstream response")
|
||||
}
|
||||
if len(servers) != 1 || len(servers[0].IPv4) == 0 {
|
||||
t.Fatalf("expected root from TCP response, got %+v", servers)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExtractNSRecords(t *testing.T) {
|
||||
t.Run("empty", func(t *testing.T) {
|
||||
names := extractNSRecords(nil)
|
||||
if len(names) != 0 {
|
||||
if names := extractNSRecords(nil); len(names) != 0 {
|
||||
t.Errorf("expected 0 names, got %d", len(names))
|
||||
}
|
||||
})
|
||||
@@ -103,18 +389,24 @@ func TestExtractNSRecords(t *testing.T) {
|
||||
&dns.NS{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS}, Ns: "a.root-servers.net."},
|
||||
&dns.NS{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS}, Ns: "a.root-servers.net."},
|
||||
}
|
||||
names := extractNSRecords(rrs)
|
||||
if len(names) != 1 {
|
||||
if names := extractNSRecords(rrs); len(names) != 1 {
|
||||
t.Errorf("expected 1 deduped name, got %d", len(names))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("non-NS ignored", func(t *testing.T) {
|
||||
rrs := []dns.RR{
|
||||
&dns.A{Hdr: dns.RR_Header{Name: "a.root-servers.net.", Rrtype: dns.TypeA}, A: net.ParseIP("198.41.0.4")},
|
||||
}
|
||||
if names := extractNSNames(rrs); len(names) != 0 {
|
||||
t.Errorf("expected 0 names, got %d", len(names))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestExtractIPsFromAnswer(t *testing.T) {
|
||||
t.Run("empty", func(t *testing.T) {
|
||||
ips := extractIPsFromAnswer(nil, dns.TypeA)
|
||||
if len(ips) != 0 {
|
||||
if ips := extractIPsFromAnswer(nil, dns.TypeA); len(ips) != 0 {
|
||||
t.Errorf("expected 0 IPs, got %d", len(ips))
|
||||
}
|
||||
})
|
||||
@@ -124,347 +416,41 @@ func TestExtractIPsFromAnswer(t *testing.T) {
|
||||
&dns.A{Hdr: dns.RR_Header{Rrtype: dns.TypeA}, A: net.ParseIP("198.41.0.4")},
|
||||
&dns.A{Hdr: dns.RR_Header{Rrtype: dns.TypeA}, A: net.ParseIP("199.9.14.201")},
|
||||
}
|
||||
ips := extractIPsFromAnswer(rrs, dns.TypeA)
|
||||
if len(ips) != 2 {
|
||||
if ips := extractIPsFromAnswer(rrs, dns.TypeA); len(ips) != 2 {
|
||||
t.Fatalf("expected 2 IPs, got %d", len(ips))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("AAAA records", func(t *testing.T) {
|
||||
rrs := []dns.RR{
|
||||
&dns.AAAA{Hdr: dns.RR_Header{Rrtype: dns.TypeAAAA}, AAAA: net.ParseIP("2001:503:ba3e::2:30")},
|
||||
}
|
||||
ips := extractIPsFromAnswer(rrs, dns.TypeAAAA)
|
||||
if len(ips) != 1 {
|
||||
t.Fatalf("expected 1 IP, got %d", len(ips))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("filter by type", func(t *testing.T) {
|
||||
rrs := []dns.RR{
|
||||
&dns.A{Hdr: dns.RR_Header{Rrtype: dns.TypeA}, A: net.ParseIP("198.41.0.4")},
|
||||
&dns.AAAA{Hdr: dns.RR_Header{Rrtype: dns.TypeAAAA}, AAAA: net.ParseIP("2001:503:ba3e::2:30")},
|
||||
}
|
||||
ips := extractIPsFromAnswer(rrs, dns.TypeA)
|
||||
if len(ips) != 1 {
|
||||
if ips := extractIPsFromAnswer(rrs, dns.TypeA); len(ips) != 1 {
|
||||
t.Fatalf("expected 1 A IP, got %d", len(ips))
|
||||
}
|
||||
if ips := extractIPsFromAnswer(rrs, dns.TypeAAAA); len(ips) != 1 {
|
||||
t.Fatalf("expected 1 AAAA IP, got %d", len(ips))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestDiscoverRootsOverride(t *testing.T) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
|
||||
cfg := &RootDiscoveryConfig{
|
||||
Server: "a.root-servers.net",
|
||||
IncludeAAAA: false,
|
||||
}
|
||||
|
||||
servers, err := DiscoverRoots(ctx, cfg)
|
||||
if err != nil {
|
||||
t.Logf("skipping (no resolver available): %v", err)
|
||||
t.Skip()
|
||||
}
|
||||
if len(servers) == 0 {
|
||||
t.Fatal("expected at least one root server")
|
||||
}
|
||||
if len(servers[0].IPv4) == 0 {
|
||||
t.Error("expected IPv4 addresses for a.root-servers.net")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsSingle(t *testing.T) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
|
||||
servers, err := DiscoverRoots(ctx, nil)
|
||||
if err != nil {
|
||||
t.Logf("skipping (no resolver available): %v", err)
|
||||
t.Skip()
|
||||
}
|
||||
if len(servers) == 0 {
|
||||
t.Fatal("expected at least one root server")
|
||||
}
|
||||
if servers[0].Name == "" {
|
||||
t.Error("root server name should not be empty")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsNilConfig(t *testing.T) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
|
||||
servers, err := DiscoverRoots(ctx, nil)
|
||||
if err != nil {
|
||||
t.Logf("skipping (no resolver available): %v", err)
|
||||
t.Skip()
|
||||
}
|
||||
if len(servers) == 0 {
|
||||
t.Fatal("expected at least one root server with nil config")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildNSResponse(t *testing.T) {
|
||||
func TestAdditionalIPs(t *testing.T) {
|
||||
msg := new(dns.Msg)
|
||||
msg.SetReply(new(dns.Msg))
|
||||
msg.Answer = append(msg.Answer,
|
||||
&dns.NS{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS, Class: dns.ClassINET}, Ns: "a.root-servers.net."},
|
||||
&dns.NS{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS, Class: dns.ClassINET}, Ns: "b.root-servers.net."},
|
||||
&dns.NS{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS, Class: dns.ClassINET}, Ns: "c.root-servers.net."},
|
||||
msg.Extra = append(msg.Extra,
|
||||
&dns.A{Hdr: dns.RR_Header{Name: "A.ROOT-SERVERS.NET.", Rrtype: dns.TypeA, Class: dns.ClassINET}, A: net.ParseIP("198.41.0.4")},
|
||||
&dns.A{Hdr: dns.RR_Header{Name: "b.root-servers.net.", Rrtype: dns.TypeA, Class: dns.ClassINET}, A: net.ParseIP("170.247.170.2")},
|
||||
&dns.AAAA{Hdr: dns.RR_Header{Name: "a.root-servers.net.", Rrtype: dns.TypeAAAA, Class: dns.ClassINET}, AAAA: net.ParseIP("2001:503:ba3e::2:30")},
|
||||
)
|
||||
|
||||
names := extractNSRecords(msg.Answer)
|
||||
if len(names) != 3 {
|
||||
t.Fatalf("expected 3 NS records, got %d", len(names))
|
||||
ips := additionalIPs(msg, "a.root-servers.net.", dns.TypeA)
|
||||
if len(ips) != 1 || !ips[0].Equal(net.ParseIP("198.41.0.4")) {
|
||||
t.Errorf("case-insensitive glue match failed: %v", ips)
|
||||
}
|
||||
|
||||
for _, name := range names {
|
||||
if len(name) == 0 || name[len(name)-1] != '.' {
|
||||
t.Errorf("expected FQDN, got %q", name)
|
||||
}
|
||||
if ips := additionalIPs(msg, "a.root-servers.net.", dns.TypeAAAA); len(ips) != 1 {
|
||||
t.Errorf("expected 1 AAAA glue, got %v", ips)
|
||||
}
|
||||
if ips := additionalIPs(msg, "c.root-servers.net.", dns.TypeA); len(ips) != 0 {
|
||||
t.Errorf("expected no glue for c, got %v", ips)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExtractNSNames(t *testing.T) {
|
||||
rrs := []dns.RR{
|
||||
&dns.NS{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS}, Ns: "a.root-servers.net."},
|
||||
&dns.NS{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS}, Ns: "b.root-servers.net."},
|
||||
}
|
||||
names := extractNSNames(rrs)
|
||||
if len(names) != 2 {
|
||||
t.Fatalf("extractNSNames: expected 2 names, got %d", len(names))
|
||||
}
|
||||
}
|
||||
|
||||
func TestExtractNSNamesEmpty(t *testing.T) {
|
||||
names := extractNSNames(nil)
|
||||
if len(names) != 0 {
|
||||
t.Errorf("extractNSNames(nil): expected 0 names, got %d", len(names))
|
||||
}
|
||||
}
|
||||
|
||||
func TestExtractNSNamesNonNS(t *testing.T) {
|
||||
rrs := []dns.RR{
|
||||
&dns.A{Hdr: dns.RR_Header{Name: "a.root-servers.net.", Rrtype: dns.TypeA}, A: net.ParseIP("198.41.0.4")},
|
||||
}
|
||||
names := extractNSNames(rrs)
|
||||
if len(names) != 0 {
|
||||
t.Errorf("extractNSNames with A records: expected 0 names, got %d", len(names))
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsAllRoots(t *testing.T) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
||||
defer cancel()
|
||||
|
||||
cfg := &RootDiscoveryConfig{
|
||||
AllRoots: true,
|
||||
IncludeAAAA: false,
|
||||
}
|
||||
|
||||
servers, err := DiscoverRoots(ctx, cfg)
|
||||
if err != nil {
|
||||
t.Logf("skipping (no resolver available): %v", err)
|
||||
t.Skip()
|
||||
}
|
||||
if len(servers) == 0 {
|
||||
t.Fatal("expected root servers with AllRoots=true")
|
||||
}
|
||||
t.Logf("discovered %d root servers", len(servers))
|
||||
}
|
||||
|
||||
func TestDiscoverRootsAllRootsIncludeAAAA(t *testing.T) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
||||
defer cancel()
|
||||
|
||||
cfg := &RootDiscoveryConfig{
|
||||
AllRoots: true,
|
||||
IncludeAAAA: true,
|
||||
}
|
||||
|
||||
servers, err := DiscoverRoots(ctx, cfg)
|
||||
if err != nil {
|
||||
t.Logf("skipping (no resolver available): %v", err)
|
||||
t.Skip()
|
||||
}
|
||||
if len(servers) == 0 {
|
||||
t.Fatal("expected root servers")
|
||||
}
|
||||
}
|
||||
|
||||
// startMockDNSServer starts a UDP DNS server on a random port that serves
|
||||
// pre-configured responses. It returns the server address and a stop function.
|
||||
func startMockDNSServer(t *testing.T, handlerFn dns.HandlerFunc) string {
|
||||
t.Helper()
|
||||
|
||||
mux := dns.NewServeMux()
|
||||
mux.HandleFunc(".", handlerFn)
|
||||
|
||||
srv := &dns.Server{
|
||||
Addr: "127.0.0.1:0",
|
||||
Net: "udp",
|
||||
Handler: mux,
|
||||
}
|
||||
|
||||
started := make(chan struct{})
|
||||
srv.NotifyStartedFunc = func() { close(started) }
|
||||
|
||||
go func() {
|
||||
if err := srv.ListenAndServe(); err != nil && t.Failed() {
|
||||
return
|
||||
}
|
||||
}()
|
||||
|
||||
select {
|
||||
case <-started:
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatal("mock DNS server did not start in time")
|
||||
}
|
||||
|
||||
// Retrieve the actual bound address from the server's PacketConn.
|
||||
addr := srv.PacketConn.LocalAddr().String()
|
||||
t.Cleanup(func() { _ = srv.Shutdown() })
|
||||
return addr
|
||||
}
|
||||
|
||||
func TestQueryResolverSuccess(t *testing.T) {
|
||||
addr := startMockDNSServer(t, func(w dns.ResponseWriter, r *dns.Msg) {
|
||||
m := new(dns.Msg)
|
||||
m.SetReply(r)
|
||||
m.Answer = append(m.Answer,
|
||||
&dns.NS{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: 300}, Ns: "a.root-servers.net."},
|
||||
)
|
||||
_ = w.WriteMsg(m)
|
||||
})
|
||||
|
||||
// queryResolver uses 5ns timeout without deadline; provide one
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
||||
defer cancel()
|
||||
msg, err := queryResolver(ctx, addr, ".", dns.TypeNS)
|
||||
if err != nil {
|
||||
t.Fatalf("queryResolver: %v", err)
|
||||
}
|
||||
names := extractNSRecords(msg.Answer)
|
||||
if len(names) == 0 {
|
||||
t.Fatal("expected NS records in answer")
|
||||
}
|
||||
}
|
||||
|
||||
func TestQueryResolverError(t *testing.T) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
|
||||
defer cancel()
|
||||
// Use an address nothing is listening on
|
||||
_, err := queryResolver(ctx, "127.0.0.1:19999", ".", dns.TypeNS)
|
||||
if err == nil {
|
||||
t.Fatal("expected error for unreachable resolver")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverSingleRootWithMock(t *testing.T) {
|
||||
addr := startMockDNSServer(t, func(w dns.ResponseWriter, r *dns.Msg) {
|
||||
m := new(dns.Msg)
|
||||
m.SetReply(r)
|
||||
q := r.Question[0]
|
||||
switch q.Qtype {
|
||||
case dns.TypeNS:
|
||||
m.Answer = append(m.Answer,
|
||||
&dns.NS{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: 300}, Ns: "mock.root-servers.test."},
|
||||
)
|
||||
case dns.TypeA:
|
||||
m.Answer = append(m.Answer,
|
||||
&dns.A{Hdr: dns.RR_Header{Name: q.Name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300}, A: net.ParseIP("127.0.0.1")},
|
||||
)
|
||||
}
|
||||
_ = w.WriteMsg(m)
|
||||
})
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
||||
defer cancel()
|
||||
msg, err := queryResolver(ctx, addr, ".", dns.TypeNS)
|
||||
if err != nil {
|
||||
t.Fatalf("queryResolver: %v", err)
|
||||
}
|
||||
names := extractNSRecords(msg.Answer)
|
||||
if len(names) == 0 {
|
||||
names = extractNSNames(msg.Ns)
|
||||
}
|
||||
if len(names) == 0 {
|
||||
t.Skip("mock NS query returned no NS records")
|
||||
}
|
||||
t.Logf("found %d root NS names from mock: %v", len(names), names)
|
||||
}
|
||||
|
||||
func TestDiscoverAllRootsWithMockServer(t *testing.T) {
|
||||
addr := startMockDNSServer(t, func(w dns.ResponseWriter, r *dns.Msg) {
|
||||
m := new(dns.Msg)
|
||||
m.SetReply(r)
|
||||
q := r.Question[0]
|
||||
switch q.Qtype {
|
||||
case dns.TypeNS:
|
||||
m.Answer = append(m.Answer,
|
||||
&dns.NS{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: 300}, Ns: "a.mock-roots.test."},
|
||||
&dns.NS{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: 300}, Ns: "b.mock-roots.test."},
|
||||
)
|
||||
case dns.TypeA:
|
||||
m.Answer = append(m.Answer,
|
||||
&dns.A{Hdr: dns.RR_Header{Name: q.Name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300}, A: net.ParseIP("127.0.0.1")},
|
||||
)
|
||||
}
|
||||
_ = w.WriteMsg(m)
|
||||
})
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
msg, err := queryResolver(ctx, addr, ".", dns.TypeNS)
|
||||
if err != nil {
|
||||
t.Fatalf("queryResolver: %v", err)
|
||||
}
|
||||
names := extractNSRecords(msg.Answer)
|
||||
if len(names) < 2 {
|
||||
t.Fatalf("expected 2 NS names, got %d", len(names))
|
||||
}
|
||||
|
||||
// Also cover AAAA path
|
||||
aaaaMsg, err := queryResolver(ctx, addr, "a.mock-roots.test.", dns.TypeAAAA)
|
||||
if err != nil {
|
||||
t.Logf("AAAA query error (acceptable): %v", err)
|
||||
} else {
|
||||
t.Logf("AAAA query returned %d answers", len(aaaaMsg.Answer))
|
||||
}
|
||||
}
|
||||
|
||||
func TestMinTTLFromMsgWithExtraRecords(t *testing.T) {
|
||||
msg := new(dns.Msg)
|
||||
msg.Answer = append(msg.Answer, &dns.A{
|
||||
Hdr: dns.RR_Header{Ttl: 300},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
})
|
||||
// Extra record (non-OPT) with smaller TTL
|
||||
msg.Extra = append(msg.Extra, &dns.NS{
|
||||
Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS, Ttl: 60},
|
||||
Ns: "a.root-servers.net.",
|
||||
})
|
||||
|
||||
ttl := minTTLFromMsg(msg)
|
||||
if ttl != 60*time.Second {
|
||||
t.Errorf("minTTLFromMsg = %v, want 60s", ttl)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMinTTLFromMsgOPTIgnored(t *testing.T) {
|
||||
msg := new(dns.Msg)
|
||||
msg.Answer = append(msg.Answer, &dns.A{
|
||||
Hdr: dns.RR_Header{Ttl: 300},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
})
|
||||
// OPT record should be ignored
|
||||
msg.Extra = append(msg.Extra, &dns.OPT{
|
||||
Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeOPT},
|
||||
})
|
||||
|
||||
ttl := minTTLFromMsg(msg)
|
||||
if ttl != 300*time.Second {
|
||||
t.Errorf("minTTLFromMsg with OPT = %v, want 300s", ttl)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user