proxy

package
v1.2.0-beta.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 2, 2022 License: MIT Imports: 25 Imported by: 0

Documentation

Overview

Package proxy defines necessary components for proxy.

Config Format 配置格式

一共有三种配置格式，极简模式，标准模式，兼容模式。

“极简模式”(即 verysimple mode)，入口和出口仅有一个，而且都是使用共享链接的url格式来配置.

标准模式使用toml格式。

兼容模式可以兼容v2ray现有json格式。（暂未实现）。

极简模式的理念是，配置文件的字符尽量少，尽量短小精悍;

还有个命令行模式，就是直接把极简模式的url 放到命令行参数中，比如: 

verysimple -L socks5://sfdfsaf -D direct://

Layer Definition

目前认为，一个传输过程大概由四个部分组成，基础连接（udp/tcp），TLS（可选），中间层（ws、grpc、http等，可选），具体协议（socks5，vless，trojan等）.

其中，ws和grpc被认为是 高级应用层，http（伪装）属于 header 层.

TLS - Transport Layer Security 顾名思义TLS作用于传输层，第四层，但是我们tcp也是第四层，所以在本项目中，认为不需要“会话层”，单独加一个专用于tls的层比较稳妥.

正常OSI是7层，我们在这里规定一个 第八层和第九层，第八层就是 vless协议所在位置，第九层就是我们实际传输的承载数据.

New Model - VSI 新的VSI 模型

那么我们提出一个 verysimple Interconnection Model， 简称vsi模型。1到4层与OSI相同（物理、链路、网络、传输).

把第五层替换成“加密层”，把TLS放进去；把第六层改为 http头(1.1) 层

第七层 改为高级应用层，ws/grpc/http2 属于这一层, 简称高级层；第八层定为 代理层，vless/trojan 在这层.

第九层为 承载数据层，承载的为 另一大串 第四层的数据.

不过有时比如 trojan 的 smux 和 v2ray 的 mux.cool ，实际上属于 高级层，那么它们就是 代理层里面又包了一层高级层.

一般来说，如果内层高级层是普通的协议的话，实际上是透明的, 不必单列出一个层级.

这里的关键地方是【内层多路复用】. 因为在内层多路复用时，一个连接会被抽象出多个子连接，在流量的走向方面开始分叉，所以确实有实质性不同。

内层多路复用的性质是，多路复用分离出一个个子协议后，子协议又是代理层。

所以第九层除了承载数据外, 还可以为 inner mux 层, 第十层可以为 inner proxy 层, 此时第11层才是承载数据.

我们verysimple实际上就是 基于 “层” 的架构，或称 可分层结构. 

11｜        --------------               （client real tcp/udp data)
--------------------------------------------------------------------------------
10｜        (simplesocks)           |    （inner proxy layer)
--------------------------------------------------------------------------------
9 ｜ [client real tcp/udp data]     or   [inner mux Layer]
--------------------------------------------------------------------------------
8 ｜      vless/trojan/socks5       ｜     proxy layer
--------------------------------------------------------------------------------
7 ｜          ws/grpc/quic          ｜     advanced layer
--------------------------------------------------------------------------------
6 ｜           http header          ｜     http layer
--------------------------------------------------------------------------------
5 ｜           tls                  ｜     tls layer
--------------------------------------------------------------------------------
4 ｜ tcp/udp/unix domain socket/kcp ｜     transport layer
--------------------------------------------------------------------------------

另外，实际上quic属于一种超级协议，横跨传输层一直到高级层，不过为了分类方便，这里认为它也是一种 高级层。 也就是说，如果遇到横跨多个层的协议，我们认为它属于其中最高的层级。

基本上5-8层都是可控的.第四层也可以给出一些参数进行控制，比如在tproxy时。

对应的理想配置文件应该如下. 

{
	"layer3_settings": {	//or network_settings，
			//可以配置一些网络层分流（ip）
	},
	"layer4_settings": {	//or transportLayer_settings，
		"tcp":{}	//可以设置一些缓存大小等配置. 和传输层协议分流（tcp/udp）
	},
	"layer5_settings": {	//or tls_settings，
		"tls":{"insecure": true},
		"utls":{}
		// 可以配置tls 层分流/回落（sni 和 alpn）
	},
	"layer6_settings": {	//or http_settings
		//可以配置http path分流 /回落 or header分流/回落
	},
	"layer7_settings": {	//or advancedLayer_settings
		"ws":{},
		"grpc":{},
		"quic":{}
	},
	"layer8_settings": {	//or proxy_settings
		"vless":{},
		"trojan":{}
	},
	"layer9_settings": {	//or innerMux_settings
		"smux":{}
	},
	"layer10_settings": {	//or innerProxy_settings
		"simplesocks":{}
	},
}

