rdns

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

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

type AdminListenerOptions struct {
	ListenOptions

	// Transport protocol to run HTTPS over. "quic" or "tcp", defaults to "tcp".
	Transport string

	TLSConfig *tls.Config
}

type AnswerShuffleFunc func(*dns.Msg)

type Blocklist struct {
	BlocklistOptions
	// contains filtered or unexported fields
}

type BlocklistDB interface {
	// Reload initializes a new instance of the same database but with
	// a new ruleset loaded.
	Reload() (BlocklistDB, error)

	// Returns true if the question matches a rule. If the IP is not nil,
	// respond with the given IP. NXDOMAIN otherwise. The returned names,
	// if set, are used to answer PTR queries
	Match(msg *dns.Msg) (ip []net.IP, names []string, m *BlocklistMatch, matched bool)

	fmt.Stringer
}

type BlocklistLoader interface {
	// Returns a list of rules that can then be stored into a blocklist DB.
	Load() ([]string, error)
}

type BlocklistMatch struct {
	List string // Identifier or name of the blocklist
	Rule string // Identifier for the rule that matched
}

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

type BlocklistOptions struct {
	// Optional, send any blocklist match to this resolver rather
	// than return NXDOMAIN.
	BlocklistResolver Resolver

	BlocklistDB BlocklistDB

	// Refresh period for the blocklist. Disabled if 0.
	BlocklistRefresh time.Duration

	// Optional, send anything that matches the allowlist to an
	// alternative resolver rather than the default upstream one.
	AllowListResolver Resolver

	// Rules that override the blocklist rules, effectively negate them.
	AllowlistDB BlocklistDB

	// Refresh period for the allowlist. Disabled if 0.
	AllowlistRefresh time.Duration

	// Optional, allows specifying extended errors to be used in the
	// response when blocking.
	EDNS0EDETemplate *EDNS0EDETemplate
}

type ByteCode struct {
	*lua.FunctionProto
}

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

type CacheBackend interface {
	Store(query *dns.Msg, item *cacheAnswer)

	// Lookup a cached response
	Lookup(q *dns.Msg) (answer *dns.Msg, prefetchEligible bool, ok bool)

	// Return the number of items in the cache
	Size() int

	// Flush all records in the store
	Flush()

	Close() error
}

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

type CacheOptions struct {
	// Time period the cache garbage collection runs. Defaults to one minute if set to 0.
	//
	// Deprecated: Pass a configured cache backend instead.
	GCPeriod time.Duration

	// Max number of responses to keep in the cache. Defaults to 0 which means no limit. If
	// the limit is reached, the least-recently used entry is removed from the cache.
	//
	// Deprecated: Pass a configured cache backend instead.
	Capacity int

	// TTL to use for negative responses that do not have an SOA record, default 60
	NegativeTTL uint32

	// Define upper limits on cache TTLs based on RCODE, regardless of SOA. For example this
	// allows settings a limit on how long NXDOMAIN (code 3) responses can be kept in the cache.
	CacheRcodeMaxTTL map[int]uint32

	// Allows control over the order of answer RRs in cached responses. Default is to keep
	// the order if nil.
	ShuffleAnswerFunc AnswerShuffleFunc

	// If enabled, will return NXDOMAIN for every name query under another name that is
	// already cached as NXDOMAIN. For example, if example.com is in the cache with
	// NXDOMAIN, a query for www.example.com will also immediately return NXDOMAIN.
	// See RFC8020.
	HardenBelowNXDOMAIN bool

	// Query name that will trigger a cache flush. Disabled if empty.
	FlushQuery string

	// If a query is received for a record with less that PrefetchTrigger TTL left, the
	// cache will send another query to upstream. The goal is to automatically refresh
	// the record in the cache.
	PrefetchTrigger uint32

	// Only records with at least PrefetchEligible seconds TTL are eligible to be prefetched.
	PrefetchEligible uint32

	// Cache backend used to store records.
	Backend CacheBackend
}

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

type ClientBlocklist struct {
	ClientBlocklistOptions
	// contains filtered or unexported fields
}

type ClientBlocklistOptions struct {
	// Optional, if the client is found to match the blocklist, send the query to this resolver.
	BlocklistResolver Resolver

	BlocklistDB IPBlocklistDB

	// Refresh period for the blocklist. Disabled if 0.
	BlocklistRefresh time.Duration

	// Use the provided ECS address instead of the real client IP if one was
	// provided. This can be used to "test" blocklists by simulating different
	// client IPs.
	UseECS bool
}

