client

type Client interface {
	// DialTCP connects to `raddr` over TCP though a Shadowsocks proxy.
	// `laddr` is a local bind address, a local address is automatically chosen if nil.
	// `raddr` is the target socks address.
	DialTCP(laddr *net.TCPAddr, raddr []byte, dialerTFO bool) (onet.DuplexConn, error)

	// ListenUDP starts a new Shadowsocks UDP session and returns a connection that
	// can be used to relay UDP packets though the proxy.
	// `laddr` is a local bind address, a local address is automatically chosen if nil.
	// For Shadowsocks 2022, this encapsulation does not support multiplexing several sessions
	// into one proxy connection.
	ListenUDP(laddr *net.UDPAddr) (ShadowsocksPacketConn, error)

	// Cipher gets the underlying Shadowsocks cipher used by the client.
	Cipher() *ss.Cipher
}

type Handshaker interface {
	String() string
	Handshake(*net.TCPConn) (socks.Addr, error)
}

type PacketAdapter interface {
	String() string

	// ParsePacket parses an incoming packet and returns payload start index, payload length,
	// a detached socks address (if applicable), or an error.
	//
	// The detached socks address is only returned when the payload does not start with a socks address.
	ParsePacket(pkt []byte, start, length int) (payloadStart, payloadLength int, detachedSocksAddr []byte, err error)

	// EncapsulatePacket encapsulates the decrypted packet from proxy
	// into a new form so it's ready to be sent on the local interface.
	// The encapsulation must not extend beyond the range of the full decrypted packet.
	EncapsulatePacket(decryptedFullPacket []byte, socksAddrStart, payloadStart, payloadLength int) (pkt []byte, err error)
}

type Service interface {
	// String returns the service's name.
	// This method may be called on a nil pointer.
	String() string

	// Start starts the service.
	Start() error

	// Stop stops the service.
	Stop() error
}

type ShadowsocksNoneHandshaker struct{}

type ShadowsocksNonePacketAdapter struct{}

type ShadowsocksPacketConn interface {
	net.PacketConn

	// RemoteAddr returns the remote proxy's address.
	RemoteAddr() net.Addr

	// ReadFromZeroCopy eliminates copying by requiring that a big enough buffer is passed for reading.
	ReadFromZeroCopy(b []byte) (socksAddrStart, payloadStart, payloadLength int, err error)

	// WriteToZeroCopy minimizes copying by requiring that enough space is reserved in b.
	// The socks address is still being copied into the buffer.
	//
	// You should reserve 24 + ss.UDPClientMessageHeaderFixedLength + ss.MaxPaddingLength + socks.MaxAddrLen
	// in the beginning, and cipher.TagSize() in the end.
	//
	// start points to where the actual payload (excluding header) starts.
	// length is payload length.
	WriteToZeroCopy(b []byte, start, length int, socksAddr []byte) (n int, err error)
}

type SimpleHttpConnectHandshaker struct{}

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

type SimpleSocks5PacketAdapter struct{}

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

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

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

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