我们项目的文件夹，netLayer 第3，4层，tlsLayer文件夹代表第5层; httpLayer第六层， advLayer文件夹 代表第七层, proxy文件夹代表第8层或第10层, 同时连带 处理了 第九层.

同级的ws和grpc是独占的，可以都放到一个layer里，然后比如第八层配置了一个vless一个trojan，那么排列组合就是4种，vless+ws, vless+ grpc, trojan+ws, trojan+grpc.

这就大大减轻了各种”一键脚本“的 使用需求，咱们只要选择自己喜欢的各个层，程序自动就为我们生成所有配置.

运行时，如果所有配置都要有，那么就需要多种端口；共用端口的话可以用nginx.

也可以程序指定一种 特定的情况，比如开始运行程序时，冒出交互界面，自己按项选择好后，就自动运行，然后自动生成客户端分享url.

可以在脑海里想象 “穿鞋带” 的画面，有很多洞可以经过，都穿好了 鞋带就系好了。或手机手势解锁的情况.

这种好处是，每次运行都可以采用不同的配置，不同的uuid，手机一扫码就能连上.

然而，这种“高级模式”是不容易实现、也不好理解的，目前初始阶段先不考虑。

目前的标准模式的配置文件中，整个一个节点的配置完全是扁平化的，所有的层的配置都会在同一级别中。比如tls的配置完全和节点本身的配置放在一起。

总之 verysimple 的思路就是，要不就完全扁平化，要不就完全分层。

本作认为，所有的代理是都可以有tls层，http层和ws/grpc层的，所以就统一嵌入所有的代理协议的配置当中,直接扁平化了.

Contents of proxy package - proxy包内容

接口 ProxyCommon 和 结构 ProxyCommonStruct 给 这个架构定义了标准.

而 Client 和 Server 接口 是 具体利用该架构的 客户端 和 服务端，都位于VSI中的第八层.

使用 RegisterClient 和 RegisterServer 来注册新的实现.

Server and Client

我们服务端和 客户端的程序，都是有至少一个入口和一个出口的。入口我们叫做 inServer ，出口我们叫做 outClient.

这两个词的含义和 v2ray的 inbound 和 outbound 是等价的.

在 inServer 中，我们负责监听未知连接；在 outClient 中，我们负责拨号特定目标服务器.

proxy中默认实现了 direct 和 reject 这两种 Client

Index

Constants

View Source 
const (
	SimpleMode = iota
	StandardMode
	V2rayCompatibleMode
)

配置文件格式

View Source 
const DirectName = "direct"
View Source 
const FirstPayloadTimeout = time.Millisecond * 100

some client may 建立tcp连接后首先由客户端读服务端的数据？虽较少见但确实存在. Anyway firstpayload might not be read, and we should try to reduce this delay. 也有可能是有人用 nc 来测试，也会遇到这种读不到 firstpayload 的情况

View Source 
const RejectName = "reject"

Variables

This section is empty.

Functions

func GetFullName 

func GetFullName(pc ProxyCommon) string

FullName can fully represent the VSI model for a proxy. We think tcp/udp/kcp/raw_socket is FirstName，protocol of the proxy is LastName, and the rest is MiddleName。

An Example of a full name: tcp+tls+ws+vless. 总之，类似【域名】的规则，只不过分隔符从 点号 变成了加号。

func GetVSI_url 

func GetVSI_url(pc ProxyCommon) string

return GetFullName(pc) + "://" + pc.AddrStr()

func LoadConfig 

func LoadConfig(configFileName, listenURL, dialURL string, jsonMode int) (standardConf StandardConf, simpleConf SimpleConf, confMode int, mainFallback *httpLayer.ClassicFallback, err error)

先检查configFileName是否存在，存在就尝试加载文件到 standardConf or simpleConf，否则尝试 listenURL, dialURL 参数. 若 返回的是 simpleConf, 则还可能返回 mainFallback.

func PrintAllClientNames 

func PrintAllClientNames()

func PrintAllServerNames 

func PrintAllServerNames()

func RegisterClient 

func RegisterClient(name string, c ClientCreator)

