Signed-off-by: arraykeys@gmail.com <arraykeys@gmail.com>

CHANGELOG

@@ -1,8 +1,16 @@
-proxy更新日志:
+proxy更新日志
+
+v3.1
+1.优化了内网穿透功能,bridge,client和server只需要启动一个即可。  
+  server端启动的时候可以指定client端要暴露的一个或者多个端口。  
+2.修复了重复解析命令行参数的问题。  
+3.手册增加了微信接口本地开发的示例。  
+4.增加了配置文件使用说明.  
+
 v3.0
 1.此次更新不兼容2.x版本,重构了全部代码,架构更合理,利于功能模块的增加与维护。
 2.增加了代理死循环检查,增强了安全性。
-3.增加了反向代理模式(即:内网穿透),支持TCP和UDP两种协议,可以把任何局域网的机器A所在网络的任何端口
+3.增加了反向代理模式(即:内网穿透),支持TCP和UDP两种协议,可以把任何局域网的机器A所在网络的任何端。
   暴露到任何局域网的机器B的本地端口或暴露到任何公网VPS上。
 4.正向代理增加了UDP模式支持。
 
@@ -21,7 +29,7 @@ v2.1
 
 v2.0
 1.增加了连接池功能,大幅提高了通过上级代理访问的速度。
-2.HTTP代理模式,优化了请求URL的获取逻辑,可以支持:http,https,websocket
+2.HTTP代理模式,优化了请求URL的获取逻辑,可以支持:http,https,websocke。
 3.增加了TCP代理模式,支持是否加密通讯。
 4.优化了链接关闭逻辑,避免出现大量CLOSE_WAIT。
 5.增加了黑白名单机制,更自由快速的访问。

README.md

@@ -1,5 +1,5 @@
 <img src="https://github.com/snail007/goproxy/blob/master/docs/images/logo.jpg?raw=true" width="200"/>  
-Proxy是golang实现的高性能http,https,websocket,tcp,udp代理服务器,支持正向代理和反响代理(即:内网穿透).  
+Proxy是golang实现的高性能http,https,websocket,tcp,udp代理服务器,支持正向代理和内网穿透.  
   
 ---  
   
@@ -12,7 +12,7 @@ Proxy是golang实现的高性能http,https,websocket,tcp,udp代理服务器,支
 - 域名黑白名单，更加自由的控制网站的访问方式。  
 - 跨平台性,无论你是widows,linux,还是mac,甚至是树莓派,都可以很好的运行proxy.  
 - 多协议支持,支持HTTP,TCP,UDP,Websocket代理.  
-- 支持反向代理也就是"内网穿透",协议支持TCP和UDP.  
+- 支持内网穿透,协议支持TCP和UDP.  
   
 ### Why need these?  
 - 当由于安全因素或者限制,我们不能顺畅的访问我们在其它地方的服务,我们可以通过多个相连的proxy节点建立起一个安全的隧道,顺畅的访问我们的服务.  
@@ -20,7 +20,13 @@ Proxy是golang实现的高性能http,https,websocket,tcp,udp代理服务器,支
 - 远程访问内网机器.  
 - 和小伙伴一起玩局域网游戏.  
 - 以前只能在局域网玩的,现在可以在任何地方玩.  
