dns

type AddressPair ¶ added in v1.9.0

type AddressPair struct {
	Network string
	Addr    netip.AddrPort
}

AddressPair represents a network and address with port.

func (a AddressPair) String() string

type Cache ¶

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

Cache is a dns.Handler to plugin.Handler adapter.

func NewCache(next plugin.Handler, l *zap.Logger) *Cache

func (c *Cache) Clear()

func (c *Cache) ServeDNS(wr dns.ResponseWriter, msg *dns.Msg)

type ControlFn ¶ added in v1.7.2

type ControlFn = func(string, string, syscall.RawConn) error

ControlFn is an alias to net.ListenConfig.Control function.

func MakeControl(network string, forwardEnabled bool) (ControlFn, error)

type Handler ¶

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

Handler is a dns proxy selector.

func NewHandler(logger *zap.Logger) *Handler

func (h *Handler) Name() string

func (h *Handler) ServeDNS(ctx context.Context, wrt dns.ResponseWriter, msg *dns.Msg) (int, error)

func (h *Handler) SetProxy(prxs iter.Seq[Upstream]) bool

func (h *Handler) Stop()

type HostMapper ¶

type HostMapper interface {
	ResolveAddr(ctx context.Context, qType uint16, name string) (iter.Seq[netip.Addr], bool)
}

HostMapper is a name to node mapper.

type Manager ¶ added in v1.9.0

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

Manager manages DNS runners.

func NewManager(mr MemberReader, shr StaticHostReader, hook suture.EventHook, logger *zap.Logger) *Manager

func (m *Manager) AllowNodeResolving(enabled bool)

func (m *Manager) ClearAll(dry bool) error

func (m *Manager) Done() <-chan error

func (m *Manager) RunAll(pairs iter.Seq[AddressPair], forwardEnabled bool) iter.Seq2[RunResult, error]

func (m *Manager) ServeBackground(ctx context.Context)

func (m *Manager) SetUpstreams(prxs iter.Seq[Upstream]) bool

type MemberReader ¶ added in v1.9.0

type MemberReader interface {
	ReadMembers(ctx context.Context) (iter.Seq[*cluster.Member], error)
}

MemberReader is an interface to read members.

type NodeHandler ¶

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

NodeHandler try to resolve dns request to a node. If required node is not found, it will move to the next handler.

func NewNodeHandler(next plugin.Handler, hostMapper HostMapper, logger *zap.Logger) *NodeHandler

func (h *NodeHandler) Name() string

func (h *NodeHandler) ServeDNS(ctx context.Context, wrt dns.ResponseWriter, msg *dns.Msg) (int, error)

func (h *NodeHandler) SetEnabled(enabled bool)

type RunResult ¶ added in v1.9.0

type RunResult struct {
	AddressPair

	Status Status
}

RunResult represents the result of a RunAll iteration.

type Runner ¶ added in v1.9.0

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

Runner is a DNS server runner.

func NewRunner(newOpts func() (RunnerOptions, error), l *zap.Logger) *Runner

func (r *Runner) Serve(ctx context.Context) error

type RunnerOptions ¶ added in v1.9.0

type RunnerOptions struct {
	Listener      net.Listener
	PacketConn    net.PacketConn
	Handler       dns.Handler
	ReadTimeout   time.Duration
	WriteTimeout  time.Duration
	IdleTimeout   func() time.Duration
	MaxTCPQueries int
}

RunnerOptions is a Runner options.

type StaticHostHandler ¶ added in v1.14.0

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

StaticHostHandler resolves a configured set of host names to fixed addresses.

It sits in the handler chain ahead of NodeHandler/Handler so that statically configured entries always win against upstream resolution. On miss, the request is forwarded to the next handler.

func NewStaticHostHandler(next plugin.Handler, mapper HostMapper, logger *zap.Logger) *StaticHostHandler

func (h *StaticHostHandler) Name() string

func (h *StaticHostHandler) ServeDNS(ctx context.Context, wrt dns.ResponseWriter, msg *dns.Msg) (int, error)

type StaticHostReader ¶ added in v1.14.0

type StaticHostReader interface {
	ReadStaticHosts(ctx context.Context, name string) (iter.Seq[netip.Addr], error)
}

StaticHostReader is an interface to read static hosts.

type Status ¶ added in v1.9.0

type Status int

Status represents the status of a runner.

const (
	// StatusNew represents a new runner.
	StatusNew Status = iota
	// StatusRunning represents a already running runner.
	StatusRunning
	// StatusRemoved represents a removed runner.
	StatusRemoved
)

type Upstream ¶ added in v1.14.0

type Upstream interface {
	// Connect sends a DNS query to the upstream and returns the response.
	Connect(ctx context.Context, state request.Request, opts proxy.Options) (*dns.Msg, error)
	// Addr returns the upstream address (used for logging).
	Addr() string
}

Upstream is the abstraction used by Handler to forward DNS queries to a concrete upstream resolver.

It is implemented by the CoreDNS plugin proxy (used for plain DNS and DoT) and by the DoH proxy in this package, so the handler can iterate uniformly across all configured upstream protocols.