规定，每个 实现Client的包必须使用本函数进行注册。 direct 和 reject 统一使用本包提供的方法, 自定义协议不得覆盖 direct 和 reject。

func RegisterServer 

func RegisterServer(name string, c ServerCreator)

规定，每个 实现 Server 的包必须使用本函数进行注册

func TestTCP 

func TestTCP(protocol string, version int, port string, t *testing.T)

func TestUDP 

func TestUDP(protocol string, version int, proxyPort string, use_multi int, t *testing.T)

完整模拟整个 protocol 的udp请求 过程，即 客户端连接代理服务器，代理服务器试图访问远程服务器，这里是使用的模拟的办法模拟出一个远程udp服务器； 其他tcp测试因为比较简单，不需要第二步测试，而这里需要

Types

type AppConf 

type AppConf struct {
	LogLevel          *int    `toml:"loglevel"` //需要为指针, 否则无法判断0到底是未给出的默认值还是 显式声明的0
	LogFile           *string `toml:"logfile"`
	DefaultUUID       string  `toml:"default_uuid"`
	MyCountryISO_3166 string  `toml:"mycountry" json:"mycountry"` //加了mycountry后，就会自动按照geoip分流,也会对顶级域名进行国别分流

	NoReadV bool `toml:"noreadv"`

	AdminPass string `toml:"admin_pass"` //用于apiServer等情况

	UDP_timeout *int `toml:"udp_timeout"`
}

type Client 