type ClientInfo struct {
	SourceIP net.IP

	// DoH query path used by the client. Only populated when
	// the query was received over DoH.
	DoHPath string

	// TLS SNI server name
	TLSServerName string

	// Listener ID of the listener that first received the request. Can be
	// used to route queries.
	Listener string
}

type DNS64 struct {
	DNS64Options
	// contains filtered or unexported fields
}

type DNS64Options struct {
	// IPv6 prefixes used for address synthesis per RFC 6052.
	// Each string is a CIDR like "64:ff9b::/96".
	// Only prefix lengths /32, /40, /48, /56, /64, /96 are allowed.
	// Default: ["64:ff9b::/96"] (well-known prefix)
	Prefixes []string
}

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

type DNSClientOptions struct {
	// Local IP to use for outbound connections. If nil, a local address is chosen.
	LocalAddr   net.IP
	LocalAddrV4 net.IP
	LocalAddrV6 net.IP

	// Sets the EDNS0 UDP size for all queries sent upstream. If set to 0, queries
	// are not changed.
	UDPSize uint16

	QueryTimeout time.Duration

	// Optional dialer, e.g. proxy
	Dialer Dialer

	// Linux network namespace for outbound connections.
	NetNS *NetNS

	// Linux socket options for fwmark and interface binding.
	SocketOptions SocketOptions
}

type DNSDialer interface {
	Dial(address string) (*dns.Conn, error)
}

type DNSListener struct {
	*dns.Server
	// contains filtered or unexported fields
}

type DNSSECValidator struct {
	DNSSECValidatorOptions
	// contains filtered or unexported fields
}

type DNSSECValidatorOptions struct {
	TrustAnchors   []TrustAnchor
	TrustAnchorURL string // URL to fetch trust anchors from (e.g. IANA root-anchors.xml)
	LogOnly        bool   // Log validation failures without returning SERVFAIL
}

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

type DTLSClientOptions struct {
	// Bootstrap address - IP to use for the service instead of looking up
	// the service's hostname with potentially plain DNS.
	BootstrapAddr string

	// Local IP to use for outbound connections. If nil, a local address is chosen.
	LocalAddr   net.IP
	LocalAddrV4 net.IP
	LocalAddrV6 net.IP

	// Sets the EDNS0 UDP size for all queries sent upstream. If set to 0, queries
	// are not changed.
	UDPSize uint16

	DTLSConfig *dtls.Config

	QueryTimeout time.Duration

	// Linux network namespace for outbound connections.
	NetNS *NetNS

	// Linux socket options for fwmark and interface binding.
	SocketOptions SocketOptions
}

type DTLSListener struct {
	*dns.Server
	// contains filtered or unexported fields
}

type DTLSListenerOptions struct {
	ListenOptions

	DTLSConfig *dtls.Config
}

type Dialer interface {
	Dial(net string, address string) (net.Conn, error)
}

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

type DoHClientOptions struct {
	// Query method, either GET or POST. If empty, POST is used.
	Method string

	// Bootstrap address - IP to use for the service instead of looking up
	// the service's hostname with potentially plain DNS.
	BootstrapAddr string

	// Transport protocol to run HTTPS over. "quic" or "tcp", defaults to "tcp".
	Transport string

	// Local IP to use for outbound connections. If nil, a local address is chosen.
	LocalAddr   net.IP
	LocalAddrV4 net.IP
	LocalAddrV6 net.IP

	TLSConfig *tls.Config

	QueryTimeout time.Duration

	// IdleTimeout is the maximum amount of time an idle connection will remain
	// open before being closed. For TCP transport, defaults to 30 seconds if not set.
	// For QUIC transport, defaults to the quic-go library default if not set. Note
	// that for QUIC, the actual timeout is the minimum of client and server values.
	IdleTimeout time.Duration

	// Optional dialer, e.g. proxy
	Dialer Dialer

	Use0RTT bool

	// Linux network namespace for outbound connections.
	NetNS *NetNS

	// Linux socket options for fwmark and interface binding.
	SocketOptions SocketOptions
}

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

type DoHListenerMetrics struct {
	ListenerMetrics
	// contains filtered or unexported fields
}

