querylog

Documentation

Overview

Package querylog provides query log functions and interfaces.

Index

• Constants
• func AnonymizeIP(ip net.IP)
• type AddParams
• type Client
• type ClientProto
  • func NewClientProto(s string) (cp ClientProto, err error)
• type Config
• type QueryLog
  • func New(conf Config) (ql QueryLog, err error)

Constants

const ErrEndOfToken errors.Error = "end of token"

ErrEndOfToken is an error returned by parse key token when the closing bracket is found.

Functions

func AnonymizeIP

func AnonymizeIP(ip net.IP)

AnonymizeIP masks ip to anonymize the client if the ip is a valid one.

Types

type AddParams

type AddParams struct {
	Question *dns.Msg

	// ReqECS is the IP network extracted from EDNS Client-Subnet option of a
	// request.
	ReqECS *net.IPNet

	// Answer is the response which is sent to the client, if any.
	Answer *dns.Msg

	// OrigAnswer is the response from an upstream server.  It's only set if the
	// answer has been modified by filtering.
	OrigAnswer *dns.Msg

	// Result is the filtering result (optional).
	Result *filtering.Result

	ClientID string

	// Upstream is the URL of the upstream DNS server.
	Upstream string

	ClientProto ClientProto

	ClientIP net.IP

	// Elapsed is the time spent for processing the request.
	Elapsed time.Duration

	// Cached indicates if the response is served from cache.
	Cached bool

	// AuthenticatedData shows if the response had the AD bit set.
	AuthenticatedData bool
}

AddParams is the parameters for adding an entry.

type Client

type Client struct {
	WHOIS          *whois.Info `json:"whois,omitempty"`
	Name           string      `json:"name"`
	DisallowedRule string      `json:"disallowed_rule"`
	Disallowed     bool        `json:"disallowed"`
	IgnoreQueryLog bool        `json:"-"`
}

Client is the information required by the query log to match against clients during searches.

type ClientProto

type ClientProto string

ClientProto values are names of the client protocols.

const (
	ClientProtoDoH      ClientProto = "doh"
	ClientProtoDoQ      ClientProto = "doq"
	ClientProtoDoT      ClientProto = "dot"
	ClientProtoDNSCrypt ClientProto = "dnscrypt"
	ClientProtoPlain    ClientProto = ""
)

Client protocol names.

func NewClientProto

func NewClientProto(s string) (cp ClientProto, err error)

NewClientProto validates that the client protocol name is valid and returns the name as a ClientProto.

type Config

type Config struct {
	// Logger is used for logging the operation of the query log.  It must not
	// be nil.
	Logger *slog.Logger

	// Ignored contains the list of host names, which should not be written to
	// log, and matches them.
	Ignored *aghnet.IgnoreEngine

	// Anonymizer processes the IP addresses to anonymize those if needed.
	Anonymizer *aghnet.IPMut

	// ConfigModified is called when the configuration is changed, for example
	// by HTTP requests.
	ConfigModified func()

	// HTTPRegister registers an HTTP handler.
	HTTPRegister aghhttp.RegisterFunc

	// FindClient returns client information by their IDs.
	FindClient func(ids []string) (c *Client, err error)

	// BaseDir is the base directory for log files.
	BaseDir string

	// RotationIvl is the interval for log rotation.  After that period, the old
	// log file will be renamed, NOT deleted, so the actual log retention time
	// is twice the interval.
	RotationIvl time.Duration

	// MemSize is the number of entries kept in a memory buffer before they are
	// flushed to disk.
	MemSize uint

	// Enabled tells if the query log is enabled.
	Enabled bool

	// FileEnabled tells if the query log writes logs to files.
	FileEnabled bool

	// AnonymizeClientIP tells if the query log should anonymize clients' IP
	// addresses.
	AnonymizeClientIP bool
}

Config is the query log configuration structure.

Do not alter any fields of this structure after using it.

type QueryLog

type QueryLog interface {
	// Interface starts and stops the query log.
	service.Interface

	// Add adds a log entry.
	Add(params *AddParams)

	// WriteDiskConfig writes the query log configuration to c.
	WriteDiskConfig(c *Config)

	// ShouldLog returns true if request for the host should be logged.
	ShouldLog(host string, qType, qClass uint16, ids []string) bool
}

QueryLog is the query log interface for use by other packages.

func New

func New(conf Config) (ql QueryLog, err error)

New creates a new instance of the query log.