gost

type Accepter interface {
	Accept() (net.Conn, error)
}

type Authenticator interface {
	Authenticate(user, password string) bool
}

type BindIP interface {
	Bind(network, address string) net.Addr
}

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

type Chain struct {
	Retries int
	// contains filtered or unexported fields
}

type ChainOption func(opts *ChainOptions)

type ChainOptions struct {
	Retries     int
	Timeout     time.Duration
	Hosts       *Hosts
	Resolver    Resolver
	FDProtector FDProtector
	BindIP      BindIP
}

type Client struct {
	Connector
	Transporter
}

type ConnectOption func(opts *ConnectOptions)

type ConnectOptions struct {
	Addr      string
	Timeout   time.Duration
	User      *url.Userinfo
	Selector  gosocks5.Selector
	UserAgent string
	NoTLS     bool
	NoDelay   bool
}

type Connector interface {
	// Deprecated: use ConnectContext instead.
	Connect(conn net.Conn, address string, options ...ConnectOption) (net.Conn, error)
	ConnectContext(ctx context.Context, conn net.Conn, network, address string, options ...ConnectOption) (net.Conn, error)
}

type DNSOptions struct {
	Mode         string
	UDPSize      int
	ReadTimeout  time.Duration
	WriteTimeout time.Duration
	TLSConfig    *tls.Config
}

type DialOption func(opts *DialOptions)

type DialOptions struct {
	Timeout     time.Duration
	Chain       *Chain
	Host        string
	FDProtector FDProtector
	BindIP      BindIP
	Resolver    Resolver
}

type Exchanger interface {
	Exchange(ctx context.Context, query []byte) ([]byte, error)
}

type ExchangerOption func(opts *exchangerOptions)

type FDProtector interface {
	Protect(fd int32) bool
}

type FIFOStrategy struct{}

type FailFilter struct {
	MaxFails    int
	FailTimeout time.Duration
}

type FakeTCPListenConfig struct {
	TTL       time.Duration
	Backlog   int
	QueueSize int
}

type Filter interface {
	Filter([]Node) []Node
	String() string
}

type Handler interface {
	Init(options ...HandlerOption)
	Handle(net.Conn)
}

type HandlerOption func(opts *HandlerOptions)

type HandlerOptions struct {
	Addr          string
	Chain         *Chain
	Users         []*url.Userinfo
	Authenticator Authenticator
	TLSConfig     *tls.Config
	Whitelist     *Permissions
	Blacklist     *Permissions
	Strategy      Strategy
	MaxFails      int
	FailTimeout   time.Duration
	Bypass        *Bypass
	Retries       int
	Timeout       time.Duration
	Resolver      Resolver
	Hosts         *Hosts
	ProbeResist   string
	KnockingHost  string
	Node          Node
	Host          string
	IPs           []string
	TCPMode       bool
	IPRoutes      []IPRoute
}

type HandshakeOption func(opts *HandshakeOptions)

type HandshakeOptions struct {
	Addr       string
	Host       string
	User       *url.Userinfo
	Timeout    time.Duration
	Interval   time.Duration
	Retry      int
	TLSConfig  *tls.Config
	WSOptions  *WSOptions
	KCPConfig  *KCPConfig
	QUICConfig *QUICConfig
	SSHConfig  *SSHConfig
}

type Host struct {
	IP       net.IP
	Hostname string
	Aliases  []string
}

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

type IPRoute struct {
	Dest    *net.IPNet
	Gateway net.IP
}

type InvalidFilter struct{}

type KCPConfig struct {
	Key          string `json:"key"`
	Crypt        string `json:"crypt"`
	Mode         string `json:"mode"`
	MTU          int    `json:"mtu"`
	SndWnd       int    `json:"sndwnd"`
	RcvWnd       int    `json:"rcvwnd"`
	DataShard    int    `json:"datashard"`
	ParityShard  int    `json:"parityshard"`
	DSCP         int    `json:"dscp"`
	NoComp       bool   `json:"nocomp"`
	AckNodelay   bool   `json:"acknodelay"`
	NoDelay      int    `json:"nodelay"`
	Interval     int    `json:"interval"`
	Resend       int    `json:"resend"`
	NoCongestion int    `json:"nc"`
	SockBuf      int    `json:"sockbuf"`
	KeepAlive    int    `json:"keepalive"`
	SnmpLog      string `json:"snmplog"`
	SnmpPeriod   int    `json:"snmpperiod"`
	Signal       bool   `json:"signal"` // Signal enables the signal SIGUSR1 feature.
	TCP          bool   `json:"tcp"`
}

