rdns

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(q dns.Question) (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 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
}

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 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

	// 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
}

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

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

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

type DTLSClientOptions struct {
	// Bootstrap address - IP to use for the serivce 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

	// 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
}

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

	TLSConfig *tls.Config

	QueryTimeout time.Duration

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

	Use0RTT bool
}

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
}

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

type DoTClientOptions struct {
	// Bootstrap address - IP to use for the serivce 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

	TLSConfig *tls.Config

	QueryTimeout time.Duration

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

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
}

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
}

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
	Timeout   time.Duration
}

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
}

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

type ListenerMetrics 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 Pipeline struct {
	// contains filtered or unexported fields
}

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
}

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 allwed 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
}

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 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

	// 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
}

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 {
}