From 5fa000f7e6a23e5a46d49c94a1160140d6278e17 Mon Sep 17 00:00:00 2001 From: arraykeys Date: Sat, 7 Oct 2017 17:31:31 +0800 Subject: [PATCH] no message --- config.go | 6 +++--- services/tunnel_bridge.go | 36 ++++++++++++++++++++---------------- services/tunnel_client.go | 11 ++++++----- services/tunnel_server.go | 34 +++++++++++++++++++--------------- 4 files changed, 48 insertions(+), 39 deletions(-) diff --git a/config.go b/config.go index 86ab9d0..b1afb47 100755 --- a/config.go +++ b/config.go @@ -52,7 +52,7 @@ 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() @@ -61,7 +61,7 @@ func initConfig() (err error) { 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 ").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() @@ -69,7 +69,7 @@ func initConfig() (err error) { 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 ").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() diff --git a/services/tunnel_bridge.go b/services/tunnel_bridge.go index e7e575e..10a200d 100644 --- a/services/tunnel_bridge.go +++ b/services/tunnel_bridge.go @@ -12,8 +12,8 @@ import ( type ServerConn struct { ClientLocalAddr string //tcp:2.2.22:333@ID - // Conn *net.Conn - Conn *utils.HeartbeatReadWriter + Conn *net.Conn + //Conn *utils.HeartbeatReadWriter } type TunnelBridge struct { cfg TunnelBridgeArgs @@ -117,13 +117,14 @@ func (s *TunnelBridge) Start(args interface{}) (err error) { switch connType { case CONN_SERVER: - 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) - }) + // 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: &hb, + Conn: &inConn, ClientLocalAddr: addr, }) for { @@ -133,7 +134,7 @@ func (s *TunnelBridge) Start(args interface{}) (err error) { time.Sleep(time.Second * 3) continue } - _, err := (*item.(*utils.HeartbeatReadWriter)).Write([]byte(addr)) + _, 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) @@ -154,9 +155,10 @@ func (s *TunnelBridge) Start(args interface{}) (err error) { // log.Printf("%s conn %s from client released", key, ID) // hw.Close() // }) - utils.IoBind(serverConn, inConn, func(err error) { + utils.IoBind(*serverConn, inConn, func(err error) { // utils.IoBind(serverConn, inConn, func(isSrcErr bool, err error) { - serverConn.Close() + //serverConn.Close() + (*serverConn).Close() utils.CloseConn(&inConn) // hw.Close() s.serverConns.Remove(ID) @@ -166,13 +168,15 @@ func (s *TunnelBridge) Start(args interface{}) (err error) { case CONN_CONTROL: if s.clientControlConns.Has(key) { item, _ := s.clientControlConns.Get(key) - (*item.(*utils.HeartbeatReadWriter)).Close() + //(*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) + // 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) } }) diff --git a/services/tunnel_client.go b/services/tunnel_client.go index 189a8fd..279e11e 100644 --- a/services/tunnel_client.go +++ b/services/tunnel_client.go @@ -50,13 +50,14 @@ func (s *TunnelClient) Start(args interface{}) (err error) { utils.CloseConn(&ctrlConn) continue } - rw := utils.NewHeartbeatReadWriter(&ctrlConn, 3, func(err error, hb *utils.HeartbeatReadWriter) { - log.Printf("ctrlConn err %s", err) - utils.CloseConn(&ctrlConn) - }) + // rw := utils.NewHeartbeatReadWriter(&ctrlConn, 3, func(err error, hb *utils.HeartbeatReadWriter) { + // log.Printf("ctrlConn err %s", err) + // utils.CloseConn(&ctrlConn) + // }) for { signal := make([]byte, 50) - n, err := rw.Read(signal) + // n, err := rw.Read(signal) + n, err := ctrlConn.Read(signal) if err != nil { utils.CloseConn(&ctrlConn) log.Printf("read connection signal err: %s", err) diff --git a/services/tunnel_server.go b/services/tunnel_server.go index e2cbb5c..9b5556a 100644 --- a/services/tunnel_server.go +++ b/services/tunnel_server.go @@ -91,12 +91,12 @@ func (s *TunnelServer) Start(args interface{}) (err error) { break } } - 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(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 released", *s.cfg.Key, ID) @@ -166,7 +166,7 @@ func (s *TunnelServer) UDPConnDeamon() { } }() var outConn net.Conn - var hb utils.HeartbeatReadWriter + // var hb utils.HeartbeatReadWriter var ID string var cmdChn = make(chan bool, 1) @@ -185,17 +185,19 @@ func (s *TunnelServer) UDPConnDeamon() { time.Sleep(time.Second * 3) continue } else { - 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) { + // 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(&hb) + //srcAddrFromConn, body, err := utils.ReadUDPPacket(&hb) + srcAddrFromConn, body, err := utils.ReadUDPPacket(outConn) if err == io.EOF || err == io.ErrUnexpectedEOF { log.Printf("UDP deamon connection %s exited", ID) break @@ -219,13 +221,15 @@ func (s *TunnelServer) UDPConnDeamon() { } //log.Printf("udp response to local %s success , %v", srcAddrFromConn, body) } - }(outConn, hb, ID) + // }(outConn, hb, ID) + }(outConn, ID) break } } } outConn.SetWriteDeadline(time.Now().Add(time.Second)) - _, err = hb.Write(utils.UDPPacket(item.srcAddr.String(), *item.packet)) + // _, 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()