dnsx

package
v0.0.0-...-99b537f Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 8, 2024 License: MPL-2.0 Imports: 28 Imported by: 0

Documentation

Overview

Copyright (c) 2022 RethinkDNS and its authors.

This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

Index

Constants

View Source 
const (
	Start          = x.Start
	Complete       = x.Complete
	SendFailed     = x.SendFailed
	NoResponse     = x.NoResponse
	BadQuery       = x.BadQuery
	BadResponse    = x.BadResponse
	InternalError  = x.InternalError
	TransportError = x.TransportError
	ClientError    = x.ClientError
)
View Source 
const (
	EB32 = x.EB32
	EB64 = x.EB64
)

encoding type, base32 or base64

View Source 
const (
	// DNS transport types
	DOH      = x.DOH
	DNSCrypt = x.DNSCrypt
	DNS53    = x.DNS53
	DOT      = x.DOT
	ODOH     = x.ODOH

	CT = x.CT

	Goos      = x.Goos
	System    = x.System
	Local     = x.Local
	Default   = x.Default
	Preferred = x.Preferred
	Preset    = x.Preset
	Fixed     = x.Fixed
	BlockFree = x.BlockFree
	Bootstrap = x.Bootstrap
	BlockAll  = x.BlockAll
	Alg       = x.Alg
	DcProxy   = x.DcProxy
	IpMapper  = x.IpMapper

	// preferred network to use with t.Query
	NetTypeUDP = "udp"
	NetTypeTCP = "tcp"
	// preferred forwarding network, if any
	// ipn.Base is treated as a no-proxy
	NetNoProxy   = x.Base
	NetExitProxy = x.Exit

	// pseudo transport ID to tag dns64 responses
	AlgDNS64 = "dns64"
)
View Source 
const AnyResolver = "__anyresolver"
View Source 
const Local464Resolver = "__local464" // preset "forced" DNS64/NAT64
View Source 
const OverlayResolver = "__overlay" // "net.DefaultResolver" dnsx.Goos
View Source 
const Rfc7050WKN = "ipv4only.arpa."

ref: datatracker.ietf.org/doc/html/rfc8880

View Source 
const UnderlayResolver = "__underlay" // used by transport dnsx.System

Variables

View Source 
var (
	EchPrefix   = "ech."
	NoPkiPrefix = "nopki."
)
View Source 
var (
	ErrNotDefaultTransport = errors.New("not a default dns transport")
	ErrNoDcProxy           = errors.New("no dnscrypt-proxy")
	ErrNoProxyProvider     = errors.New("no proxy provider for dns")
	ErrNoProxyDNS          = errors.New("no proxy dns")
	ErrAddFailed           = errors.New("dns add failed")
)

Functions

func IsEncrypted 

func IsEncrypted(t Transport) bool

func IsLocalProxy 

func IsLocalProxy(pid string) bool

func NewDNSGateway 

func NewDNSGateway(pctx context.Context, outer RdnsResolver, dns64 NatPt) (t *dnsgateway)

NewDNSGateway returns a DNS ALG, ready for use.

func NewResolver 

func NewResolver(pctx context.Context, fakeaddrs string, tunmode *settings.TunMode, dtr x.DNSTransport, l x.DNSListener, pt NatPt) *resolver

func NewXips 

func NewXips(id string, pri []netip.Addr, sec []netip.Addr) *xips

func PrefixFor 

func PrefixFor(id string) string

func RegisterAddrs 

func RegisterAddrs(id, hostname string, ipps []string) (ok bool)

RegisterAddrs registers IP ports with all dialers for a given hostname. If id is dnsx.Bootstrap, the hostname is "protected" from re-resolutions. hostname is a domain name, and as a special case, can be protect.UidSelf or protect.UidSystem.

func Req 

func Req(t Transport, network string, q *dns.Msg, smm *x.DNSSummary) (*dns.Msg, error)

Req sends q to transport t and returns the answer, if any; errors are unset if answer is not servfail or empty; smm, the in/out parameter, is dns summary as got from t.

Types

type DNS64 

type DNS64 interface {
	// Add64 registers DNS64 resolver f to id.
	Add64(f Transport) bool
	// Remove64 deregisters any current resolver from id.
	Remove64(id string) bool
	// ResetNat64Prefix sets the NAT64 prefix for transport id to ip6prefix.
	ResetNat64Prefix(ip6prefix string) bool
	// D64 synthesizes ans64 (AAAA) from ans6 if required, using resolver f.
	// Returned ans64 is nil if no DNS64 synthesis is needed (not AAAA).
	// Returned ans64 is ans6 if it already has AAAA records.
	D64(network string, ans6 *dns.Msg, f Transport) *dns.Msg
}