type Listener interface {
	net.Listener
}

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

type LogLogger struct {
}

type Matcher interface {
	Match(v string) bool
	String() string
}

type NameServer struct {
	Addr     string
	Protocol string
	Hostname string // for TLS handshake verification
	// contains filtered or unexported fields
}

type NameServerOption func(*nameServerOptions)

type Node struct {
	ID        int
	Addr      string
	Host      string
	Protocol  string
	Transport string
	Remote    string // remote address, used by tcp/udp port forwarding

	User             *url.Userinfo
	Values           url.Values
	DialOptions      []DialOption
	HandshakeOptions []HandshakeOption
	ConnectOptions   []ConnectOption
	Client           *Client

	Bypass *Bypass
	// contains filtered or unexported fields
}

type NodeGroup struct {
	ID int
	// contains filtered or unexported fields
}

type NodeSelector interface {
	Select(nodes []Node, opts ...SelectOption) (Node, error)
}

type NopLogger struct {
}

type PasswordCallbackFunc func(conn ssh.ConnMetadata, password []byte) (*ssh.Permissions, error)

type Permission struct {
	Actions StringSet
	Hosts   StringSet
	Ports   PortSet
}

type Permissions []Permission

type PortRange struct {
	Min, Max int
}

type PortSet []PortRange

type PublicKeyCallbackFunc func(c ssh.ConnMetadata, pubKey ssh.PublicKey) (*ssh.Permissions, error)

type QUICConfig struct {
	TLSConfig   *tls.Config
	Timeout     time.Duration
	KeepAlive   bool
	IdleTimeout time.Duration
	Key         []byte
}

type RandomStrategy struct {
	Seed int64
	// contains filtered or unexported fields
}

type ReloadResolver interface {
	Resolver
	Reloader
	Stoppable
}

type Reloader interface {
	Reload(r io.Reader) error
	Period() time.Duration
}

type Resolver interface {
	// Init initializes the Resolver instance.
	Init(opts ...ResolverOption) error
	// Resolve returns a slice of that host's IPv4 and IPv6 addresses.
	Resolve(host string) ([]net.IP, error)
	// Exchange performs a synchronous query,
	// It sends the message query and waits for a reply.
	Exchange(ctx context.Context, query []byte) (reply []byte, err error)
}

type ResolverOption func(*resolverOptions)

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

type SSHConfig struct {
	Authenticator  Authenticator
	TLSConfig      *tls.Config
	Key            ssh.Signer
	AuthorizedKeys map[string]bool
}

type SelectOption func(*SelectOptions)

type SelectOptions struct {
	Filters  []Filter
	Strategy Strategy
}

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

type ServerOption func(opts *ServerOptions)

type ServerOptions struct {
	BypassAccept *Bypass
}

type Stoppable interface {
	Stop()
	Stopped() bool
}

type Strategy interface {
	Apply([]Node) Node
	String() string
}

type StringSet []string

type TapConfig struct {
	Name    string
	Addr    string
	MTU     int
	Routes  []string
	Gateway string
}

type Transporter interface {
	Dial(addr string, options ...DialOption) (net.Conn, error)
	Handshake(conn net.Conn, options ...HandshakeOption) (net.Conn, error)
	// Indicate that the Transporter supports multiplex
	Multiplex() bool
}

type TunConfig struct {
	Name    string
	Addr    string
	Peer    string // peer addr of point-to-point on MacOS
	MTU     int
	Routes  []IPRoute
	Gateway string
}

type UDPListenConfig struct {
	TTL       time.Duration // timeout per connection
	Backlog   int           // connection backlog
	QueueSize int           // recv queue size per connection
}

type WSOptions struct {
	ReadBufferSize      int
	WriteBufferSize     int
	HandshakeTimeout    time.Duration
	EnableCompression   bool
	UserAgent           string
	Path                string
	ReverseProxy        string
	ProbeResist         string
	KnockingHost        string
	MuxVersion          int //1 or 2
	MuxMaxReceiveBuffer int //mb
	MuxMaxStreamBuffer  int //kb
}