优化ngrok的tcp连接

ngrok支持tcp tunnel和http以及https，但是ngrok的tcp代理似乎优化不够好，当一段时间闲置tcp连接的话，再连接会出现连接不上的问题。

首先来看看ngrok的tcp tunnel的原理：
假设ngrok的client端配置文件如下

#填写服务器域名和连接端口
server_addr: ngrok.domain.com:4444
trust_host_root_certs: false
tunnels:
 adb:
 #这里的remote_port是指从ngrok.domain.com:5555->被代理端的5555端口
  remote_port: 5555
  proto:
  #使用tcp协议
   tcp: 5555

image.png

可以发现一共三条tcp连接，一条是被代理端到ngrok client的和ngrok client到ngrok server端的

还有就是用户端到ngrok server的。

代码原理就是把流量透传，位于ngrok代码的conn.go

func Join(c Conn, c2 Conn) (int64, int64) {
    var wait sync.WaitGroup
    pipe := func(to Conn, from Conn, bytesCopied *int64) {
        defer to.Close()
        defer from.Close()
        defer wait.Done()

        var err error
        *bytesCopied, err = io.Copy(to, from)
        if err != nil {
            from.Warn("Copied %d bytes to %s before failing with error %v", *bytesCopied, to.Id(), err)
        } else {
            from.Debug("Copied %d bytes to %s", *bytesCopied, to.Id())
        }
    }

    wait.Add(2)
    var fromBytes, toBytes int64
    go pipe(c, c2, &fromBytes)
    go pipe(c2, c, &toBytes)
    c.Info("Joined with connection %s", c2.Id())
    wait.Wait()
    return fromBytes, toBytes
}

利用两个go 执行方法，io.Copy(to,from)传输流量。
但是这样子闲置tcp连接一段时间的话，这三条tcp连接都有可能因为路由网络问题，其实已经断开了，但是linux服务没有响应过来。

我们怎么解决呢？业界的做法是用心跳包，但是别忘了，这里的三个tcp连接都是透明传输的，因此没有任何额外的心跳包协议可以定义。不能修改和增加任何tcp的流量包。

这时候我们可以用keepalive，这是在TCP中一个可以检测死连接的机制。

工作原理是：摘自百度百科
keepalive原理很简单，TCP会在空闲了一定时间后发送数据给对方：
1.如果主机可达，对方就会响应ACK应答，就认为是存活的。
2.如果可达，但应用程序退出，对方就发FIN应答，发送TCP撤消连接。
3.如果可达，但应用程序崩溃，对方就发RST消息。
4.如果对方主机不响应ack, rst，继续发送直到超时，就撤消连接。这个时间就是默认
的二个小时。

linux的默认keepalive时间是2小时。所以我们需要在代码里加上。

检查了下ngrok的监听连接代码：conn/conn.go

func Listen(addr, typ string, tlsCfg *tls.Config) (l *Listener, err error) {
    // listen for incoming connections
    listener, err := net.Listen("tcp", addr)
    if err != nil {
        return
    }

    l = &Listener{
        Addr:  listener.Addr(),
        Conns: make(chan *loggedConn),
    }

    go func() {
        for {
            rawConn, err := listener.Accept()
      if err != nil {
                log.Error("Failed to accept new TCP connection of type %s: %v", typ, err)
                continue
            }

            c := wrapConn(rawConn, typ)
            if tlsCfg != nil {
                c.Conn = tls.Server(c.Conn, tlsCfg)
            }
            c.Info("New connection from %v", c.RemoteAddr())
            l.Conns <- c

发现没有做keepAlive处理

因此在rawConn, err := listener.Accept()之后增加keepAlive代码。

if rawConn, ok := rawConn.(*net.TCPConn); ok {
                err := rawConn.SetKeepAlive(true)
                if err != nil {
                    fmt.Println(err.Error())
                }
                err = rawConn.SetKeepAlivePeriod(time.Minute)
                if err != nil {
                    fmt.Println(err.Error())
                }
            }

同样找到另一段代码：位于server/tunnel.go

/ Listens for new public tcp connections from the internet.
func (t *Tunnel) listenTcp(listener *net.TCPListener) {
    for {
        defer func() {
            if r := recover(); r != nil {
                log.Warn("listenTcp failed with error %v", r)
            }
        }()

        // accept public connections
        tcpConn, err := listener.AcceptTCP()

        if err != nil {
            // not an error, we're shutting down this tunnel
            if atomic.LoadInt32(&t.closing) == 1 {
                return
            }

            t.Error("Failed to accept new TCP connection: %v", err)
            continue
        }
        conn := conn.Wrap(tcpConn, "pub")
        conn.AddLogPrefix(t.Id())
        conn.Info("New connection from %v", conn.RemoteAddr())

        go t.HandlePublicConnection(conn)

同样需要在AcceptTCP之后增加keepalive设置

err1 := tcpConn.SetKeepAlive(true)
        if err1 != nil {
            fmt.Println(err1.Error())
        }
        err2 := tcpConn.SetKeepAlivePeriod(time.Minute)
        if err2 != nil {
            fmt.Println(err2.Error())
        }

全部补上之后，重新编译server和client，发现tcp连接即时好长一段时间不使用也没有问题。