type Client interface {
	ProxyCommon

	//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 through this channel constantly request data for each UDP addr. target can be nil theoretically.
	EstablishUDPChannel(underlay net.Conn, target netLayer.Addr) (netLayer.MsgConn, error)

	IsUDP_MultiChannel() bool

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

Client is used to dial a server. Because Server is "target agnostic", Client's Handshake requires a target addr as param.

A Client has all the data of all layers in its VSI model. Once a Client is fully defined, the flow of the data is fully defined.

func ClientFromURL 

func ClientFromURL(s string) (Client, bool, utils.ErrInErr)

ClientFromURL calls the registered creator to create client.

func NewClient 

func NewClient(dc *DialConf) (Client, error)

type ClientCreator 

type ClientCreator interface {
	NewClient(*DialConf) (Client, error)
	NewClientFromURL(url *url.URL) (Client, error)
}

可通过两种配置方式来初始化。

type CommonConf 

type CommonConf struct {
	Tag      string `toml:"tag"`      //可选
	Protocol string `toml:"protocol"` //代理层; 约定，如果一个Protocol尾缀去掉了's'后仍然是一个有效协议，则该协议使用了 tls。这种方法继承自 v2simple，适合极简模式
	Uuid     string `toml:"uuid"`     //代理层用户的唯一标识，视代理层协议而定，一般使用uuid，但trojan协议是随便的.
	Host     string `toml:"host"`     //ip 或域名. 若unix domain socket 则为文件路径
	IP       string `toml:"ip"`       //给出Host后，该项可以省略; 既有Host又有ip的情况比较适合cdn
	Port     int    `toml:"port"`     //若Network不为 unix , 则port项必填
	Version  int    `toml:"version"`  //可选

	Network string `toml:"network"` //传输层协议; 默认使用tcp, network可选值为 tcp, udp, unix; 理论上来说应该用 transportLayer，但是怕小白不懂，所以使用 network作为名称。而且也不算错，因为go的net包 也是用 network来指示 传输层/网络层协议的. 比如 net.Listen()第一个参数可以用 ip, tcp, udp 等。

	Sockopt *netLayer.Sockopt `toml:"sockopt"`

	TLS      bool     `toml:"tls"`      //tls层; 可选. 如果不使用 's' 后缀法，则还可以配置这一项来更清晰第标明使用tls
	Insecure bool     `toml:"insecure"` //tls 是否安全
	Alpn     []string `toml:"alpn"`

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

	AdvancedLayer string `toml:"advancedLayer"` //高级层; 可不填

	IsEarly bool `toml:"early"` //是否启用 0-rtt

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

	Extra map[string]any `toml:"extra"` //用于包含任意其它数据.虽然本包自己定义的协议肯定都是已知的，但是如果其他人使用了本包的话，那就有可能添加一些 新协议 特定的数据.
}

CommonConf 是标准配置中 Listen和Dial 都有的部分 如果新协议有其他新项，可以放入 Extra.

func (*CommonConf) GetAddrStr 

func (cc *CommonConf) GetAddrStr() string

func (*CommonConf) GetAddrStrForListenOrDial 

func (cc *CommonConf) GetAddrStrForListenOrDial() string

若为unix, 返回Host，否则返回 ip:port / host:port; 和 GetAddr的区别是，它优先使用ip，其次再使用host

type DialConf 

type DialConf struct {
	CommonConf
	Utls     bool `toml:"utls"`     //是否使用 uTls 库 替换 go官方tls库
	Fullcone bool `toml:"fullcone"` //在direct会用到, fullcone的话因为不能关闭udp连接, 所以可能会导致too many open files. fullcone 的话一般人是用不到的, 所以 有需要的人自行手动打开 即可

	Mux bool `toml:"use_mux"` //是否使用内层mux。在某些支持mux命令的协议中（vless v1/trojan）, 开启此开关会让 dial 使用 内层mux。
}

拨号所使用的设置, 使用者可被称为 dialer or outClient 

CommonConf.Host , CommonConf.IP, CommonConf.Port  为拨号地址与端口

type DirectClient 

type DirectClient struct {
	ProxyCommonStruct
	// contains filtered or unexported fields
}

func (*DirectClient) EstablishUDPChannel 

func (d *DirectClient) EstablishUDPChannel(_ net.Conn, target netLayer.Addr) (netLayer.MsgConn, error)

direct的Client的 EstablishUDPChannel 直接 监听一个udp端口，无视传入的net.Conn.

func (*DirectClient) Handshake 

func (d *DirectClient) Handshake(underlay net.Conn, firstPayload []byte, target netLayer.Addr) (result io.ReadWriteCloser, err error)

若 underlay 为nil，则会对target进行拨号, 否则直接返回underlay。

func (*DirectClient) Name 

func (*DirectClient) Name() string

type DirectCreator added in v1.2.0 

type DirectCreator struct{}

implements ClientCreator for direct

func (DirectCreator) NewClient added in v1.2.0 

func (DirectCreator) NewClient(dc *DialConf) (Client, error)

func (DirectCreator) NewClientFromURL added in v1.2.0 

func (DirectCreator) NewClientFromURL(url *url.URL) (Client, error)

type ListenConf 

type ListenConf struct {
	CommonConf
	Fallback any    `toml:"fallback"` //可选，默认回落的地址，一般可为 ip:port,数字port or unix socket的文件名
	TLSCert  string `toml:"cert"`
	TLSKey   string `toml:"key"`

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

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

}

监听所使用的设置, 使用者可被称为 listener or inServer 

CommonConf.Host , CommonConf.IP, CommonConf.Port  为监听地址与端口

type MuxMarker 

type MuxMarker interface {
	io.ReadWriteCloser
	IsMux()
}

规定，如果 proxy的server的handshake如果返回的是具有内层mux的连接，该连接要实现 MuxMarker 接口.

type MuxMarkerConn 

type MuxMarkerConn struct {
	netLayer.ReadWrapper
}

实现 MuxMarker

func (*MuxMarkerConn) IsMux 

func (mh *MuxMarkerConn) IsMux()

type ProxyCommon 

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

	Stop()

	GetSockopt() *netLayer.Sockopt

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

	CantRoute() bool //for inServer
	GetTag() string

	SetUseTLS()
	IsUseTLS() 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)
	// contains filtered or unexported methods
}

Provide supports for all VSI model layers except proxy layer for a proxy.

type ProxyCommonStruct 

type ProxyCommonStruct struct {
	Addr string
	TLS  bool
	Tag  string //可用于路由, 见 netLayer.route.go

	Sockopt *netLayer.Sockopt

	AdvancedL string

	FallbackAddr *netLayer.Addr
	// contains filtered or unexported fields
}

ProxyCommonStruct 实现 ProxyCommon中除了Name 之外的其他方法. 规定，所有的proxy都要内嵌本struct. 我们用这种方式实现 "继承". 这是verysimple的架构所要求的。 verysimple规定，在加载完配置文件后，一个listen和一个dial所使用的全部层级都是确定了的. 

因为所有使用的层级都是确定的，就可以进行针对性优化

func (*ProxyCommonStruct) AddrStr 

func (s *ProxyCommonStruct) AddrStr() string

func (*ProxyCommonStruct) AdvancedLayer 

func (pcs *ProxyCommonStruct) AdvancedLayer() string

func (*ProxyCommonStruct) CanFallback 

func (s *ProxyCommonStruct) CanFallback() bool

return false. As a placeholder.

