dns

type Cache ¶

type Cache struct {
	// contains filtered or unexported fields
}

Cache is a DNS middleware that caches successful responses and forwards misses to an attachable upstream. Detach cancels requests that are currently waiting on the old upstream. Cached responses remain available across attach, detach, and reattach operations.

func NewCache(upstream Interface, storage CacheStorage) *Cache

func (c *Cache) Attach(upstream Interface)

func (c *Cache) Close() error

func (c *Cache) Detach()

func (c *Cache) Requests() chan<- Request

type CacheStorage ¶

type CacheStorage interface {
	Get(key string, now time.Time) (*Message, bool)
	Set(key string, msg *Message, now time.Time)
	Delete(key string)
}

CacheStorage stores DNS messages by cache key. Implementations must be safe for concurrent callers when shared by multiple Cache values.

type Client ¶

type Client struct {
	// TLSConfig configures TLS for dot:// upstreams. The config is cloned for
	// each connection. If ServerName is empty, the URL host is used.
	TLSConfig *tls.Config
	// contains filtered or unexported fields
}

Client is a simple DNS client for udp://, tcp://, and dot:// servers.

It sends supported DNS query messages to the configured servers and returns the first successful wire response. The client allocates a fresh wire ID for every upstream request and maps the response ID back to the caller's message ID before replying.

func NewClient(dial gonnect.Dial, servers ...string) *Client

func (c *Client) Close() error

func (c *Client) Requests() chan<- Request

type Detached ¶

type Detached struct {
	// contains filtered or unexported fields
}

Detached is an independently closable wrapper around another DNS Interface.

Closing the detached wrapper cancels requests that are currently passing through it but does not close the wrapped interface. Other users of the wrapped interface continue to operate normally.

func Detach(upstream Interface) *Detached

func (d *Detached) Close() error

func (d *Detached) Requests() chan<- Request

type Interface ¶

type Interface interface {
	Requests() chan<- Request
	Close() error
}

Interface is a concurrent, channel based DNS message transport.

Implementations accept request messages through Requests and respond through the per-request Reply channel. Close terminates the implementation and cancels in-flight work owned by that implementation. Callers may share one Interface between multiple goroutines.

type MemoryStorage ¶

type MemoryStorage struct {
	// contains filtered or unexported fields
}

MemoryStorage is a simple map-backed CacheStorage implementation.

func NewMemoryStorage() *MemoryStorage

func (s *MemoryStorage) Delete(key string)

func (s *MemoryStorage) Get(key string, now time.Time) (*Message, bool)

func (s *MemoryStorage) Set(key string, msg *Message, now time.Time)

type Message ¶

type Message struct {
	ID       uint16
	Response bool

	Opcode uint8
	RCode  uint8

	Authoritative      bool
	Truncated          bool
	RecursionDesired   bool
	RecursionAvailable bool
	AuthenticatedData  bool
	CheckingDisabled   bool

	Questions   []Question
	Answers     []Resource
	Authorities []Resource
	Additionals []Resource
}

Message is the package-level representation of a DNS message.

It intentionally models the message header and the four standard sections without tying callers to a concrete wire codec. Name values are regular DNS names; callers may use either absolute names with a trailing dot or relative presentation names.

func Query(ctx context.Context, d Interface, req *Message) (*Message, error)

func Unpack(pkt []byte) (*Message, error)

func (m *Message) Copy() *Message

type Question ¶

type Question struct {
	Name  string
	Type  uint16
	Class uint16
}

Question identifies one DNS question.

type Request ¶

type Request struct {
	Context RequestContext
	Message *Message
	Reply   chan<- Response
}

Request is the channel envelope used by DNS implementations. Context cancels only this request. Reply receives exactly one Response unless the provider has already been closed before it can accept the request.

type RequestContext ¶

type RequestContext interface {
	context.Context
}

RequestContext is the subset of context.Context carried by a Request.

type Resolver ¶

type Resolver struct {
	DNS Interface
}

