golang手把手实现tcp内网穿透代理(3)

差不多一个星期没更新这个系列了，今天难得有点时间，然后就开始写了点代码，上一章节讲了数据模型的定义和数据发送。这些都是一些准备，但是实际上距离真正实现tcp内网穿透代理还有些距离。

所以今天的章节是快速写一个例子，来测试一下tcp内网穿透代理。然后再规范代码。

快速的demo测试，可以立马看到效果。

我自己对于写代码的理解是：

分为以下几步

1.首先需要规划，设计，考虑要做的事情，比如接口怎么定义，数据结构是怎么样的，代码逻辑，业务逻辑，流程是怎样的，这些都是需要梳理清楚的。

2.那就是根据这些东西先来个快速的编码，先不要管细节，能越快实现就越好。这一步就是不需要过度的按照设计去实现东西。

3.最后就是根据我们快速编码实现的效果，去改进优化。实现的更加优雅，通用。

今天要做的就是第二步，来快速实现一个tcp内网穿透代理。

首先还是我们需要一个http服务器，这个http服务器是我们的内网的服务器，也就是说我们需要在外网访问到这个位于内网的http服务器。假设我们内网的ip是127.0.0.1，分配的局域网ip是192.168.1.10，然后http端口是8080

那么显而易见，我们在同一内网环境是可以访问的，直接使用192.168.1.10:8000即可访问到服务器

但是如果不在同一局域网的机器就不行了，需要借助一台公网ip的服务器来做一个透传代理。

内网服务器准备

这里假设你已经安装python2或者python3，打开我们的mac终端或者windows cmd 在python2下输入python -m SimpleHTTPServer

python3下输入python -m http.server

这样我们可以快速得到一台http服务器，打开浏览器输入127.0.0.1:8000可以发现是一个文件浏览的http服务器

我们不需要很复杂的http服务器，仅仅用来做测试而已，所以这样是足够的了

服务端代码

控制客户端的监听代码

1.这里选择监听在8009端口，这个tcp服务，主要用来接受客户端的连接请求的，然后发送控制指令给到客户端，请求建立隧道连接的。这里只接受一个客户端的连接请求，如果有多余的会close掉

一旦有客户端连接到8009端口，这个tcp连接是一直保持的，为什么呢？

因为服务端需要发送控制指令给客户端，所以tcp连接必须一直保持。

然后服务端会每隔两秒发送hi这个消息给到客户端，客户端可以直接忽略掉，因为这个hi只是类似心跳机制的保证。

