network

type DialContextFunc func(ctx context.Context, network, address string) (stdnet.Conn, error)

type Forwarder interface {
	// TCPProtocolHandler forwards a TCP session.
	TCPProtocolHandler(id stack.TransportEndpointID, pkt *stack.PacketBuffer) bool
	// UDPProtocolHandler forwards a UDP session.
	UDPProtocolHandler(id stack.TransportEndpointID, pkt *stack.PacketBuffer) bool
	// ICMPProtocolHandler forwards an ICMP session.
	ICMPv4ProtocolHandler(id stack.TransportEndpointID, pkt *stack.PacketBuffer) bool
	// ICMPv6ProtocolHandler forwards an ICMPv6 session.
	ICMPv6ProtocolHandler(id stack.TransportEndpointID, pkt *stack.PacketBuffer) bool
	// ValidDestination checks if the destination address is valid for forwarding.
	ValidDestination(addr netip.Addr) bool
}

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

type Interface interface {
	io.Closer

	// MTU returns the Maximum Transmission Unit of the interface.
	MTU() (int, error)

	// BatchSize returns the preferred/max number of packets that can be read or
	// written in a single read/write call.
	BatchSize() int

	// Read one or more packets from the interface (without any additional headers).
	// On a successful read it returns a slice of packets of up-to length batchSize.
	// The caller is responsible for releasing the packets back to the pool. The
	// caller can optionally supply an unallocated packets slice (eg. from a
	// previous call to Read()) that will be used to store the read packets.
	// This allows avoiding allocating a new packets slice on each read.
	Read(ctx context.Context, packets []*Packet, offset int) ([]*Packet, error)

	// Write one or more packets to the interface (without any additional headers).
	// Ownership of the packets is transferred to the interface and must not be
	// accessed after a write operation.
	Write(ctx context.Context, packets []*Packet) error
}

type Network interface {
	io.Closer
	// Hostname returns the hostname of the local machine.
	Hostname() (string, error)
	// Domain returns the domain of the local machine.
	Domain() (string, error)
	// InterfaceAddrs returns a list of the network interfaces addresses.
	InterfaceAddrs() ([]stdnet.Addr, error)
	// LookupHost looks up the IP addresses for the given host.
	LookupHost(host string) ([]string, error)
	// LookupHostContext looks up the IP addresses for the given host.
	LookupHostContext(ctx context.Context, host string) ([]string, error)
	// Dial connects to the address on the named network.
	// Known networks are "tcp", "tcp4" (IPv4-only), "tcp6" (IPv6-only), "udp", "udp4" (IPv4-only), "udp6" (IPv6-only).
	Dial(network, address string) (stdnet.Conn, error)
	// DialContext connects to the address on the named network using the provided context.
	DialContext(ctx context.Context, network, address string) (stdnet.Conn, error)
	// Listen listens for incoming connections on the network address.
	// Known networks are "tcp", "tcp4" (IPv4-only), "tcp6" (IPv6-only).
	// If the address is an empty string, Listen listens on all available addresses.
	Listen(network, address string) (stdnet.Listener, error)
	// ListenPacket listens for incoming packets addressed to the local address.
	// Known networks are "udp", "udp4" (IPv4-only), "udp6" (IPv6-only).
	ListenPacket(network, address string) (stdnet.PacketConn, error)
	// Ping sends an ICMP echo request to the given host.
	// Network must be "ip", "ip4" (IPv4-only), "ip6" (IPv6-only).
	Ping(ctx context.Context, network, host string) error
}

type Packet struct {
	// Buf is the buffer containing the packet data.
	Buf [MaxPacketSize]byte
	// Offset is the offset inside the buffer where the packet data starts.
	Offset int
	// Size is the size of the packet data.
	Size int
	// contains filtered or unexported fields
}

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

type PipeConfiguration struct {
	// MTU is the maximum transmission unit of the pipe.
	// If not specified, a default MTU of 1500 will be used.
	MTU *int
	// BatchSize is the maximum number of packets that can be read or written at
	// once. If not specified, a default batch size of 16 will be used.
	BatchSize *int
	// PacketPool is the pool from which packets are borrowed.
	// If not specified, an unbounded pool will be created.
	PacketPool *PacketPool
}

type ResolverFactory func(dialContext DialContextFunc) (resolver.Resolver, error)

type SpliceConfiguration struct {
	// PacketWriteOffset is an optional hint to write outbound packet data at a
	// specific offset inside the buffer. This is a performance hint for
	// WireGuard (and other protocols that need to add their own headers).
	PacketWriteOffset int
}

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

type UserspaceNetworkConfig struct {
	// Hostname is the hostname of the local process.
	Hostname string
	// Domain is the local domain of the network.
	Domain string
	// Addresses is a list of IP addresses/IP prefixes to add.
	Addresses []netip.Prefix
	// ResolverFactory is an optional factory to create a DNS resolver.
	ResolverFactory ResolverFactory
	// PacketCaptureWriter is an optional writer to write a packet capture file to.
	// If nil, no packet capture file will be written.
	// This is useful for debugging network issues.
	PacketCaptureWriter io.Writer
	// PacketPool is the pool from which packets are borrowed.
	// If not specified, an unbounded pool will be created.
	PacketPool *PacketPool
	// PacketWriteOffset is an optional hint to write outbound packet data at a
	// specific offset inside the buffer. This is a performance hint for
	// WireGuard (and other protocols that need to add their own headers).
	PacketWriteOffset int
}