func (*ProxyCommonStruct) CantRoute 

func (pcs *ProxyCommonStruct) CantRoute() bool

func (*ProxyCommonStruct) CloseInnerMuxSession 

func (pcs *ProxyCommonStruct) CloseInnerMuxSession()

func (*ProxyCommonStruct) GetAdvClient 

func (s *ProxyCommonStruct) GetAdvClient() advLayer.Client

func (*ProxyCommonStruct) GetAdvServer 

func (s *ProxyCommonStruct) GetAdvServer() advLayer.Server

func (*ProxyCommonStruct) GetClientInnerMuxSession 

func (pcs *ProxyCommonStruct) GetClientInnerMuxSession(wrc io.ReadWriteCloser) *smux.Session

func (*ProxyCommonStruct) GetFallback 

func (pcs *ProxyCommonStruct) GetFallback() *netLayer.Addr

func (*ProxyCommonStruct) GetServerInnerMuxSession 

func (*ProxyCommonStruct) GetServerInnerMuxSession(wlc io.ReadWriteCloser) *smux.Session

func (*ProxyCommonStruct) GetSockopt 

func (pcs *ProxyCommonStruct) GetSockopt() *netLayer.Sockopt

func (*ProxyCommonStruct) GetTLS_Client 

func (s *ProxyCommonStruct) GetTLS_Client() *tlsLayer.Client

func (*ProxyCommonStruct) GetTLS_Server 

func (s *ProxyCommonStruct) GetTLS_Server() *tlsLayer.Server

func (*ProxyCommonStruct) GetTag 

func (pcs *ProxyCommonStruct) GetTag() string

func (*ProxyCommonStruct) HasHeader 

func (pcs *ProxyCommonStruct) HasHeader() *httpLayer.HeaderPreset

func (*ProxyCommonStruct) HasInnerMux 

func (pcs *ProxyCommonStruct) HasInnerMux() (int, string)

placeholder

func (*ProxyCommonStruct) InitAdvLayer 

func (s *ProxyCommonStruct) InitAdvLayer()

func (*ProxyCommonStruct) InnerMuxEstablished 

func (pcs *ProxyCommonStruct) InnerMuxEstablished() bool

func (*ProxyCommonStruct) IsUDP_MultiChannel 

func (pcs *ProxyCommonStruct) IsUDP_MultiChannel() bool

return false. As a placeholder.

func (*ProxyCommonStruct) IsUseTLS 

func (s *ProxyCommonStruct) IsUseTLS() bool

func (*ProxyCommonStruct) MiddleName 

func (pcs *ProxyCommonStruct) MiddleName() string

func (*ProxyCommonStruct) Network 

func (pcs *ProxyCommonStruct) Network() string

func (*ProxyCommonStruct) SetAddrStr 

func (s *ProxyCommonStruct) SetAddrStr(a string)

func (*ProxyCommonStruct) SetUseTLS 

func (s *ProxyCommonStruct) SetUseTLS()

func (*ProxyCommonStruct) Stop 

func (s *ProxyCommonStruct) Stop()

try close inner mux

type RejectClient 

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

RejectClient implements Client, optionally response a 403 and close the underlay immediately.

"blackhole" 名字不准确, 本作 使用 "reject".

正常的 blackhole，并不会立即关闭连接，而是悄无声息地 读 数据，并舍弃。 而 v2ray的 blackhole是 选择性返回 403错误 后立即关闭连接. 完全是 Reject的特性。

func (*RejectClient) EstablishUDPChannel 

func (b *RejectClient) EstablishUDPChannel(underlay net.Conn, _ netLayer.Addr) (netLayer.MsgConn, error)

function the same as Handshake

func (*RejectClient) Handshake 

func (b *RejectClient) Handshake(underlay net.Conn, _ []byte, _ netLayer.Addr) (result io.ReadWriteCloser, err error)

optionally response a 403 and close the underlay.

func (*RejectClient) Name 

func (*RejectClient) Name() string

type RejectCreator 

type RejectCreator struct{}

implements ClientCreator for reject

func (RejectCreator) NewClient 

func (RejectCreator) NewClient(dc *DialConf) (Client, error)

func (RejectCreator) NewClientFromURL 

func (RejectCreator) NewClientFromURL(url *url.URL) (Client, error)

type RoutingEnv 

type RoutingEnv struct {
	RoutePolicy   *netLayer.RoutePolicy
	MainFallback  *httpLayer.ClassicFallback
	DnsMachine    *netLayer.DNSMachine
	ClientsTagMap map[string]Client //用于分流到某个tag的Client, 所以需要知道所有的client
}