var cache *net.TCPConn = nil func makeControl() { var tcpAddr *net.TCPAddr tcpAddr, _ = net.ResolveTCPAddr("tcp", "127.0.0.1:8009") //打开一个tcp断点监听 tcpListener, err := net.ListenTCP("tcp", tcpAddr) if err != nil { panic(err) } fmt.Println("控制端口已经监听") for { tcpConn, err := tcpListener.AcceptTCP() if err != nil { panic(err) } fmt.Println("新的客户端连接到控制端服务进程:" + tcpConn.RemoteAddr().String()) if cache != nil { fmt.Println("已经存在一个客户端连接!") //直接关闭掉多余的客户端请求 tcpConn.Close() } else { cache = tcpConn } go control(tcpConn) } func control(conn *net.TCPConn) { go func() { for { //一旦有客户端连接到服务端的话，服务端每隔2秒发送hi消息给到客户端 //如果发送不出去，则认为链路断了，清除cache连接 _, e := conn.Write(([]byte)("hi\n")) if e != nil { cache = nil } time.Sleep(time.Second * 2) } }() }

对外访问的服务端口监听

假设端口是8007，这里的对外访问的服务端口监听，也就是说假设我们服务器ip是10.18.10.1的话，那么访问10.18.10.1的端口8007，就等于请求内网的127.0.0.1:8000127.0.0.1:8000就是上面的python服务器

和上面的代码看起来很像，但是用处不一样，上面那个主要目的是控制客户端，要求它建立请求

这里的目的主要是提供真正需要tcp代理透传的服务！

func makeAccept() { var tcpAddr *net.TCPAddr tcpAddr, _ = net.ResolveTCPAddr("tcp", "127.0.0.1:8007") tcpListener, err := net.ListenTCP("tcp", tcpAddr) if err != nil { panic(err) } defer tcpListener.Close() for { tcpConn, err := tcpListener.AcceptTCP() if err != nil { fmt.Println(err) continue } fmt.Println("A client connected 8007:" + tcpConn.RemoteAddr().String()) addConnMathAccept(tcpConn) sendMessage("new\n") } }

这里大家思考一下，如果真的有请求来了，也就是访问8007了，我们怎么办呢？显然我们需要把进来的流量发给127.0.0.1:8000，让它去处理就行了。

这么一想好像很简单的样子，但是好像有问题，那就是我的10.18.10.1是公网ip啊，大家都知道，只有非公网可以主动访问公网，非公网主动访问公网的意思就是好像我们日常访问百度一样。公网是不可以直接跟非公网建立tcp连接的。

那么怎么解决呢？

那就是我们需要先记录下这个进来的8007的tcp连接，然后上面不是说到我们有个tcp连接是一直hold住的，那就是8009那个，服务器每隔2秒发送hi给客户端的。

那么我们可以通过这个8009的tcp链路发送一条消息给客户端，告诉客户端赶紧和我建立一个新的tcp请求吧，为了方便描述，我把"告诉客户端赶紧和我建立一个新的tcp请求"这个新的请求标记为8008链路

这时候就可以把8007的tcp流量发送到这个新建立的tcp链路上。然后把这个新建立的tcp链路的请求发送回去，建立一个读写传输链路即可。

注意这里不能使用8009的tcp链路，8009只是我们用来沟通的链路。

理清楚后，开始编码吧

记录进来的8007的tcp连接，使用一个结构体来存储，这个结构体需要记录accept的tcp连接，也就是8007的tcp链路，和请求的时间，以及8008的链路

刚开始记录的时候8008的链路肯定是nil的，所以设置为nil即可

把它添加到map里面。使用unixNano作为临时key

type ConnMatch struct { accept*net.TCPConn //8007 tcp链路 accept acceptAddTime int64//接受请求的时间 tunnel*net.TCPConn //8008 tcp链路 tunnel } var connListMap = make(map[string]*ConnMatch) var lock = sync.Mutex{} func addConnMathAccept(accept *net.TCPConn) { //加锁防止竞争读写map lock.Lock() defer lock.Unlock() now := time.Now().UnixNano() connListMap[strconv.FormatInt(now, 10)] = &ConnMatch{accept, time.Now().Unix(), nil} }

告诉客户端赶紧和我建立一个新的tcp请求

这里直接用上面那个cache的tcp链路发送消息即可，不需要太复杂，这里简单定义为new\n即可

........ addConnMathAccept(tcpConn) sendMessage("new\n") } } func sendMessage(message string) { fmt.Println("send Message " + message) if cache != nil { _, e := cache.Write([]byte(message)) if e != nil { fmt.Println("消息发送异常") fmt.Println(e.Error()) } } else { fmt.Println("没有客户端连接，无法发送消息") } }

转发的tcp监听服务

这里我们来创建前面提到的8008tcp连接了，这里的8008端口，也就是前面说的发送new这个消息告诉客户端来和这个8008连接吧

func makeForward() { var tcpAddr *net.TCPAddr tcpAddr, _ = net.ResolveTCPAddr("tcp", "127.0.0.1:8008") tcpListener, err := net.ListenTCP("tcp", tcpAddr) if err != nil { panic(err) } defer tcpListener.Close() fmt.Println("Server ready to read ...") for { tcpConn, err := tcpListener.AcceptTCP() if err != nil { fmt.Println(err) continue } fmt.Println("A client connected 8008 :" + tcpConn.RemoteAddr().String()) configConnListTunnel(tcpConn) } }

然后把8008链路分配到ConnMatch，这两个tcp链路是配对的

