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:
co-authored by
Claude Fable 5
parent
af15c9c2d4
commit
d71c7fbef2
@@ -1 +0,0 @@
|
||||
package dns
|
||||
+15
-34
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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
@@ -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
@@ -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")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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
@@ -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
@@ -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]
|
||||
}
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
Reference in New Issue
Block a user