type DoHListenerOptions struct {
	ListenOptions

	// Transport protocol to run HTTPS over. "quic" or "tcp", defaults to "tcp".
	Transport string

	TLSConfig *tls.Config

	// IP(v4/v6) subnet of known reverse proxies in front of this server.
	HTTPProxyNet *net.IPNet

	// Disable TLS on the server (insecure, for testing purposes only).
	NoTLS bool
	// contains filtered or unexported fields
}

type DoQClient struct {
	DoQClientOptions
	// contains filtered or unexported fields
}

type DoQClientOptions struct {
	// Bootstrap address - IP to use for the service instead of looking up
	// the service's hostname with potentially plain DNS.
	BootstrapAddr string

	// Local IP to use for outbound connections. If nil, a local address is chosen.
	LocalAddr   net.IP
	LocalAddrV4 net.IP
	LocalAddrV6 net.IP

	TLSConfig    *tls.Config
	QueryTimeout time.Duration
	Use0RTT      bool

	// Linux network namespace for outbound connections.
	NetNS *NetNS

	// Linux socket options for fwmark and interface binding.
	SocketOptions SocketOptions
}

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

type DoQListenerMetrics struct {
	ListenerMetrics
	// contains filtered or unexported fields
}

type DoQListenerOptions struct {
	ListenOptions

	TLSConfig *tls.Config
}

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

type DoTClientOptions struct {
	// Bootstrap address - IP to use for the service instead of looking up
	// the service's hostname with potentially plain DNS.
	BootstrapAddr string

	// Local IP to use for outbound connections. If nil, a local address is chosen.
	LocalAddr   net.IP
	LocalAddrV4 net.IP
	LocalAddrV6 net.IP

	TLSConfig *tls.Config

	QueryTimeout time.Duration

	// Optional dialer, e.g. proxy
	Dialer Dialer

	// Linux network namespace for outbound connections.
	NetNS *NetNS

	// Linux socket options for fwmark and interface binding.
	SocketOptions SocketOptions
}

type DoTListener struct {
	*dns.Server
	// contains filtered or unexported fields
}

type DoTListenerOptions struct {
	ListenOptions

	TLSConfig *tls.Config
}

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

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

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

type ECSModifierFunc func(id string, q *dns.Msg, ci ClientInfo)

type EDNS0EDEInput struct {
	*dns.Msg
	*BlocklistMatch
}

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

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

type EDNS0ModifierFunc func(q *dns.Msg, ci ClientInfo)

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

type FailBackOptions struct {
	// Switch back to the first resolver in the group after no further failures
	// for this amount of time. Default 1 minute.
	ResetAfter time.Duration

	// Determines if a SERVFAIL returned by a resolver should be considered an
	// error response and trigger a failover.
	ServfailError bool

	// Determines if an empty response returned by a resolver should be considered an
	// error response and trigger a failover.
	EmptyError bool
}

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

type FailRotateOptions struct {
	// Determines if a SERVFAIL returned by a resolver should be considered an
	// error response and trigger a failover.
	ServfailError bool

	// Determines if an empty response returned by a resolver should be considered an
	// error response and trigger a failover.
	EmptyError bool
}

type FailRouterMetrics struct {
	RouterMetrics
	// contains filtered or unexported fields
}

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

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

type FastestTCPOptions struct {
	// Port number to use for TCP probes, default 443
	Port int

	// Wait for all connection probes and sort the responses based on time
	// (fastest first). This is generally slower than just waiting for the
	// fastest, since the response time is determined by the slowest probe.
	WaitAll bool

	// TTL set on all RRs when TCP probing was successful. Can be used to
	// ensure these are kept for longer in a cache and improve performance.
	SuccessTTLMin uint32
}

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

type FileLoaderOptions struct {
	// Don't fail when trying to load the list
	AllowFailure bool
}

type GenericDNSClient struct {
	Dialer        Dialer
	Net           string
	TLSConfig     *tls.Config
	LocalAddr     net.IP
	LocalAddrV4   net.IP
	LocalAddrV6   net.IP
	Timeout       time.Duration
	NetNS         *NetNS
	SocketOptions SocketOptions
}

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

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

type HTTPLoaderOptions struct {
	CacheDir string

	// Don't fail when trying to load the list
	AllowFailure bool
}

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