var connListMapUpdate = make(chan int) func configConnListTunnel(tunnel *net.TCPConn) { //加锁解决竞争问题 lock.Lock() used := false for _, connMatch := range connListMap { //找到tunnel为nil的而且accept不为nil的connMatch if connMatch.tunnel == nil && connMatch.accept != nil { //填充tunnel链路 connMatch.tunnel = tunnel used = true //这里要break，是防止这条链路被赋值到多个connMatch！ break } } if !used { //如果没有被使用的话，则说明所有的connMatch都已经配对好了，直接关闭多余的8008链路 fmt.Println(len(connListMap)) _ = tunnel.Close() fmt.Println("关闭多余的tunnel") } lock.Unlock() //使用channel机制来告诉另一个方法已经就绪 connListMapUpdate <- UPDATE }

tcp 转发，这里读取connListMapUpdate这个chain，说明map有更新，需要建立tcpForward隧道

func tcpForward() { for { select { case <-connListMapUpdate: lock.Lock() for key, connMatch := range connListMap { //如果两个都不为空的话，建立隧道连接 if connMatch.tunnel != nil && connMatch.accept != nil { fmt.Println("建立tcpForward隧道连接") go joinConn2(connMatch.accept, connMatch.tunnel) //从map中删除 delete(connListMap, key) } } lock.Unlock() } } } func joinConn2(conn1 *net.TCPConn, conn2 *net.TCPConn) { f := func(local *net.TCPConn, remote *net.TCPConn) { //defer保证close defer local.Close() defer remote.Close() //使用io.Copy传输两个tcp连接， _, err := io.Copy(local, remote) if err != nil { fmt.Println(err.Error()) return } fmt.Println("join Conn2 end") } go f(conn2, conn1) go f(conn1, conn2) }

最后增加一个超时机制，因为会存在这种情况，就是当用户请求8007端口的时候，迟迟等不到配对的connMatch的tunnel链路啊，因为有可能client端挂掉了，导致server不管怎么发送"new"请求，client都无动于衷。

在浏览器看来表现就是一直转着，但是我们不能这样子。

所以当超时的时候，我们主动断掉connMatch中的accept链路即可，设置为5秒

func releaseConnMatch() { for { lock.Lock() for key, connMatch := range connListMap { //如果在指定时间内没有tunnel的话，则释放该连接 if connMatch.tunnel == nil && connMatch.accept != nil { if time.Now().Unix()-connMatch.acceptAddTime > 5 { fmt.Println("释放超时连接") err := connMatch.accept.Close() if err != nil { fmt.Println("释放连接的时候出错了:" + err.Error()) } delete(connListMap, key) } } } lock.Unlock() time.Sleep(5 * time.Second) } }

最后把所有方法整合起来

func main() { //监听控制端口8009 go makeControl() //监听服务端口8007 go makeAccept() //监听转发端口8008 go makeForward() //定时释放连接 go releaseConnMatch() //执行tcp转发 tcpForward() }

客户端代码

连接到服务器的8009控制端口，随时接受服务器的控制请求，随时待命

func connectControl() { var tcpAddr *net.TCPAddr //这里在一台机测试，所以没有连接到公网，可以修改到公网ip tcpAddr, _ = net.ResolveTCPAddr("tcp", "127.0.0.1:8009") conn, err := net.DialTCP("tcp", nil, tcpAddr) if err != nil { fmt.Println("Client connect error ! " + err.Error()) return } fmt.Println(conn.LocalAddr().String() + " : Client connected!8009") reader := bufio.NewReader(conn) for { s, err := reader.ReadString(\n) if err != nil || err == io.EOF { break } else { //接收到new的指令的时候，新建一个tcp连接 if s == "new\n" { go combine() } if s == "hi" { //忽略掉hi的请求 } } } }

combine方法的代码，整合local和remote的tcp连接

func combine() { local := connectLocal() remote := connectRemote() if local != nil && remote != nil { joinConn(local, remote) } else { if local != nil { err := local.Close() if err!=nil{ fmt.Println("close local:" + err.Error()) } } if remote != nil { err := remote.Close() if err!=nil{ fmt.Println("close remote:" + err.Error()) } } } } func joinConn(local *net.TCPConn, remote *net.TCPConn) { f := func(local *net.TCPConn, remote *net.TCPConn) { defer local.Close() defer remote.Close() _, err := io.Copy(local, remote) if err != nil { fmt.Println(err.Error()) return } fmt.Println("end") } go f(local, remote) go f(remote, local) }

connectLocal 连接到python的8000端口！

func connectLocal() *net.TCPConn { var tcpAddr *net.TCPAddr tcpAddr, _ = net.ResolveTCPAddr("tcp", "127.0.0.1:8000") conn, err := net.DialTCP("tcp", nil, tcpAddr) if err != nil { fmt.Println("Client connect error ! " + err.Error()) return nil } fmt.Println(conn.LocalAddr().String() + " : Client connected!8000") return conn }

connectRemote 连接到服务端的8008端口！

func connectRemote() *net.TCPConn { var tcpAddr *net.TCPAddr tcpAddr, _ = net.ResolveTCPAddr("tcp", "127.0.0.1:8008") conn, err := net.DialTCP("tcp", nil, tcpAddr) if err != nil { fmt.Println("Client connect error ! " + err.Error()) return nil } fmt.Println(conn.LocalAddr().String() + " : Client connected!8008") return conn; }

全部整合起来就是

func main() { connectControl() }

最后把服务端和客户端运行起来看看效果，访问8007，而不是访问8000