used in real relay progress. See source code of v2ray_simple for details.

func LoadEnvFromStandardConf 

func LoadEnvFromStandardConf(standardConf *StandardConf) (routingEnv RoutingEnv, Default_uuid string)

type Server 

type Server interface {
	ProxyCommon

	//ReadWriteCloser is for TCP request, net.PacketConn is for UDP request
	Handshake(underlay net.Conn) (net.Conn, netLayer.MsgConn, netLayer.Addr, error)

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

Server is used for listening clients. Because Server is "target agnostic"，Handshake should return the target addr that the Client requested.

A Server has all the data of all layers in its VSI model. Once a Server is fully defined, the flow of the data is fully defined.

func NewServer 

func NewServer(lc *ListenConf) (Server, error)

func ServerFromURL 

func ServerFromURL(s string) (Server, bool, utils.ErrInErr)

ServerFromURL calls the registered creator to create proxy servers.

type ServerCreator 

type ServerCreator interface {
	NewServer(*ListenConf) (Server, error)
	NewServerFromURL(url *url.URL) (Server, error)
}

可通过两种配置方式来初始化。

type SimpleConf 

type SimpleConf struct {
	Server_ThatListenPort_Url string                    `json:"listen"`
	Client_ThatDialRemote_Url string                    `json:"dial"`
	Route                     []*netLayer.RuleConf      `json:"route"`
	Fallbacks                 []*httpLayer.FallbackConf `json:"fallbacks"`
	MyCountryISO_3166         string                    `json:"mycountry"`
}

极简配置模式；只支持json

func LoadSimpleConfigFile 

func LoadSimpleConfigFile(fileNamePath string) (config SimpleConf, hasError bool, E utils.ErrInErr)

func LoadSimpleConfigFromStr 

func LoadSimpleConfigFromStr(str string) (config SimpleConf, hasE bool, E utils.ErrInErr)

type StandardConf 

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

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

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

标准配置，使用toml格式。 toml：https://toml.io/cn/

English: https://toml.io/en/

func LoadTomlConfFile 

func LoadTomlConfFile(fileNamePath string) (StandardConf, error)

func LoadTomlConfStr 

func LoadTomlConfStr(str string) (c StandardConf, err error)

type User 

type User interface {
	GetIdentityStr() string //每个user唯一，通过比较这个string 即可 判断两个User 是否相等

	GetIdentityBytes() []byte
}

User是一个唯一身份标识。

type UserBus 

type UserBus interface {
	AddUser(User) error
	DelUser(User)
}

可以控制 User 登入和登出 的接口

type UserClient 

type UserClient interface {
	Client
	GetUser() User
}

type UserConn 

type UserConn interface {
	io.ReadWriter
	User
	GetProtocolVersion() int
}

type UserContainer 

type UserContainer interface {
	GetUserByStr(idStr string) User
	GetUserByBytes(bs []byte) User

	//tlsLayer.UserHaser
	HasUserByBytes(bs []byte) bool
	UserBytesLen() int
}

type UserServer 

type UserServer interface {
	Server
	UserContainer
}

type V2rayUser 

type V2rayUser [16]byte

一种专门用于v2ray协议族(vmess/vless)的 用于标识用户的符号 , 实现 User 接口

func NewV2rayUser 

func NewV2rayUser(s string) (V2rayUser, error)

func (V2rayUser) GetIdentityBytes 

func (u V2rayUser) GetIdentityBytes() []byte

func (V2rayUser) GetIdentityStr 

func (u V2rayUser) GetIdentityStr() string

Source Files

View all Source files

Directories

Path Synopsis
Package dokodemo implements a dokodemo-door proxy.Server.
 Package dokodemo implements a dokodemo-door proxy.Server.
Package http implements an http proxy server
 Package http implements an http proxy server
Package simplesocks implements SimpleSocks protocol.
 Package simplesocks implements SimpleSocks protocol.
Package socks5 provies socks5 proxy support for proxy.Client and proxy.Server.
 Package socks5 provies socks5 proxy support for proxy.Client and proxy.Server.
package trojan implements proxy.Client and proxy.Server with trojan protocol.
 package trojan implements proxy.Client and proxy.Server with trojan protocol.
Package vless provies vless proxy support for proxy.Client and proxy.Server
 Package vless provies vless proxy support for proxy.Client and proxy.Server

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.