type IPBlocklistDB interface {
	Reload() (IPBlocklistDB, error)
	Match(ip net.IP) (*BlocklistMatch, bool)
	Close() error
	fmt.Stringer
}

type ListenOptions struct {
	// Network allowed to query this listener.
	AllowedNet []*net.IPNet

	// Linux network namespace for the listening socket.
	NetNS *NetNS

	// Linux socket options for fwmark and interface binding.
	SocketOptions SocketOptions
}

type Listener interface {
	Start() error
	Stop() error
	fmt.Stringer
}

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

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

type LoadBalanceOptions struct {
	// Duration recorded as the RTT penalty for persistently failing resolvers
	// (after loadBalancePenaltyThreshold consecutive failures). 0 disables the
	// penalty; without it fast-failing resolvers are still prevented from
	// gaining weight via the upward-only EMA update on failure.
	FailurePenalty time.Duration

	// Determines if a SERVFAIL returned by a resolver should be considered an
	// error response and trigger a failover.
	ServfailError bool

	// Determines if an empty response returned by a resolver should be considered an
	// error response and trigger a failover.
	EmptyError bool
}

type LogFormat string

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

type LuaOptions struct {
	Script      string
	Concurrency uint
	NoSandbox   bool // Disables the sandbox. When false (default), scripts cannot access os/io/debug/etc.
}

type LuaScript struct {
	L *lua.LState
}

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

type MemoryBackendOptions struct {
	// Total capacity of the cache, default unlimited
	Capacity int

	// How often to run garbage collection, default 1 minute
	GCPeriod time.Duration

	// Load the cache from file on startup and write it on close
	Filename string

	// Write the file in an interval. Only write on shutdown if not set
	SaveInterval time.Duration
}

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

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

type NetNS struct {
	Name    string
	XSocket string
}

type NetNSState int

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

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

type ODoHListenerOptions struct {
	ListenOptions

	OdohMode  string
	AllowDoH  bool
	KeySeed   string
	TLSConfig *tls.Config
}

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

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

type PrefetchOptions struct {
	PrefetchWindow    time.Duration
	PrefetchThreshold uint64
	PrefetchCacheSize int
	PrefetchMaxItems  int
}

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

type QueryLogResolverOptions struct {
	OutputFile   string // Output filename, leave blank for STDOUT
	OutputFormat LogFormat
}

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

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

type RandomOptions struct {
	// Re-enable resolvers after this time after a failure
	ResetAfter time.Duration

	// Determines if a SERVFAIL returned by a resolver should be considered an
	// error response and cause the resolver to be removed from the group temporarily.
	ServfailError bool

	// Determines if an empty response returned by a resolver should be considered an
	// error response and trigger a failover.
	EmptyError bool
}

type RateLimiter struct {
	RateLimiterOptions
	// contains filtered or unexported fields
}

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

type RateLimiterOptions struct {
	Requests      uint     // Number of requests allowed per time period
	Window        uint     // Time period in seconds
	Prefix4       uint8    // Netmask to identify IP4 clients
	Prefix6       uint8    // Netmask to identify IP6 clients
	LimitResolver Resolver // Alternate resolver for rate-limited requests
}

type RedisBackendOptions struct {
	RedisOptions redis.Options
	KeyPrefix    string
	SyncSet      bool // When true, perform Redis SET synchronously. Default is false (async writes).
}

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

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

type ReplaceOperation struct {
	From string
	To   string
}

type Resolver interface {
	Resolve(*dns.Msg, ClientInfo) (*dns.Msg, error)
	fmt.Stringer
}

type ResponseBlocklistIP struct {
	ResponseBlocklistIPOptions
	// contains filtered or unexported fields
}

type ResponseBlocklistIPOptions struct {
	// Optional, if the response is found to match the blocklist, send the query to this resolver.
	BlocklistResolver Resolver

	BlocklistDB IPBlocklistDB

	// Refresh period for the blocklist. Disabled if 0.
	BlocklistRefresh time.Duration

	// If true, removes matching records from the response rather than replying with NXDOMAIN. Can
	// not be combined with alternative blocklist-resolver
	Filter bool

	// Inverted behavior, only allow responses that can be found on at least one list.
	Inverted bool

	// Optional, allows specifying extended errors to be used in the
	// response when blocking.
	EDNS0EDETemplate *EDNS0EDETemplate
}

