network

type DelegatePacketProxy interface {
	PacketProxy

	// SetProxy updates the underlying PacketProxy to `proxy`; `proxy` must not be nil. After this function
	// returns, all new PacketProxy calls will be forwarded to the `proxy`. Existing sessions will not be affected.
	SetProxy(proxy PacketProxy) error
}

type IPDevice interface {
	// Close closes this device. Any future Read will return io.EOF and Write will return ErrClosed.
	Close() error

	// Read reads an IP packet from this device into p, returning the number of bytes read. It blocks until a full IP
	// packet has been received. Note that an IP packet might be fragmented, and we will not reassemble it. Instead, we
	// will simply return the fragmented packets to the caller.
	//
	// If len(p) is smaller than the incoming IP packet, only len(p) bytes will be copied to p, the excess bytes are
	// discarded (this aligns with the socket recvfrom function), and nil error will be returned. You can Use MTU to get
	// the maximum size of the packets.
	//
	// If the returned error is nil, it means that Read has completed successfully and that an IP packet has been copied
	// into p.
	Read(p []byte) (int, error)

	// Write writes an IP packet p to this device and returns the number of bytes written. Similar to Read, large IP
	// packets must be fragmented by the caller, and len(p) must not exceed the maximum buffer size returned by MTU.
	//
	// Write will return (0, ErrMsgSize) if len(p) > MTU(). This aligns with the socket sendto function.
	//
	// If the returned error is nil, it means that Write has completed successfully and that the entire packet has been
	// written to the destination.
	//
	// If only a portion of the packet has been written, Write will return a non-nil error as well as the number of bytes
	// written (< len(p)).
	Write(b []byte) (int, error)

	// MTU returns the size of the Maximum Transmission Unit for this device, which is the maximum size of a single IP
	// packet that can be received/sent.
	MTU() int
}

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

type PacketProxy interface {
	// NewSession function tells the PacketProxy that a new UDP socket session has been started (using socket as an
	// example, a session will be started by calling the bind() function). The PacketProxy then creates a
	// PacketRequestSender object to handle requests from this session, and it also uses the PacketResponseReceiver
	// to send responses back to the upstream network stack.
	//
	// Note that it is possible for a session to receive UDP packets without sending any requests.
	NewSession(PacketResponseReceiver) (PacketRequestSender, error)
}

type PacketRequestSender interface {
	// WriteTo sends a UDP request packet to the PacketProxy. The packet is destined for the remote server identified
	// by `destination` and the payload of the packet is stored in `p`. If `p` is empty, the request packet will be
	// ignored. WriteTo returns the number of bytes written from `p` and any error encountered that caused the function
	// to stop early.
	//
	// `p` must not be modified, and it must not be referenced after WriteTo returns.
	WriteTo(p []byte, destination netip.AddrPort) (int, error)

	// Close indicates that the sender is no longer accepting new requests. Any future attempts to call WriteTo on the
	// sender will fail with ErrClosed.
	Close() error
}

type PacketResponseReceiver interface {
	// WriteFrom is a callback function that is called by a PacketProxy when a UDP response packet is received. The
	// `source` identifies the remote server that sent the packet and the `p` contains the packet payload. WriteFrom
	// returns the number of bytes written from `p` and any error encountered that caused the function to stop early.
	//
	// `p` must not be modified, and it must not be referenced after WriteFrom returns.
	WriteFrom(p []byte, source net.Addr) (int, error)

	// Close indicates that the receiver is no longer accepting new responses. Any future attempts to call WriteFrom on
	// the receiver will fail with ErrClosed.
	Close() error
}