proxy

type Base struct {
	ListenConf *ListenConf
	DialConf   *DialConf

	Addr           string
	TLS            bool
	Tag            string //可用于路由, 见 netLayer.route.go
	TransportLayer string

	Sockopt *netLayer.Sockopt
	Xver    int

	IsFullcone bool

	Tls_s   *tlsLayer.Server
	Tls_c   *tlsLayer.Client
	TlsConf tlsLayer.Conf

	Header *httpLayer.HeaderPreset

	IsCantRoute bool //for inServer, 若为true，则 inServer 读得的数据 不会经过分流，一定会通过用户指定的remoteclient发出

	AdvancedL string

	AdvC advLayer.Client
	AdvS advLayer.Server

	FallbackAddr *netLayer.Addr

	Innermux *smux.Session //用于存储 client的已拨号的mux连接

	sync.Mutex

	//用于sendthrough
	LTA *net.TCPAddr
	LUA *net.UDPAddr
}

type BaseInterface interface {
	Name() string       //代理协议名称, 如vless
	MiddleName() string //不包含传输层 和 代理层的 其它VSI层 所使用的协议，前后被加了加号，如 +tls+ws+

	Stop()

	GetBase() *Base
	GetTag() string

	// 地址,若tcp/udp的话则为 ip:port/host:port的形式, 若是 unix domain socket 则是文件路径 ，
	// 在 inServer就是监听地址，在 outClient就是拨号地址
	AddrStr() string
	SetAddrStr(string)

	GetSockopt() *netLayer.Sockopt

	CantRoute() bool //for inServer

	Network() string //传输层协议,如 tcp, udp, unix, kcp, etc. 这里叫做Network而不是transport, 是遵循 golang 标准包 net包的用法。我们兼容 net的Listen等方法, 可把Network直接作为 net.Listen等方法的 network 参数。
	GetXver() int

	Sniffing() bool //for inServer, 是否开启嗅探功能

	IsUseTLS() bool
	IsLazyTls() bool

	GetTLS_Server() *tlsLayer.Server
	GetTLS_Client() *tlsLayer.Client

	HasHeader() *httpLayer.HeaderPreset

	//默认回落地址.
	GetFallback() *netLayer.Addr

	CanFallback() bool //如果能fallback，则handshake失败后，可能会专门返回 httpLayer.FallbackErr,如监测到返回了 FallbackErr, 则main函数会进行 回落处理.

	AdvancedLayer() string //所使用的高级层的协议名称

	GetAdvClient() advLayer.Client
	GetAdvServer() advLayer.Server

	// 判断是否有内层mux。
	//0 为不会有 innermux, 1 为有可能有 innermux, 2 为总是使用 innerMux;
	// 规定是，客户端 只能返回0/2， 服务端 只能返回 0/1（除非服务端协议不支持不mux的情况，此时可以返回2）。
	// string 为 innermux内部的 代理 协议 名称。（一般用simplesocks）
	HasInnerMux() (int, string)
}

type Client interface {
	BaseInterface

	//Perform handshake when request is TCP。firstPayload 用于如 vless/trojan 这种 没有握手包的协议，可为空。
	Handshake(underlay net.Conn, firstPayload []byte, target netLayer.Addr) (wrappedConn io.ReadWriteCloser, err error)

	//Establish a channel and constantly request data for each UDP addr through this channel. firstpayload and target can be empty theoretically, depending on the implementation.
	EstablishUDPChannel(underlay net.Conn, firstPayload []byte, target netLayer.Addr) (netLayer.MsgConn, error)

	//If udp is send through multiple connection or not
	IsUDP_MultiChannel() bool

	//get/listen a useable inner mux
	GetClientInnerMuxSession(wrc io.ReadWriteCloser) *smux.Session
	InnerMuxEstablished() bool
	CloseInnerMuxSession()

	//用于在拨号时选用一个特定的ip拨号。
	LocalTCPAddr() *net.TCPAddr
	LocalUDPAddr() *net.UDPAddr

	GetCreator() ClientCreator

	sync.Locker //用于锁定 innerMux
}