type ResponseBlocklistName struct {
	ResponseBlocklistNameOptions
	// contains filtered or unexported fields
}

type ResponseBlocklistNameOptions struct {
	// Optional, if the response is found to match the blocklist, send the query to this resolver.
	BlocklistResolver Resolver

	BlocklistDB BlocklistDB

	// Refresh period for the blocklist. Disabled if 0.
	BlocklistRefresh time.Duration

	// Inverted behavior, only allow responses that can be found on at least one list.
	Inverted bool

	// Optional, allows specifying extended errors to be used in the
	// response when blocking.
	EDNS0EDETemplate *EDNS0EDETemplate
}

type ResponseCollapse struct {
	ResponseCollapseOptions
	// contains filtered or unexported fields
}

type ResponseCollapseOptions struct {
	NullRCode int // Response code when there's nothing left after collapsing the response
}

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

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

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

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

type SocketOptions struct {
	// Firewall mark (SO_MARK) to set on the socket. 0 means unset.
	FWMark uint32

	// Network interface to bind the socket to (SO_BINDTODEVICE). Empty means unset.
	BindInterface string
}

type Socks5Dialer struct {
	*socks5.Client
	// contains filtered or unexported fields
}

type Socks5DialerOptions struct {
	Username    string
	Password    string
	UDPTimeout  time.Duration
	TCPTimeout  time.Duration
	LocalAddr   net.IP
	LocalAddrV4 net.IP
	LocalAddrV6 net.IP

	// When the resolver is configured with a name, not an IP, e.g. one.one.one.one:53
	// this setting will resolve that name locally rather than on the SOCKS proxy. The
	// name will be resolved either on the local system, or via the bootstrap-resolver
	// if one is setup.
	ResolveLocal bool

	// Linux network namespace for the connection to the SOCKS5 proxy. Only the
	// xsocket mechanism is handled here; setns-based namespaces are entered by
	// the caller (which wraps Dial in RunInNetNS). A nil or empty value reaches
	// the proxy from the current namespace.
	NetNS *NetNS

	// Linux socket options (fwmark, interface binding) applied to the socket
	// used to reach the proxy. Only honoured when dialing the proxy via xsocket;
	// other paths apply them around Dial.
	SocketOptions SocketOptions
}

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

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

type StaticResolverOptions struct {
	// Records in zone-file format
	Answer   []string
	NS       []string
	Extra    []string
	RCode    int
	Truncate bool
	// Optional, allows specifying extended errors to be used in the
	// response when blocking.
	EDNS0EDETemplate *EDNS0EDETemplate
}

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

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

type SyslogOptions struct {
	// "udp", "tcp", "unix". Defaults to "udp"
	Network string

	// Remote address, defaults to local syslog server
	Address string

	// Priority value as per https://pkg.go.dev/log/syslog#Priority
	Priority int

	// Syslog tag
	Tag string

	// Log requests and/or responses
	LogRequest  bool
	LogResponse bool

	// Log all response records, including those that do not match the query type
	Verbose bool
}

type TTLModifier struct {
	TTLModifierOptions
	// contains filtered or unexported fields
}

type TTLModifierOptions struct {
	// Function performing the initial modifications (min/max are applied after).
	// Returns true if at least one value was modified.
	SelectFunc TTLSelectFunc

	// Minimum TTL, any RR with a TTL below will be updated to this value.
	MinTTL uint32

	// Maximum TTL, any RR with a TTL higher than this will have their value
	// set to the max. A value of 0 disables the limit. Default 0.
	MaxTTL uint32
}

type TTLSelectFunc func(*TTLModifier, *dns.Msg) bool

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

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

type TruncateRetry struct {
	TruncateRetryOptions
	// contains filtered or unexported fields
}

type TruncateRetryOptions struct {
}

type TrustAnchor struct {
	Owner      string
	Digest     string
	KeyTag     uint16
	Algorithm  uint8
	DigestType uint8
}

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

type XSocketServerOptions struct {
	// Hand out any socket the client asks for rather than just the
	// IPv4/IPv6 stream and datagram sockets RouteDNS itself uses.
	Unrestricted bool

	// Permissions applied to the Unix socket after it is created. Zero
	// leaves the permissions at what the process umask produces. Has no
	// effect on abstract sockets.
	SocketMode fs.FileMode
}