no message

2017-10-07 17:31:31 +08:00
parent ae56bb1edd
commit 5fa000f7e6
4 changed files with 48 additions and 39 deletions
--- 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 <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()

@ -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 <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()

--- 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)
 		}
 	})
--- 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)
--- 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()