type ClientCreator interface {
	CreatorCommon
	//大部分通用内容都会被proxy包解析，方法只需要处理proxy包未知的内容
	NewClient(*DialConf) (Client, error) //标准配置

	//URLToDialConf 执行proxy自定义的非标准代码;
	//iv: initial value, can be nil.
	URLToDialConf(url *url.URL, iv *DialConf, format int) (*DialConf, error)
}

type CommonConf struct {
	Tag string `toml:"tag"` //可选

	Extra map[string]any `toml:"extra"` //用于包含任意其它数据.虽然本包自己定义的协议肯定都是已知的，但是如果其他人使用了本包的话，那就有可能添加一些 新协议 特定的数据. 而且这也便于扁平化，避免出现大量各种子块。任何子块内容都放在extra中，比如 quic的就是 extra.quic_xxx

	Host string `toml:"host"` //ip 或域名. 若unix domain socket 则为文件路径
	IP   string `toml:"ip"`   //给出Host后，该项可以省略; 既有Host又有ip的情况比较适合cdn

	Network string `toml:"network"` //传输层协议; 默认使用tcp, network可选值为 tcp, udp, unix;

	Sockopt *netLayer.Sockopt `toml:"sockopt"` //可选

	Port int `toml:"port"` //若Network不为 unix , 则port项必填

	Xver int `toml:"xver"` //可选，只能为0/1/2. 若不为0, 则使用 PROXY protocol 协议头.

	Fullcone bool `toml:"fullcone"` //在udp会用到, fullcone的话因为不能关闭udp连接, 所以 时间长后, 可能会导致too many open files. fullcone 的话一般人是用不到的, 所以 有需要的人自行手动打开 即可

	TLS      bool     `toml:"tls"`      //tls层; 可选. 如果不使用 's' 后缀法，则还可以配置这一项来更清晰地标明使用tls
	TlsType  string   `toml:"tls_type"` //可选，可以为 utls或者shadowTls, 若不给出或为空, 则为golang的标准tls. utls 只在客户端有效。
	Insecure bool     `toml:"insecure"` //tls 是否安全
	Alpn     []string `toml:"alpn"`

	TLSCert string `toml:"cert"` //可选
	TLSKey  string `toml:"key"`  //可选

	Lazy bool `toml:"lazy"` //可选, 是否开启 tls_lazy_encrypt 功能

	HttpHeader *httpLayer.HeaderPreset `toml:"header"` //http伪装头; 可选

	Path string `toml:"path"` //ws 的path 或 grpc的 serviceName。为了简便我们在同一位置给出.

	AdvancedLayer string `toml:"adv"`   //高级层; 可选
	IsEarly       bool   `toml:"early"` //是否启用 0-rtt

	Protocol    string `toml:"protocol"`     //代理层; 约定，如果一个Protocol尾缀去掉了一个's'后仍然是一个有效协议，则该协议使用了 tls。这种方法继承自 v2simple，适合极简模式
	UUID        string `toml:"uuid"`         //代理层用户的唯一标识，视代理层协议而定，一般使用uuid，但trojan协议是随便的password, 而socks5 和 http 则使用 user+pass 的形式。 我们为了简洁、一致，就统一放到了 这个字段里。
	Version     int    `toml:"version"`      //可选，代理层协议版本号，vless v1 要用到。
	EncryptAlgo string `toml:"encrypt_algo"` //内部加密算法，vmess/ss 等协议可指定

}

type CreatorCommon interface {
	//若为true，则表明该协议可同时使用tcp和udp来传输数据。direct, socks5 和 shadowsocks 都为true。
	//此时，是否开启udp取决于Network(), 如果为dual, 则均支持; 如果仅为tcp或者udp，则不支持。
	// direct的默认Network为dual。
	MultiTransportLayer() bool
}

type CreatorCommonStruct struct{}