Resolver adapts a DNS Interface into a full gonnect.Resolver.

func NewResolver(d Interface) *Resolver

func (r *Resolver) LookupAddr(
	ctx context.Context,
	addr string,
) ([]string, error)

func (r *Resolver) LookupCNAME(
	ctx context.Context,
	host string,
) (string, error)

func (r *Resolver) LookupHost(
	ctx context.Context,
	host string,
) ([]string, error)

func (r *Resolver) LookupIP(
	ctx context.Context,
	network, host string,
) ([]net.IP, error)

func (r *Resolver) LookupIPAddr(
	ctx context.Context,
	host string,
) ([]net.IPAddr, error)

func (r *Resolver) LookupMX(
	ctx context.Context,
	name string,
) ([]*net.MX, error)

func (r *Resolver) LookupNS(
	ctx context.Context,
	name string,
) ([]*net.NS, error)

func (r *Resolver) LookupNetIP(
	ctx context.Context,
	network, host string,
) ([]netip.Addr, error)

func (r *Resolver) LookupPort(
	ctx context.Context,
	network, service string,
) (int, error)

func (r *Resolver) LookupSRV(
	ctx context.Context,
	service, proto, name string,
) (string, []*net.SRV, error)

func (r *Resolver) LookupTXT(
	ctx context.Context,
	name string,
) ([]string, error)

type ResolverProvider ¶

type ResolverProvider struct {
	// contains filtered or unexported fields
}

ResolverProvider adapts a gonnect.Resolver into a DNS Interface.

It supports standard IN-class A, AAAA, PTR, CNAME, TXT, MX, NS, and SRV queries. Unsupported opcodes, classes, or record types are answered with RCodeNotImplemented. Resolver lookup failures are mapped to NameError when the resolver reports not-found and ServerFailure otherwise. Successful resource records use the configured TTL.

func NewResolverProvider(
	resolver gonnect.Resolver,
	ttl time.Duration,
) *ResolverProvider

func (r *ResolverProvider) Close() error

func (r *ResolverProvider) Requests() chan<- Request

type Resource ¶

type Resource struct {
	Name  string
	Type  uint16
	Class uint16
	TTL   uint32
	Data  []byte
}

Resource identifies one DNS resource record. Data stores record-specific payload in DNS wire format without the owner name, type, class, or TTL.

type Response ¶

type Response struct {
	Message *Message
	Err     error
}

Response is delivered on a request's response channel.

type RouteFunc ¶

type RouteFunc func(*Message) string

RouteFunc selects the backend name for a DNS request.

Returning an empty string or a name without an attached backend rejects the request with ErrNoUpstream.

type Router ¶

type Router struct {
	// contains filtered or unexported fields
}

Router is a DNS Interface that routes requests to named backend interfaces.

Backends and the route function can be attached, detached, or replaced while the Router is serving requests. Mutations cancel in-flight requests that were routed through an older backend set or route function. Closing the Router cancels in-flight work owned by the Router but does not close attached backends.

func NewRouter() *Router

func (r *Router) Attach(name string, backend Interface) error

func (r *Router) AttachRouter(route RouteFunc) error

func (r *Router) Close() error

func (r *Router) Detach(name string) error

func (r *Router) DetachRouter() error

func (r *Router) Requests() chan<- Request

func (r *Router) SetRouter(route RouteFunc) error

type Server ¶

type Server struct {
	// contains filtered or unexported fields
}

Server is a simple UDP DNS server backed by a packet connection.

For every client packet it unpacks the DNS message, replaces the client's ID with a new internal ID before forwarding through the attached DNS Interface, then maps the response ID back to the original client ID. Attach and Detach can replace the upstream without closing the packet connection; detaching cancels requests currently waiting on the old upstream.

func NewServer(conn net.PacketConn, upstream Interface) *Server

func (s *Server) Attach(upstream Interface)

func (s *Server) Close() error

func (s *Server) Detach()

func (s *Server) Requests() chan<- Request