gdns

Documentation

Index

• Constants
• Variables
• func CSVtoIPs(csv string) (ips []net.IP, err error)
• type DNSQuestion
• type DNSRR
  • func (r DNSRR) DNSRR() (dns.RR, error)
  • func (r DNSRR) RR() dns.RR
  • func (r DNSRR) String() string
• type DNSResponse
• type Endpoint
  • func CSVtoEndpoints(csv string) (eps []Endpoint, err error)
  • func ParseEndpoint(endpoint string, defaultPort int) (ep Endpoint, err error)
  • func (e Endpoint) String() string
• type Endpoints
  • func (e Endpoints) Random() Endpoint
• type GDNSOptions
• type GDNSProvider
  • func NewGDNSProvider(endpoint string, opts *GDNSOptions) (*GDNSProvider, error)
  • func (g GDNSProvider) Query(q DNSQuestion) (*DNSResponse, error)
• type GDNSQuestion
  • func (r GDNSQuestion) DNSQuestion() DNSQuestion
• type GDNSQuestions
  • func (rs GDNSQuestions) DNSQuestions() (rqs []DNSQuestion)
• type GDNSRR
  • func (r GDNSRR) DNSRR() DNSRR
• type GDNSRRs
  • func (rs GDNSRRs) DNSRRs() (rrs []DNSRR)
• type GDNSResponse
• type Handler
  • func NewHandler(provider Provider, options *HandlerOptions) *Handler
  • func (h *Handler) Handle(w dns.ResponseWriter, r *dns.Msg)
• type HandlerOptions
• type Provider
• type SimpleDNSClient
  • func NewSimpleDNSClient(servers Endpoints) (*SimpleDNSClient, error)
  • func (c *SimpleDNSClient) LookupIP(host string) ([]net.IP, error)

Constants

const (
	LFATAL = iota
	LERROR
	LWARNING
	LINFO
	LDEBUG
)

Log level for glog

const (
	// DNSNameMaxBytes is the maximum number of bytes a DNS name may contain
	DNSNameMaxBytes = 253
)

Variables

var ErrFailedParsingIP = errors.New("unable to parse IP from string")

ErrFailedParsingIP is returned when the endpoint string looked valid, but the IP portion of the string was unable to be parsed

var ErrFailedParsingPort = errors.New("unable to parse port from string")

ErrFailedParsingPort is returned when the endpoint string looked valid, but the port portion of the string was unable to be parsed

var ErrInvalidEndpointString = errors.New("invalid endpoint string")

ErrInvalidEndpointString is returned when an endpoint string is in an unexpected format; the string is expected to be in `ip[:port]` format

Functions

func CSVtoIPs

func CSVtoIPs(csv string) (ips []net.IP, err error)

CSVtoIPs takes a comma-separated string of IPs, and parses to a []net.IP

Types

type DNSQuestion

type DNSQuestion struct {
	Name   string            `json:"name,omitempty"`
	Type   uint16            `json:"type,omitempty"`
	Subnet *dns.EDNS0_SUBNET `json:"subnet,omitempty"`
}

DNSQuestion represents a DNS question to be resolved by a DNS server

type DNSRR

type DNSRR struct {
	Name string `json:"name,omitempty"`
	Type uint16 `json:"type,omitempty"`
	TTL  uint32 `json:"TTL,omitempty"`
	Data string `json:"data,omitempty"`
}

DNSRR represents a DNS record, part of a response to a DNSQuestion

func (DNSRR) DNSRR

func (r DNSRR) DNSRR() (dns.RR, error)

DNSRR transforms a DNSRR to a dns.RR; returns `nil` if an RR could not be created from the record.

func (DNSRR) RR

func (r DNSRR) RR() dns.RR

RR is deprecated as of 2.2.0, use DNSRR instead

func (DNSRR) String

func (r DNSRR) String() string

type DNSResponse

type DNSResponse struct {
	Question           []DNSQuestion
	Answer             []DNSRR
	Authority          []DNSRR
	Extra              []dns.RR
	Truncated          bool
	RecursionDesired   bool
	RecursionAvailable bool
	AuthenticatedData  bool
	CheckingDisabled   bool
	ResponseCode       int
}

DNSResponse represents a complete DNS server response, to be served by the DNS server handler.

type Endpoint

type Endpoint net.TCPAddr

Endpoint represents a host/port combo

func CSVtoEndpoints

func CSVtoEndpoints(csv string) (eps []Endpoint, err error)

CSVtoEndpoints takes a comma-separated string of endpoints, and parses to a []gdns.Endpoint

func ParseEndpoint

func ParseEndpoint(endpoint string, defaultPort int) (ep Endpoint, err error)

ParseEndpoint parses a string into an Endpoint object, where the endpoint string is in the format of "ip:port". If a port is not present in the string, the defaultPort is used.

func (Endpoint) String

func (e Endpoint) String() string

type Endpoints