type DialConf struct {
	CommonConf

	SendThrough string `toml:"sendThrough"` //可选，用于发送数据的 IP 地址, 可以是ip:port, 或者 tcp:ip:port\nudp:ip:port
	Mux         bool   `toml:"mux"`         //是否使用内层mux。在某些支持mux命令的协议中（vless v1/trojan）, 开启此开关会让 dial 使用 内层mux。
}

type DirectClient struct {
	Base
}

type DirectCreator struct{ CreatorCommonStruct }

type ListenConf struct {
	CommonConf

	Users []utils.UserConf `toml:"users"` //可选, 用于储存多个用户/密码 信息。

	CA string `toml:"ca"` //可选,用于 验证"客户端证书"

	SniffConf *SniffConf `toml:"sniffing"` //用于嗅探出 host 来帮助 分流。

	Fallback any `toml:"fallback"` //可选，默认回落的地址，一般可为 ip:port,数字port or unix socket的文件名

	//noroute 意味着 传入的数据 不会被分流，一定会被转发到默认的 dial
	// 这一项是针对 分流功能的. 如果不设noroute, 则所有listen 得到的流量都会被 试图 进行分流
	NoRoute bool `toml:"noroute"`

	TargetAddr string `toml:"target"` //若使用dokodemo协议，则这一项会给出. 格式为url, 如 tcp://127.0.0.1:443 , 必须带scheme，以及端口。只能为tcp或udp

}

type ListenerServer interface {
	Server

	//非阻塞
	StartListen(func(netLayer.TCPRequestInfo), func(netLayer.UDPRequestInfo)) io.Closer
}

type MuxMarker interface {
	io.ReadWriteCloser
	IsMux() bool
}

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

type RejectCreator struct{ CreatorCommonStruct }

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

type RoutingEnv struct {
	RoutePolicy *netLayer.RoutePolicy
	Fallback    *httpLayer.ClassicFallback
	DnsMachine  *netLayer.DNSMachine

	ClientsTagMap map[string]Client //ClientsTagMap 存储 tag 对应的 Client；因为分流时，需要通过某个tag找到Client对象。 若要访问map，请用 Get*, Set*, Del* 方法
	// contains filtered or unexported fields
}

type Server interface {
	BaseInterface

	//net.Conn is for TCP request, netLayer.MsgConn is for UDP request.
	// 约定，如果error返回的是 utils.ErrHandled， 则调用代码停止进一步处理。
	Handshake(underlay net.Conn) (net.Conn, netLayer.MsgConn, netLayer.Addr, error)

	//get/listen a useable inner mux
	GetServerInnerMuxSession(wlc io.ReadWriteCloser) *smux.Session

	//tproxy,tun 和 shadowsocks(udp) 都用到了 SelfListen
	//
	//is表示开启自监听; 此时若 tcp=1, 表示监听tcp, 若tcp=0, 表示自己不监听tcp, 但需要vs进行监听; 若tcp<0, 则表示自己不监听, 也不要vs监听; udp同理; 开启SelfListen同时表明 Server实现了 ListenerServer
	SelfListen() (is bool, tcp, udp int)
}

type ServerCreator interface {
	CreatorCommon

	NewServer(*ListenConf) (Server, error)
	AfterCommonConfServer(Server) error

	URLToListenConf(url *url.URL, iv *ListenConf, format int) (*ListenConf, error)
}

type SniffConf struct {
	Enable bool `toml:"enabled"`
}

type StandardConf struct {
	DnsConf *netLayer.DnsConf `toml:"dns"`

	Listen []*ListenConf `toml:"listen"`
	Dial   []*DialConf   `toml:"dial"`

	Route     []*netLayer.RuleConf      `toml:"route"`
	Fallbacks []*httpLayer.FallbackConf `toml:"fallback"`
}

type UrlConf struct {
	ListenUrl string `json:"listen"`
	DialUrl   string `json:"dial"`
}

type UserClient interface {
	Client
	GetUser() utils.User
}

type UserReadWrapper struct {
	utils.User
	netLayer.ReadWrapper
	Mux bool
}

type UserServer interface {
	Server
	utils.UserContainer
}