conn

type Bind interface {
	// Open puts the Bind into a listening state on a given port and reports the actual
	// port that it bound to. Passing zero results in a random selection.
	// fns is the set of functions that will be called to receive packets.
	Open(port uint16) (fns []ReceiveFunc, actualPort uint16, err error)

	// Close closes the Bind listener.
	// All fns returned by Open must return net.ErrClosed after a call to Close.
	Close() error

	// SetMark sets the mark for each packet sent through this Bind.
	// This mark is passed to the kernel as the socket option SO_MARK.
	SetMark(mark uint32) error

	// Send writes one or more packets in bufs to address ep. A nonzero offset
	// can be used to instruct the Bind on where packet data begins in each
	// element of the bufs slice. Space preceding offset is free to use for
	// additional encapsulation. The length of bufs must not exceed BatchSize().
	Send(bufs [][]byte, ep Endpoint, offset int) error

	// ParseEndpoint creates a new endpoint from a string.
	ParseEndpoint(s string) (Endpoint, error)

	// BatchSize is the number of buffers expected to be passed to
	// the ReceiveFuncs, and the maximum expected to be passed to SendBatch.
	BatchSize() int
}

type BindSocketToInterface interface {
	BindSocketToInterface4(interfaceIndex uint32, blackhole bool) error
	BindSocketToInterface6(interfaceIndex uint32, blackhole bool) error
}

type Endpoint interface {
	ClearSrc()           // clears the source address
	SrcToString() string // returns the local source address (ip:port)
	DstToString() string // returns the destination address (ip:port)
	DstToBytes() []byte  // used for mac2 cookie calculations
	DstIP() netip.Addr
	SrcIP() netip.Addr
}

type ErrUDPGSODisabled struct {
	RetryErr error
	// contains filtered or unexported fields
}

type InitiationAwareEndpoint interface {
	// InitiationMessagePublicKey is called when a handshake initiation message
	// has been received, and the sender's public key has been identified, but
	// BEFORE an attempt has been made to verify it.
	InitiationMessagePublicKey(peerPublicKey [32]byte)
}

type PeekLookAtSocketFd interface {
	PeekLookAtSocketFd4() (fd int, err error)
	PeekLookAtSocketFd6() (fd int, err error)
}

type PeerAwareEndpoint interface {
	// FromPeer is called at least once per successfully Cryptokey Routing ID'd
	// [ReceiveFunc] packets batch for a given node key. wireguard-go will
	// always call it for the latest/tail packet in the batch, only ever
	// suppressing calls for older packets.
	FromPeer(peerPublicKey [32]byte)
}

type ReceiveFunc func(slab []byte, packets []ReceivedPacket) (n int, err error)

type ReceivedPacket struct {
	// Offset is the starting byte offset.
	Offset int
	// Size is the size of the packet.
	Size int
	// Endpoint is the associated [Endpoint].
	Endpoint Endpoint
}

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

type StdNetEndpoint struct {
	// AddrPort is the endpoint destination.
	netip.AddrPort
	// contains filtered or unexported fields
}