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
可以发现一共三条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连接即时好长一段时间不使用也没有问题。
