advLayer

type Client interface {
	Common

	IsEarly() bool //is 0-rtt or not.

}

type Common interface {
	Creator

	GetPath() string // for logging procedure to get the path settings. Doesn't have to be the full path, as long as different settings can be distinguished. For example, grpc's GetPath() might return its ServiceName.
}

type Conf struct {
	TlsConf *tls.Config //for quic

	Host    string
	Addr    netLayer.Addr
	Path    string
	Headers *httpLayer.HeaderPreset
	IsEarly bool           //is 0-rtt or not; for quic and ws.
	Xver    int            //for Super, like quic, PROXY protocol
	Extra   map[string]any //quic: useHysteria, hysteria_manual, maxbyte; grpc: multiMode
}

type Creator interface {
	ProtocolName() string
	PackageID() string //unique for each package. Sub packages included in v2ray_simple don't need to apply any prefix, but if you want to implement your own package, you should use full git path, like github.com/somebody/mypackage. This is for distinguishing different packages.

	NewClientFromConf(conf *Conf) (Client, error)
	NewServerFromConf(conf *Conf) (Server, error)

	GetDefaultAlpn() (alpn string, mustUse bool)

	CanHandleHeaders() bool //If true, there won't be an extra http header layer during the relay progress, and the matching progress of the customized http headers will be handled inside this package.

	IsMux() bool // if IsMux, if is Client, then it is a MuxClient, or it's a SingleClient; if is Server, then it is a MuxServer, or it's a SingleServer

	IsSuper() bool // quic is a super protocol, which handles transport layer dialing and tls layer handshake directly. If IsSuper, then it's a SuperMuxServer

}

type MuxClient interface {
	Client

	// If IsSuper, underlay should be nil; conn must be non nil when err==nil.
	//
	// If not IsSuper and underlay == nil, it will return error if it can't find any extablished connection.
	// Usually underlay  is tls.Conn.
	GetCommonConn(underlay net.Conn) (conn any, err error)

	//underlay is conn returned from  GetCommonConn
	DialSubConn(underlay any) (net.Conn, error)
}

type MuxServer interface {

	//blocking. if fallbackFunc != nil, then it can serve for fallback feature.
	//
	//newSubConnFunc and fallbackFunc are blocking
	StartHandle(underlay net.Conn, newSubConnFunc func(net.Conn), fallbackFunc func(httpLayer.FallbackMeta))
}

type Server interface {
	Common

	Stop()
}

type SingleClient interface {
	Client

	//it may use 0-rtt if firstPayloadLen>0 && IsEarly() == true
	Handshake(underlay net.Conn, firstPayloadLen int) (net.Conn, error)
}

type SingleServer interface {

	//如果遇到不符合握手条件但是却合法的http请求，可返回 httpLayer.FallbackMeta 和 httpLayer.ErrShouldFallback
	Handshake(underlay net.Conn) (net.Conn, error)
}

type SuperMuxServer interface {
	MuxServer

	//non-blocking.  Super will listen raw conn directly, and pass subStreamConn to newSubConnChan。Can stop the listening progress by closer.Close().
	//
	// newSubConnFunc is a blocking func.
	StartListen(newSubConnFunc func(net.Conn)) (closer io.Closer)
}