netstack

type DemuxerFn func(in net.Conn, to netip.AddrPort) error

type Direction int

type EpStat struct {
	// Fd is the file descriptor of the endpoint.
	Fd int
	// Alive indicates whether the endpoint is alive.
	Alive bool
	// Age is the age of the endpoint.
	Age string
	// Read is the number of bytes read from the endpoint.
	Read string
	// Written is the number of bytes written to the endpoint.
	Written string
	// LastRead is the last time the endpoint was read from.
	LastRead string
	// LastWrite is the last time the endpoint was written to.
	LastWrite string
}

type FdSwapper interface {
	// Swap closes existing FDs; uses new fd.
	Swap(fd, mtu int) error
	// Dispose closes all existing FDs.
	Dispose() error
	// Stat returns EpStat (fd, age, read, written, lastRead, lastWrite).
	Stat() EpStat
}

type GBaseConnHandler interface {
	// OpenConns returns the number of active connections.
	OpenConns() string
	// CloseConns closes conns by ids, or all if ids is empty.
	CloseConns([]string) []string
	// end closes the handler and all its connections.
	End()
}

type GConnHandler interface {
	Src() []netip.Prefix
	TCP() GTCPConnHandler         // TCP returns the TCP handler.
	UDP() GUDPConnHandler         // UDP returns the UDP handler.
	ICMP() GICMPHandler           // ICMP returns the ICMP handler.
	CloseConns(csv string) string // CloseConns closes the connections with the given IDs, or all if empty.
}

type GEchoConnHandler interface {
	// Ping informs if ICMP Echo from src to dst is replied to
	Ping(msg []byte, src, dst netip.AddrPort) bool
}

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

type GICMPHandler interface {
	GBaseConnHandler
	GEchoConnHandler
}

type GMuxConnHandler[T gconns] interface {
	// ProxyMux proxies data between conn and multiple destinations
	// (endpoint-independent mapping).
	ProxyMux(in T, src, dst netip.AddrPort, dmx DemuxerFn) bool
}

type GSpecConnHandler[T gconns] interface {
	GBaseConnHandler
	// Proxy copies data between conn and dst (egress).
	// must not block forever as it may block netstack
	// see: netstack/dispatcher.go:newReadvDispatcher
	Proxy(in T, src, dst netip.AddrPort) bool
	// ReverseProxy copies data between conn and dst (ingress).
	ReverseProxy(out T, in net.Conn, src, dst netip.AddrPort) bool
	// Error notes the error in connecting src to dst; retrying if necessary.
	Error(in T, src, dst netip.AddrPort, err error)
}

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

type GTCPConnHandler interface {
	GSpecConnHandler[*GTCPConn]
}

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

type GUDPConnHandler interface {
	GSpecConnHandler[*GUDPConn]
	GMuxConnHandler[*GUDPConn]
}

type Options struct {
	// FDs is a set of FDs used to read/write packets.
	FDs []int

	// MTU is the mtu to use for this endpoint.
	MTU uint32

	// EthernetHeader if true, indicates that the endpoint should read/write
	// ethernet frames instead of IP packets.
	EthernetHeader bool

	// Address is the link address for this endpoint. Only used if
	// EthernetHeader is true.
	Address tcpip.LinkAddress

	// SaveRestore if true, indicates that this NIC capability set should
	// include CapabilitySaveRestore
	SaveRestore bool

	// DisconnectOk if true, indicates that this NIC capability set should
	// include CapabilityDisconnectOk.
	DisconnectOk bool

	// TXChecksumOffload if true, indicates that this endpoints capability
	// set should include CapabilityTXChecksumOffload.
	TXChecksumOffload bool

	// RXChecksumOffload if true, indicates that this endpoints capability
	// set should include CapabilityRXChecksumOffload.
	RXChecksumOffload bool

	// If MaxSyscallHeaderBytes is non-zero, it is the maximum number of bytes
	// of struct iovec, msghdr, and mmsghdr that may be passed by each host
	// system call.
	MaxSyscallHeaderBytes int
}

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

type SeamlessEndpoint interface {
	stack.LinkEndpoint
	FdSwapper
}