type Gateway 

type Gateway interface {
	// given an alg or real ip, retrieves assoc real ips as csv, if any
	X(maybeAlg netip.Addr, tids ...string) (realips []netip.Addr, undidAlg bool)
	// given an alg or real ip, retrieves assoc dns names as csv, if any
	PTR(maybeAlg netip.Addr, force bool) (domaincsv string, didForce bool)
	// given domain, retrieve assoc alg ips or real ips as csv, if any
	RESOLV(domain string) []netip.Addr
	// given an alg or real ip, retrieve assoc blocklists as csv, if any
	RDNSBL(maybeAlg netip.Addr) (blocklistcsv string)
	// contains filtered or unexported methods
}

type NAT64 

type NAT64 interface {
	// Returns true if ip is a NAT64 address from transport id.
	IsNat64(id string, ip netip.Addr) bool
	// Translates ip to IPv4 using the NAT64 prefix for transport id.
	// As a special case, ip is zero addr, output is always IPv4 zero addr.
	X64(id string, ip netip.Addr) netip.Addr
}

type NatPt 

type NatPt interface {
	DNS64
	NAT64
}

type QueryError 

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

func NewBadQueryError 

func NewBadQueryError(err error) *QueryError

func NewBadResponseQueryError 

func NewBadResponseQueryError(err error) *QueryError

func NewClientQueryError 

func NewClientQueryError(err error) *QueryError

with http, for 4xx errors

func NewInternalQueryError 

func NewInternalQueryError(err error) *QueryError

func NewNoResponseQueryError 

func NewNoResponseQueryError(err error) *QueryError

func NewSendFailedQueryError 

func NewSendFailedQueryError(err error) *QueryError

func NewTransportQueryError 

func NewTransportQueryError(err error) *QueryError

with http, for 5xx errors

func (*QueryError) Error 

func (e *QueryError) Error() string

func (*QueryError) Status 

func (e *QueryError) Status() int

func (*QueryError) String 

func (e *QueryError) String() string

func (*QueryError) Unwrap 

func (e *QueryError) Unwrap() error

type RDNS 

type RDNS interface {
	x.RDNS
	OnDeviceBlock() bool // Mode
	// contains filtered or unexported methods
}

type RdnsResolver 

type RdnsResolver interface {
	x.RDNSResolver
	// contains filtered or unexported methods
}

type Resolver 

type Resolver interface {
	x.DNSTransportMult
	RdnsResolver
	NatPt

	// special purpose pre-defined transports
	// Gateway implements a DNS ALG transport
	Gateway() Gateway
	// GetMult returns multi-transport, if available
	GetMult(id string) (TransportMult, error)

	IsDnsAddr(ipport netip.AddrPort) bool
	// Lookup performs resolution on Default and/or Goos DNSes
	LocalLookup(q []byte) ([]byte, error)
	// LookupIPs performs resolution on chosen Transport.
	Lookup([]byte, ...string) ([]byte, error)
	// Forward performs resolution on any DNS transport
	Forward(q []byte) ([]byte, error)
	// Serve reads DNS query from conn and writes DNS answer to conn
	Serve(proto string, conn protect.Conn)
	// contains filtered or unexported methods
}

type TestFn 

type TestFn[T any] func(T) bool

type Transport 

type Transport interface {
	x.DNSTransport
	// Given a DNS query (including ID), returns a DNS response with matching
	// ID, or an error if no response was received.  The error may be accompanied
	// by a SERVFAIL response if appropriate.
	Query(network string, q *dns.Msg, summary *x.DNSSummary) (*dns.Msg, error)
	// Stop closes the transport.
	Stop() error
}

Transport represents a DNS query transport. This interface is exported by gobind, so it has to be very simple.

func NewCachingTransport 

func NewCachingTransport(t Transport, ttl time.Duration) Transport

func NewDefaultCachingTransport 

func NewDefaultCachingTransport(t Transport) Transport

type TransportMult 

type TransportMult interface {
	x.DNSTransportMult
	Transport
}

TransportMult is a hybrid: transport and a multi-transport.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.