socks5

type AuthenticationMethod interface {
	// Authenticate will respond to the net.Conn with the selected authentication method.
	// Then, the AuthenticationMethod should proceed and finish the authentication process.
	//
	// If returned error is nil, the authentication process is considered successful.
	// Otherwise, the authentication process is considered failed and the connection
	// MUST be closed by the caller.
	Authenticate(net.Conn) error
}

type Authenticator struct {
	Forced         bool // default: false, if set to true, NO_AUTHENTICATION_REQUIRED is not accepted
	UserPass       map[string]string
	PrivateMethods map[byte]AuthenticationMethod
}

type Config struct {
	// Auth specifies an *Authenticator to be used by the SOCKS5 server to
	// authenticate incoming SOCKS5 client connections. If nil, the SOCKS5 server
	// will not require authentication.
	Auth *Authenticator

	// LoggingHandler specifies a handler to be used by the SOCKS5 server. If nil,
	// the default logging handler will be used.
	//
	// TODO: switch to log/slog from experimental once it became stable in Go 1.21
	LoggingHandler slog.Handler

	// Proxy specifies a proxy implementation to be used by the SOCKS5 server.
	//
	// See proxy.go for more details about the Proxy interface and the localProxy
	// implementation.
	Proxy Proxy

	// ConnectTimeout specifies the maximum amount of time a Server will wait for
	// a Connect invocation to complete on the Proxy.
	//
	// If zero, no timeout is set and the Server may block indefinitely.
	ConnectTimeout time.Duration

	// BindTimeout specifies the maximum amount of time a Server will wait for a
	// Bind invocation to complete on the Proxy. It is recommended that this value
	// be set to a reasonable value to prevent port exhaustion.
	//
	// If zero, no timeout is set and the Server may block indefinitely.
	BindTimeout time.Duration

	// UDPTimeout specifies the maximum amount of time a Server will wait for a
	// UDP associate invocation to complete on the Proxy.
	//
	// If zero, no timeout is set and the Server may block indefinitely.
	UDPTimeout time.Duration
}

type NoAuthenticationRequired struct{}

type Packet interface {
	// Read reads the packet from the given reader into the Packet object.
	//
	// SHOULD ONLY be called for client-sent packets. Calling this method
	// on a server-sent packet SHOULD result in an error.
	Read(io.Reader) error

	// Write writes the packet to the given writer.
	//
	// SHOULD ONLY be called for server-sent packets. Calling this method
	// on a client-sent packet SHOULD result in an error.
	Write(io.Writer) error
}

type PacketAuthRequest struct {
	VER      byte
	NMETHODS byte
	METHODS  []byte // length: NMETHODS
}

type PacketAuthSelect struct {
	VER    byte
	METHOD byte
}

type PacketReply struct {
	VER     byte
	REP     byte
	RSV     byte // must be 0x00, fail otherwise
	ATYP    byte
	BNDADDR string
	BNDPORT uint16
}

type PacketRequest struct {
	VER     byte
	CMD     byte
	RSV     byte
	ATYP    byte
	DSTADDR string
	DSTPORT uint16
}

type PacketUDPRequest struct {
	RSV     uint16
	FRAG    byte
	ATYP    byte
	DSTADDR string
	DSTPORT uint16
	DATA    []byte

	ClientAddr net.Addr // Proxy Server should verify this is the same as the client
}

type PacketUserPassAuth struct {
	VER    byte
	ULEN   byte
	UNAME  string // length: ULEN
	PLEN   byte
	PASSWD string // length: PLEN
}

type PacketUserPassAuthStatus struct {
	VER    byte
	STATUS byte
}

type Proxy interface {
	// Connect is used to create an outgoing TCP connection from the proxy server to the
	// destination specified as dst.
	// The proxy implementation SHOULD use the provided context to cancel the connection attempt
	// if the context expires before the connection is established.
	//
	// The returned net.Conn MUST be a connection to the destination, i.e. any data written to
	// it will be send to the remote destination.
	// Its LocalAddr() method SHOULD return the address used to connect to the destination if known,
	// otherwise it MUST return 0.0.0.0 (IPv4) or ::0 (IPv6).
	Connect(ctx context.Context, dst net.Addr) (conn net.Conn, err error)

	// Bind requests the proxy server to listen for an incoming (TCP) connection. The proxy
	// implementation SHOULD bind a TCP address and port, and listen for the FIRST incoming
	// connection on to it.
	// The proxy implementation SHOULD use the provided context to cancel the connection
	// attempt if the context expires before the connection is established.
	//
	// The returned net.Listener MUST return the address the proxy server is listening on when
	// its Addr() method is called. Its Accept() method MUST block until the FIRST incoming
	// connection is received, and return a net.Conn representing the incoming connection, whose
	// RemoteAddr() call MUST return the address of the source and LocalAddr() call is expected to
	// return the address the listener is bound to, same as the one returned by Addr() of the
	// net.Listener.
	//
	// It is up to the implementation to decide how to handle subsequent incoming connections
	// on the same address and port, as well as how to handle multiple calls to Bind() with the same
	// dst address specified.
	Bind(ctx context.Context, dst net.Addr) (net.Listener, error)

	// UDPAssociate creates a UDP socket on the proxy server. The proxy implementation SHOULD use
	// the provided context to cancel the connection attempt if the context expires before the
	// connection is established.
	//
	// Invoking the WriteTo() method on the returned net.PacketConn sends a UDP datagram to the
	// remote address specified in the function call. And UDP datagrams received from the remote
	// address should be accessible by invoking ReadFrom() on the returned net.PacketConn.
	UDPAssociate(ctx context.Context) (net.PacketConn, error)

	// Close closes the proxy server and cleans up any resources associated with it if possible.
	//
	// Calling Close on a proxy server does not necessarily close any connections created by it.
	// However, it SHOULD prevent any new connections from being created. If
	Close() error
}

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

type UsernamePassword struct {
	UserPass map[string]string
}