resolvers

Documentation

Index

• type Answer
• type Authority
• type ClassicResolver
  • func (r *ClassicResolver) Lookup(ctx context.Context, questions []dns.Question, flags QueryFlags) ([]Response, error)
• type ClassicResolverOpts
• type DNSCryptResolver
  • func (r *DNSCryptResolver) Lookup(ctx context.Context, questions []dns.Question, flags QueryFlags) ([]Response, error)
• type DNSCryptResolverOpts
• type DOHResolver
  • func (r *DOHResolver) Lookup(ctx context.Context, questions []dns.Question, flags QueryFlags) ([]Response, error)
• type DOQResolver
  • func (r *DOQResolver) Lookup(ctx context.Context, questions []dns.Question, flags QueryFlags) ([]Response, error)
• type Options
• type QueryFlags
• type QueryFunc
• type Question
• type Resolver
  • func LoadResolvers(opts Options) ([]Resolver, error)
  • func NewClassicResolver(server string, classicOpts ClassicResolverOpts, resolverOpts Options) (Resolver, error)
  • func NewDNSCryptResolver(server string, dnscryptOpts DNSCryptResolverOpts, resolverOpts Options) (Resolver, error)
  • func NewDOHResolver(server string, resolverOpts Options) (Resolver, error)
  • func NewDOQResolver(server string, resolverOpts Options) (Resolver, error)
• type Response
  • func ConcurrentLookup(ctx context.Context, questions []dns.Question, flags QueryFlags, ...) ([]Response, error)

Types

type Answer

type Answer struct {
	Name       string `json:"name"`
	Type       string `json:"type"`
	Class      string `json:"class"`
	TTL        string `json:"ttl"`
	Address    string `json:"address"`
	Status     string `json:"status"`
	RTT        string `json:"rtt"`
	Nameserver string `json:"nameserver"`
}

type Authority

type Authority struct {
	Name       string `json:"name"`
	Type       string `json:"type"`
	Class      string `json:"class"`
	TTL        string `json:"ttl"`
	MName      string `json:"mname"`
	Status     string `json:"status"`
	RTT        string `json:"rtt"`
	Nameserver string `json:"nameserver"`
}

type ClassicResolver

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

ClassicResolver represents the config options for setting up a Resolver.

func (*ClassicResolver) Lookup

func (r *ClassicResolver) Lookup(ctx context.Context, questions []dns.Question, flags QueryFlags) ([]Response, error)

Lookup implements the Resolver interface

type ClassicResolverOpts

type ClassicResolverOpts struct {
	UseTLS bool
	UseTCP bool
}

ClassicResolverOpts holds options for setting up a Classic resolver.

type DNSCryptResolver

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

DNSCryptResolver represents the config options for setting up a Resolver.

func (*DNSCryptResolver) Lookup

func (r *DNSCryptResolver) Lookup(ctx context.Context, questions []dns.Question, flags QueryFlags) ([]Response, error)

Lookup implements the Resolver interface

type DNSCryptResolverOpts

type DNSCryptResolverOpts struct {
	UseTCP bool
}

DNSCryptResolverOpts holds options for setting up a DNSCrypt resolver.

type DOHResolver

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

DOHResolver represents the config options for setting up a DOH based resolver.

func (*DOHResolver) Lookup

func (r *DOHResolver) Lookup(ctx context.Context, questions []dns.Question, flags QueryFlags) ([]Response, error)

Lookup implements the Resolver interface

type DOQResolver

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

DOQResolver represents the config options for setting up a DOQ based resolver.

func (*DOQResolver) Lookup

func (r *DOQResolver) Lookup(ctx context.Context, questions []dns.Question, flags QueryFlags) ([]Response, error)

Lookup implements the Resolver interface

type Options

type Options struct {
	Logger *slog.Logger

	Nameservers        []models.Nameserver
	UseIPv4            bool
	UseIPv6            bool
	SearchList         []string
	Ndots              int
	Timeout            time.Duration
	Strategy           string
	InsecureSkipVerify bool
	TLSHostname        string
}

Options represent a set of common options to configure a Resolver.

type QueryFlags

type QueryFlags struct {
	AA bool // Authoritative Answer
	AD bool // Authenticated Data
	CD bool // Checking Disabled
	RD bool // Recursion Desired
	Z  bool // Reserved for future use
	DO bool // DNSSEC OK
}

QueryFlags represents the various DNS query flags

type QueryFunc

type QueryFunc func(ctx context.Context, question dns.Question, flags QueryFlags) (Response, error)

QueryFunc represents the signature of a query function

type Question

type Question struct {
	Name  string `json:"name"`
	Type  string `json:"type"`
	Class string `json:"class"`
}

type Resolver

type Resolver interface {
	Lookup(ctx context.Context, questions []dns.Question, flags QueryFlags) ([]Response, error)
}

Resolver implements the configuration for a DNS Client. Different types of providers can load a DNS Resolver satisfying this interface.

func LoadResolvers

func LoadResolvers(opts Options) ([]Resolver, error)

LoadResolvers loads differently configured resolvers based on a list of nameserver.

func NewClassicResolver

func NewClassicResolver(server string, classicOpts ClassicResolverOpts, resolverOpts Options) (Resolver, error)

NewClassicResolver accepts a list of nameservers and configures a DNS resolver.

func NewDNSCryptResolver

func NewDNSCryptResolver(server string, dnscryptOpts DNSCryptResolverOpts, resolverOpts Options) (Resolver, error)

NewDNSCryptResolver accepts a list of nameservers and configures a DNS resolver.

func NewDOHResolver

func NewDOHResolver(server string, resolverOpts Options) (Resolver, error)

NewDOHResolver accepts a nameserver address and configures a DOH based resolver.

func NewDOQResolver

func NewDOQResolver(server string, resolverOpts Options) (Resolver, error)

NewDOQResolver accepts a nameserver address and configures a DOQ based resolver.

type Response

type Response struct {
	Answers     []Answer    `json:"answers"`
	Authorities []Authority `json:"authorities"`
	Questions   []Question  `json:"questions"`
}

Response represents a custom output format for DNS queries. It wraps metadata about the DNS query and the DNS Answer as well.

func ConcurrentLookup

func ConcurrentLookup(ctx context.Context, questions []dns.Question, flags QueryFlags, queryFunc QueryFunc, logger *slog.Logger) ([]Response, error)

ConcurrentLookup performs concurrent DNS lookups