type Endpoints []Endpoint

Endpoints is a list of Endpoint objects

func (Endpoints) Random

func (e Endpoints) Random() Endpoint

Random retrieves a random Endpoint from a list of Endpoints

type GDNSOptions

type GDNSOptions struct {
	// Pad specifies if a DNS request should be padded to a fixed length
	Pad bool
	// Secure specifies if a DNS request should check ca-certificates
	Secure bool
	// EndpointIPs is a list of IPs to be used as the GDNS endpoint, avoiding
	// DNS lookups in the case where they are provided. One is chosen randomly
	// for each request.
	EndpointIPs []net.IP
	// DNSServers is a list of Endpoints to be used as DNS servers when looking
	// up the endpoint; if not provided, the system DNS resolver is used.
	DNSServers Endpoints
	// Extension mechanisms for DNS
	EDNS string
	// PROXY for http get
	// Support SOCKS5 and SHADOWSOCKS
	PROXY string
}

GDNSOptions is a configuration object for optional GDNSProvider configuration

type GDNSProvider

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

GDNSProvider is the Google DNS-over-HTTPS provider; it implements the Provider interface.

func NewGDNSProvider

func NewGDNSProvider(endpoint string, opts *GDNSOptions) (*GDNSProvider, error)

NewGDNSProvider creates a GDNSProvider

func (GDNSProvider) Query

func (g GDNSProvider) Query(q DNSQuestion) (*DNSResponse, error)

Query sends a DNS question to Google, and returns the response

type GDNSQuestion

type GDNSQuestion DNSQuestion

GDNSQuestion represents a question response item from Google's DNS service This is currently the same as DNSQuestion, our internal implementation, but since Google's API is in flux, we keep them separate

func (GDNSQuestion) DNSQuestion

func (r GDNSQuestion) DNSQuestion() DNSQuestion

DNSQuestion transforms a GDNSQuestion to a DNSQuestion and returns it.

type GDNSQuestions

type GDNSQuestions []GDNSQuestion

GDNSQuestions is a array of GDNSQuestion objects

func (GDNSQuestions) DNSQuestions

func (rs GDNSQuestions) DNSQuestions() (rqs []DNSQuestion)

DNSQuestions transforms an array of GDNSQuestion objects to an array of DNSQuestion objects

type GDNSRR

type GDNSRR DNSRR

GDNSRR represents a dns response record item from Google's DNS service. This is currently the same as DNSRR, our internal implementation, but since Google's API is in flux, we keep them separate

func (GDNSRR) DNSRR

func (r GDNSRR) DNSRR() DNSRR

DNSRR transforms a GDNSRR to a DNSRR

type GDNSRRs

type GDNSRRs []GDNSRR

GDNSRRs represents an array of GDNSRR objects

func (GDNSRRs) DNSRRs

func (rs GDNSRRs) DNSRRs() (rrs []DNSRR)

DNSRRs transforms an array of GDNSRR objects to an array of DNSRR objects

type GDNSResponse

type GDNSResponse struct {
	Status           int32         `json:"Status"`
	TC               bool          `json:"TC"`
	RD               bool          `json:"RD"`
	RA               bool          `json:"RA"`
	AD               bool          `json:"AD"`
	CD               bool          `json:"CD"`
	Question         GDNSQuestions `json:"Question,omitempty"`
	Answer           GDNSRRs       `json:"Answer,omitempty"`
	Authority        GDNSRRs       `json:"Authority,omitempty"`
	Additional       GDNSRRs       `json:"Additional,omitempty"`
	EDNSClientSubnet string        `json:"edns_client_subnet,omitempty"`
	Comment          string        `json:"Comment,omitempty"`
}

GDNSResponse represents a response from the Google DNS-over-HTTPS servers

type Handler

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

Handler represents a DNS handler

func NewHandler

func NewHandler(provider Provider, options *HandlerOptions) *Handler

NewHandler creates a new Handler

func (*Handler) Handle

func (h *Handler) Handle(w dns.ResponseWriter, r *dns.Msg)

Handle handles a DNS request

type HandlerOptions

type HandlerOptions struct{}

HandlerOptions specifies options to be used when instantiating a handler

type Provider

type Provider interface {
	Query(DNSQuestion) (*DNSResponse, error)
}

Provider is an interface representing a servicer of DNS queries.

type SimpleDNSClient

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

SimpleDNSClient is a DNS client, primarily for internal use in secure operator.

It provides an in-memory cache, but was optimized to look up one address at a time only.

func NewSimpleDNSClient

func NewSimpleDNSClient(servers Endpoints) (*SimpleDNSClient, error)

NewSimpleDNSClient creates a SimpleDNSClient

func (*SimpleDNSClient) LookupIP

func (c *SimpleDNSClient) LookupIP(host string) ([]net.IP, error)

LookupIP does a single lookup against the client's configured DNS servers, returning a value from cache if its still valid. It looks at A records only.