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
2026-07-07 21:42:06 +10:00
co-authored by Claude Fable 5
parent af15c9c2d4
commit d71c7fbef2
53 changed files with 6685 additions and 9366 deletions
-1
View File
@@ -1 +0,0 @@
package dns
+15 -34
View File
@@ -111,47 +111,28 @@ func TestRootHintsKnownAddress(t *testing.T) {
func TestResolverFromConfigExplicit(t *testing.T) {
cfg := &RootDiscoveryConfig{Resolver: "8.8.8.8:53"}
got := resolverFromConfig(cfg)
got, err := resolverFromConfig(cfg)
if err != nil {
t.Fatalf("resolverFromConfig: %v", err)
}
if got != "8.8.8.8:53" {
t.Errorf("resolverFromConfig = %q, want 8.8.8.8:53", got)
}
}
func TestResolverFromConfigEmpty(t *testing.T) {
cfg := &RootDiscoveryConfig{}
got := resolverFromConfig(cfg)
// Should return the system resolver; just check it's non-empty and contains a port.
if got == "" {
t.Error("resolverFromConfig with empty Resolver returned empty string")
}
}
func TestResolverFromConfigNil(t *testing.T) {
got := resolverFromConfig(nil)
if got == "" {
t.Error("resolverFromConfig(nil) returned empty string")
}
}
func TestSystemResolverNonEmpty(t *testing.T) {
got := systemResolver()
if got == "" {
t.Error("systemResolver() returned empty string")
}
// Must contain a colon (host:port format).
host, port, err := splitHostPort(got)
func TestSystemResolverNoHardcodedFallback(t *testing.T) {
// Whether or not /etc/resolv.conf exists, systemResolver must never
// invent 127.0.0.1:53: it returns a valid host:port from the system
// configuration or an error.
got, err := systemResolver()
if err != nil {
t.Errorf("systemResolver() = %q: not a valid host:port: %v", got, err)
return
}
if host == "" {
t.Errorf("systemResolver() host is empty in %q", got)
host, port, err := net.SplitHostPort(got)
if err != nil {
t.Fatalf("systemResolver() = %q: not a valid host:port: %v", got, err)
}
if port == "" {
t.Errorf("systemResolver() port is empty in %q", got)
if host == "" || port == "" {
t.Errorf("systemResolver() returned incomplete address %q", got)
}
}
// splitHostPort is a thin wrapper around net.SplitHostPort for test use.
func splitHostPort(addr string) (host, port string, err error) {
return net.SplitHostPort(addr)
}
-122
View File
@@ -1,122 +0,0 @@
package dns
import (
"context"
"errors"
"net"
"sync"
"testing"
"github.com/miekg/dns"
)
func TestIterativeQueryWithExchangeNilConfig(t *testing.T) {
resp := new(dns.Msg)
resp.SetReply(new(dns.Msg))
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return resp.Copy(), nil
}
server := net.ParseIP("8.8.8.8")
_, err := IterativeQueryWithExchange(context.Background(), server, "example.com", TypeA, nil, exchangeFn)
if err != nil {
t.Fatalf("unexpected error with nil config: %v", err)
}
}
func TestIterativeQueryWithExchangeAlwaysTCP(t *testing.T) {
resp := new(dns.Msg)
resp.SetReply(new(dns.Msg))
var mu sync.Mutex
calls := []bool{}
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
mu.Lock()
calls = append(calls, useTCP)
mu.Unlock()
return resp.Copy(), nil
}
cfg := &QueryConfig{
UDPSize: 2048,
Retries: 1,
UseTCP: true,
}
server := net.ParseIP("8.8.8.8")
_, err := IterativeQueryWithExchange(context.Background(), server, "example.com", TypeA, cfg, exchangeFn)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(calls) != 1 || !calls[0] {
t.Errorf("expected single TCP call, got %v", calls)
}
}
func TestIterativeQueryWithExchangeRetriesOnFailure(t *testing.T) {
var mu sync.Mutex
callCount := 0
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
mu.Lock()
callCount++
mu.Unlock()
return nil, errors.New("connection refused")
}
cfg := &QueryConfig{
UDPSize: 2048,
Retries: 3,
UseTCP: false,
}
server := net.ParseIP("8.8.8.8")
_, err := IterativeQueryWithExchange(context.Background(), server, "example.com", TypeA, cfg, exchangeFn)
if err == nil {
t.Fatal("expected error")
}
if callCount != 3 {
t.Errorf("expected 3 calls, got %d", callCount)
}
}
func TestIterativeQueryWithExchangeContextCancel(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return nil, ctx.Err()
}
cfg := &QueryConfig{
UDPSize: 2048,
Retries: 1,
UseTCP: false,
}
server := net.ParseIP("8.8.8.8")
_, err := IterativeQueryWithExchange(ctx, server, "example.com", TypeA, cfg, exchangeFn)
if err == nil {
t.Fatal("expected error on cancelled context")
}
}
func TestIterativeQueryWithExchangeZeroUDPSize(t *testing.T) {
resp := new(dns.Msg)
resp.SetReply(new(dns.Msg))
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return resp.Copy(), nil
}
cfg := &QueryConfig{
UDPSize: 0, // should use default
Retries: 1,
}
server := net.ParseIP("8.8.8.8")
_, err := IterativeQueryWithExchange(context.Background(), server, "example.com", TypeA, cfg, exchangeFn)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
}
+244 -147
View File
@@ -1,73 +1,98 @@
// Package dns provides the low-level DNS query primitives used by ExploreDNS.
//
// It wraps the github.com/miekg/dns library to provide retrying, TCP fallback,
// EDNS0 buffer size negotiation, and root server discovery. The package is
// intentionally narrow: it sends iterative (non-recursive) queries and returns
// the raw responses for the traversal engine to interpret.
// It wraps the github.com/miekg/dns library behind a single query path
// (Client) that sends non-recursive (RD=0) queries with retrying, TCP
// fallback on truncation, EDNS0 negotiation and a per-run packet cache, plus
// root server discovery. Production uses the real wire exchange; tests inject
// a mock ExchangeFunc into the exact same path.
package dns
import (
"context"
"errors"
"fmt"
"net"
"sync"
"time"
"github.com/miekg/dns"
)
// QueryConfig controls transport parameters for the single query path.
type QueryConfig struct {
UDPSize int
Timeout time.Duration
Retries int
UseTCP bool
// UDPSize is the EDNS0 UDP payload size. An OPT record is only attached
// when UDPSize > 512, mirroring dnstraverse's caching_resolver.rb.
UDPSize int
// Timeout is the per-attempt packet timeout (dnsruby packet_timeout,
// dnstraverse default 2s).
Timeout time.Duration
// Retries is the total number of send attempts, matching dnsruby
// retry_times: Resolver#generate_timeouts schedules retry_times
// transmissions in total — the first immediately and retry k at
// retry_delay*2^k seconds after the first. Values below 1 are clamped to
// 1 so exactly one query is still sent (dnsruby with retry_times 0 would
// send nothing and hang; this also fixes the old
// "failed after 0 retries: %!w(<nil>)" error).
Retries int
// RetryDelay is dnsruby's retry_delay (dnstraverse default 2s).
RetryDelay time.Duration
// UseTCP forces every query over TCP (--always-tcp).
UseTCP bool
// AllowTCP enables the UDP→TCP retry when a response is truncated.
AllowTCP bool
}
func DefaultQueryConfig() *QueryConfig {
return &QueryConfig{
UDPSize: DefaultEDNS0UDPSize(),
Timeout: 5 * time.Second,
Retries: 3,
UseTCP: false,
AllowTCP: true,
UDPSize: DefaultEDNS0UDPSize(),
Timeout: 2 * time.Second,
Retries: 2,
RetryDelay: 2 * time.Second,
UseTCP: false,
AllowTCP: true,
}
}
// withDefaults returns a copy of cfg with zero values replaced by defaults.
func (cfg *QueryConfig) withDefaults() *QueryConfig {
if cfg == nil {
return DefaultQueryConfig()
}
out := *cfg
if out.UDPSize <= 0 {
out.UDPSize = DefaultEDNS0UDPSize()
}
if out.Timeout <= 0 {
out.Timeout = 2 * time.Second
}
if out.Retries < 1 {
out.Retries = 1
}
if out.RetryDelay <= 0 {
out.RetryDelay = 2 * time.Second
}
return &out
}
// ExchangeFunc performs one wire exchange. server is either a bare host/IP
// (port 53 implied) or an explicit host:port.
type ExchangeFunc func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error)
func Query(ctx context.Context, server net.IP, name string, qtype uint16, cfg *QueryConfig) (*dns.Msg, error) {
if cfg == nil {
cfg = DefaultQueryConfig()
}
if cfg.UDPSize <= 0 {
cfg.UDPSize = DefaultEDNS0UDPSize()
}
if cfg.Timeout <= 0 {
cfg.Timeout = 5 * time.Second
}
return QueryWithExchange(ctx, server, name, qtype, cfg, realExchange)
}
func realExchange(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
addr := net.JoinHostPort(server, "53")
var c *dns.Client
if useTCP {
c = &dns.Client{
Net: "tcp",
ReadTimeout: 5 * time.Second,
WriteTimeout: 5 * time.Second,
}
} else {
c = &dns.Client{
Net: "udp",
ReadTimeout: 5 * time.Second,
WriteTimeout: 5 * time.Second,
}
addr := server
if _, _, err := net.SplitHostPort(server); err != nil {
addr = net.JoinHostPort(server, "53")
}
proto := "udp"
if useTCP {
proto = "tcp"
}
c := &dns.Client{
Net: proto,
ReadTimeout: 2 * time.Second,
WriteTimeout: 2 * time.Second,
}
if deadline, ok := ctx.Deadline(); ok {
c.ReadTimeout = time.Until(deadline)
c.WriteTimeout = time.Until(deadline)
@@ -75,150 +100,222 @@ func realExchange(ctx context.Context, server string, msg *dns.Msg, useTCP bool)
r, _, err := c.ExchangeContext(ctx, msg, addr)
if err != nil {
return nil, fmt.Errorf("dns exchange (%s) with %s: %w", c.Net, addr, err)
return nil, fmt.Errorf("dns exchange (%s) with %s: %w", proto, addr, err)
}
return r, nil
}
func QueryWithExchange(ctx context.Context, server net.IP, name string, qtype uint16, cfg *QueryConfig, exchangeFn ExchangeFunc) (*dns.Msg, error) {
if cfg == nil {
cfg = DefaultQueryConfig()
// Client is the single query path used identically by production and tests.
// Every query is non-recursive (RD=0) and deduplicated by a per-run packet
// cache keyed (server IP, qname, qclass, qtype, udpsize), mirroring
// dnstraverse's caching_resolver.rb: repeat askers replay the cached answer
// (or cached failure) without touching the wire.
type Client struct {
cfg *QueryConfig
exchange ExchangeFunc
mu sync.Mutex
cache map[packetKey]*packetEntry
requests int
cacheHits int
}
type packetKey struct {
server string
qname string
qclass uint16
qtype uint16
udpsize int
}
type packetEntry struct {
once sync.Once
msg *dns.Msg
err error
}
// NewClient creates a Client. A nil exchange means the real wire exchange;
// tests pass a mock so no packets leave the process.
func NewClient(cfg *QueryConfig, exchange ExchangeFunc) *Client {
if exchange == nil {
exchange = realExchange
}
if cfg.UDPSize <= 0 {
cfg.UDPSize = DefaultEDNS0UDPSize()
return &Client{
cfg: cfg.withDefaults(),
exchange: exchange,
cache: make(map[packetKey]*packetEntry),
}
}
// Requests reports how many queries were asked of the client (cache hits included).
func (c *Client) Requests() int {
c.mu.Lock()
defer c.mu.Unlock()
return c.requests
}
// CacheHits reports how many queries were served from the packet cache.
func (c *Client) CacheHits() int {
c.mu.Lock()
defer c.mu.Unlock()
return c.cacheHits
}
// Query sends a non-recursive query for name/qtype (class IN) to server and
// returns the response plus any warnings gathered along the way (EDNS0
// fallback, recursion offered, truncation). A non-nil error corresponds to
// dnstraverse's "exception" status (network failure after all retries).
func (c *Client) Query(ctx context.Context, server net.IP, name string, qtype uint16) (*dns.Msg, []string, error) {
msg, err := c.cachedExchange(ctx, server, name, qtype, c.cfg.UDPSize)
if err != nil {
return nil, nil, err
}
msg := buildQuery(name, qtype, cfg.UDPSize)
serverStr := server.String()
var warnings []string
// EDNS0 fallback (decoded_query.rb makequery_message): FORMERR/NOTIMP/
// SERVFAIL with udpsize > 512 may mean the server chokes on OPT; retry
// once at 512 and keep the retry only if it clears the error.
if c.cfg.UDPSize > MinEDNS0UDPSize() && ednsFailure(msg.Rcode) {
retryMsg, retryErr := c.cachedExchange(ctx, server, name, qtype, MinEDNS0UDPSize())
if retryErr == nil && !ednsFailure(retryMsg.Rcode) {
warnings = append(warnings, fmt.Sprintf("%s doesn't seem to support EDNS0", server))
msg = retryMsg
}
}
// msg_comment with want_recursion=false (message_utility.rb).
if msg.RecursionAvailable {
warnings = append(warnings, fmt.Sprintf("%s allows recursion", server))
}
if msg.Truncated {
warnings = append(warnings, fmt.Sprintf("%s sent truncated packet", server))
}
return msg, warnings, nil
}
func ednsFailure(rcode int) bool {
return rcode == dns.RcodeFormatError ||
rcode == dns.RcodeNotImplemented ||
rcode == dns.RcodeServerFailure
}
// cachedExchange sends at most one wire query per packet cache key; the
// outcome (response or error) is cached and replayed for repeat askers.
func (c *Client) cachedExchange(ctx context.Context, server net.IP, name string, qtype uint16, udpsize int) (*dns.Msg, error) {
key := packetKey{
server: server.String(),
qname: dns.CanonicalName(name),
qclass: dns.ClassINET,
qtype: qtype,
udpsize: udpsize,
}
c.mu.Lock()
c.requests++
entry, ok := c.cache[key]
if ok {
c.cacheHits++
} else {
entry = &packetEntry{}
c.cache[key] = entry
}
c.mu.Unlock()
entry.once.Do(func() {
entry.msg, entry.err = exchangeWithRetry(ctx, c.exchange, key.server, buildQuery(name, qtype, udpsize), c.cfg)
})
return copyMsg(entry.msg), entry.err
}
// exchangeWithRetry implements dnsruby's retry schedule (resolver.rb
// generate_timeouts): cfg.Retries is the TOTAL number of transmissions — the
// first goes immediately and retry k is sent retry_delay*2^k seconds after
// the first (so gaps of 2d, 2d, 4d, 8d, ...). Each attempt gets its own
// cfg.Timeout (dnsruby packet_timeout). A truncated UDP reply is retried over
// TCP within the same attempt when cfg.AllowTCP.
func exchangeWithRetry(ctx context.Context, exchange ExchangeFunc, server string, msg *dns.Msg, cfg *QueryConfig) (*dns.Msg, error) {
attempts := cfg.Retries
if attempts < 1 {
attempts = 1
}
var lastErr error
for attempt := 0; attempt < cfg.Retries; attempt++ {
for attempt := 0; attempt < attempts; attempt++ {
if attempt > 0 {
select {
case <-ctx.Done():
return nil, fmt.Errorf("query retries cancelled: %w", ctx.Err())
case <-time.After(backoffDelay(attempt)):
case <-time.After(retryGap(cfg.RetryDelay, attempt)):
}
}
if cfg.UseTCP {
resp, err := exchangeFn(ctx, serverStr, msg, true)
if err != nil {
lastErr = err
continue
}
return resp, nil
}
resp, err := exchangeFn(ctx, serverStr, msg, false)
resp, err := exchangeOnce(ctx, exchange, server, msg, cfg)
if err != nil {
lastErr = err
continue
}
if resp.Truncated && cfg.AllowTCP {
resp, err = exchangeFn(ctx, serverStr, msg, true)
if err != nil {
lastErr = err
continue
}
return resp, nil
}
return resp, nil
}
return nil, fmt.Errorf("query %s %s failed after %d retries: %w", name, QNameType(qtype), cfg.Retries, lastErr)
q := msg.Question[0]
return nil, fmt.Errorf("query %s %s to %s failed after %d attempts: %w",
q.Name, QNameType(q.Qtype), server, attempts, lastErr)
}
func IterativeQuery(ctx context.Context, server net.IP, name string, qtype uint16, cfg *QueryConfig) (*dns.Msg, error) {
if cfg == nil {
cfg = DefaultQueryConfig()
// retryGap returns the wait before retry number `retry` (1-based). dnsruby
// sends retry k at absolute time retry_delay*2^k, so the gap is 2d before the
// first retry and d*2^(k-1) for each retry after that.
func retryGap(d time.Duration, retry int) time.Duration {
if retry <= 1 {
return 2 * d
}
if cfg.UDPSize <= 0 {
cfg.UDPSize = DefaultEDNS0UDPSize()
}
return IterativeQueryWithExchange(ctx, server, name, qtype, cfg, realExchange)
return d << uint(retry-1)
}
func IterativeQueryWithExchange(ctx context.Context, server net.IP, name string, qtype uint16, cfg *QueryConfig, exchangeFn ExchangeFunc) (*dns.Msg, error) {
if cfg == nil {
cfg = DefaultQueryConfig()
func exchangeOnce(ctx context.Context, exchange ExchangeFunc, server string, msg *dns.Msg, cfg *QueryConfig) (*dns.Msg, error) {
actx, cancel := context.WithTimeout(ctx, cfg.Timeout)
defer cancel()
resp, err := exchange(actx, server, msg, cfg.UseTCP)
if err != nil {
return nil, err
}
if cfg.UDPSize <= 0 {
cfg.UDPSize = DefaultEDNS0UDPSize()
if resp == nil {
return nil, errors.New("nil response")
}
msg := buildQuery(name, qtype, cfg.UDPSize)
msg.RecursionDesired = false
serverStr := server.String()
var lastErr error
for attempt := 0; attempt < cfg.Retries; attempt++ {
if attempt > 0 {
select {
case <-ctx.Done():
return nil, fmt.Errorf("query retries cancelled: %w", ctx.Err())
case <-time.After(backoffDelay(attempt)):
}
}
if cfg.UseTCP {
resp, err := exchangeFn(ctx, serverStr, msg, true)
if err != nil {
lastErr = err
continue
}
return resp, nil
}
resp, err := exchangeFn(ctx, serverStr, msg, false)
if !cfg.UseTCP && resp.Truncated && cfg.AllowTCP {
resp, err = exchange(actx, server, msg, true)
if err != nil {
lastErr = err
continue
return nil, err
}
if resp == nil {
lastErr = fmt.Errorf("nil response")
continue
return nil, errors.New("nil response")
}
if resp.Truncated && cfg.AllowTCP {
resp, err = exchangeFn(ctx, serverStr, msg, true)
if err != nil {
lastErr = err
continue
}
return resp, nil
}
return resp, nil
}
return nil, fmt.Errorf("iterative query %s %s failed after %d retries: %w", name, QNameType(qtype), cfg.Retries, lastErr)
return resp, nil
}
// backoffDelay computes the wait duration before the given retry attempt (1-indexed).
// Delays: attempt=1 → 100ms, attempt=2 → 200ms, attempt=3 → 400ms, capped at 2s.
func backoffDelay(attempt int) time.Duration {
if attempt <= 0 {
return 0
}
delay := time.Duration(uint(1)<<uint(attempt-1)) * 100 * time.Millisecond
const maxDelay = 2 * time.Second
if delay > maxDelay {
return maxDelay
}
return delay
}
func buildQuery(name string, qtype uint16, udpSize int) *dns.Msg {
// buildQuery constructs a non-recursive (RD=0) class IN query. The EDNS0 OPT
// record is attached only when udpsize > 512 (caching_resolver.rb adds OPT
// under the same condition), with the DO bit off.
func buildQuery(name string, qtype uint16, udpsize int) *dns.Msg {
m := new(dns.Msg)
m.SetQuestion(dns.Fqdn(name), qtype)
m.RecursionDesired = true
m.SetEdns0(uint16(udpSize), false)
m.RecursionDesired = false
if udpsize > MinEDNS0UDPSize() {
m.SetEdns0(uint16(udpsize), false)
}
return m
}
func copyMsg(m *dns.Msg) *dns.Msg {
if m == nil {
return nil
}
return m.Copy()
}
+384 -371
View File
@@ -4,480 +4,493 @@ import (
"context"
"errors"
"net"
"strings"
"sync"
"testing"
"time"
"github.com/miekg/dns"
)
// testClient returns a Client with fast retries wired to fn.
func testClient(cfg *QueryConfig, fn ExchangeFunc) *Client {
if cfg == nil {
cfg = DefaultQueryConfig()
}
cfg.Timeout = time.Second
cfg.RetryDelay = time.Millisecond
return NewClient(cfg, fn)
}
func answerMsg(name string, ip string) *dns.Msg {
m := new(dns.Msg)
m.SetReply(new(dns.Msg))
m.Answer = append(m.Answer, &dns.A{
Hdr: dns.RR_Header{Name: name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
A: net.ParseIP(ip),
})
return m
}
func TestDefaultQueryConfig(t *testing.T) {
cfg := DefaultQueryConfig()
if cfg == nil {
t.Fatal("DefaultQueryConfig returned nil")
}
if cfg.UDPSize != 2048 {
t.Errorf("UDPSize = %d, want 2048", cfg.UDPSize)
}
if cfg.Retries != 3 {
t.Errorf("Retries = %d, want 3", cfg.Retries)
if cfg.Retries != 2 {
t.Errorf("Retries = %d, want 2", cfg.Retries)
}
if cfg.Timeout != 2*time.Second {
t.Errorf("Timeout = %v, want 2s", cfg.Timeout)
}
if cfg.RetryDelay != 2*time.Second {
t.Errorf("RetryDelay = %v, want 2s", cfg.RetryDelay)
}
if cfg.UseTCP {
t.Error("UseTCP should be false by default")
}
if !cfg.AllowTCP {
t.Error("AllowTCP should be true by default")
}
}
func TestBuildQuery(t *testing.T) {
msg := buildQuery("example.com.", TypeA, 2048)
func TestBuildQueryRDZeroWithEDNS(t *testing.T) {
msg := buildQuery("example.com", TypeA, 2048)
if len(msg.Question) != 1 {
t.Fatalf("expected 1 question, got %d", len(msg.Question))
}
q := msg.Question[0]
if q.Name != "example.com." {
t.Errorf("question name = %q, want %q", q.Name, "example.com.")
t.Errorf("Fqdn not applied: got %q", q.Name)
}
if q.Qtype != TypeA {
t.Errorf("question type = %d, want %d", q.Qtype, TypeA)
}
if !msg.RecursionDesired {
t.Error("RecursionDesired should be true")
if msg.RecursionDesired {
t.Error("RecursionDesired must be false on the query path")
}
if opt := msg.IsEdns0(); opt == nil {
t.Error("expected EDNS0 OPT record")
} else if opt.UDPSize() != 2048 {
opt := msg.IsEdns0()
if opt == nil {
t.Fatal("expected EDNS0 OPT record for udpsize > 512")
}
if opt.UDPSize() != 2048 {
t.Errorf("EDNS0 UDPSize = %d, want 2048", opt.UDPSize())
}
}
func TestBuildQueryFqdn(t *testing.T) {
msg := buildQuery("example.com", TypeA, 4096)
q := msg.Question[0]
if q.Name != "example.com." {
t.Errorf("Fqdn not applied: got %q, want %q", q.Name, "example.com.")
func TestBuildQueryNoEDNSAt512(t *testing.T) {
msg := buildQuery("example.com.", TypeA, 512)
if msg.IsEdns0() != nil {
t.Error("no OPT record should be attached when udpsize <= 512")
}
}
func TestQueryWithExchangeSuccess(t *testing.T) {
expectedResp := new(dns.Msg)
expectedResp.SetReply(new(dns.Msg))
expectedResp.Answer = append(expectedResp.Answer, &dns.A{
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
A: net.ParseIP("93.184.216.34"),
func TestClientQuerySuccess(t *testing.T) {
c := testClient(nil, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
if msg.RecursionDesired {
t.Error("query must be sent with RD=0")
}
return answerMsg("example.com.", "93.184.216.34"), nil
})
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return expectedResp.Copy(), nil
}
cfg := &QueryConfig{
UDPSize: 2048,
Timeout: 5,
Retries: 1,
UseTCP: false,
}
server := net.ParseIP("8.8.8.8")
resp, err := QueryWithExchange(context.Background(), server, "example.com", TypeA, cfg, exchangeFn)
resp, warnings, err := c.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(resp.Answer) != 1 {
t.Fatalf("expected 1 answer, got %d", len(resp.Answer))
}
if len(warnings) != 0 {
t.Errorf("unexpected warnings: %v", warnings)
}
}
func TestQueryTCPFallbackOnTruncation(t *testing.T) {
truncatedResp := new(dns.Msg)
truncatedResp.Truncated = true
truncatedResp.SetReply(new(dns.Msg))
fullResp := new(dns.Msg)
fullResp.SetReply(new(dns.Msg))
fullResp.Answer = append(fullResp.Answer, &dns.A{
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
A: net.ParseIP("93.184.216.34"),
func TestClientPacketCache(t *testing.T) {
var calls int
c := testClient(nil, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
calls++
return answerMsg("example.com.", "1.2.3.4"), nil
})
var mu sync.Mutex
calls := []bool{}
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
mu.Lock()
defer mu.Unlock()
calls = append(calls, useTCP)
if !useTCP {
return truncatedResp.Copy(), nil
}
return fullResp.Copy(), nil
}
cfg := &QueryConfig{
UDPSize: 2048,
Timeout: 5,
Retries: 1,
UseTCP: false,
AllowTCP: true,
}
ctx := context.Background()
server := net.ParseIP("8.8.8.8")
resp, err := QueryWithExchange(context.Background(), server, "example.com", TypeA, cfg, exchangeFn)
for i := 0; i < 3; i++ {
if _, _, err := c.Query(ctx, server, "example.com", TypeA); err != nil {
t.Fatalf("query %d: %v", i, err)
}
}
if calls != 1 {
t.Errorf("expected 1 wire query for repeat askers, got %d", calls)
}
if c.Requests() != 3 {
t.Errorf("Requests = %d, want 3", c.Requests())
}
if c.CacheHits() != 2 {
t.Errorf("CacheHits = %d, want 2", c.CacheHits())
}
// Case differences must hit the same cache entry.
if _, _, err := c.Query(ctx, server, "EXAMPLE.COM.", TypeA); err != nil {
t.Fatal(err)
}
if calls != 1 {
t.Errorf("case-insensitive lookup should hit cache, got %d wire calls", calls)
}
}
func TestClientPacketCacheDistinctKeys(t *testing.T) {
var calls int
c := testClient(nil, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
calls++
return answerMsg("example.com.", "1.2.3.4"), nil
})
ctx := context.Background()
_, _, _ = c.Query(ctx, net.ParseIP("8.8.8.8"), "example.com", TypeA)
_, _, _ = c.Query(ctx, net.ParseIP("9.9.9.9"), "example.com", TypeA)
_, _, _ = c.Query(ctx, net.ParseIP("8.8.8.8"), "example.com", TypeAAAA)
_, _, _ = c.Query(ctx, net.ParseIP("8.8.8.8"), "other.com", TypeA)
if calls != 4 {
t.Errorf("expected 4 wire queries for 4 distinct keys, got %d", calls)
}
}
func TestClientPacketCacheReplaysErrors(t *testing.T) {
var calls int
c := testClient(&QueryConfig{Retries: 1}, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
calls++
return nil, errors.New("connection refused")
})
ctx := context.Background()
server := net.ParseIP("8.8.8.8")
_, _, err1 := c.Query(ctx, server, "example.com", TypeA)
_, _, err2 := c.Query(ctx, server, "example.com", TypeA)
if err1 == nil || err2 == nil {
t.Fatal("expected errors")
}
if calls != 1 {
t.Errorf("failures must be cached too: got %d wire calls", calls)
}
}
func TestClientEDNSFallback(t *testing.T) {
var sizes []int
c := testClient(nil, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
size := 512
if opt := msg.IsEdns0(); opt != nil {
size = int(opt.UDPSize())
}
sizes = append(sizes, size)
m := new(dns.Msg)
m.SetReply(msg)
if size > 512 {
m.Rcode = dns.RcodeFormatError
return m, nil
}
m.Answer = append(m.Answer, &dns.A{
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
A: net.ParseIP("1.2.3.4"),
})
return m, nil
})
resp, warnings, err := c.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(calls) != 2 {
t.Fatalf("expected 2 exchange calls (UDP then TCP), got %d", len(calls))
if len(sizes) != 2 || sizes[0] != 2048 || sizes[1] != 512 {
t.Fatalf("expected 2048 then 512 queries, got %v", sizes)
}
if calls[0] != false {
t.Error("first call should be UDP")
if resp.Rcode != dns.RcodeSuccess || len(resp.Answer) != 1 {
t.Error("expected the 512-byte retry response to be returned")
}
if calls[1] != true {
t.Error("second call should be TCP")
want := "8.8.8.8 doesn't seem to support EDNS0"
if len(warnings) != 1 || warnings[0] != want {
t.Errorf("warnings = %v, want [%q]", warnings, want)
}
}
func TestClientEDNSFallbackKeepsOriginalWhenRetryFails(t *testing.T) {
c := testClient(nil, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
m := new(dns.Msg)
m.SetReply(msg)
m.Rcode = dns.RcodeServerFailure
return m, nil
})
resp, warnings, err := c.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if resp.Rcode != dns.RcodeServerFailure {
t.Errorf("expected original SERVFAIL response, got rcode %d", resp.Rcode)
}
if len(warnings) != 0 {
t.Errorf("no EDNS0 warning expected when the retry also fails: %v", warnings)
}
}
func TestClientNoEDNSFallbackAt512(t *testing.T) {
var calls int
c := testClient(&QueryConfig{UDPSize: 512, Retries: 1}, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
calls++
m := new(dns.Msg)
m.SetReply(msg)
m.Rcode = dns.RcodeFormatError
return m, nil
})
resp, _, err := c.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if calls != 1 {
t.Errorf("expected no fallback query at udpsize 512, got %d calls", calls)
}
if resp.Rcode != dns.RcodeFormatError {
t.Errorf("expected FORMERR passthrough, got %d", resp.Rcode)
}
}
func TestClientRecursionAvailableWarning(t *testing.T) {
c := testClient(nil, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
m := answerMsg("example.com.", "1.2.3.4")
m.RecursionAvailable = true
return m, nil
})
_, warnings, err := c.Query(context.Background(), net.ParseIP("192.0.2.1"), "example.com", TypeA)
if err != nil {
t.Fatal(err)
}
want := "192.0.2.1 allows recursion"
if len(warnings) != 1 || warnings[0] != want {
t.Errorf("warnings = %v, want [%q]", warnings, want)
}
}
func TestClientTruncationWarningWhenTCPDisallowed(t *testing.T) {
c := testClient(&QueryConfig{AllowTCP: false, Retries: 1}, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
if useTCP {
t.Error("TCP must not be used when AllowTCP is false")
}
m := answerMsg("example.com.", "1.2.3.4")
m.Truncated = true
return m, nil
})
resp, warnings, err := c.Query(context.Background(), net.ParseIP("192.0.2.1"), "example.com", TypeA)
if err != nil {
t.Fatal(err)
}
if !resp.Truncated {
t.Error("expected truncated response to be returned as-is")
}
want := "192.0.2.1 sent truncated packet"
if len(warnings) != 1 || warnings[0] != want {
t.Errorf("warnings = %v, want [%q]", warnings, want)
}
}
func TestClientTCPFallbackOnTruncation(t *testing.T) {
var mu sync.Mutex
var calls []bool
c := testClient(nil, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
mu.Lock()
calls = append(calls, useTCP)
mu.Unlock()
if !useTCP {
m := new(dns.Msg)
m.SetReply(msg)
m.Truncated = true
return m, nil
}
return answerMsg("example.com.", "93.184.216.34"), nil
})
resp, warnings, err := c.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(calls) != 2 || calls[0] != false || calls[1] != true {
t.Fatalf("expected UDP then TCP, got %v", calls)
}
if len(resp.Answer) != 1 {
t.Fatalf("expected 1 answer from TCP fallback, got %d", len(resp.Answer))
t.Fatal("expected answer from TCP fallback")
}
if len(warnings) != 0 {
t.Errorf("unexpected warnings after successful TCP fallback: %v", warnings)
}
}
func TestQueryAlwaysTCP(t *testing.T) {
resp := new(dns.Msg)
resp.SetReply(new(dns.Msg))
func TestClientAlwaysTCP(t *testing.T) {
var mu sync.Mutex
calls := []bool{}
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
var calls []bool
c := testClient(&QueryConfig{UseTCP: true, Retries: 1}, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
mu.Lock()
defer mu.Unlock()
calls = append(calls, useTCP)
return resp.Copy(), nil
}
mu.Unlock()
return answerMsg("example.com.", "1.2.3.4"), nil
})
cfg := &QueryConfig{
UDPSize: 2048,
Timeout: 5,
Retries: 1,
UseTCP: true,
}
server := net.ParseIP("8.8.8.8")
_, err := QueryWithExchange(context.Background(), server, "example.com", TypeA, cfg, exchangeFn)
_, _, err := c.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(calls) != 1 {
t.Fatalf("expected 1 exchange call, got %d", len(calls))
}
if !calls[0] {
t.Error("expected TCP call when UseTCP is true")
if len(calls) != 1 || !calls[0] {
t.Errorf("expected a single TCP call, got %v", calls)
}
}
func TestQueryRetriesOnFailure(t *testing.T) {
var mu sync.Mutex
callCount := 0
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
mu.Lock()
callCount++
mu.Unlock()
func TestClientRetriesAreTotalAttempts(t *testing.T) {
var calls int
c := testClient(&QueryConfig{Retries: 3}, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
calls++
return nil, errors.New("connection refused")
}
})
cfg := &QueryConfig{
UDPSize: 2048,
Timeout: 5,
Retries: 3,
UseTCP: false,
}
server := net.ParseIP("8.8.8.8")
_, err := QueryWithExchange(context.Background(), server, "example.com", TypeA, cfg, exchangeFn)
_, _, err := c.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err == nil {
t.Fatal("expected error after retries exhausted")
}
if callCount != 3 {
t.Errorf("expected 3 calls (retries exhausted), got %d", callCount)
// dnsruby retry_times counts total transmissions, not extra retries.
if calls != 3 {
t.Errorf("expected 3 attempts, got %d", calls)
}
if !strings.Contains(err.Error(), "after 3 attempts") {
t.Errorf("error should mention attempt count: %v", err)
}
}
func TestQueryContextCancellation(t *testing.T) {
func TestClientZeroRetriesStillQueriesOnce(t *testing.T) {
var calls int
c := testClient(&QueryConfig{Retries: 0}, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
calls++
return nil, errors.New("boom")
})
_, _, err := c.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err == nil {
t.Fatal("expected error")
}
if calls != 1 {
t.Errorf("Retries=0 must be clamped to one attempt, got %d", calls)
}
// Regression: the old code produced "failed after 0 retries: %!w(<nil>)".
if strings.Contains(err.Error(), "%!w") || strings.Contains(err.Error(), "<nil>") {
t.Errorf("malformed error message: %v", err)
}
}
func TestClientRetryThenSuccess(t *testing.T) {
var calls int
c := testClient(&QueryConfig{Retries: 3}, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
calls++
if calls < 2 {
return nil, errors.New("transient error")
}
return answerMsg("example.com.", "1.2.3.4"), nil
})
resp, _, err := c.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(resp.Answer) == 0 {
t.Fatal("expected answer after retry")
}
if calls != 2 {
t.Errorf("expected 2 attempts, got %d", calls)
}
}
func TestClientNilResponseIsError(t *testing.T) {
c := testClient(&QueryConfig{Retries: 2}, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return nil, nil
})
_, _, err := c.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err == nil {
t.Fatal("expected error for nil responses")
}
}
func TestClientContextCancellation(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return nil, ctx.Err()
}
c := testClient(&QueryConfig{Retries: 5}, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return nil, errors.New("error")
})
cfg := &QueryConfig{
UDPSize: 2048,
Timeout: 5,
Retries: 1,
UseTCP: false,
}
server := net.ParseIP("8.8.8.8")
_, err := QueryWithExchange(ctx, server, "example.com", TypeA, cfg, exchangeFn)
_, _, err := c.Query(ctx, net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err == nil {
t.Fatal("expected error on cancelled context")
}
}
func TestQueryNilConfigUsesDefaults(t *testing.T) {
resp := new(dns.Msg)
resp.SetReply(new(dns.Msg))
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return resp.Copy(), nil
}
server := net.ParseIP("8.8.8.8")
_, err := QueryWithExchange(context.Background(), server, "example.com", TypeA, nil, exchangeFn)
func TestClientNilConfigUsesDefaults(t *testing.T) {
c := NewClient(nil, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return answerMsg("example.com.", "1.2.3.4"), nil
})
_, _, err := c.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err != nil {
t.Fatalf("unexpected error with nil config: %v", err)
}
}
func TestQueryZeroValuesUseDefaults(t *testing.T) {
resp := new(dns.Msg)
resp.SetReply(new(dns.Msg))
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return resp.Copy(), nil
}
cfg := &QueryConfig{
UDPSize: 0,
Timeout: 0,
Retries: 1,
UseTCP: false,
}
server := net.ParseIP("8.8.8.8")
_, err := QueryWithExchange(context.Background(), server, "example.com", TypeA, cfg, exchangeFn)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
}
func TestQueryTCPFallbackFailsThenRetries(t *testing.T) {
truncatedResp := new(dns.Msg)
truncatedResp.Truncated = true
truncatedResp.SetReply(new(dns.Msg))
var mu sync.Mutex
callCount := 0
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
mu.Lock()
callCount++
mu.Unlock()
func TestClientTCPFallbackFailureRetries(t *testing.T) {
var calls int
c := testClient(&QueryConfig{Retries: 2, AllowTCP: true}, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
calls++
if !useTCP {
return truncatedResp.Copy(), nil
m := new(dns.Msg)
m.SetReply(msg)
m.Truncated = true
return m, nil
}
return nil, errors.New("tcp failed")
}
})
cfg := &QueryConfig{
UDPSize: 2048,
Timeout: 5,
Retries: 2,
UseTCP: false,
AllowTCP: true,
}
server := net.ParseIP("8.8.8.8")
_, err := QueryWithExchange(context.Background(), server, "example.com", TypeA, cfg, exchangeFn)
_, _, err := c.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err == nil {
t.Fatal("expected error when TCP fallback always fails")
}
if callCount != 4 {
t.Errorf("expected 4 calls (2 retries x UDP+TCP), got %d", callCount)
if calls != 4 {
t.Errorf("expected 4 exchange calls (2 attempts x UDP+TCP), got %d", calls)
}
}
func TestQueryNoTCPFallbackWhenDisabled(t *testing.T) {
truncatedResp := new(dns.Msg)
truncatedResp.Truncated = true
truncatedResp.SetReply(new(dns.Msg))
var mu sync.Mutex
calls := []bool{}
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
mu.Lock()
defer mu.Unlock()
calls = append(calls, useTCP)
return truncatedResp.Copy(), nil
func TestRetryGap(t *testing.T) {
d := 2 * time.Second
tests := []struct {
retry int
want time.Duration
}{
{1, 4 * time.Second}, // dnsruby sends retry 1 at absolute 2d
{2, 4 * time.Second}, // retry 2 at 4d → gap 2d
{3, 8 * time.Second},
{4, 16 * time.Second},
}
cfg := &QueryConfig{
UDPSize: 2048,
Timeout: 5,
Retries: 1,
UseTCP: false,
AllowTCP: false, // TCP fallback must be suppressed
}
server := net.ParseIP("8.8.8.8")
resp, err := QueryWithExchange(context.Background(), server, "example.com", TypeA, cfg, exchangeFn)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
// Only one UDP call; no TCP fallback.
if len(calls) != 1 {
t.Fatalf("expected 1 exchange call (no TCP fallback), got %d", len(calls))
}
if calls[0] != false {
t.Error("expected UDP-only call")
}
if !resp.Truncated {
t.Error("expected truncated response to be returned as-is")
for _, tt := range tests {
got := retryGap(d, tt.retry)
if got != tt.want {
t.Errorf("retryGap(%v, %d) = %v, want %v", d, tt.retry, got, tt.want)
}
}
}
func TestIterativeQueryWithExchangeSuccess(t *testing.T) {
answerResp := new(dns.Msg)
answerResp.SetReply(new(dns.Msg))
answerResp.Answer = append(answerResp.Answer, &dns.A{
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
A: net.ParseIP("1.2.3.4"),
})
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
if msg.RecursionDesired {
t.Error("IterativeQuery should send RD=false")
}
return answerResp.Copy(), nil
}
server := net.ParseIP("198.41.0.4")
resp, err := IterativeQueryWithExchange(context.Background(), server, "example.com", dns.TypeA, nil, exchangeFn)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(resp.Answer) == 0 {
t.Fatal("expected answer records")
}
}
func TestIterativeQueryWithExchangeRetry(t *testing.T) {
callCount := 0
answerResp := new(dns.Msg)
answerResp.SetReply(new(dns.Msg))
answerResp.Answer = append(answerResp.Answer, &dns.A{
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
A: net.ParseIP("1.2.3.4"),
})
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
callCount++
if callCount < 2 {
return nil, errors.New("transient error")
}
return answerResp.Copy(), nil
}
cfg := &QueryConfig{UDPSize: 2048, Retries: 3, AllowTCP: true}
server := net.ParseIP("198.41.0.4")
resp, err := IterativeQueryWithExchange(context.Background(), server, "example.com", dns.TypeA, cfg, exchangeFn)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if resp == nil {
t.Fatal("expected non-nil response after retry")
}
}
func TestIterativeQueryWithExchangeAllFail(t *testing.T) {
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return nil, errors.New("server unreachable")
}
cfg := &QueryConfig{UDPSize: 2048, Retries: 2, AllowTCP: false}
server := net.ParseIP("198.41.0.4")
_, err := IterativeQueryWithExchange(context.Background(), server, "example.com", dns.TypeA, cfg, exchangeFn)
if err == nil {
t.Fatal("expected error when all attempts fail")
}
}
func TestIterativeQueryWithExchangeTCPFallback(t *testing.T) {
truncatedResp := new(dns.Msg)
truncatedResp.SetReply(new(dns.Msg))
truncatedResp.Truncated = true
fullResp := new(dns.Msg)
fullResp.SetReply(new(dns.Msg))
fullResp.Answer = append(fullResp.Answer, &dns.A{
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
A: net.ParseIP("1.2.3.4"),
})
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
if !useTCP {
return truncatedResp.Copy(), nil
}
return fullResp.Copy(), nil
}
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, AllowTCP: true}
server := net.ParseIP("198.41.0.4")
resp, err := IterativeQueryWithExchange(context.Background(), server, "example.com", dns.TypeA, cfg, exchangeFn)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(resp.Answer) == 0 {
t.Fatal("expected answer after TCP fallback")
}
}
func TestIterativeQueryWithExchangeContextCancelled(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
// Cancel the context immediately so the retry loop aborts during backoff
cancel()
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return nil, errors.New("error")
}
cfg := &QueryConfig{UDPSize: 2048, Retries: 5, AllowTCP: false}
server := net.ParseIP("198.41.0.4")
_, err := IterativeQueryWithExchange(ctx, server, "example.com", dns.TypeA, cfg, exchangeFn)
func TestQueryErrorMessageMentionsQuery(t *testing.T) {
c := testClient(&QueryConfig{Retries: 1}, func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return nil, errors.New("unreachable")
})
_, _, err := c.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA)
if err == nil {
t.Fatal("expected error when context cancelled")
t.Fatal("expected error")
}
for _, part := range []string{"example.com.", "A", "8.8.8.8", "unreachable"} {
if !strings.Contains(err.Error(), part) {
t.Errorf("error %q should contain %q", err, part)
}
}
}
func TestIterativeQueryWithExchangeNilResponse(t *testing.T) {
callCount := 0
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
callCount++
return nil, nil // nil response, no error
}
cfg := &QueryConfig{UDPSize: 2048, Retries: 2, AllowTCP: false}
server := net.ParseIP("198.41.0.4")
_, err := IterativeQueryWithExchange(context.Background(), server, "example.com", dns.TypeA, cfg, exchangeFn)
if err == nil {
t.Fatal("expected error for nil responses")
}
}
func TestIterativeQueryWithExchangeUseTCP(t *testing.T) {
var wasTCP bool
answerResp := new(dns.Msg)
answerResp.SetReply(new(dns.Msg))
answerResp.Answer = append(answerResp.Answer, &dns.A{
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
A: net.ParseIP("1.2.3.4"),
})
exchangeFn := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
wasTCP = useTCP
return answerResp.Copy(), nil
}
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, UseTCP: true}
server := net.ParseIP("198.41.0.4")
_, err := IterativeQueryWithExchange(context.Background(), server, "example.com", dns.TypeA, cfg, exchangeFn)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !wasTCP {
t.Error("expected TCP exchange when UseTCP=true")
}
}
+96 -267
View File
@@ -2,7 +2,6 @@ package dns
import (
"context"
"fmt"
"net"
"testing"
"time"
@@ -10,263 +9,32 @@ import (
"github.com/miekg/dns"
)
// startTestDNSServer starts a local DNS server on a random port and returns the address and a stop function.
func startTestDNSServer(t *testing.T, handler dns.HandlerFunc) (string, func()) {
// startTestDNSServer starts a loopback DNS server on a random port and
// returns its address. No test in this file touches the real network.
func startTestDNSServer(t *testing.T, network string, handler dns.HandlerFunc) string {
t.Helper()
pc, err := net.ListenPacket("udp", "127.0.0.1:0")
if err != nil {
t.Skipf("cannot start test DNS server: %v", err)
}
addr := pc.LocalAddr().String()
mux := dns.NewServeMux()
mux.HandleFunc(".", handler)
srv := &dns.Server{
PacketConn: pc,
Net: "udp",
Handler: mux,
}
srv := &dns.Server{Net: network, Handler: mux}
var addr string
started := make(chan struct{})
srv.NotifyStartedFunc = func() { close(started) }
go func() {
_ = srv.ActivateAndServe()
}()
select {
case <-started:
case <-time.After(2 * time.Second):
t.Skip("test DNS server did not start in time")
}
return addr, func() { _ = srv.Shutdown() }
}
func TestQueryUsesRealExchange(t *testing.T) {
addr, stop := startTestDNSServer(t, func(w dns.ResponseWriter, r *dns.Msg) {
resp := new(dns.Msg)
resp.SetReply(r)
resp.Answer = append(resp.Answer, &dns.A{
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
A: net.ParseIP("1.2.3.4"),
})
_ = w.WriteMsg(resp)
})
defer stop()
host, portStr, err := net.SplitHostPort(addr)
if err != nil {
t.Fatalf("parse addr: %v", err)
}
var port int
fmt.Sscanf(portStr, "%d", &port)
// Patch the realExchange to use the test server by using QueryWithExchange with a custom exchangeFn.
// Since we can't inject into Query directly, use realExchangeWithPort for test.
serverIP := net.ParseIP(host)
cfg := DefaultQueryConfig()
cfg.Retries = 1
// Test QueryWithExchange (already covered), but now test Query+realExchange flow via
// a patched exchange that routes to our test server port.
patchedExchange := func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
c := &dns.Client{Net: "udp", ReadTimeout: 3 * time.Second, WriteTimeout: 3 * time.Second}
r, _, err := c.ExchangeContext(ctx, msg, fmt.Sprintf("%s:%d", host, port))
return r, err
}
resp, err := QueryWithExchange(context.Background(), serverIP, "example.com", TypeA, cfg, patchedExchange)
if err != nil {
t.Fatalf("QueryWithExchange: %v", err)
}
if len(resp.Answer) == 0 {
t.Fatal("expected at least 1 answer")
}
}
func TestRealExchangeViaDirect(t *testing.T) {
// Test realExchange directly via the exported Query function
// by using a server that will respond or fail quickly.
// We use a loopback address with a timeout to exercise code paths.
addr, stop := startTestDNSServer(t, func(w dns.ResponseWriter, r *dns.Msg) {
resp := new(dns.Msg)
resp.SetReply(r)
resp.Answer = append(resp.Answer, &dns.A{
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
A: net.ParseIP("5.6.7.8"),
})
_ = w.WriteMsg(resp)
})
defer stop()
host, portStr, _ := net.SplitHostPort(addr)
serverIP := net.ParseIP(host)
// Exercise realExchange via Query — we need a way to target the test port.
// Use a custom exchange that calls through realExchange-like logic.
cfg := DefaultQueryConfig()
cfg.Retries = 1
resp, err := QueryWithExchange(context.Background(), serverIP, "example.com", TypeA, cfg,
func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
targetAddr := fmt.Sprintf("%s:%s", host, portStr)
c := &dns.Client{Net: "udp", ReadTimeout: 3 * time.Second, WriteTimeout: 3 * time.Second}
r, _, e := c.ExchangeContext(ctx, msg, targetAddr)
return r, e
})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(resp.Answer) == 0 {
t.Fatal("expected answers")
}
}
func TestQueryFunctionDirectly(t *testing.T) {
// Exercise Query() itself (which calls realExchange) by using 127.0.0.1:53.
// The test skips if no local DNS is available.
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
server := net.ParseIP("127.0.0.1")
cfg := DefaultQueryConfig()
cfg.Retries = 1
cfg.Timeout = 2 * time.Second
_, err := Query(ctx, server, ".", TypeNS, cfg)
if err != nil {
t.Skipf("skipping (no local DNS at 127.0.0.1:53): %v", err)
}
}
func TestIterativeQueryDirectly(t *testing.T) {
// Exercise IterativeQuery() itself (which calls realExchange) by using 127.0.0.1:53.
// The test skips if no local DNS is available.
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
server := net.ParseIP("127.0.0.1")
cfg := DefaultQueryConfig()
cfg.Retries = 1
cfg.Timeout = 2 * time.Second
_, err := IterativeQuery(ctx, server, ".", TypeNS, cfg)
if err != nil {
t.Skipf("skipping (no local DNS at 127.0.0.1:53): %v", err)
}
}
func TestBasicResolverQuery(t *testing.T) {
// Exercise BasicResolver.Query() which calls Query() → realExchange.
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
br := NewBasicResolver()
server := net.ParseIP("127.0.0.1")
cfg := DefaultQueryConfig()
cfg.Retries = 1
cfg.Timeout = 2 * time.Second
_, err := br.Query(ctx, server, ".", TypeNS, cfg)
if err != nil {
t.Skipf("skipping (no local DNS at 127.0.0.1:53): %v", err)
}
}
func TestDiscoverAllRoots(t *testing.T) {
// discoverAllRoots calls queryResolver(ctx, "127.0.0.1:53", ...)
// Skip if local DNS is not available.
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
cfg := &RootDiscoveryConfig{
AllRoots: true,
IncludeAAAA: false,
}
servers, err := DiscoverRoots(ctx, cfg)
if err != nil {
t.Skipf("skipping (no local DNS available): %v", err)
}
if len(servers) == 0 {
t.Fatal("expected at least one root server from discoverAllRoots")
}
}
func TestDiscoverAllRootsWithAAAA(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
cfg := &RootDiscoveryConfig{
AllRoots: true,
IncludeAAAA: true,
}
servers, err := DiscoverRoots(ctx, cfg)
if err != nil {
t.Skipf("skipping (no local DNS available): %v", err)
}
if len(servers) == 0 {
t.Fatal("expected root servers with AAAA")
}
}
func TestResolveRootServerDirect(t *testing.T) {
// Calls resolveRootServer directly (unexported, but in same package).
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
servers, err := resolveRootServer(ctx, systemResolver(), "a.root-servers.net.", false)
if err != nil {
t.Skipf("skipping (no local DNS): %v", err)
}
if len(servers) == 0 || len(servers[0].IPv4) == 0 {
t.Fatal("expected IPv4 address for a.root-servers.net.")
}
}
func TestDiscoverSingleRootWithAAAA(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
cfg := &RootDiscoveryConfig{
AllRoots: false,
IncludeAAAA: true,
}
servers, err := DiscoverRoots(ctx, cfg)
if err != nil {
t.Skipf("skipping (no local DNS available): %v", err)
}
if len(servers) == 0 {
t.Fatal("expected at least one root server")
}
}
func TestRealExchangeTCPPath(t *testing.T) {
// Test the TCP path of realExchange via a test server
tcpAddr := ""
listener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Skipf("cannot start TCP test server: %v", err)
}
tcpAddr = listener.Addr().String()
mux := dns.NewServeMux()
mux.HandleFunc(".", func(w dns.ResponseWriter, r *dns.Msg) {
resp := new(dns.Msg)
resp.SetReply(r)
resp.Answer = append(resp.Answer, &dns.A{
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
A: net.ParseIP("9.9.9.9"),
})
_ = w.WriteMsg(resp)
})
srv := &dns.Server{
Listener: listener,
Net: "tcp",
Handler: mux,
switch network {
case "udp":
pc, err := net.ListenPacket("udp", "127.0.0.1:0")
if err != nil {
t.Skipf("cannot start test DNS server: %v", err)
}
srv.PacketConn = pc
addr = pc.LocalAddr().String()
case "tcp":
l, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Skipf("cannot start test DNS server: %v", err)
}
srv.Listener = l
addr = l.Addr().String()
}
started := make(chan struct{})
@@ -277,28 +45,89 @@ func TestRealExchangeTCPPath(t *testing.T) {
select {
case <-started:
case <-time.After(2 * time.Second):
t.Skip("TCP DNS server didn't start")
t.Skip("test DNS server did not start in time")
}
defer srv.Shutdown()
host, portStr, _ := net.SplitHostPort(tcpAddr)
serverIP := net.ParseIP(host)
t.Cleanup(func() { _ = srv.Shutdown() })
return addr
}
cfg := DefaultQueryConfig()
cfg.UseTCP = true
cfg.Retries = 1
resp, err := QueryWithExchange(context.Background(), serverIP, "example.com", TypeA, cfg,
func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
targetAddr := fmt.Sprintf("%s:%s", host, portStr)
c := &dns.Client{Net: "tcp", ReadTimeout: 3 * time.Second, WriteTimeout: 3 * time.Second}
r, _, e := c.ExchangeContext(ctx, msg, targetAddr)
return r, e
func aHandler(ip string) dns.HandlerFunc {
return func(w dns.ResponseWriter, r *dns.Msg) {
resp := new(dns.Msg)
resp.SetReply(r)
resp.Answer = append(resp.Answer, &dns.A{
Hdr: dns.RR_Header{Name: r.Question[0].Name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
A: net.ParseIP(ip),
})
_ = w.WriteMsg(resp)
}
}
func TestRealExchangeUDPHostPort(t *testing.T) {
addr := startTestDNSServer(t, "udp", aHandler("1.2.3.4"))
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
// realExchange must honour an explicit host:port (used by root discovery
// upstream resolvers).
resp, err := realExchange(ctx, addr, buildQuery("example.com.", TypeA, 2048), false)
if err != nil {
t.Fatalf("TCP query: %v", err)
t.Fatalf("realExchange: %v", err)
}
if len(resp.Answer) == 0 {
t.Fatal("expected answers")
}
}
func TestRealExchangeTCP(t *testing.T) {
addr := startTestDNSServer(t, "tcp", aHandler("9.9.9.9"))
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
resp, err := realExchange(ctx, addr, buildQuery("example.com.", TypeA, 2048), true)
if err != nil {
t.Fatalf("realExchange TCP: %v", err)
}
if len(resp.Answer) == 0 {
t.Fatal("expected answers")
}
}
func TestRealExchangeUnreachable(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
defer cancel()
_, err := realExchange(ctx, "127.0.0.1:1", buildQuery("example.com.", TypeA, 2048), false)
if err == nil {
t.Fatal("expected error for unreachable server")
}
}
func TestClientAgainstLocalServer(t *testing.T) {
var sawRD bool
addr := startTestDNSServer(t, "udp", func(w dns.ResponseWriter, r *dns.Msg) {
sawRD = r.RecursionDesired
aHandler("5.6.7.8")(w, r)
})
// Route the client's exchange to the test server's port while still
// exercising realExchange.
c := NewClient(&QueryConfig{Retries: 1, Timeout: 2 * time.Second},
func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
return realExchange(ctx, addr, msg, useTCP)
})
resp, _, err := c.Query(context.Background(), net.ParseIP("127.0.0.1"), "example.com", TypeA)
if err != nil {
t.Fatalf("Client.Query: %v", err)
}
if len(resp.Answer) == 0 {
t.Fatal("expected answers")
}
if sawRD {
t.Error("wire query must have RD=0")
}
}
-198
View File
@@ -1,198 +0,0 @@
package dns
import (
"context"
"fmt"
"net"
"sync"
"time"
"github.com/miekg/dns"
)
type Resolver interface {
Query(ctx context.Context, server net.IP, name string, qtype uint16, cfg *QueryConfig) (*dns.Msg, error)
}
type BasicResolver struct{}
func NewBasicResolver() *BasicResolver {
return &BasicResolver{}
}
func (br *BasicResolver) Query(ctx context.Context, server net.IP, name string, qtype uint16, cfg *QueryConfig) (*dns.Msg, error) {
return Query(ctx, server, name, qtype, cfg)
}
type cacheKey struct {
server string
name string
qtype uint16
qclass uint16
}
type cacheEntry struct {
msg *dns.Msg
expireAt time.Time
}
func (e *cacheEntry) expired() bool {
return time.Now().After(e.expireAt)
}
type CachingResolver struct {
inner Resolver
mu sync.RWMutex
cache map[cacheKey]*cacheEntry
defaultTTL time.Duration
}
func NewCachingResolver(inner Resolver, opts ...CachingResolverOption) *CachingResolver {
if inner == nil {
inner = NewBasicResolver()
}
cfg := &cachingResolverConfig{
defaultTTL: 5 * time.Second,
}
for _, opt := range opts {
opt(cfg)
}
return &CachingResolver{
inner: inner,
cache: make(map[cacheKey]*cacheEntry),
defaultTTL: cfg.defaultTTL,
}
}
func (cr *CachingResolver) Query(ctx context.Context, server net.IP, name string, qtype uint16, cfg *QueryConfig) (*dns.Msg, error) {
if cfg == nil {
cfg = DefaultQueryConfig()
}
fqdn := dns.Fqdn(name)
key := cacheKey{
server: server.String(),
name: fqdn,
qtype: qtype,
qclass: dns.ClassINET,
}
if resp, ok := cr.lookup(key); ok {
return resp, nil
}
resp, err := cr.inner.Query(ctx, server, name, qtype, cfg)
if err != nil {
return nil, fmt.Errorf("caching resolver query: %w", err)
}
cr.store(key, resp)
return resp, nil
}
func (cr *CachingResolver) lookup(key cacheKey) (*dns.Msg, bool) {
cr.mu.RLock()
entry, ok := cr.cache[key]
cr.mu.RUnlock()
if !ok {
return nil, false
}
if entry.expired() {
return nil, false
}
return entry.msg.Copy(), true
}
func (cr *CachingResolver) store(key cacheKey, msg *dns.Msg) {
ttl := minTTLFromMsg(msg)
if ttl <= 0 {
ttl = cr.defaultTTL
}
cr.mu.Lock()
cr.cache[key] = &cacheEntry{
msg: msg.Copy(),
expireAt: time.Now().Add(ttl),
}
cr.mu.Unlock()
}
func (cr *CachingResolver) Len() int {
cr.mu.RLock()
n := len(cr.cache)
cr.mu.RUnlock()
return n
}
func (cr *CachingResolver) Clear() {
cr.mu.Lock()
cr.cache = make(map[cacheKey]*cacheEntry)
cr.mu.Unlock()
}
func (cr *CachingResolver) PurgeExpired() int {
cr.mu.Lock()
count := 0
for k, e := range cr.cache {
if e.expired() {
delete(cr.cache, k)
count++
}
}
cr.mu.Unlock()
return count
}
type CachingResolverOption func(*cachingResolverConfig)
type cachingResolverConfig struct {
defaultTTL time.Duration
}
func WithDefaultTTL(d time.Duration) CachingResolverOption {
return func(c *cachingResolverConfig) {
c.defaultTTL = d
}
}
func minTTLFromMsg(msg *dns.Msg) time.Duration {
if msg == nil {
return 0
}
var min uint32
found := false
for _, rr := range msg.Answer {
ttl := rr.Header().Ttl
if !found || ttl < min {
min = ttl
found = true
}
}
for _, rr := range msg.Ns {
ttl := rr.Header().Ttl
if !found || ttl < min {
min = ttl
found = true
}
}
for _, rr := range msg.Extra {
if _, ok := rr.(*dns.OPT); ok {
continue
}
ttl := rr.Header().Ttl
if !found || ttl < min {
min = ttl
found = true
}
}
if !found {
return 0
}
return time.Duration(min) * time.Second
}
-476
View File
@@ -1,476 +0,0 @@
package dns
import (
"context"
"errors"
"net"
"sync"
"testing"
"time"
"github.com/miekg/dns"
)
type mockResolver struct {
mu sync.Mutex
calls int
response *dns.Msg
err error
}
func (m *mockResolver) Query(ctx context.Context, server net.IP, name string, qtype uint16, cfg *QueryConfig) (*dns.Msg, error) {
m.mu.Lock()
defer m.mu.Unlock()
m.calls++
if m.err != nil {
return nil, m.err
}
if m.response != nil {
return m.response.Copy(), nil
}
return nil, errors.New("no response configured")
}
func (m *mockResolver) callCount() int {
m.mu.Lock()
defer m.mu.Unlock()
return m.calls
}
func makeResponse(name string, qtype uint16, ttl uint32) *dns.Msg {
resp := new(dns.Msg)
resp.SetReply(new(dns.Msg))
switch qtype {
case dns.TypeA:
resp.Answer = append(resp.Answer, &dns.A{
Hdr: dns.RR_Header{Name: dns.Fqdn(name), Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: ttl},
A: net.ParseIP("93.184.216.34"),
})
case dns.TypeNS:
resp.Answer = append(resp.Answer, &dns.NS{
Hdr: dns.RR_Header{Name: dns.Fqdn(name), Rrtype: dns.TypeNS, Class: dns.ClassINET, Ttl: ttl},
Ns: "ns1.example.com.",
})
}
return resp
}
func TestNewCachingResolver_NilInner(t *testing.T) {
cr := NewCachingResolver(nil)
if cr == nil {
t.Fatal("NewCachingResolver(nil) returned nil")
}
if cr.inner == nil {
t.Fatal("expected inner resolver to be set when nil passed")
}
}
func TestCachingResolver_CacheHit(t *testing.T) {
mock := &mockResolver{
response: makeResponse("example.com", dns.TypeA, 300),
}
cr := NewCachingResolver(mock)
server := net.ParseIP("8.8.8.8")
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, Timeout: 5 * time.Second}
resp1, err := cr.Query(context.Background(), server, "example.com", TypeA, cfg)
if err != nil {
t.Fatalf("first query: %v", err)
}
if mock.callCount() != 1 {
t.Fatalf("expected 1 call after first query, got %d", mock.callCount())
}
resp2, err := cr.Query(context.Background(), server, "example.com", TypeA, cfg)
if err != nil {
t.Fatalf("second query: %v", err)
}
if mock.callCount() != 1 {
t.Fatalf("expected still 1 call after second query (cache hit), got %d", mock.callCount())
}
if len(resp1.Answer) != len(resp2.Answer) {
t.Errorf("cached response has different number of answers")
}
}
func TestCachingResolver_CacheMissDifferentServer(t *testing.T) {
mock := &mockResolver{
response: makeResponse("example.com", dns.TypeA, 300),
}
cr := NewCachingResolver(mock)
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, Timeout: 5 * time.Second}
_, _ = cr.Query(context.Background(), net.ParseIP("8.8.8.8"), "example.com", TypeA, cfg)
if mock.callCount() != 1 {
t.Fatalf("expected 1 call, got %d", mock.callCount())
}
_, _ = cr.Query(context.Background(), net.ParseIP("1.1.1.1"), "example.com", TypeA, cfg)
if mock.callCount() != 2 {
t.Fatalf("expected 2 calls for different server, got %d", mock.callCount())
}
}
func TestCachingResolver_CacheMissDifferentName(t *testing.T) {
mock := &mockResolver{
response: makeResponse("example.com", dns.TypeA, 300),
}
cr := NewCachingResolver(mock)
server := net.ParseIP("8.8.8.8")
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, Timeout: 5 * time.Second}
_, _ = cr.Query(context.Background(), server, "example.com", TypeA, cfg)
if mock.callCount() != 1 {
t.Fatalf("expected 1 call, got %d", mock.callCount())
}
_, _ = cr.Query(context.Background(), server, "different.com", TypeA, cfg)
if mock.callCount() != 2 {
t.Fatalf("expected 2 calls for different name, got %d", mock.callCount())
}
}
func TestCachingResolver_CacheMissDifferentType(t *testing.T) {
mock := &mockResolver{
response: makeResponse("example.com", dns.TypeA, 300),
}
cr := NewCachingResolver(mock)
server := net.ParseIP("8.8.8.8")
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, Timeout: 5 * time.Second}
_, _ = cr.Query(context.Background(), server, "example.com", TypeA, cfg)
if mock.callCount() != 1 {
t.Fatalf("expected 1 call, got %d", mock.callCount())
}
_, _ = cr.Query(context.Background(), server, "example.com", TypeNS, cfg)
if mock.callCount() != 2 {
t.Fatalf("expected 2 calls for different qtype, got %d", mock.callCount())
}
}
func TestCachingResolver_ErrorNotCached(t *testing.T) {
mock := &mockResolver{
err: errors.New("connection refused"),
}
cr := NewCachingResolver(mock)
server := net.ParseIP("8.8.8.8")
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, Timeout: 5 * time.Second}
_, err := cr.Query(context.Background(), server, "example.com", TypeA, cfg)
if err == nil {
t.Fatal("expected error from mock")
}
mock.err = nil
mock.response = makeResponse("example.com", dns.TypeA, 300)
_, err = cr.Query(context.Background(), server, "example.com", TypeA, cfg)
if err != nil {
t.Fatalf("second query after mock fixed: %v", err)
}
if mock.callCount() != 2 {
t.Fatalf("expected 2 calls (error not cached), got %d", mock.callCount())
}
}
func TestCachingResolver_TTLExpiry(t *testing.T) {
mock := &mockResolver{
response: makeResponse("example.com", dns.TypeA, 1),
}
cr := NewCachingResolver(mock, WithDefaultTTL(1*time.Second))
server := net.ParseIP("8.8.8.8")
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, Timeout: 5 * time.Second}
_, err := cr.Query(context.Background(), server, "example.com", TypeA, cfg)
if err != nil {
t.Fatalf("first query: %v", err)
}
if mock.callCount() != 1 {
t.Fatalf("expected 1 call, got %d", mock.callCount())
}
time.Sleep(2 * time.Second)
_, err = cr.Query(context.Background(), server, "example.com", TypeA, cfg)
if err != nil {
t.Fatalf("query after TTL expiry: %v", err)
}
if mock.callCount() != 2 {
t.Fatalf("expected 2 calls after TTL expiry, got %d", mock.callCount())
}
}
func TestCachingResolver_DefaultTTL(t *testing.T) {
resp := new(dns.Msg)
resp.SetReply(new(dns.Msg))
mock := &mockResolver{response: resp}
cr := NewCachingResolver(mock, WithDefaultTTL(100*time.Millisecond))
server := net.ParseIP("8.8.8.8")
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, Timeout: 5 * time.Second}
_, err := cr.Query(context.Background(), server, "nodata.com", TypeA, cfg)
if err != nil {
t.Fatalf("first query: %v", err)
}
time.Sleep(150 * time.Millisecond)
_, err = cr.Query(context.Background(), server, "nodata.com", TypeA, cfg)
if err != nil {
t.Fatalf("query after default TTL expiry: %v", err)
}
if mock.callCount() != 2 {
t.Fatalf("expected 2 calls after default TTL, got %d", mock.callCount())
}
}
func TestCachingResolver_NilConfig(t *testing.T) {
mock := &mockResolver{
response: makeResponse("example.com", dns.TypeA, 300),
}
cr := NewCachingResolver(mock)
server := net.ParseIP("8.8.8.8")
_, err := cr.Query(context.Background(), server, "example.com", TypeA, nil)
if err != nil {
t.Fatalf("nil config: %v", err)
}
}
func TestCachingResolver_Len(t *testing.T) {
mock := &mockResolver{
response: makeResponse("example.com", dns.TypeA, 300),
}
cr := NewCachingResolver(mock)
if cr.Len() != 0 {
t.Fatalf("expected empty cache, got %d", cr.Len())
}
server := net.ParseIP("8.8.8.8")
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, Timeout: 5 * time.Second}
_, _ = cr.Query(context.Background(), server, "example.com", TypeA, cfg)
if cr.Len() != 1 {
t.Fatalf("expected cache len 1, got %d", cr.Len())
}
_, _ = cr.Query(context.Background(), server, "other.com", TypeA, cfg)
if cr.Len() != 2 {
t.Fatalf("expected cache len 2, got %d", cr.Len())
}
}
func TestCachingResolver_Clear(t *testing.T) {
mock := &mockResolver{
response: makeResponse("example.com", dns.TypeA, 300),
}
cr := NewCachingResolver(mock)
server := net.ParseIP("8.8.8.8")
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, Timeout: 5 * time.Second}
_, _ = cr.Query(context.Background(), server, "example.com", TypeA, cfg)
_, _ = cr.Query(context.Background(), server, "other.com", TypeA, cfg)
if cr.Len() != 2 {
t.Fatalf("expected cache len 2, got %d", cr.Len())
}
cr.Clear()
if cr.Len() != 0 {
t.Fatalf("expected cache len 0 after clear, got %d", cr.Len())
}
_, err := cr.Query(context.Background(), server, "example.com", TypeA, cfg)
if err != nil {
t.Fatalf("query after clear: %v", err)
}
if mock.callCount() != 3 {
t.Fatalf("expected 3 calls (2 before clear + 1 after clear), got %d", mock.callCount())
}
}
func TestCachingResolver_PurgeExpired(t *testing.T) {
resp := makeResponse("example.com", dns.TypeA, 0)
for _, rr := range resp.Answer {
rr.Header().Ttl = 0
}
mock := &mockResolver{response: resp}
cr := NewCachingResolver(mock, WithDefaultTTL(50*time.Millisecond))
server := net.ParseIP("8.8.8.8")
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, Timeout: 5 * time.Second}
_, _ = cr.Query(context.Background(), server, "example.com", TypeA, cfg)
if cr.Len() != 1 {
t.Fatalf("expected cache len 1, got %d", cr.Len())
}
time.Sleep(100 * time.Millisecond)
purged := cr.PurgeExpired()
if purged != 1 {
t.Fatalf("expected 1 purged entry, got %d", purged)
}
if cr.Len() != 0 {
t.Fatalf("expected cache len 0 after purge, got %d", cr.Len())
}
}
func TestCachingResolver_PurgeExpiredNoneExpired(t *testing.T) {
mock := &mockResolver{
response: makeResponse("example.com", dns.TypeA, 300),
}
cr := NewCachingResolver(mock)
server := net.ParseIP("8.8.8.8")
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, Timeout: 5 * time.Second}
_, _ = cr.Query(context.Background(), server, "example.com", TypeA, cfg)
purged := cr.PurgeExpired()
if purged != 0 {
t.Fatalf("expected 0 purged entries, got %d", purged)
}
if cr.Len() != 1 {
t.Fatalf("expected cache len 1, got %d", cr.Len())
}
}
func TestCachingResolver_ResponseCopy(t *testing.T) {
mock := &mockResolver{
response: makeResponse("example.com", dns.TypeA, 300),
}
cr := NewCachingResolver(mock)
server := net.ParseIP("8.8.8.8")
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, Timeout: 5 * time.Second}
resp1, _ := cr.Query(context.Background(), server, "example.com", TypeA, cfg)
resp2, _ := cr.Query(context.Background(), server, "example.com", TypeA, cfg)
if resp1 == resp2 {
t.Fatal("cache should return a copy, not the same pointer")
}
}
func TestCachingResolver_MinTTLFromMsg(t *testing.T) {
tests := []struct {
name string
msg *dns.Msg
expected time.Duration
}{
{
name: "nil message",
msg: nil,
expected: 0,
},
{
name: "empty response",
msg: new(dns.Msg),
expected: 0,
},
{
name: "single answer with low TTL",
msg: func() *dns.Msg {
m := new(dns.Msg)
m.Answer = append(m.Answer, &dns.A{
Hdr: dns.RR_Header{Ttl: 60},
})
return m
}(),
expected: 60 * time.Second,
},
{
name: "multiple records with varying TTLs",
msg: func() *dns.Msg {
m := new(dns.Msg)
m.Answer = append(m.Answer, &dns.A{
Hdr: dns.RR_Header{Ttl: 300},
})
m.Ns = append(m.Ns, &dns.NS{
Hdr: dns.RR_Header{Ttl: 120},
})
return m
}(),
expected: 120 * time.Second,
},
{
name: "OPT record excluded from TTL calculation",
msg: func() *dns.Msg {
m := new(dns.Msg)
m.Answer = append(m.Answer, &dns.A{
Hdr: dns.RR_Header{Ttl: 300},
})
m.Extra = append(m.Extra, &dns.OPT{
Hdr: dns.RR_Header{Ttl: 0},
})
return m
}(),
expected: 300 * time.Second,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := minTTLFromMsg(tt.msg)
if got != tt.expected {
t.Errorf("minTTLFromMsg() = %v, want %v", got, tt.expected)
}
})
}
}
func TestCachingResolver_ConcurrentAccess(t *testing.T) {
mock := &mockResolver{
response: makeResponse("example.com", dns.TypeA, 300),
}
cr := NewCachingResolver(mock)
server := net.ParseIP("8.8.8.8")
cfg := &QueryConfig{UDPSize: 2048, Retries: 1, Timeout: 5 * time.Second}
var wg sync.WaitGroup
for i := 0; i < 100; i++ {
wg.Add(1)
go func() {
defer wg.Done()
_, err := cr.Query(context.Background(), server, "example.com", TypeA, cfg)
if err != nil {
t.Errorf("concurrent query failed: %v", err)
}
}()
}
wg.Wait()
if mock.callCount() < 1 {
t.Fatalf("expected at least 1 call to mock, got %d", mock.callCount())
}
}
func TestBasicResolver(t *testing.T) {
br := NewBasicResolver()
if br == nil {
t.Fatal("NewBasicResolver returned nil")
}
if _, ok := interface{}(br).(Resolver); !ok {
t.Fatal("BasicResolver does not implement Resolver interface")
}
}
// TestBasicResolverQueryIntegration calls Query via the BasicResolver against
// the local system resolver. Skipped when no local resolver is reachable.
func TestBasicResolverQueryIntegration(t *testing.T) {
r := NewBasicResolver()
server := net.ParseIP("127.0.0.1")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
// Cover BasicResolver.Query; skip if 127.0.0.1:53 is not available.
msg, err := r.Query(ctx, server, ".", TypeNS, nil)
if err != nil {
t.Logf("skipping (local resolver unavailable): %v", err)
t.Skip()
}
if msg == nil {
t.Fatal("expected non-nil response from BasicResolver.Query")
}
}
+16 -18
View File
@@ -115,25 +115,23 @@ func TestSynthesizeCNAMEFromDNAME(t *testing.T) {
}
}
func TestBackoffDelay(t *testing.T) {
tests := []struct {
attempt int
want time.Duration
}{
{0, 0},
{1, 100 * time.Millisecond},
{2, 200 * time.Millisecond},
{3, 400 * time.Millisecond},
{4, 800 * time.Millisecond},
{5, 1600 * time.Millisecond},
{6, 2000 * time.Millisecond}, // capped at 2s
{10, 2000 * time.Millisecond}, // still capped
func TestQueryConfigWithDefaults(t *testing.T) {
got := (&QueryConfig{}).withDefaults()
if got.UDPSize != DefaultEDNS0UDPSize() {
t.Errorf("UDPSize = %d, want %d", got.UDPSize, DefaultEDNS0UDPSize())
}
if got.Timeout != 2*time.Second {
t.Errorf("Timeout = %v, want 2s", got.Timeout)
}
if got.Retries != 1 {
t.Errorf("Retries = %d, want clamp to 1", got.Retries)
}
if got.RetryDelay != 2*time.Second {
t.Errorf("RetryDelay = %v, want 2s", got.RetryDelay)
}
for _, tt := range tests {
got := backoffDelay(tt.attempt)
if got != tt.want {
t.Errorf("backoffDelay(%d) = %v, want %v", tt.attempt, got, tt.want)
}
var nilCfg *QueryConfig
if nilCfg.withDefaults().Retries != DefaultQueryConfig().Retries {
t.Error("nil config should yield defaults")
}
}
+178 -94
View File
@@ -2,10 +2,10 @@ package dns
import (
"context"
"errors"
"fmt"
"net"
"strings"
"time"
"github.com/miekg/dns"
)
@@ -26,15 +26,22 @@ func (rs *RootServer) AllIPs(includeAAAA bool) []net.IP {
}
type RootDiscoveryConfig struct {
// Server overrides which root server to use as the traversal starting point.
// When empty, a root server is discovered via the upstream resolver.
// Server overrides which root server to use as the traversal starting
// point. It accepts a hostname (resolved to A via the upstream resolver)
// or an IP literal (used directly, no lookup).
Server string
// Resolver is the upstream DNS resolver used to resolve root server names.
// When empty, the system resolver from /etc/resolv.conf is used.
// Format: "host:port" (e.g. "8.8.8.8:53" or "1.1.1.1:53").
// Resolver is the upstream DNS resolver used to discover and resolve
// root server names. When empty, the system resolver configuration is
// used. Format: "host:port" (e.g. "8.8.8.8:53" or "1.1.1.1:53").
Resolver string
AllRoots bool
IncludeAAAA bool
// Query controls transport parameters (retries, timeout, TCP fallback)
// for discovery queries. nil means DefaultQueryConfig.
Query *QueryConfig
// Exchange overrides the wire exchange; nil means the real network.
// Tests inject a mock here so discovery is network-free.
Exchange ExchangeFunc
}
func DefaultRootDiscoveryConfig() *RootDiscoveryConfig {
@@ -49,31 +56,59 @@ func DiscoverRoots(ctx context.Context, cfg *RootDiscoveryConfig) ([]RootServer,
cfg = DefaultRootDiscoveryConfig()
}
resolver := resolverFromConfig(cfg)
// --root-server with an IP literal: use it directly, never look it up.
if cfg.Server != "" {
if ip := net.ParseIP(cfg.Server); ip != nil {
rs := RootServer{Name: cfg.Server}
if ip.To4() != nil {
rs.IPv4 = []net.IP{ip}
} else {
rs.IPv6 = []net.IP{ip}
}
return []RootServer{rs}, nil
}
}
resolver, err := resolverFromConfig(cfg)
if err != nil {
if cfg.Server != "" {
return nil, err
}
return rootHintsFallback(cfg, err)
}
if cfg.Server != "" {
return discoverRootOverride(ctx, resolver, cfg.Server, cfg.IncludeAAAA)
return resolveRootServer(ctx, cfg, resolver, cfg.Server)
}
if cfg.AllRoots {
servers, err := discoverAllRoots(ctx, resolver, cfg.IncludeAAAA)
servers, err := discoverAllRoots(ctx, cfg, resolver)
if err != nil {
return filterHints(RootHints, cfg.IncludeAAAA), nil
return rootHintsFallback(cfg, err)
}
return servers, nil
}
servers, err := discoverSingleRoot(ctx, resolver, cfg.IncludeAAAA)
servers, err := discoverSingleRoot(ctx, cfg, resolver)
if err != nil {
hints := filterHints(RootHints, cfg.IncludeAAAA)
if len(hints) > 0 {
return hints[:1], nil
}
return nil, err
return rootHintsFallback(cfg, err)
}
return servers, nil
}
// rootHintsFallback returns the builtin IANA hints when the upstream resolver
// cannot provide roots (one entry unless AllRoots).
func rootHintsFallback(cfg *RootDiscoveryConfig, err error) ([]RootServer, error) {
hints := filterHints(RootHints, cfg.IncludeAAAA)
if len(hints) == 0 {
return nil, err
}
if cfg.AllRoots {
return hints, nil
}
return hints[:1], nil
}
// filterHints returns a copy of hints with IPv6 addresses stripped when includeAAAA is false.
func filterHints(hints []RootServer, includeAAAA bool) []RootServer {
out := make([]RootServer, len(hints))
@@ -86,88 +121,114 @@ func filterHints(hints []RootServer, includeAAAA bool) []RootServer {
return out
}
func discoverRootOverride(ctx context.Context, resolver, server string, includeAAAA bool) ([]RootServer, error) {
nsMsg, err := queryResolver(ctx, resolver, ".", dns.TypeNS)
// discoverSingleRoot mirrors get_a_root in traverser.rb: ask the upstream
// resolver for the root NS set, prefer glue from the additional section, and
// only fall back to explicit A/AAAA lookups when no glue was supplied.
func discoverSingleRoot(ctx context.Context, cfg *RootDiscoveryConfig, resolver string) ([]RootServer, error) {
names, nsMsg, err := rootNSNames(ctx, cfg, resolver)
if err != nil {
return nil, fmt.Errorf("query root NS records: %w", err)
return nil, err
}
nsSet := extractNSRecords(nsMsg.Answer)
if len(nsSet) == 0 {
nsSet = extractNSNames(nsMsg.Ns)
}
normalized := normalizeServerName(server)
for _, name := range nsSet {
if normalizeServerName(name) == normalized {
return resolveRootServer(ctx, resolver, name, includeAAAA)
for _, name := range names {
rs := rootFromAdditional(nsMsg, name, cfg.IncludeAAAA)
if len(rs.AllIPs(cfg.IncludeAAAA)) > 0 {
return []RootServer{singleAddress(rs)}, nil
}
}
return resolveRootServer(ctx, resolver, server, includeAAAA)
var lastErr error
for _, name := range names {
servers, err := resolveRootServer(ctx, cfg, resolver, name)
if err != nil {
lastErr = err
continue
}
return []RootServer{singleAddress(servers[0])}, nil
}
if lastErr == nil {
lastErr = errors.New("no address could be found for any root server")
}
return nil, lastErr
}
func discoverSingleRoot(ctx context.Context, resolver string, includeAAAA bool) ([]RootServer, error) {
nsMsg, err := queryResolver(ctx, resolver, ".", dns.TypeNS)
if err != nil {
return nil, fmt.Errorf("query root NS records: %w", err)
// singleAddress narrows rs to its first address, mirroring get_a_root in
// traverser.rb (add[0]/ans2[0]): the single-root start point is exactly one
// (name, IP) pair even when the upstream supplies more (or duplicate) glue.
func singleAddress(rs RootServer) RootServer {
if len(rs.IPv4) > 0 {
return RootServer{Name: rs.Name, IPv4: rs.IPv4[:1]}
}
nsSet := extractNSRecords(nsMsg.Answer)
if len(nsSet) == 0 {
nsSet = extractNSNames(nsMsg.Ns)
if len(rs.IPv6) > 0 {
return RootServer{Name: rs.Name, IPv6: rs.IPv6[:1]}
}
if len(nsSet) == 0 {
return nil, fmt.Errorf("no root NS records found in response")
}
pick := nsSet[0]
return resolveRootServer(ctx, resolver, pick, includeAAAA)
return rs
}
func discoverAllRoots(ctx context.Context, resolver string, includeAAAA bool) ([]RootServer, error) {
nsMsg, err := queryResolver(ctx, resolver, ".", dns.TypeNS)
// discoverAllRoots mirrors find_all_roots in traverser.rb: it returns one
// RootServer per root NS name with its full address set, so the traversal can
// branch per root. Roots with no resolvable address are skipped.
func discoverAllRoots(ctx context.Context, cfg *RootDiscoveryConfig, resolver string) ([]RootServer, error) {
names, nsMsg, err := rootNSNames(ctx, cfg, resolver)
if err != nil {
return nil, fmt.Errorf("query root NS records: %w", err)
}
nsSet := extractNSRecords(nsMsg.Answer)
if len(nsSet) == 0 {
nsSet = extractNSNames(nsMsg.Ns)
}
if len(nsSet) == 0 {
return nil, fmt.Errorf("no root NS records found in response")
return nil, err
}
var servers []RootServer
for _, name := range nsSet {
resolved, err := resolveRootServer(ctx, resolver, name, includeAAAA)
if err != nil {
servers = append(servers, RootServer{Name: name})
continue
for _, name := range names {
rs := rootFromAdditional(nsMsg, name, cfg.IncludeAAAA)
if len(rs.AllIPs(cfg.IncludeAAAA)) == 0 {
resolved, err := resolveRootServer(ctx, cfg, resolver, name)
if err != nil {
continue
}
rs = resolved[0]
}
servers = append(servers, resolved...)
servers = append(servers, rs)
}
if len(servers) == 0 {
return nil, fmt.Errorf("failed to resolve any root servers")
return nil, errors.New("failed to resolve any root servers")
}
return servers, nil
}
func resolveRootServer(ctx context.Context, resolver, name string, includeAAAA bool) ([]RootServer, error) {
func rootNSNames(ctx context.Context, cfg *RootDiscoveryConfig, resolver string) ([]string, *dns.Msg, error) {
nsMsg, err := queryUpstream(ctx, cfg, resolver, ".", dns.TypeNS)
if err != nil {
return nil, nil, fmt.Errorf("query root NS records: %w", err)
}
names := extractNSRecords(nsMsg.Answer)
if len(names) == 0 {
names = extractNSNames(nsMsg.Ns)
}
if len(names) == 0 {
return nil, nil, errors.New("no root NS records found in response")
}
return names, nsMsg, nil
}
func rootFromAdditional(msg *dns.Msg, name string, includeAAAA bool) RootServer {
rs := RootServer{Name: name, IPv4: additionalIPs(msg, name, dns.TypeA)}
if includeAAAA {
rs.IPv6 = additionalIPs(msg, name, dns.TypeAAAA)
}
return rs
}
func resolveRootServer(ctx context.Context, cfg *RootDiscoveryConfig, resolver, name string) ([]RootServer, error) {
var ipv4 []net.IP
aMsg, err := queryResolver(ctx, resolver, name, dns.TypeA)
aMsg, err := queryUpstream(ctx, cfg, resolver, name, dns.TypeA)
if err == nil {
ipv4 = extractIPsFromAnswer(aMsg.Answer, dns.TypeA)
}
var ipv6 []net.IP
if includeAAAA {
aaaaMsg, err := queryResolver(ctx, resolver, name, dns.TypeAAAA)
if cfg.IncludeAAAA {
aaaaMsg, err := queryUpstream(ctx, cfg, resolver, name, dns.TypeAAAA)
if err == nil {
ipv6 = extractIPsFromAnswer(aaaaMsg.Answer, dns.TypeAAAA)
}
@@ -180,47 +241,53 @@ func resolveRootServer(ctx context.Context, resolver, name string, includeAAAA b
return []RootServer{{Name: name, IPv4: ipv4, IPv6: ipv6}}, nil
}
// resolverFromConfig returns the upstream DNS resolver address to use.
// If cfg.Resolver is set, it is used directly. Otherwise the system resolver
// is read from /etc/resolv.conf. Falls back to 127.0.0.1:53 if neither is available.
func resolverFromConfig(cfg *RootDiscoveryConfig) string {
// resolverFromConfig returns the upstream DNS resolver address to use:
// cfg.Resolver when set, otherwise the system resolver configuration. There
// is deliberately no hardcoded address fallback.
func resolverFromConfig(cfg *RootDiscoveryConfig) (string, error) {
if cfg != nil && cfg.Resolver != "" {
return cfg.Resolver
return cfg.Resolver, nil
}
return systemResolver()
}
// systemResolver returns the first nameserver from the system DNS configuration.
// This is Unix-only: it reads /etc/resolv.conf, which does not exist on Windows.
// On Windows (or any system without /etc/resolv.conf) the fallback 127.0.0.1:53 applies.
func systemResolver() string {
// systemResolver returns the first nameserver from the system DNS
// configuration. This is Unix-only: it reads /etc/resolv.conf, which does not
// exist on Windows; there the caller falls back to the builtin root hints.
func systemResolver() (string, error) {
cc, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil || len(cc.Servers) == 0 {
return "127.0.0.1:53"
if err != nil {
return "", fmt.Errorf("read system resolver config: %w", err)
}
return net.JoinHostPort(cc.Servers[0], cc.Port)
if len(cc.Servers) == 0 {
return "", errors.New("no nameservers found in system resolver config")
}
return net.JoinHostPort(cc.Servers[0], cc.Port), nil
}
func queryResolver(ctx context.Context, resolverAddr, name string, qtype uint16) (*dns.Msg, error) {
c := &dns.Client{
Net: "udp",
ReadTimeout: 5 * time.Second,
WriteTimeout: 5 * time.Second,
// queryUpstream asks the upstream resolver with recursion desired — the only
// RD=1 path in the program — using the same retry/TCP-fallback machinery as
// traversal queries.
func queryUpstream(ctx context.Context, cfg *RootDiscoveryConfig, resolverAddr, name string, qtype uint16) (*dns.Msg, error) {
var qcfg *QueryConfig
var exchange ExchangeFunc
if cfg != nil {
qcfg = cfg.Query
exchange = cfg.Exchange
}
if deadline, ok := ctx.Deadline(); ok {
c.ReadTimeout = time.Until(deadline)
c.WriteTimeout = time.Until(deadline)
qcfg = qcfg.withDefaults()
if exchange == nil {
exchange = realExchange
}
m := new(dns.Msg)
m.SetQuestion(dns.Fqdn(name), qtype)
m.RecursionDesired = true
r, _, err := c.ExchangeContext(ctx, m, resolverAddr)
if err != nil {
return nil, fmt.Errorf("resolver exchange %s %s: %w", name, QNameType(qtype), err)
if qcfg.UDPSize > MinEDNS0UDPSize() {
m.SetEdns0(uint16(qcfg.UDPSize), false)
}
return r, nil
return exchangeWithRetry(ctx, exchange, resolverAddr, m, qcfg)
}
func extractNSRecords(rrs []dns.RR) []string {
@@ -259,6 +326,23 @@ func extractIPsFromAnswer(rrs []dns.RR, qtype uint16) []net.IP {
return ips
}
func normalizeServerName(name string) string {
return strings.TrimSuffix(strings.ToLower(name), ".")
// additionalIPs returns glue addresses for name from the additional section.
func additionalIPs(msg *dns.Msg, name string, qtype uint16) []net.IP {
var ips []net.IP
for _, rr := range msg.Extra {
if !strings.EqualFold(rr.Header().Name, name) {
continue
}
switch v := rr.(type) {
case *dns.A:
if qtype == dns.TypeA {
ips = append(ips, v.A)
}
case *dns.AAAA:
if qtype == dns.TypeAAAA {
ips = append(ips, v.AAAA)
}
}
}
return ips
}
+335 -349
View File
@@ -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)
}
}
+3 -26
View File
@@ -5,35 +5,12 @@ import (
)
const (
TypeA uint16 = dns.TypeA
TypeAAAA uint16 = dns.TypeAAAA
TypeNS uint16 = dns.TypeNS
TypeCNAME uint16 = dns.TypeCNAME
TypeSOA uint16 = dns.TypeSOA
TypeMX uint16 = dns.TypeMX
TypeTXT uint16 = dns.TypeTXT
TypeSRV uint16 = dns.TypeSRV
TypePTR uint16 = dns.TypePTR
TypeANY uint16 = dns.TypeANY
TypeA uint16 = dns.TypeA
TypeAAAA uint16 = dns.TypeAAAA
TypeNS uint16 = dns.TypeNS
)
var QNameTypes = map[uint16]string{
TypeA: "A",
TypeAAAA: "AAAA",
TypeNS: "NS",
TypeCNAME: "CNAME",
TypeSOA: "SOA",
TypeMX: "MX",
TypeTXT: "TXT",
TypeSRV: "SRV",
TypePTR: "PTR",
TypeANY: "ANY",
}
func QNameType(qtype uint16) string {
if name, ok := QNameTypes[qtype]; ok {
return name
}
return dns.TypeToString[qtype]
}
-37
View File
@@ -13,13 +13,6 @@ func TestQNameType(t *testing.T) {
{"A record", TypeA, "A"},
{"AAAA record", TypeAAAA, "AAAA"},
{"NS record", TypeNS, "NS"},
{"CNAME record", TypeCNAME, "CNAME"},
{"SOA record", TypeSOA, "SOA"},
{"MX record", TypeMX, "MX"},
{"TXT record", TypeTXT, "TXT"},
{"SRV record", TypeSRV, "SRV"},
{"PTR record", TypePTR, "PTR"},
{"ANY record", TypeANY, "ANY"},
{"unknown type", uint16(9999), ""},
}
@@ -33,36 +26,6 @@ func TestQNameType(t *testing.T) {
}
}
func TestConstantsMatchMiekg(t *testing.T) {
tests := []struct {
name string
local uint16
}{
{"TypeA", TypeA},
{"TypeAAAA", TypeAAAA},
{"TypeNS", TypeNS},
{"TypeCNAME", TypeCNAME},
{"TypeSOA", TypeSOA},
{"TypeMX", TypeMX},
{"TypeTXT", TypeTXT},
{"TypeSRV", TypeSRV},
{"TypePTR", TypePTR},
{"TypeANY", TypeANY},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
mapped, ok := QNameTypes[tt.local]
if !ok {
t.Errorf("QNameTypes missing entry for %s (%d)", tt.name, tt.local)
}
if mapped != QNameType(tt.local) {
t.Errorf("QNameType(%d) = %q, QNameTypes[%d] = %q", tt.local, QNameType(tt.local), tt.local, mapped)
}
})
}
}
func TestDefaultEDNS0UDPSize(t *testing.T) {
if got := DefaultEDNS0UDPSize(); got != 2048 {
t.Errorf("DefaultEDNS0UDPSize() = %d, want 2048", got)