-- ...  
+- 替代圣剑内网通，显IP内网通，花生壳之类的工具.
+- ...  
+
+### 手册目录  
+本页是最新v3.1手册,其他版本手册请点击下面链接查看.  
+- [v3.0手册](https://github.com/snail007/goproxy/tree/v3.0)
+- [v2.x手册](https://github.com/snail007/goproxy/tree/v2.2)
 
 ### Fast Start  
 提示:所有操作需要root权限.  
@@ -44,7 +50,7 @@ wget https://github.com/reddec/monexec/releases/download/v0.1.1/monexec_0.1.1_li
 下载地址:https://github.com/snail007/goproxy/releases  
 ```shell  
 cd /root/proxy/  
-wget https://github.com/snail007/goproxy/releases/download/v2.0/proxy-linux-amd64.tar.gz  
+wget https://github.com/snail007/goproxy/releases/download/v3.1/proxy-linux-amd64.tar.gz  
 ```  
 **3.下载自动安装脚本**  
 ```shell  
@@ -57,11 +63,20 @@ chmod +x install.sh
 ## 使用教程  
   
 **提示**  
-本教程是v3版本,不兼容v2版本,v2版本教程请移驾:[v2教程](https://github.com/snail007/goproxy/tree/v2.2)  
-  
 接下来的教程,默认系统是linux,程序是proxy；所有操作需要root权限；  
 如果你的是windows,请使用windows版本的proxy.exe即可.  
   
+**使用配置文件**  
+接下来的教程都是通过命令行参数介绍使用方法,也可以通过读取配置文件获取参数.  
+具体格式是通过@符号指定配置文件,例如:./proxy @configfile.txt  
+configfile.txt里面的格式是,第一行是子命令名称,第二行开始一行一个:参数的长格式=参数值,前后不能有空格和双引号.  
+参数的长格式都是--开头的,短格式参数都是-开头,如果你不知道某个短格式参数对应长格式参数,查看帮助命令即可.  
+比如configfile.txt内容如下:
+```shell
+http
+--local-type=tcp
+--local=:33080
+```
 ### 0.生成加密通讯需要的证书文件  
   
 http,tcp,udp代理过程会和上级通讯,为了安全我们采用加密通讯,当然可以选择不加密通信通讯,本教程所有和上级通讯都采用加密,需要证书文件.  
@@ -202,7 +217,7 @@ VPS(IP:22.22.22.33)执行:
 **3.6.查看帮助**  
 `./proxy help udp`  
   
-### 4.反向代理(内网穿透)  
+### 4.内网穿透  
 **4.1、原理说明**  
 内网穿透,由三部分组成:client端,server端,bridge端；client和server主动连接bridge端进行桥接.  
 当用户访问server端,流程是:  
@@ -216,6 +231,7 @@ VPS(IP:22.22.22.33)执行:
 背景:  
 - 公司机器A提供了web服务80端口  
 - 有VPS一个,公网IP:22.22.22.22  
+- 本用法典型案例就是微信接口本地开发    
 
 需求:  
 在家里能够通过访问VPS的28080端口访问到公司机器A的80端口  
@@ -223,14 +239,36 @@ VPS(IP:22.22.22.33)执行:
 步骤:  
 1. 在vps上执行  
     `./proxy tbridge -p ":33080" -C proxy.crt -K proxy.key`  
-    `./proxy tserver -p ":28080" -P "127.0.0.1:33080" -C proxy.crt -K proxy.key`  
+    `./proxy tserver -r ":28080@:80" -P "127.0.0.1:33080" -C proxy.crt -K proxy.key`  
   
 1. 在公司机器A上面执行  
-    `./proxy tclient -p "127.0.0.1:80" -P "22.22.22.22:33080" -C proxy.crt -K proxy.key`  
+    `./proxy tclient -C proxy.crt -K proxy.key`  
 
 1. 完成  
   
-**4.3、UDP普通用法**  
+**4.3、微信接口本地开发**  
+背景:  
+- 自己的笔记本提供了nginx服务80端口  
+- 有VPS一个,公网IP:22.22.22.22  
+
+需求:  
+在微信的开发帐号的网页回调接口配置里面填写地址:http://22.22.22.22/calback.php  
+然后就可以访问到笔记本的80端口下面的calback.php,如果需要绑定域名,可以用自己的域名  
+比如:wx-dev.xxx.com解析到22.22.22.22,然后在自己笔记本的nginx里  
+配置域名wx-dev.xxx.com到具体的目录即可.  
+
+  
+步骤:  
+1. 在vps上执行,确保vps的80端口没被其它程序占用.  
+    `./proxy tbridge -p ":33080" -C proxy.crt -K proxy.key`  
+    `./proxy tserver -r ":80@:80" -P ":33080" -C proxy.crt -K proxy.key`  
+
+1. 在自己笔记本上面执行  
+    `./proxy tclient -C proxy.crt -K proxy.key`  
+
+1. 完成  
+  
+**4.4、UDP普通用法**  
 背景:  
 - 公司机器A提供了DNS解析服务,UDP:53端口  
 - 有VPS一个,公网IP:22.22.22.22  
@@ -241,14 +279,14 @@ VPS(IP:22.22.22.33)执行:
 步骤:  
 1. 在vps上执行  
     `./proxy tbridge -p ":33080" -C proxy.crt -K proxy.key`  
-    `./proxy tserver --udp -p ":53" -P "127.0.0.1:33080" -C proxy.crt -K proxy.key`  
+    `./proxy tserver --udp -r ":53@:53" -P "127.0.0.1:33080" -C proxy.crt -K proxy.key`  
 
 1. 在公司机器A上面执行  
-    `./proxy tclient --udp -p "127.0.0.1:53" -P "22.22.22.22:33080" -C proxy.crt -K proxy.key`  
+    `./proxy tclient --udp -P "22.22.22.22:33080" -C proxy.crt -K proxy.key`  
 
 1. 完成  
   
-**4.4、高级用法一**  
+**4.5、高级用法一**  
 背景:  
 - 公司机器A提供了web服务80端口  
 - 有VPS一个,公网IP:22.22.22.22  
@@ -262,17 +300,19 @@ VPS(IP:22.22.22.33)执行:
     `./proxy tbridge -p ":33080" -C proxy.crt -K proxy.key`  
   
 1. 在公司机器A上面执行  
-    `./proxy tclient -p "127.0.0.1:80" -P "22.22.22.22:33080" -C proxy.crt -K proxy.key`  
+    `./proxy tclient -P "22.22.22.22:33080" -C proxy.crt -K proxy.key`  
   
 1. 在家里电脑上执行  
-    `./proxy tserver -p ":28080" -P "22.22.22.22:33080" -C proxy.crt -K proxy.key`  
+    `./proxy tserver -r ":28080@:80" -P "22.22.22.22:33080" -C proxy.crt -K proxy.key`  
   
 1. 完成  
   
-**4.5、高级用法二**  
+**4.6、高级用法二**  
 提示:  
-一个client和一个server是一对,如果要暴露多个端口,需要使用--k参数进行分组,  
---k可以是任意唯一字符串,只要多个端口使用的不一样即可.  
+如果同时有多个client连接到同一个bridge,需要指定不同的key,可以通过--k参数设定,--k可以是任意唯一字符串,
+只要在同一个bridge上唯一即可.  
+server连接到bridge的时候,如果同时有多个client连接到同一个bridge,需要使用--k参数选择client. 
+暴露多个端口重复-r参数即可.-r格式是:"本地IP:本地端口@clientHOST:client端口"  
   
 背景:  
 - 公司机器A提供了web服务80端口,ftp服务21端口  
@@ -285,23 +325,21 @@ VPS(IP:22.22.22.33)执行:
 步骤:  
 1. 在vps上执行  
     `./proxy tbridge -p ":33080" -C proxy.crt -K proxy.key`  
-    `./proxy tserver -p ":28080" --k web -P "127.0.0.1:33080" -C proxy.crt -K proxy.key`  
-    `./proxy tserver -p ":29090" --k ftp -P "127.0.0.1:33080" -C proxy.crt -K proxy.key`  
+    `./proxy tserver -r ":28080@:80" -r ":29090@:21" --k test -P "127.0.0.1:33080" -C proxy.crt -K proxy.key`  
 
 1. 在公司机器A上面执行  
-    `./proxy tclient -p "127.0.0.1:80" --k web -P "22.22.22.22:33080" -C proxy.crt -K proxy.key` 
-    `./proxy tclient -p "127.0.0.1:21" --k ftp -P "22.22.22.22:33080" -C proxy.crt -K proxy.key` 
+    `./proxy tclient --k test -P "22.22.22.22:33080" -C proxy.crt -K proxy.key` 
 
 1. 完成  
   
-**3.6.查看帮助**  
+**4.7.查看帮助**  
 `./proxy help tbridge`  
 `./proxy help tserver`  
 `./proxy help tserver`  
   
   
 ### TODO  
-- UDP Over TCP,通过tcp代理udp协议.  
+- socks5代理支持.  
 ### License  
 Proxy is licensed under GPLv3 license.  
 ### Contact  

config.go

@@ -37,7 +37,6 @@ func initConfig() (err error) {
 	app = kingpin.New("proxy", "happy with proxy")
 	app.Author("snail").Version(APP_VERSION)
 	args.Parent = app.Flag("parent", "parent address, such as: \"23.32.32.19:28008\"").Default("").Short('P').String()
-	args.Local = app.Flag("local", "local ip:port to listen").Short('p').Default(":33080").String()
 	certTLS := app.Flag("cert", "cert file for tls").Short('C').Default("proxy.crt").String()
 	keyTLS := app.Flag("key", "key file for tls").Short('K').Default("proxy.key").String()
 
@@ -53,41 +52,47 @@ func initConfig() (err error) {
 	httpArgs.Direct = http.Flag("direct", "direct domain file , one domain each line").Default("direct").Short('d').String()
 	httpArgs.AuthFile = http.Flag("auth-file", "http basic auth file,\"username:password\" each line in file").Short('F').String()
 	httpArgs.Auth = http.Flag("auth", "http basic auth username and password, mutiple user repeat -a ,such as: -a user1:pass1 -a user2:pass2").Short('a').Strings()
-	httpArgs.PoolSize = http.Flag("pool-size", "conn pool size , which connect to parent proxy, zero: means turn off pool").Short('L').Default("20").Int()
+	httpArgs.PoolSize = http.Flag("pool-size", "conn pool size , which connect to parent proxy, zero: means turn off pool").Short('L').Default("0").Int()
 	httpArgs.CheckParentInterval = http.Flag("check-parent-interval", "check if proxy is okay every interval seconds,zero: means no check").Short('I').Default("3").Int()
+	httpArgs.Local = http.Flag("local", "local ip:port to listen").Short('p').Default(":33080").String()
 
 	//########tcp#########
 	tcp := app.Command("tcp", "proxy on tcp mode")
 	tcpArgs.Timeout = tcp.Flag("timeout", "tcp timeout milliseconds when connect to real server or parent proxy").Short('t').Default("2000").Int()
 	tcpArgs.ParentType = tcp.Flag("parent-type", "parent protocol type <tls|tcp|udp>").Short('T').Enum("tls", "tcp", "udp")
 	tcpArgs.IsTLS = tcp.Flag("tls", "proxy on tls mode").Default("false").Bool()
-	tcpArgs.PoolSize = tcp.Flag("pool-size", "conn pool size , which connect to parent proxy, zero: means turn off pool").Short('L').Default("20").Int()
+	tcpArgs.PoolSize = tcp.Flag("pool-size", "conn pool size , which connect to parent proxy, zero: means turn off pool").Short('L').Default("0").Int()
 	tcpArgs.CheckParentInterval = tcp.Flag("check-parent-interval", "check if proxy is okay every interval seconds,zero: means no check").Short('I').Default("3").Int()
+	tcpArgs.Local = tcp.Flag("local", "local ip:port to listen").Short('p').Default(":33080").String()
 
 	//########udp#########
 	udp := app.Command("udp", "proxy on udp mode")
 	udpArgs.Timeout = udp.Flag("timeout", "tcp timeout milliseconds when connect to parent proxy").Short('t').Default("2000").Int()
 	udpArgs.ParentType = udp.Flag("parent-type", "parent protocol type <tls|tcp|udp>").Short('T').Enum("tls", "tcp", "udp")
-	udpArgs.PoolSize = udp.Flag("pool-size", "conn pool size , which connect to parent proxy, zero: means turn off pool").Short('L').Default("20").Int()
+	udpArgs.PoolSize = udp.Flag("pool-size", "conn pool size , which connect to parent proxy, zero: means turn off pool").Short('L').Default("0").Int()
 	udpArgs.CheckParentInterval = udp.Flag("check-parent-interval", "check if proxy is okay every interval seconds,zero: means no check").Short('I').Default("3").Int()
+	udpArgs.Local = udp.Flag("local", "local ip:port to listen").Short('p').Default(":33080").String()
 
 	//########tunnel-server#########
 	tunnelServer := app.Command("tserver", "proxy on tunnel server mode")
 	tunnelServerArgs.Timeout = tunnelServer.Flag("timeout", "tcp timeout with milliseconds").Short('t').Default("2000").Int()
 	tunnelServerArgs.IsUDP = tunnelServer.Flag("udp", "proxy on udp tunnel server mode").Default("false").Bool()
-	tunnelServerArgs.Key = tunnelServer.Flag("k", "key same with client").Default("default").String()
+	tunnelServerArgs.Key = tunnelServer.Flag("k", "client key").Default("default").String()
+	//tunnelServerArgs.Remote = tunnelServer.Flag("remote", "client's network host:port").Short('R').Default("").String()
+	//tunnelServerArgs.Local = tunnelServer.Flag("local", "local ip:port to listen").Short('p').Default(":33080").String()
+	tunnelServerArgs.Route = tunnelServer.Flag("route", "local route to client's network, such as :localip:localport@clienthost:clientport").Short('r').Default("").Strings()
 
 	//########tunnel-client#########
 	tunnelClient := app.Command("tclient", "proxy on tunnel client mode")
 	tunnelClientArgs.Timeout = tunnelClient.Flag("timeout", "tcp timeout with milliseconds").Short('t').Default("2000").Int()
-	tunnelClientArgs.IsUDP = tunnelClient.Flag("udp", "proxy on udp tunnel client mode").Default("false").Bool()
 	tunnelClientArgs.Key = tunnelClient.Flag("k", "key same with server").Default("default").String()
 
 	//########tunnel-bridge#########
 	tunnelBridge := app.Command("tbridge", "proxy on tunnel bridge mode")
 	tunnelBridgeArgs.Timeout = tunnelBridge.Flag("timeout", "tcp timeout with milliseconds").Short('t').Default("2000").Int()
+	tunnelBridgeArgs.Local = tunnelBridge.Flag("local", "local ip:port to listen").Short('p').Default(":33080").String()
 
-	kingpin.MustParse(app.Parse(os.Args[1:]))
+	serviceName := kingpin.MustParse(app.Parse(os.Args[1:]))
 
 	if *certTLS != "" && *keyTLS != "" {
 		args.CertBytes, args.KeyBytes = tlsBytes(*certTLS, *keyTLS)
@@ -100,14 +105,12 @@ func initConfig() (err error) {
 	tunnelBridgeArgs.Args = args
 	tunnelClientArgs.Args = args
 	tunnelServerArgs.Args = args
-
 	poster()
 	//regist services and run service
-	serviceName := kingpin.MustParse(app.Parse(os.Args[1:]))
 	services.Regist("http", services.NewHTTP(), httpArgs)
 	services.Regist("tcp", services.NewTCP(), tcpArgs)
 	services.Regist("udp", services.NewUDP(), udpArgs)
-	services.Regist("tserver", services.NewTunnelServer(), tunnelServerArgs)
+	services.Regist("tserver", services.NewTunnelServerManager(), tunnelServerArgs)
 	services.Regist("tclient", services.NewTunnelClient(), tunnelClientArgs)
 	services.Regist("tbridge", services.NewTunnelBridge(), tunnelBridgeArgs)
 	service, err = services.Run(serviceName)

install.sh

@@ -1,10 +1,6 @@
 #!/bin/bash
 set -e
-if [ -e /tmp/proxy ]; then
-    rm -rf /tmp/proxy
-fi
-mkdir /tmp/proxy
-cd /tmp/proxy
+
 # install monexec
 tar zxvf monexec_0.1.1_linux_amd64.tar.gz
 cd  monexec_0.1.1_linux_amd64

install_auto.sh

@@ -6,7 +6,7 @@ fi
 mkdir /tmp/proxy
 cd /tmp/proxy
 wget https://github.com/reddec/monexec/releases/download/v0.1.1/monexec_0.1.1_linux_amd64.tar.gz
-wget https://github.com/snail007/goproxy/releases/download/v3.0/proxy-linux-amd64.tar.gz
+wget https://github.com/snail007/goproxy/releases/download/v3.1/proxy-linux-amd64.tar.gz
 
 # install monexec
 tar zxvf monexec_0.1.1_linux_amd64.tar.gz

release.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-VER="3.0"
+VER="3.1"
 RELEASE="release-${VER}"
 rm -rf .cert
 mkdir .cert

services/args.go

@@ -14,29 +14,32 @@ const (
 )
 
 type Args struct {
-	Local     *string
 	Parent    *string
 	CertBytes []byte
 	KeyBytes  []byte
 }
 type TunnelServerArgs struct {
 	Args
+	Local   *string
 	IsUDP   *bool
 	Key     *string
+	Remote  *string
 	Timeout *int
+	Route   *[]string
 }
 type TunnelClientArgs struct {
 	Args
-	IsUDP   *bool
 	Key     *string
 	Timeout *int
 }
 type TunnelBridgeArgs struct {
 	Args
+	Local   *string
 	Timeout *int
 }
 type TCPArgs struct {
 	Args
+	Local               *string
 	ParentType          *string
 	IsTLS               *bool
 	Timeout             *int
@@ -46,6 +49,7 @@ type TCPArgs struct {
 
 type HTTPArgs struct {
 	Args
+	Local               *string
 	Always              *bool
 	HTTPTimeout         *int
 	Interval            *int
@@ -61,6 +65,7 @@ type HTTPArgs struct {
 }
 type UDPArgs struct {
 	Args
+	Local               *string
 	ParentType          *string
 	Timeout             *int
 	PoolSize            *int

services/http.go

@@ -139,7 +139,7 @@ func (s *HTTP) OutToTCP(useProxy bool, address string, inConn *net.Conn, req *ut
 	} else {
 		outConn.Write(req.HeadBuf)
 	}
-	utils.IoBind((*inConn), outConn, func(isSrcErr bool, err error) {
+	utils.IoBind((*inConn), outConn, func(err error) {
 		log.Printf("conn %s - %s - %s -%s released [%s]", inAddr, inLocalAddr, outLocalAddr, outAddr, req.Host)
 		utils.CloseConn(inConn)
 		utils.CloseConn(&outConn)

services/service.go

@@ -25,7 +25,7 @@ func Regist(name string, s Service, args interface{}) {
 		Name: name,
 	}
 }
-func Run(name string) (service *ServiceItem, err error) {
+func Run(name string, args ...interface{}) (service *ServiceItem, err error) {
 	service, ok := servicesMap[name]
 	if ok {
 		go func() {
@@ -35,7 +35,11 @@ func Run(name string) (service *ServiceItem, err error) {
 					log.Fatalf("%s servcie crashed, ERR: %s\ntrace:%s", name, err, string(debug.Stack()))
 				}
 			}()
-			err := service.S.Start(service.Args)
+			if len(args) == 1 {
+				err = service.S.Start(args[0])
+			} else {
+				err = service.S.Start(service.Args)
+			}
 			if err != nil {
 				log.Fatalf("%s servcie fail, ERR: %s", name, err)
 			}

services/tcp.go

@@ -1,6 +1,7 @@
 package services
 
 import (
+	"bufio"
 	"fmt"
 	"io"
 	"log"
@@ -97,7 +98,7 @@ func (s *TCP) OutToTCP(inConn *net.Conn) (err error) {
 	inLocalAddr := (*inConn).LocalAddr().String()
 	outAddr := outConn.RemoteAddr().String()
 	outLocalAddr := outConn.LocalAddr().String()
-	utils.IoBind((*inConn), outConn, func(isSrcErr bool, err error) {
+	utils.IoBind((*inConn), outConn, func(err error) {
 		log.Printf("conn %s - %s - %s -%s released", inAddr, inLocalAddr, outLocalAddr, outAddr)
 		utils.CloseConn(inConn)
 		utils.CloseConn(&outConn)
@@ -108,7 +109,7 @@ func (s *TCP) OutToTCP(inConn *net.Conn) (err error) {
 func (s *TCP) OutToUDP(inConn *net.Conn) (err error) {
 	log.Printf("conn created , remote : %s ", (*inConn).RemoteAddr())
 	for {
-		srcAddr, body, err := utils.ReadUDPPacket(inConn)
+		srcAddr, body, err := utils.ReadUDPPacket(bufio.NewReader(*inConn))
 		if err == io.EOF || err == io.ErrUnexpectedEOF {
 			//log.Printf("connection %s released", srcAddr)
 			utils.CloseConn(inConn)

services/tunnel_bridge.go

@@ -3,31 +3,29 @@ package services
 import (
 	"bufio"
 	"encoding/binary"
-	"fmt"
 	"log"
 	"net"
 	"proxy/utils"
 	"strconv"
-	"sync"
 	"time"
 )
 
-type BridgeItem struct {
-	ServerChn     chan *net.Conn
-	ClientChn     chan *net.Conn
-	ClientControl *net.Conn
-	Once          *sync.Once
-	Key           string
+type ServerConn struct {
+	ClientLocalAddr string //tcp:2.2.22:333@ID
+	Conn            *net.Conn
+	//Conn *utils.HeartbeatReadWriter
 }
 type TunnelBridge struct {
 	cfg                TunnelBridgeArgs
-	br  utils.ConcurrentMap
+	serverConns        utils.ConcurrentMap
+	clientControlConns utils.ConcurrentMap
 }
 
 func NewTunnelBridge() Service {
 	return &TunnelBridge{
 		cfg:                TunnelBridgeArgs{},
-		br:  utils.NewConcurrentMap(),
+		serverConns:        utils.NewConcurrentMap(),
+		clientControlConns: utils.NewConcurrentMap(),
 	}
 }
 
@@ -52,6 +50,8 @@ func (s *TunnelBridge) Start(args interface{}) (err error) {
 	sc := utils.NewServerChannel(host, p)
 
 	err = sc.ListenTls(s.cfg.CertBytes, s.cfg.KeyBytes, func(inConn net.Conn) {
+		//log.Printf("connection from %s ", inConn.RemoteAddr())
+
 		reader := bufio.NewReader(inConn)
 		var connType uint8
 		err = binary.Read(reader, binary.LittleEndian, &connType)
@@ -59,14 +59,16 @@ func (s *TunnelBridge) Start(args interface{}) (err error) {
 			utils.CloseConn(&inConn)
 			return
 		}
-		var key string
+		//log.Printf("conn type %d", connType)
+
+		var key, clientLocalAddr, ID string
 		var connTypeStrMap = map[uint8]string{CONN_SERVER: "server", CONN_CLIENT: "client", CONN_CONTROL: "client"}
-		if connType == CONN_SERVER || connType == CONN_CLIENT || connType == CONN_CONTROL {
 		var keyLength uint16
 		err = binary.Read(reader, binary.LittleEndian, &keyLength)
 		if err != nil {
 			return
 		}
+
 		_key := make([]byte, keyLength)
 		n, err := reader.Read(_key)
 		if err != nil {
@@ -76,18 +78,106 @@ func (s *TunnelBridge) Start(args interface{}) (err error) {
 			return
 		}
 		key = string(_key)
-			log.Printf("connection from %s , key: %s", connTypeStrMap[connType], key)
+		//log.Printf("conn key %s", key)
+
+		if connType != CONN_CONTROL {
+			var IDLength uint16
+			err = binary.Read(reader, binary.LittleEndian, &IDLength)
+			if err != nil {
+				return
 			}
+			_id := make([]byte, IDLength)
+			n, err := reader.Read(_id)
+			if err != nil {
+				return
+			}
+			if n != int(IDLength) {
+				return
+			}
+			ID = string(_id)
+
+			if connType == CONN_SERVER {
+				var addrLength uint16
+				err = binary.Read(reader, binary.LittleEndian, &addrLength)
+				if err != nil {
+					return
+				}
+				_addr := make([]byte, addrLength)
+				n, err = reader.Read(_addr)
+				if err != nil {
+					return
+				}
+				if n != int(addrLength) {
+					return
+				}
+				clientLocalAddr = string(_addr)
+			}
+		}
+		log.Printf("connection from %s , key: %s , id: %s", connTypeStrMap[connType], key, ID)
+
 		switch connType {
 		case CONN_SERVER:
-			s.ServerConn(&inConn, key)
+			// hb := utils.NewHeartbeatReadWriter(&inConn, 3, func(err error, hb *utils.HeartbeatReadWriter) {
+			// 	log.Printf("%s conn %s from server released", key, ID)
+			// 	s.serverConns.Remove(ID)
+			// })
+			addr := clientLocalAddr + "@" + ID
+			s.serverConns.Set(ID, ServerConn{
+				//Conn:            &hb,
+				Conn:            &inConn,
+				ClientLocalAddr: addr,
+			})
+			for {
+				item, ok := s.clientControlConns.Get(key)
+				if !ok {
+					log.Printf("client %s control conn not exists", key)
+					time.Sleep(time.Second * 3)
+					continue
+				}
+				_, err := (*item.(*net.Conn)).Write([]byte(addr))
+				if err != nil {
+					log.Printf("%s client control conn write signal fail, err: %s, retrying...", key, err)
+					time.Sleep(time.Second * 3)
+					continue
+				} else {
+					break
+				}
+			}
 		case CONN_CLIENT:
-			s.ClientConn(&inConn, key)
-		case CONN_CONTROL:
-			s.ClientControlConn(&inConn, key)
-		default:
-			log.Printf("unkown conn type %d", connType)
+			serverConnItem, ok := s.serverConns.Get(ID)
+			if !ok {
+				inConn.Close()
+				log.Printf("server conn %s exists", ID)
+				return
+			}
+			serverConn := serverConnItem.(ServerConn).Conn
+			// hw := utils.NewHeartbeatReadWriter(&inConn, 3, func(err error, hw *utils.HeartbeatReadWriter) {
+			// 	log.Printf("%s conn %s from client released", key, ID)
+			// 	hw.Close()
+			// })
+			utils.IoBind(*serverConn, inConn, func(err error) {
+				// utils.IoBind(serverConn, inConn, func(isSrcErr bool, err error) {
+				//serverConn.Close()
+				(*serverConn).Close()
 				utils.CloseConn(&inConn)
+				// hw.Close()
+				s.serverConns.Remove(ID)
+				log.Printf("conn %s released", ID)
+			}, func(i int, b bool) {}, 0)
+			log.Printf("conn %s created", ID)
+		case CONN_CONTROL:
+			if s.clientControlConns.Has(key) {
+				item, _ := s.clientControlConns.Get(key)
+				//(*item.(*utils.HeartbeatReadWriter)).Close()
+				(*item.(*net.Conn)).Close()
+			}
+			// hb := utils.NewHeartbeatReadWriter(&inConn, 3, func(err error, hb *utils.HeartbeatReadWriter) {
+			// 	log.Printf("client %s disconnected", key)
+			// 	s.clientControlConns.Remove(key)
+			// })
+			// s.clientControlConns.Set(key, &hb)
+			s.clientControlConns.Set(key, &inConn)
+			log.Printf("set client %s control conn", key)
 		}
 	})
 	if err != nil {
@@ -99,85 +189,3 @@ func (s *TunnelBridge) Start(args interface{}) (err error) {
 func (s *TunnelBridge) Clean() {
 	s.StopService()
 }
-func (s *TunnelBridge) ClientConn(inConn *net.Conn, key string) {
-	chn, _ := s.ConnChn(key, CONN_CLIENT)
-	chn <- inConn
-}
-func (s *TunnelBridge) ServerConn(inConn *net.Conn, key string) {
-	chn, _ := s.ConnChn(key, CONN_SERVER)
-	chn <- inConn
-}
-func (s *TunnelBridge) ClientControlConn(inConn *net.Conn, key string) {
-	_, item := s.ConnChn(key, CONN_CLIENT)
-	utils.CloseConn(item.ClientControl)
-	if item.ClientControl != nil {
-		*item.ClientControl = *inConn
-	} else {
-		item.ClientControl = inConn
-	}
-	log.Printf("set client control conn,remote: %s", (*inConn).RemoteAddr())
-}
-func (s *TunnelBridge) ConnChn(key string, typ uint8) (chn chan *net.Conn, item *BridgeItem) {
-	s.br.SetIfAbsent(key, &BridgeItem{
-		ServerChn: make(chan *net.Conn, 10000),
-		ClientChn: make(chan *net.Conn, 10000),
-		Once:      &sync.Once{},
-		Key:       key,
-	})
-	_item, _ := s.br.Get(key)
-	item = _item.(*BridgeItem)
-	item.Once.Do(func() {
-		s.ChnDeamon(item)
-	})
-	if typ == CONN_CLIENT {
-		chn = item.ClientChn
-	} else {
-		chn = item.ServerChn
-	}
-	return
-}
-func (s *TunnelBridge) ChnDeamon(item *BridgeItem) {
-	go func() {
-		log.Printf("%s conn chan deamon started", item.Key)
-		for {
-			var clientConn *net.Conn
-			var serverConn *net.Conn
-			serverConn = <-item.ServerChn
-			log.Printf("%s server conn picked up", item.Key)
-		OUT:
-			for {
-				_item, _ := s.br.Get(item.Key)
-				Item := _item.(*BridgeItem)
-				var err error
-				if Item.ClientControl != nil && *Item.ClientControl != nil {
-					_, err = (*Item.ClientControl).Write([]byte{'0'})
-				} else {
-					err = fmt.Errorf("client control conn not exists")
-				}
-				if err != nil {
-					log.Printf("%s client control conn write signal fail, err: %s, retrying...", item.Key, err)
-					utils.CloseConn(Item.ClientControl)
-					*Item.ClientControl = nil
-					Item.ClientControl = nil
-					time.Sleep(time.Second * 3)
-					continue
-				} else {
-					select {
-					case clientConn = <-item.ClientChn:
-						log.Printf("%s client conn picked up", item.Key)
-						break OUT
-					case <-time.After(time.Second * time.Duration(*s.cfg.Timeout*5)):
-						log.Printf("%s client conn picked timeout, retrying...", item.Key)
-					}
-				}
-			}
-
-			utils.IoBind(*serverConn, *clientConn, func(isSrcErr bool, err error) {
-				utils.CloseConn(serverConn)
-				utils.CloseConn(clientConn)
-				log.Printf("%s conn %s - %s - %s - %s released", item.Key, (*serverConn).RemoteAddr(), (*serverConn).LocalAddr(), (*clientConn).LocalAddr(), (*clientConn).RemoteAddr())
-			}, func(i int, b bool) {}, 0)
-			log.Printf("%s conn %s - %s - %s - %s created", item.Key, (*serverConn).RemoteAddr(), (*serverConn).LocalAddr(), (*clientConn).LocalAddr(), (*clientConn).RemoteAddr())
-		}
-	}()
-}

services/tunnel_client.go

@@ -9,6 +9,7 @@ import (
 	"log"
 	"net"
 	"proxy/utils"
+	"strings"
 	"time"
 )
 
@@ -40,36 +41,40 @@ func (s *TunnelClient) Start(args interface{}) (err error) {
 	s.cfg = args.(TunnelClientArgs)
 	s.Check()
 	s.InitService()
-
+	log.Printf("proxy on tunnel client mode")
 	for {
-		ctrlConn, err := s.GetInConn(CONN_CONTROL)
+		ctrlConn, err := s.GetInConn(CONN_CONTROL, "")
 		if err != nil {
 			log.Printf("control connection err: %s", err)
 			time.Sleep(time.Second * 3)
 			utils.CloseConn(&ctrlConn)
 			continue
 		}
-		if *s.cfg.IsUDP {
-			log.Printf("proxy on udp tunnel client mode")
-		} else {
-			log.Printf("proxy on tcp tunnel client mode")
-		}
+		// rw := utils.NewHeartbeatReadWriter(&ctrlConn, 3, func(err error, hb *utils.HeartbeatReadWriter) {
+		// 	log.Printf("ctrlConn err %s", err)
+		// 	utils.CloseConn(&ctrlConn)
+		// })
 		for {
-			signal := make([]byte, 1)
-			if signal[0] == 1 {
-				continue
-			}
-			_, err = ctrlConn.Read(signal)
+			signal := make([]byte, 50)
+			// n, err := rw.Read(signal)
+			n, err := ctrlConn.Read(signal)
 			if err != nil {
 				utils.CloseConn(&ctrlConn)
 				log.Printf("read connection signal err: %s", err)
 				break
 			}
-			log.Printf("signal revecived:%s", signal)
-			if *s.cfg.IsUDP {
-				go s.ServeUDP()
+			addr := string(signal[:n])
+			// log.Printf("n:%d addr:%s err:%s", n, addr, err)
+			// os.Exit(0)
+			log.Printf("signal revecived:%s", addr)
+			protocol := addr[:3]
+			atIndex := strings.Index(addr, "@")
+			ID := addr[atIndex+1:]
+			localAddr := addr[4:atIndex]
+			if protocol == "udp" {
+				go s.ServeUDP(localAddr, ID)
 			} else {
-				go s.ServeConn()
+				go s.ServeConn(localAddr, ID)
 			}
 		}
 	}
@@ -77,7 +82,7 @@ func (s *TunnelClient) Start(args interface{}) (err error) {
 func (s *TunnelClient) Clean() {
 	s.StopService()
 }
-func (s *TunnelClient) GetInConn(typ uint8) (outConn net.Conn, err error) {
+func (s *TunnelClient) GetInConn(typ uint8, ID string) (outConn net.Conn, err error) {
 	outConn, err = s.GetConn()
 	if err != nil {
 		err = fmt.Errorf("connection err: %s", err)
@@ -89,6 +94,12 @@ func (s *TunnelClient) GetInConn(typ uint8) (outConn net.Conn, err error) {
 	binary.Write(pkg, binary.LittleEndian, typ)
 	binary.Write(pkg, binary.LittleEndian, keyLength)
 	binary.Write(pkg, binary.LittleEndian, keyBytes)
+	if ID != "" {
+		IDBytes := []byte(ID)
+		IDLength := uint16(len(IDBytes))
+		binary.Write(pkg, binary.LittleEndian, IDLength)
+		binary.Write(pkg, binary.LittleEndian, IDBytes)
+	}
 	_, err = outConn.Write(pkg.Bytes())
 	if err != nil {
 		err = fmt.Errorf("write connection data err: %s ,retrying...", err)
@@ -105,12 +116,12 @@ func (s *TunnelClient) GetConn() (conn net.Conn, err error) {
 	}
 	return
 }
-func (s *TunnelClient) ServeUDP() {
+func (s *TunnelClient) ServeUDP(localAddr, ID string) {
 	var inConn net.Conn
 	var err error
+	// for {
 	for {
-		for {
-			inConn, err = s.GetInConn(CONN_CLIENT)
+		inConn, err = s.GetInConn(CONN_CLIENT, ID)
 		if err != nil {
 			utils.CloseConn(&inConn)
 			log.Printf("connection err: %s, retrying...", err)
@@ -120,21 +131,30 @@ func (s *TunnelClient) ServeUDP() {
 			break
 		}
 	}
-		log.Printf("conn created , remote : %s ", inConn.RemoteAddr())
+	log.Printf("conn %s created", ID)
+	// hw := utils.NewHeartbeatReadWriter(&inConn, 3, func(err error, hw *utils.HeartbeatReadWriter) {
+	// 	log.Printf("hw err %s", err)
+	// 	hw.Close()
+	// })
 	for {
-			srcAddr, body, err := utils.ReadUDPPacket(&inConn)
+		// srcAddr, body, err := utils.ReadUDPPacket(&hw)
+		srcAddr, body, err := utils.ReadUDPPacket(inConn)
 		if err == io.EOF || err == io.ErrUnexpectedEOF {
-				log.Printf("connection %s released", srcAddr)
+			log.Printf("connection %s released", ID)
 			utils.CloseConn(&inConn)
 			break
+		} else if err != nil {
+			log.Printf("udp packet revecived fail, err: %s", err)
+		} else {
+			log.Printf("udp packet revecived:%s,%v", srcAddr, body)
+			go s.processUDPPacket(&inConn, srcAddr, localAddr, body)
 		}
-			//log.Printf("udp packet revecived:%s,%v", srcAddr, body)
-			go s.processUDPPacket(&inConn, srcAddr, body)
+
 	}
+	// }
 }
-}
-func (s *TunnelClient) processUDPPacket(inConn *net.Conn, srcAddr string, body []byte) {
-	dstAddr, err := net.ResolveUDPAddr("udp", *s.cfg.Local)
+func (s *TunnelClient) processUDPPacket(inConn *net.Conn, srcAddr, localAddr string, body []byte) {
+	dstAddr, err := net.ResolveUDPAddr("udp", localAddr)
 	if err != nil {
 		log.Printf("can't resolve address: %s", err)
 		utils.CloseConn(inConn)
@@ -153,27 +173,28 @@ func (s *TunnelClient) processUDPPacket(inConn *net.Conn, srcAddr string, body [
 		return
 	}
 	//log.Printf("send udp packet to %s success", dstAddr.String())
-	buf := make([]byte, 512)
-	len, _, err := conn.ReadFromUDP(buf)
+	buf := make([]byte, 1024)
+	length, _, err := conn.ReadFromUDP(buf)
 	if err != nil {
 		log.Printf("read udp response from %s fail ,ERR:%s", dstAddr.String(), err)
 		return
 	}
-	respBody := buf[0:len]
-	//log.Printf("revecived udp packet from %s , %v", dstAddr.String(), respBody)
-	_, err = (*inConn).Write(utils.UDPPacket(srcAddr, respBody))
+	respBody := buf[0:length]
+	log.Printf("revecived udp packet from %s , %v", dstAddr.String(), respBody)
+	bs := utils.UDPPacket(srcAddr, respBody)
+	_, err = (*inConn).Write(bs)
 	if err != nil {
 		log.Printf("send udp response fail ,ERR:%s", err)
 		utils.CloseConn(inConn)
 		return
 	}
-	//log.Printf("send udp response success ,from:%s", dstAddr.String())
+	log.Printf("send udp response success ,from:%s ,%d ,%v", dstAddr.String(), len(bs), bs)
 }
-func (s *TunnelClient) ServeConn() {
+func (s *TunnelClient) ServeConn(localAddr, ID string) {
 	var inConn, outConn net.Conn
 	var err error
 	for {
-		inConn, err = s.GetInConn(CONN_CLIENT)
+		inConn, err = s.GetInConn(CONN_CLIENT, ID)
 		if err != nil {
 			utils.CloseConn(&inConn)
 			log.Printf("connection err: %s, retrying...", err)
@@ -187,29 +208,27 @@ func (s *TunnelClient) ServeConn() {
 	i := 0
 	for {
 		i++
-		outConn, err = utils.ConnectHost(*s.cfg.Local, *s.cfg.Timeout)
+		outConn, err = utils.ConnectHost(localAddr, *s.cfg.Timeout)
 		if err == nil || i == 3 {
 			break
 		} else {
 			if i == 3 {
-				log.Printf("connect to %s err: %s, retrying...", *s.cfg.Local, err)
+				log.Printf("connect to %s err: %s, retrying...", localAddr, err)
 				time.Sleep(2 * time.Second)
 				continue
 			}
 		}
 	}
-
 	if err != nil {
 		utils.CloseConn(&inConn)
 		utils.CloseConn(&outConn)
 		log.Printf("build connection error, err: %s", err)
 		return
 	}
-
-	utils.IoBind(inConn, outConn, func(isSrcErr bool, err error) {
-		log.Printf("%s conn %s - %s - %s - %s released", *s.cfg.Key, inConn.RemoteAddr(), inConn.LocalAddr(), outConn.LocalAddr(), outConn.RemoteAddr())
+	utils.IoBind(inConn, outConn, func(err error) {
+		log.Printf("conn %s released", ID)
 		utils.CloseConn(&inConn)
 		utils.CloseConn(&outConn)
 	}, func(i int, b bool) {}, 0)
-	log.Printf("%s conn %s - %s - %s - %s created", *s.cfg.Key, inConn.RemoteAddr(), inConn.LocalAddr(), outConn.LocalAddr(), outConn.RemoteAddr())
+	log.Printf("conn %s created", ID)
 }

services/tunnel_server.go

@@ -1,7 +1,6 @@
 package services
 
 import (
-	"bufio"
 	"bytes"
 	"crypto/tls"
 	"encoding/binary"
@@ -21,6 +20,48 @@ type TunnelServer struct {
 	sc     utils.ServerChannel
 }
 
+type TunnelServerManager struct {
+	cfg    TunnelServerArgs
+	udpChn chan UDPItem
+	sc     utils.ServerChannel
+}
+
+func NewTunnelServerManager() Service {
+	return &TunnelServerManager{
+		cfg:    TunnelServerArgs{},
+		udpChn: make(chan UDPItem, 50000),
+	}
+}
+func (s *TunnelServerManager) Start(args interface{}) (err error) {
+	s.cfg = args.(TunnelServerArgs)
+	if *s.cfg.Parent != "" {
+		log.Printf("use tls parent %s", *s.cfg.Parent)
+	} else {
+		log.Fatalf("parent required")
+	}
+	//log.Printf("route:%v", *s.cfg.Route)
+	for _, info := range *s.cfg.Route {
+		_routeInfo := strings.Split(info, "@")
+		server := NewTunnelServer()
+		local := _routeInfo[0]
+		remote := _routeInfo[1]
+		err = server.Start(TunnelServerArgs{
+			Args:    s.cfg.Args,
+			Local:   &local,
+			IsUDP:   s.cfg.IsUDP,
+			Remote:  &remote,
+			Key:     s.cfg.Key,
+			Timeout: s.cfg.Timeout,
+		})
+		if err != nil {
+			return
+		}
+	}
+	return
+}
+func (s *TunnelServerManager) Clean() {
+
+}
 func NewTunnelServer() Service {
 	return &TunnelServer{
 		cfg:    TunnelServerArgs{},
@@ -38,10 +79,8 @@ func (s *TunnelServer) InitService() {
 	s.UDPConnDeamon()
 }
 func (s *TunnelServer) Check() {
-	if *s.cfg.Parent != "" {
-		log.Printf("use tls parent %s", *s.cfg.Parent)
-	} else {
-		log.Fatalf("parent required")
+	if *s.cfg.Remote == "" {
+		log.Fatalf("remote required")
 	}
 	if s.cfg.CertBytes == nil || s.cfg.KeyBytes == nil {
 		log.Fatalf("cert and key file required")
@@ -56,7 +95,6 @@ func (s *TunnelServer) Start(args interface{}) (err error) {
 	host, port, _ := net.SplitHostPort(*s.cfg.Local)
 	p, _ := strconv.Atoi(port)
 	s.sc = utils.NewServerChannel(host, p)
-
 	if *s.cfg.IsUDP {
 		err = s.sc.ListenUDP(func(packet []byte, localAddr, srcAddr *net.UDPAddr) {
 			s.udpChn <- UDPItem{
@@ -77,8 +115,9 @@ func (s *TunnelServer) Start(args interface{}) (err error) {
 				}
 			}()
 			var outConn net.Conn
+			var ID string
 			for {
-				outConn, err = s.GetOutConn()
+				outConn, ID, err = s.GetOutConn("")
 				if err != nil {
 					utils.CloseConn(&outConn)
 					log.Printf("connect to %s fail, err: %s, retrying...", *s.cfg.Parent, err)
@@ -88,14 +127,18 @@ func (s *TunnelServer) Start(args interface{}) (err error) {
 					break
 				}
 			}
-
-			utils.IoBind(inConn, outConn, func(isSrcErr bool, err error) {
+			// hb := utils.NewHeartbeatReadWriter(&outConn, 3, func(err error, hb *utils.HeartbeatReadWriter) {
+			// 	log.Printf("%s conn %s to bridge released", *s.cfg.Key, ID)
+			// 	hb.Close()
+			// })
+			// utils.IoBind(inConn, &hb, func(err error) {
+			utils.IoBind(inConn, outConn, func(err error) {
 				utils.CloseConn(&outConn)
 				utils.CloseConn(&inConn)
-				log.Printf("%s conn %s - %s - %s - %s released", *s.cfg.Key, inConn.RemoteAddr(), inConn.LocalAddr(), outConn.LocalAddr(), outConn.RemoteAddr())
+				log.Printf("%s conn %s released", *s.cfg.Key, ID)
 			}, func(i int, b bool) {}, 0)
 
-			log.Printf("%s conn %s - %s - %s - %s created", *s.cfg.Key, inConn.RemoteAddr(), inConn.LocalAddr(), outConn.LocalAddr(), outConn.RemoteAddr())
+			log.Printf("%s conn %s created", *s.cfg.Key, ID)
 		})
 		if err != nil {
 			return
@@ -107,7 +150,7 @@ func (s *TunnelServer) Start(args interface{}) (err error) {
 func (s *TunnelServer) Clean() {
 	s.StopService()
 }
-func (s *TunnelServer) GetOutConn() (outConn net.Conn, err error) {
+func (s *TunnelServer) GetOutConn(id string) (outConn net.Conn, ID string, err error) {
 	outConn, err = s.GetConn()
 	if err != nil {
 		log.Printf("connection err: %s", err)
@@ -115,10 +158,26 @@ func (s *TunnelServer) GetOutConn() (outConn net.Conn, err error) {
 	}
 	keyBytes := []byte(*s.cfg.Key)
 	keyLength := uint16(len(keyBytes))
+	ID = utils.Uniqueid()
+	IDBytes := []byte(ID)
+	if id != "" {
+		ID = id
+		IDBytes = []byte(id)
+	}
+	IDLength := uint16(len(IDBytes))
+	remoteAddr := []byte("tcp:" + *s.cfg.Remote)
+	if *s.cfg.IsUDP {
+		remoteAddr = []byte("udp:" + *s.cfg.Remote)
+	}
+	remoteAddrLength := uint16(len(remoteAddr))
 	pkg := new(bytes.Buffer)
 	binary.Write(pkg, binary.LittleEndian, CONN_SERVER)
 	binary.Write(pkg, binary.LittleEndian, keyLength)
 	binary.Write(pkg, binary.LittleEndian, keyBytes)
+	binary.Write(pkg, binary.LittleEndian, IDLength)
+	binary.Write(pkg, binary.LittleEndian, IDBytes)
+	binary.Write(pkg, binary.LittleEndian, remoteAddrLength)
+	binary.Write(pkg, binary.LittleEndian, remoteAddr)
 	_, err = outConn.Write(pkg.Bytes())
 	if err != nil {
 		log.Printf("write connection data err: %s ,retrying...", err)
@@ -143,6 +202,8 @@ func (s *TunnelServer) UDPConnDeamon() {
 			}
 		}()
 		var outConn net.Conn
+		// var hb utils.HeartbeatReadWriter
+		var ID string
 		var cmdChn = make(chan bool, 1)
 
 		var err error
@@ -151,7 +212,7 @@ func (s *TunnelServer) UDPConnDeamon() {
 		RETRY:
 			if outConn == nil {
 				for {
-					outConn, err = s.GetOutConn()
+					outConn, ID, err = s.GetOutConn("")
 					if err != nil {
 						cmdChn <- true
 						outConn = nil
@@ -160,19 +221,25 @@ func (s *TunnelServer) UDPConnDeamon() {
 						time.Sleep(time.Second * 3)
 						continue
 					} else {
-						go func(outConn net.Conn) {
+						// hb = utils.NewHeartbeatReadWriter(&outConn, 3, func(err error, hb *utils.HeartbeatReadWriter) {
+						// 	log.Printf("%s conn %s to bridge released", *s.cfg.Key, ID)
+						// 	hb.Close()
+						// })
+						// go func(outConn net.Conn, hb utils.HeartbeatReadWriter, ID string) {
+						go func(outConn net.Conn, ID string) {
 							go func() {
 								<-cmdChn
 								outConn.Close()
 							}()
 							for {
-								srcAddrFromConn, body, err := utils.ReadUDPPacket(&outConn)
+								//srcAddrFromConn, body, err := utils.ReadUDPPacket(&hb)
+								srcAddrFromConn, body, err := utils.ReadUDPPacket(outConn)
 								if err == io.EOF || err == io.ErrUnexpectedEOF {
-									log.Printf("udp connection deamon exited, %s -> %s", outConn.LocalAddr(), outConn.RemoteAddr())
+									log.Printf("UDP deamon connection %s exited", ID)
 									break
 								}
 								if err != nil {
-									log.Printf("parse revecived udp packet fail, err: %s", err)
+									log.Printf("parse revecived udp packet fail, err: %s ,%v", err, body)
 									continue
 								}
 								//log.Printf("udp packet revecived over parent , local:%s", srcAddrFromConn)
@@ -188,19 +255,25 @@ func (s *TunnelServer) UDPConnDeamon() {
 									log.Printf("udp response to local %s fail,ERR:%s", srcAddrFromConn, err)
 									continue
 								}
-								//log.Printf("udp response to local %s success", srcAddrFromConn)
+								//log.Printf("udp response to local %s success , %v", srcAddrFromConn, body)
 							}
-						}(outConn)
+							// }(outConn, hb, ID)
+						}(outConn, ID)
 						break
 					}
 				}
 			}
-			writer := bufio.NewWriter(outConn)
-			writer.Write(utils.UDPPacket(item.srcAddr.String(), *item.packet))
-			err := writer.Flush()
+			outConn.SetWriteDeadline(time.Now().Add(time.Second))
+			// _, err = hb.Write(utils.UDPPacket(item.srcAddr.String(), *item.packet))
+			_, err = outConn.Write(utils.UDPPacket(item.srcAddr.String(), *item.packet))
+			// writer := bufio.NewWriter(outConn)
+			// writer.Write(utils.UDPPacket(item.srcAddr.String(), *item.packet))
+			// err := writer.Flush()
+			outConn.SetWriteDeadline(time.Time{})
 			if err != nil {
+				utils.CloseConn(&outConn)
 				outConn = nil
-				log.Printf("write udp packet to %s fail ,flush err:%s", *s.cfg.Parent, err)
+				log.Printf("write udp packet to %s fail ,flush err:%s ,retrying...", *s.cfg.Parent, err)
 				goto RETRY
 			}
 			//log.Printf("write packet %v", *item.packet)

services/udp.go

@@ -120,7 +120,7 @@ func (s *UDP) OutToTCP(packet []byte, localAddr, srcAddr *net.UDPAddr) (err erro
 			}()
 			log.Printf("conn %d created , local: %s", connKey, srcAddr.String())
 			for {
-				srcAddrFromConn, body, err := utils.ReadUDPPacket(&conn)
+				srcAddrFromConn, body, err := utils.ReadUDPPacket(bufio.NewReader(conn))
 				if err == io.EOF || err == io.ErrUnexpectedEOF {
 					//log.Printf("connection %d released", connKey)
 					s.p.Remove(fmt.Sprintf("%d", connKey))

utils/functions.go

@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"math/rand"
 	"net"
 	"net/http"
 	"os"
@@ -22,7 +23,7 @@ import (
 	"time"
 )
 
-func IoBind(dst io.ReadWriter, src io.ReadWriter, fn func(isSrcErr bool, err error), cfn func(count int, isPositive bool), bytesPreSec float64) {
+func IoBind(dst io.ReadWriter, src io.ReadWriter, fn func(err error), cfn func(count int, isPositive bool), bytesPreSec float64) {
 	var one = &sync.Once{}
 	go func() {
 		defer func() {
@@ -31,22 +32,21 @@ func IoBind(dst io.ReadWriter, src io.ReadWriter, fn func(isSrcErr bool, err err
 			}
 		}()
 		var err error
-		var isSrcErr bool
 		if bytesPreSec > 0 {
 			newreader := NewReader(src)
 			newreader.SetRateLimit(bytesPreSec)
-			_, isSrcErr, err = ioCopy(dst, newreader, func(c int) {
+			_, err = ioCopy(dst, newreader, func(c int) {
 				cfn(c, false)
 			})
 
 		} else {
-			_, isSrcErr, err = ioCopy(dst, src, func(c int) {
+			_, err = ioCopy(dst, src, func(c int) {
 				cfn(c, false)
 			})
 		}
 		if err != nil {
 			one.Do(func() {
-				fn(isSrcErr, err)
+				fn(err)
 			})
 		}
 	}()
@@ -57,26 +57,25 @@ func IoBind(dst io.ReadWriter, src io.ReadWriter, fn func(isSrcErr bool, err err
 			}
 		}()
 		var err error
-		var isSrcErr bool
 		if bytesPreSec > 0 {
 			newReader := NewReader(dst)
 			newReader.SetRateLimit(bytesPreSec)
-			_, isSrcErr, err = ioCopy(src, newReader, func(c int) {
+			_, err = ioCopy(src, newReader, func(c int) {
 				cfn(c, true)
 			})
 		} else {
-			_, isSrcErr, err = ioCopy(src, dst, func(c int) {
+			_, err = ioCopy(src, dst, func(c int) {
 				cfn(c, true)
 			})
 		}
 		if err != nil {
 			one.Do(func() {
-				fn(isSrcErr, err)
+				fn(err)
 			})
 		}
 	}()
 }
-func ioCopy(dst io.Writer, src io.Reader, fn ...func(count int)) (written int64, isSrcErr bool, err error) {
+func ioCopy(dst io.Writer, src io.Reader, fn ...func(count int)) (written int64, err error) {
 	buf := make([]byte, 32*1024)
 	for {
 		nr, er := src.Read(buf)
@@ -99,11 +98,10 @@ func ioCopy(dst io.Writer, src io.Reader, fn ...func(count int)) (written int64,
 		}
 		if er != nil {
 			err = er
-			isSrcErr = true
 			break
 		}
 	}
-	return written, isSrcErr, err
+	return written, err
 }
 func TlsConnectHost(host string, timeout int, certBytes, keyBytes []byte) (conn tls.Conn, err error) {
 	h := strings.Split(host, ":")
@@ -265,6 +263,7 @@ func UDPPacket(srcAddr string, packet []byte) []byte {
 	addrBytes := []byte(srcAddr)
 	addrLength := uint16(len(addrBytes))
 	bodyLength := uint16(len(packet))
+	//log.Printf("build packet : addr len %d, body len %d", addrLength, bodyLength)
 	pkg := new(bytes.Buffer)
 	binary.Write(pkg, binary.LittleEndian, addrLength)
 	binary.Write(pkg, binary.LittleEndian, addrBytes)
@@ -272,8 +271,8 @@ func UDPPacket(srcAddr string, packet []byte) []byte {
 	binary.Write(pkg, binary.LittleEndian, packet)
 	return pkg.Bytes()
 }
-func ReadUDPPacket(conn *net.Conn) (srcAddr string, packet []byte, err error) {
-	reader := bufio.NewReader(*conn)
+func ReadUDPPacket(_reader io.Reader) (srcAddr string, packet []byte, err error) {
+	reader := bufio.NewReader(_reader)
 	var addrLength uint16
 	var bodyLength uint16
 	err = binary.Read(reader, binary.LittleEndian, &addrLength)
@@ -286,12 +285,14 @@ func ReadUDPPacket(conn *net.Conn) (srcAddr string, packet []byte, err error) {
 		return
 	}
 	if n != int(addrLength) {
+		err = fmt.Errorf("n != int(addrLength), %d,%d", n, addrLength)
 		return
 	}
 	srcAddr = string(_srcAddr)
 
 	err = binary.Read(reader, binary.LittleEndian, &bodyLength)
 	if err != nil {
+
 		return
 	}
 	packet = make([]byte, bodyLength)
@@ -300,10 +301,16 @@ func ReadUDPPacket(conn *net.Conn) (srcAddr string, packet []byte, err error) {
 		return
 	}
 	if n != int(bodyLength) {
+		err = fmt.Errorf("n != int(bodyLength), %d,%d", n, bodyLength)
 		return
 	}
 	return
 }
+func Uniqueid() string {
+	var src = rand.NewSource(time.Now().UnixNano())
+	s := fmt.Sprintf("%d", src.Int63())
+	return s[len(s)-5:len(s)-1] + fmt.Sprintf("%d", uint64(time.Now().UnixNano()))[8:]
+}
 
 // type sockaddr struct {
 // 	family uint16

utils/structs.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"crypto/tls"
 	"encoding/base64"
+	"encoding/binary"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -11,6 +12,7 @@ import (
 	"net"
 	"net/url"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -460,3 +462,153 @@ func (op *OutPool) initPoolDeamon() {
 		}
 	}()
 }
+
+type HeartbeatData struct {
+	Data  []byte
+	N     int
+	Error error
+}
+type HeartbeatReadWriter struct {
+	conn *net.Conn
+	// rchn       chan HeartbeatData
+	l          *sync.Mutex
+	dur        int
+	errHandler func(err error, hb *HeartbeatReadWriter)
+	once       *sync.Once
+	datachn    chan byte
+	// rbuf       bytes.Buffer
+	// signal     chan bool
+	rerrchn chan error
+}
+
+func NewHeartbeatReadWriter(conn *net.Conn, dur int, fn func(err error, hb *HeartbeatReadWriter)) (hrw HeartbeatReadWriter) {
+	hrw = HeartbeatReadWriter{
+		conn: conn,
+		l:    &sync.Mutex{},
+		dur:  dur,
+		// rchn:       make(chan HeartbeatData, 10000),
+		// signal:     make(chan bool, 1),
+		errHandler: fn,
+		datachn:    make(chan byte, 4*1024),
+		once:       &sync.Once{},
+		rerrchn:    make(chan error, 1),
+		// rbuf:       bytes.Buffer{},
+	}
+	hrw.heartbeat()
+	hrw.reader()
+	return
+}
+
+func (rw *HeartbeatReadWriter) Close() {
+	CloseConn(rw.conn)
+}
+func (rw *HeartbeatReadWriter) reader() {
+	go func() {
+		//log.Printf("heartbeat read started")
+		for {
+			n, data, err := rw.read()
+			if n == -1 {
+				continue
+			}
+			//log.Printf("n:%d , data:%s ,err:%s", n, string(data), err)
+			if err == nil {
+				//fmt.Printf("write data %s\n", string(data))
+				for _, b := range data {
+					rw.datachn <- b
+				}
+			}
+			if err != nil {
+				//log.Printf("heartbeat reader err: %s", err)
+				select {
+				case rw.rerrchn <- err:
+				default:
+				}
+				rw.once.Do(func() {
+					rw.errHandler(err, rw)
+				})
+				break
+			}
+		}
+		//log.Printf("heartbeat read exited")
+	}()
+}
+func (rw *HeartbeatReadWriter) read() (n int, data []byte, err error) {
+	var typ uint8
+	err = binary.Read((*rw.conn), binary.LittleEndian, &typ)
+	if err != nil {
+		return
+	}
+	if typ == 0 {
+		// log.Printf("heartbeat revecived")
+		n = -1
+		return
+	}
+	var dataLength uint32
+	binary.Read((*rw.conn), binary.LittleEndian, &dataLength)
+	_data := make([]byte, dataLength)
+	// log.Printf("dataLength:%d , data:%s", dataLength, string(data))
+	n, err = (*rw.conn).Read(_data)
+	//log.Printf("n:%d , data:%s ,err:%s", n, string(data), err)
+	if err != nil {
+		return
+	}
+	if uint32(n) != dataLength {
+		err = fmt.Errorf("read short data body")
+		return
+	}
+	data = _data[:n]
+	return
+}
+func (rw *HeartbeatReadWriter) heartbeat() {
+	go func() {
+		//log.Printf("heartbeat started")
+		for {
+			if rw.conn == nil || *rw.conn == nil {
+				//log.Printf("heartbeat err: conn nil")
+				break
+			}
+			rw.l.Lock()
+			_, err := (*rw.conn).Write([]byte{0})
+			rw.l.Unlock()
+			if err != nil {
+				//log.Printf("heartbeat err: %s", err)
+				rw.once.Do(func() {
+					rw.errHandler(err, rw)
+				})
+				break
+			} else {
+				// log.Printf("heartbeat send ok")
+			}
+			time.Sleep(time.Second * time.Duration(rw.dur))
+		}
+		//log.Printf("heartbeat exited")
+	}()
+}
+func (rw *HeartbeatReadWriter) Read(p []byte) (n int, err error) {
+	data := make([]byte, cap(p))
+	for i := 0; i < cap(p); i++ {
+		data[i] = <-rw.datachn
+		n++
+		//fmt.Printf("read  %d %v\n", i, data[:n])
+		if len(rw.datachn) == 0 {
+			n = i + 1
+			copy(p, data[:n])
+			return
+		}
+	}
+	return
+}
+func (rw *HeartbeatReadWriter) Write(p []byte) (n int, err error) {
+	defer rw.l.Unlock()
+	rw.l.Lock()
+	pkg := new(bytes.Buffer)
+	binary.Write(pkg, binary.LittleEndian, uint8(1))
+	binary.Write(pkg, binary.LittleEndian, uint32(len(p)))
+	binary.Write(pkg, binary.LittleEndian, p)
+	bs := pkg.Bytes()
+	n, err = (*rw.conn).Write(bs)
+	if err == nil {
+		n = len(p)
+	}
+	return
+}