offloader

type BpfMetrics interface {
	MapName() string
	LoadPinnedMap() error
	Close() error

	Entries() ([64]uint64, error)
	ZeroAll() error
}

type ControlBpfReq struct {
	Dryrun    bool     `json:"dryrun"`
	Option    string   `json:"option"`
	Value     bool     `json:"value"`
	ValueList []string `json:"values,omitempty"`
}

type IPNet struct {
	IP   netip.Addr
	Mask uint32
	Bits int
}

type JericoRuntimeConfig struct {
	Mp *ebpf.Map `ebpf:"yadns_xdp_runtime_config"`

	PinPath string
}

type PassMap interface {
	MapName() string
	LoadPinnedMap() error
	Entries() (map[string]TAddr, error)
	Close() error

	Update(prefix TAddr) error
	// Create(prefix IPNet) error
	Remove(prefix TAddr) error
}

type PassMap4 struct {
	Mp *ebpf.Map `ebpf:"daddr4_pass"`

	PinPath string
}

type PassMap6 struct {
	Mp *ebpf.Map `ebpf:"daddr6_pass"`

	PinPath string
}

type PerfHistorgram struct {
	Mp *ebpf.Map `ebpf:"yadns_xdp_perf"`

	PinPath string
}

type PerfMetrics struct {
	Mp *ebpf.Map `ebpf:"yadns_xdp_metrics"`

	PinPath string
}

type RREntry interface {
	// functions hidden
	AsRawString() string

	QnameAsBytes() []byte

	Qname() RRQname
	Qtype() uint16

	Qdata() string

	QTTL() uint32

	IP() netip.Addr
}

type RREntryA struct {
	RRKey
	RRValueA
}

type RREntryAAAA struct {
	RRKey
	RRValueAAAA
}

type RRKey struct {
	// question type and class
	Qtype  uint16 `json:"qtype"`
	Qclass uint16 `json:"qclass"`

	// a qname to match, see qname definition
	// #define MAX_DNS_NAME_LENGTH 256
	Qname RRQname `json:"qname"`
}

type RRMap interface {
	MapName() string
	LoadPinnedMap() error
	Close() error

	Remove(qname RRQname, qtype uint16) error
	Create(qname RRQname, qtype uint16, ttl uint32, ip netip.Addr) error
	Update(qname RRQname, qtype uint16, ttl uint32, ip netip.Addr) error

	Lookup(qname RRQname, qtype uint16) (RREntry, error)

	Entries() ([]RREntry, error)
}

type RRMapA struct {
	Mp *ebpf.Map `ebpf:"yadns_xdp_rr_a"`

	PinPath string
}

type RRMapAAAA struct {
	Mp *ebpf.Map `ebpf:"yadns_xdp_rr_aaaa"`

	PinPath string
}

type RRQname [48]byte

type RRValue interface {
	AsRawString() string
}

type RRValueA struct {
	// unsigned long s_addr, use As4() for
	// ip4 address to fill
	Addr [4]byte `json:"addr"`

	// TTL for answer
	TTL uint32 `json:"ttl"`
}

type RRValueAAAA struct {
	// use As16() for conversion
	Addr [16]byte `json:"addr"`

	// TTL for answer
	TTL uint32 `json:"ttl"`
}

type RuntimeConfigOptions struct {
	BpfConstantBpfDyrun bool
}

type Switches struct {
	// should it be global switch or local
	Dryrun bool
}

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

type TConfigControls struct {
	// if controller should check and mount bppfs
	Bpffs bool `json:"bpffs" yaml:"bpffs"`

	// if we should set memlock to unlimit
	UnlimitMemlock bool `json:"unlimit-memlock" yaml:"unlimit-memlock"`
}

type TConfigLoader struct {

	// mode could be "primary" "secondary", auto"
	Mode string `json:"mode" yaml:"mode"`

	// hook options for "secondary" mode
	Hook THookLoader `json:"hook" yaml:"hook"`
}

type TConfigNetdev struct {
	Address   string            `json:"address"`
	Broadcast string            `json:"broadcast"`
	Flags     []string          `json:"flags"`
	Group     string            `json:"group"`
	Ifindex   int               `json:"ifindex"`
	Ifname    string            `json:"ifname"`
	Mtu       int               `json:"mtu"`
	Operstate string            `json:"operstate"`
	Xdp       *TConfigNetdevXdp `json:"xdp"`
}

type TConfigNetdevProg struct {
	ID    int    `json:"id"`
	Jited int    `json:"jited"`
	Tag   string `json:"tag"`
}

type TConfigNetdevXdp struct {
	Mode int               `json:"mode"`
	Prog TConfigNetdevProg `json:"prog"`

	Attached []TConfigNetdevXdp `json:"attached"`
}

type TConfigOptions struct {
	// interface
	Interface string `json:"interface" yaml:"interface"`

	// requests DSTS for IP6 and IP4 dst addresses
	// to match VS processing
	Addrs []string `json:"addrs" yaml:"addrs"`

	// I hope that we will need only one bpf program
	// to handle traffic
	Path string `json:"path" yaml:"path"`

	// pinpath
	PinPath string `json:"pinpath" yaml:"pinpath"`

	// bpf option dryrun
	BpfDryrun bool `json:"bpf-dryrun" yaml:"bpf-dryrun"`

	// bpf option to enable xdpcap hook call
	BpfXdpcap bool `json:"bpf-xdpcap" yaml:"bpf-xdpcap"`

	// enable of disable bpf perf
	BpfMetrics bool `json:"bpf-metrics" yaml:"bpf-metrics"`

	// if xdp should generate random TTL (it could be
	// used in ns-cache responses)
	ResponseRandomTTL bool `json:"response-random-ttl" yaml:"response-random-ttl"`

	// response flags, AA, RD, RA, MBZ
	ResponseFlags []string `json:"response-flags" yaml:"response-flags"`
}

type TDnsDaddr4 struct {
	// prefix of the network
	PrefixLen uint32

	// in V6 version we have 16 bytes slice
	Addr [4]byte
}

type TDnsDaddr6 struct {
	// prefix of the network
	PrefixLen uint32

	// in V6 version we have 16 bytes slice
	Addr [16]byte
}

type THookLoader struct {

	// hook pinpath
	PinPath string `json:"pinpath" yaml:"pinpath"`

	// index pinpath
	Index []int `json:"index" yaml:"index"`
}

type TOffloaderPlugin struct {

	// some common attributes for all plugins, global
	// configuration ref, name and type
	plugins.Plugin
	// contains filtered or unexported fields
}

type TOffloaderPluginConfig struct {
	// could be disabled
	Enabled bool `json:"enabled" yaml:"enabled"`

	// bpf controls for some cases
	Controls TConfigControls `json:"controls" yaml:"controls"`

	// bpf xdp options
	Options TConfigOptions `json:"options" yaml:"options"`

	// XDP loader options, by default we have primary mode
	Loader TConfigLoader `json:"loader" yaml:"loader"`
}

type TPerfValue struct {
	// a counter number in a cell of
	// historgram (counts of time)
	Counter uint64
}

type TXdpCiliumBinary struct {

	// used in load and assign bpf call
	// also could be set with maps
	Program *ebpf.Program `ebpf:"xdp_dns"`

	// a list of ebpf maps for each type RR
	MapA RRMapA

	MapAAAA RRMapAAAA

	// a list of maps with dst addr
	MapPass4 PassMap4
	MapPass6 PassMap6
}

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

type TXdpServiceFlags struct {
	// some xdp attach flags
	Flags link.XDPAttachFlags
}