cy/goproxy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Signed-off-by: arraykeys@gmail.com <arraykeys@gmail.com>

Browse Source
This commit is contained in:
arraykeys@gmail.com
2017-11-14 10:02:51 +08:00
parent 8bc6e0ffec
commit e89a965aff
7 changed files with 246 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
config.go
View File

@ -102,6 +102,7 @@ func initConfig() (err error) {
tunnelServerArgs.IsUDP = tunnelServer.Flag("udp", "proxy on udp tunnel server mode").Default("false").Bool() tunnelServerArgs.IsUDP = tunnelServer.Flag("udp", "proxy on udp tunnel server mode").Default("false").Bool()
tunnelServerArgs.Key = tunnelServer.Flag("k", "client key").Default("default").String() tunnelServerArgs.Key = tunnelServer.Flag("k", "client key").Default("default").String()
tunnelServerArgs.Route = tunnelServer.Flag("route", "local route to client's network, such as :PROTOCOL://LOCAL_IP:LOCAL_PORT@[CLIENT_KEY]CLIENT_LOCAL_HOST:CLIENT_LOCAL_PORT").Short('r').Default("").Strings() tunnelServerArgs.Route = tunnelServer.Flag("route", "local route to client's network, such as :PROTOCOL://LOCAL_IP:LOCAL_PORT@[CLIENT_KEY]CLIENT_LOCAL_HOST:CLIENT_LOCAL_PORT").Short('r').Default("").Strings()
tunnelServerArgs.Mux = tunnelServer.Flag("mux", "use multiplexing mode").Default("false").Bool()
//########tunnel-client######### //########tunnel-client#########
tunnelClient := app.Command("tclient", "proxy on tunnel client mode") tunnelClient := app.Command("tclient", "proxy on tunnel client mode")
@ -110,6 +111,7 @@ func initConfig() (err error) {
tunnelClientArgs.KeyFile = tunnelClient.Flag("key", "key file for tls").Short('K').Default("proxy.key").String() tunnelClientArgs.KeyFile = tunnelClient.Flag("key", "key file for tls").Short('K').Default("proxy.key").String()
tunnelClientArgs.Timeout = tunnelClient.Flag("timeout", "tcp timeout with milliseconds").Short('t').Default("2000").Int() tunnelClientArgs.Timeout = tunnelClient.Flag("timeout", "tcp timeout with milliseconds").Short('t').Default("2000").Int()
tunnelClientArgs.Key = tunnelClient.Flag("k", "key same with server").Default("default").String() tunnelClientArgs.Key = tunnelClient.Flag("k", "key same with server").Default("default").String()
tunnelClientArgs.Mux = tunnelClient.Flag("mux", "use multiplexing mode").Default("false").Bool()
//########tunnel-bridge######### //########tunnel-bridge#########
tunnelBridge := app.Command("tbridge", "proxy on tunnel bridge mode") tunnelBridge := app.Command("tbridge", "proxy on tunnel bridge mode")
@ -117,6 +119,7 @@ func initConfig() (err error) {
tunnelBridgeArgs.KeyFile = tunnelBridge.Flag("key", "key file for tls").Short('K').Default("proxy.key").String() tunnelBridgeArgs.KeyFile = tunnelBridge.Flag("key", "key file for tls").Short('K').Default("proxy.key").String()
tunnelBridgeArgs.Timeout = tunnelBridge.Flag("timeout", "tcp timeout with milliseconds").Short('t').Default("2000").Int() tunnelBridgeArgs.Timeout = tunnelBridge.Flag("timeout", "tcp timeout with milliseconds").Short('t').Default("2000").Int()
tunnelBridgeArgs.Local = tunnelBridge.Flag("local", "local ip:port to listen").Short('p').Default(":33080").String() tunnelBridgeArgs.Local = tunnelBridge.Flag("local", "local ip:port to listen").Short('p').Default(":33080").String()
tunnelBridgeArgs.Mux = tunnelBridge.Flag("mux", "use multiplexing mode").Default("false").Bool()
//########ssh######### //########ssh#########
socks := app.Command("socks", "proxy on ssh mode") socks := app.Command("socks", "proxy on ssh mode")

5
services/args.go
View File

@ -16,6 +16,8 @@ const (
CONN_SERVER_HEARBEAT = uint8(3) CONN_SERVER_HEARBEAT = uint8(3)
CONN_SERVER = uint8(4) CONN_SERVER = uint8(4)
CONN_CLIENT = uint8(5) CONN_CLIENT = uint8(5)
CONN_SERVER_MUX = uint8(6)
CONN_CLIENT_MUX = uint8(7)
) )
type TunnelServerArgs struct { type TunnelServerArgs struct {
@ -31,6 +33,7 @@ type TunnelServerArgs struct {
Timeout *int Timeout *int
Route *[]string Route *[]string
Mgr *TunnelServerManager Mgr *TunnelServerManager
Mux *bool
} }
type TunnelClientArgs struct { type TunnelClientArgs struct {
Parent *string Parent *string
@ -40,6 +43,7 @@ type TunnelClientArgs struct {
KeyBytes []byte KeyBytes []byte
Key *string Key *string
Timeout *int Timeout *int
Mux *bool
} }
type TunnelBridgeArgs struct { type TunnelBridgeArgs struct {
Parent *string Parent *string
@ -49,6 +53,7 @@ type TunnelBridgeArgs struct {
KeyBytes []byte KeyBytes []byte
Local *string Local *string
Timeout *int Timeout *int
Mux *bool
} }
type TCPArgs struct { type TCPArgs struct {
Parent *string Parent *string

3
services/socks.go
View File

@ -449,8 +449,9 @@ func (s *Socks) proxyTCP(inConn *net.Conn, methodReq socks.MethodsRequest, reque
log.Printf("conn %s - %s connected", inAddr, request.Addr()) log.Printf("conn %s - %s connected", inAddr, request.Addr())
utils.IoBind(*inConn, outConn, func(err interface{}) { utils.IoBind(*inConn, outConn, func(err interface{}) {
log.Printf("conn %s - %s released", inAddr, request.Addr()) log.Printf("conn %s - %s released,%s", inAddr, request.Addr(), err)
}) })
select {}
} }
func (s *Socks) getOutConn(methodBytes, reqBytes []byte, host string) (outConn net.Conn, err interface{}) { func (s *Socks) getOutConn(methodBytes, reqBytes []byte, host string) (outConn net.Conn, err interface{}) {
switch *s.cfg.ParentType { switch *s.cfg.ParentType {

206
services/tunnel_bridge.go
View File

@ -17,8 +17,8 @@ type TunnelBridge struct {
cfg TunnelBridgeArgs cfg TunnelBridgeArgs
serverConns utils.ConcurrentMap serverConns utils.ConcurrentMap
clientControlConns utils.ConcurrentMap clientControlConns utils.ConcurrentMap
cmServer utils.ConnManager // cmServer utils.ConnManager
cmClient utils.ConnManager // cmClient utils.ConnManager
} }
func NewTunnelBridge() Service { func NewTunnelBridge() Service {
@ -26,8 +26,8 @@ func NewTunnelBridge() Service {
cfg: TunnelBridgeArgs{}, cfg: TunnelBridgeArgs{},
serverConns: utils.NewConcurrentMap(), serverConns: utils.NewConcurrentMap(),
clientControlConns: utils.NewConcurrentMap(), clientControlConns: utils.NewConcurrentMap(),
cmServer: utils.NewConnManager(), // cmServer: utils.NewConnManager(),
cmClient: utils.NewConnManager(), // cmClient: utils.NewConnManager(),
} }
} }
@ -92,7 +92,7 @@ func (s *TunnelBridge) Start(args interface{}) (err error) {
time.Sleep(time.Second * 3) time.Sleep(time.Second * 3)
continue continue
} else { } else {
s.cmServer.Add(serverID, ID, &inConn) // s.cmServer.Add(serverID, ID, &inConn)
break break
} }
} }
@ -114,11 +114,11 @@ func (s *TunnelBridge) Start(args interface{}) (err error) {
serverConn := serverConnItem.(ServerConn).Conn serverConn := serverConnItem.(ServerConn).Conn
utils.IoBind(*serverConn, inConn, func(err interface{}) { utils.IoBind(*serverConn, inConn, func(err interface{}) {
s.serverConns.Remove(ID) s.serverConns.Remove(ID)
s.cmClient.RemoveOne(key, ID) // s.cmClient.RemoveOne(key, ID)
s.cmServer.RemoveOne(serverID, ID) // s.cmServer.RemoveOne(serverID, ID)
log.Printf("conn %s released", ID) log.Printf("conn %s released", ID)
}) })
s.cmClient.Add(key, ID, &inConn) // s.cmClient.Add(key, ID, &inConn)
log.Printf("conn %s created", ID) log.Printf("conn %s created", ID)
case CONN_CLIENT_CONTROL: case CONN_CLIENT_CONTROL:
@ -136,101 +136,101 @@ func (s *TunnelBridge) Start(args interface{}) (err error) {
s.clientControlConns.Set(key, &inConn) s.clientControlConns.Set(key, &inConn)
log.Printf("set client %s control conn", key) log.Printf("set client %s control conn", key)
case CONN_SERVER_HEARBEAT: // case CONN_SERVER_HEARBEAT:
var serverID string // var serverID string
err = utils.ReadPacketData(reader, &serverID) // err = utils.ReadPacketData(reader, &serverID)
if err != nil { // if err != nil {
log.Printf("read error,ERR:%s", err) // log.Printf("read error,ERR:%s", err)
return // return
} // }
log.Printf("server heartbeat connection, id: %s", serverID) // log.Printf("server heartbeat connection, id: %s", serverID)
writeDie := make(chan bool) // writeDie := make(chan bool)
readDie := make(chan bool) // readDie := make(chan bool)
go func() { // go func() {
for { // for {
inConn.SetWriteDeadline(time.Now().Add(time.Second * 3)) // inConn.SetWriteDeadline(time.Now().Add(time.Second * 3))
_, err = inConn.Write([]byte{0x00}) // _, err = inConn.Write([]byte{0x00})
inConn.SetWriteDeadline(time.Time{}) // inConn.SetWriteDeadline(time.Time{})
if err != nil { // if err != nil {
log.Printf("server heartbeat connection write err %s", err) // log.Printf("server heartbeat connection write err %s", err)
break // break
} // }
time.Sleep(time.Second * 3) // time.Sleep(time.Second * 3)
} // }
close(writeDie) // close(writeDie)
}() // }()
go func() { // go func() {
for { // for {
signal := make([]byte, 1) // signal := make([]byte, 1)
inConn.SetReadDeadline(time.Now().Add(time.Second * 6)) // inConn.SetReadDeadline(time.Now().Add(time.Second * 6))
_, err := inConn.Read(signal) // _, err := inConn.Read(signal)
inConn.SetReadDeadline(time.Time{}) // inConn.SetReadDeadline(time.Time{})
if err != nil { // if err != nil {
log.Printf("server heartbeat connection read err: %s", err) // log.Printf("server heartbeat connection read err: %s", err)
break // break
} else { // } else {
// log.Printf("heartbeat from server ,id:%s", serverID) // // log.Printf("heartbeat from server ,id:%s", serverID)
} // }
} // }
close(readDie) // close(readDie)
}() // }()
select { // select {
case <-readDie: // case <-readDie:
case <-writeDie: // case <-writeDie:
} // }
utils.CloseConn(&inConn) // utils.CloseConn(&inConn)
s.cmServer.Remove(serverID) // s.cmServer.Remove(serverID)
log.Printf("server heartbeat conn %s released", serverID) // log.Printf("server heartbeat conn %s released", serverID)
case CONN_CLIENT_HEARBEAT: // case CONN_CLIENT_HEARBEAT:
var clientID string // var clientID string
err = utils.ReadPacketData(reader, &clientID) // err = utils.ReadPacketData(reader, &clientID)
if err != nil { // if err != nil {
log.Printf("read error,ERR:%s", err) // log.Printf("read error,ERR:%s", err)
return // return
} // }
log.Printf("client heartbeat connection, id: %s", clientID) // log.Printf("client heartbeat connection, id: %s", clientID)
writeDie := make(chan bool) // writeDie := make(chan bool)
readDie := make(chan bool) // readDie := make(chan bool)
go func() { // go func() {
for { // for {
inConn.SetWriteDeadline(time.Now().Add(time.Second * 3)) // inConn.SetWriteDeadline(time.Now().Add(time.Second * 3))
_, err = inConn.Write([]byte{0x00}) // _, err = inConn.Write([]byte{0x00})
inConn.SetWriteDeadline(time.Time{}) // inConn.SetWriteDeadline(time.Time{})
if err != nil { // if err != nil {
log.Printf("client heartbeat connection write err %s", err) // log.Printf("client heartbeat connection write err %s", err)
break // break
} // }
time.Sleep(time.Second * 3) // time.Sleep(time.Second * 3)
} // }
close(writeDie) // close(writeDie)
}() // }()
go func() { // go func() {
for { // for {
signal := make([]byte, 1) // signal := make([]byte, 1)
inConn.SetReadDeadline(time.Now().Add(time.Second * 6)) // inConn.SetReadDeadline(time.Now().Add(time.Second * 6))
_, err := inConn.Read(signal) // _, err := inConn.Read(signal)
inConn.SetReadDeadline(time.Time{}) // inConn.SetReadDeadline(time.Time{})
if err != nil { // if err != nil {
log.Printf("client control connection read err: %s", err) // log.Printf("client control connection read err: %s", err)
break // break
} else { // } else {
// log.Printf("heartbeat from client ,id:%s", clientID) // // log.Printf("heartbeat from client ,id:%s", clientID)
} // }
} // }
close(readDie) // close(readDie)
}() // }()
select { // select {
case <-readDie: // case <-readDie:
case <-writeDie: // case <-writeDie:
} // }
utils.CloseConn(&inConn) // utils.CloseConn(&inConn)
s.cmClient.Remove(clientID) // s.cmClient.Remove(clientID)
if s.clientControlConns.Has(clientID) { // if s.clientControlConns.Has(clientID) {
item, _ := s.clientControlConns.Get(clientID) // item, _ := s.clientControlConns.Get(clientID)
(*item.(*net.Conn)).Close() // (*item.(*net.Conn)).Close()
} // }
s.clientControlConns.Remove(clientID) // s.clientControlConns.Remove(clientID)
log.Printf("client heartbeat conn %s released", clientID) // log.Printf("client heartbeat conn %s released", clientID)
} }
}) })
if err != nil { if err != nil {

135
services/tunnel_client.go
View File

@ -11,79 +11,80 @@ import (
) )
type TunnelClient struct { type TunnelClient struct {
cfg TunnelClientArgs cfg TunnelClientArgs
cm utils.ConnManager // cm utils.ConnManager
ctrlConn net.Conn ctrlConn net.Conn
} }
func NewTunnelClient() Service { func NewTunnelClient() Service {
return &TunnelClient{ return &TunnelClient{
cfg: TunnelClientArgs{}, cfg: TunnelClientArgs{},
cm: utils.NewConnManager(), // cm: utils.NewConnManager(),
} }
} }
func (s *TunnelClient) InitService() { func (s *TunnelClient) InitService() {
s.InitHeartbeatDeamon() // s.InitHeartbeatDeamon()
} }
func (s *TunnelClient) InitHeartbeatDeamon() {
log.Printf("heartbeat started")
go func() {
var heartbeatConn net.Conn
var ID = *s.cfg.Key
for {
//close all connection // func (s *TunnelClient) InitHeartbeatDeamon() {
s.cm.RemoveAll() // log.Printf("heartbeat started")
if s.ctrlConn != nil { // go func() {
s.ctrlConn.Close() // var heartbeatConn net.Conn
} // var ID = *s.cfg.Key
utils.CloseConn(&heartbeatConn) // for {
heartbeatConn, err := s.GetInConn(CONN_CLIENT_HEARBEAT, ID)
if err != nil { // //close all connection
log.Printf("heartbeat connection err: %s, retrying...", err) // s.cm.RemoveAll()
time.Sleep(time.Second * 3) // if s.ctrlConn != nil {
utils.CloseConn(&heartbeatConn) // s.ctrlConn.Close()
continue // }
} // utils.CloseConn(&heartbeatConn)
log.Printf("heartbeat connection created,id:%s", ID) // heartbeatConn, err := s.GetInConn(CONN_CLIENT_HEARBEAT, ID)
writeDie := make(chan bool) // if err != nil {
readDie := make(chan bool) // log.Printf("heartbeat connection err: %s, retrying...", err)
go func() { // time.Sleep(time.Second * 3)
for { // utils.CloseConn(&heartbeatConn)
heartbeatConn.SetWriteDeadline(time.Now().Add(time.Second * 3)) // continue
_, err = heartbeatConn.Write([]byte{0x00}) // }
heartbeatConn.SetWriteDeadline(time.Time{}) // log.Printf("heartbeat connection created,id:%s", ID)
if err != nil { // writeDie := make(chan bool)
log.Printf("heartbeat connection write err %s", err) // readDie := make(chan bool)
break // go func() {
} // for {
time.Sleep(time.Second * 3) // heartbeatConn.SetWriteDeadline(time.Now().Add(time.Second * 3))
} // _, err = heartbeatConn.Write([]byte{0x00})
close(writeDie) // heartbeatConn.SetWriteDeadline(time.Time{})
}() // if err != nil {
go func() { // log.Printf("heartbeat connection write err %s", err)
for { // break
signal := make([]byte, 1) // }
heartbeatConn.SetReadDeadline(time.Now().Add(time.Second * 6)) // time.Sleep(time.Second * 3)
_, err := heartbeatConn.Read(signal) // }
heartbeatConn.SetReadDeadline(time.Time{}) // close(writeDie)
if err != nil { // }()
log.Printf("heartbeat connection read err: %s", err) // go func() {
break // for {
} else { // signal := make([]byte, 1)
//log.Printf("heartbeat from bridge") // heartbeatConn.SetReadDeadline(time.Now().Add(time.Second * 6))
} // _, err := heartbeatConn.Read(signal)
} // heartbeatConn.SetReadDeadline(time.Time{})
close(readDie) // if err != nil {
}() // log.Printf("heartbeat connection read err: %s", err)
select { // break
case <-readDie: // } else {
case <-writeDie: // //log.Printf("heartbeat from bridge")
} // }
} // }
}() // close(readDie)
} // }()
// select {
// case <-readDie:
// case <-writeDie:
// }
// }
// }()
// }
func (s *TunnelClient) CheckArgs() { func (s *TunnelClient) CheckArgs() {
if *s.cfg.Parent != "" { if *s.cfg.Parent != "" {
log.Printf("use tls parent %s", *s.cfg.Parent) log.Printf("use tls parent %s", *s.cfg.Parent)
@ -96,7 +97,7 @@ func (s *TunnelClient) CheckArgs() {
s.cfg.CertBytes, s.cfg.KeyBytes = utils.TlsBytes(*s.cfg.CertFile, *s.cfg.KeyFile) s.cfg.CertBytes, s.cfg.KeyBytes = utils.TlsBytes(*s.cfg.CertFile, *s.cfg.KeyFile)
} }
func (s *TunnelClient) StopService() { func (s *TunnelClient) StopService() {
s.cm.RemoveAll() // s.cm.RemoveAll()
} }
func (s *TunnelClient) Start(args interface{}) (err error) { func (s *TunnelClient) Start(args interface{}) (err error) {
s.cfg = args.(TunnelClientArgs) s.cfg = args.(TunnelClientArgs)
@ -106,7 +107,7 @@ func (s *TunnelClient) Start(args interface{}) (err error) {
for { for {
//close all conn //close all conn
s.cm.Remove(*s.cfg.Key) // s.cm.Remove(*s.cfg.Key)
if s.ctrlConn != nil { if s.ctrlConn != nil {
s.ctrlConn.Close() s.ctrlConn.Close()
} }
@ -171,7 +172,7 @@ func (s *TunnelClient) ServeUDP(localAddr, ID, serverID string) {
var err error var err error
// for { // for {
for { for {
s.cm.RemoveOne(*s.cfg.Key, ID) // s.cm.RemoveOne(*s.cfg.Key, ID)
inConn, err = s.GetInConn(CONN_CLIENT, *s.cfg.Key, ID, serverID) inConn, err = s.GetInConn(CONN_CLIENT, *s.cfg.Key, ID, serverID)
if err != nil { if err != nil {
utils.CloseConn(&inConn) utils.CloseConn(&inConn)
@ -182,7 +183,7 @@ func (s *TunnelClient) ServeUDP(localAddr, ID, serverID string) {
break break
} }
} }
s.cm.Add(*s.cfg.Key, ID, &inConn) // s.cm.Add(*s.cfg.Key, ID, &inConn)
log.Printf("conn %s created", ID) log.Printf("conn %s created", ID)
for { for {
@ -275,8 +276,8 @@ func (s *TunnelClient) ServeConn(localAddr, ID, serverID string) {
} }
utils.IoBind(inConn, outConn, func(err interface{}) { utils.IoBind(inConn, outConn, func(err interface{}) {
log.Printf("conn %s released", ID) log.Printf("conn %s released", ID)
s.cm.RemoveOne(*s.cfg.Key, ID) // s.cm.RemoveOne(*s.cfg.Key, ID)
}) })
s.cm.Add(*s.cfg.Key, ID, &inConn) // s.cm.Add(*s.cfg.Key, ID, &inConn)
log.Printf("conn %s created", ID) log.Printf("conn %s created", ID)
} }

121
services/tunnel_server.go
View File

@ -24,7 +24,7 @@ type TunnelServerManager struct {
udpChn chan UDPItem udpChn chan UDPItem
sc utils.ServerChannel sc utils.ServerChannel
serverID string serverID string
cm utils.ConnManager // cm utils.ConnManager
} }
func NewTunnelServerManager() Service { func NewTunnelServerManager() Service {
@ -32,7 +32,7 @@ func NewTunnelServerManager() Service {
cfg: TunnelServerArgs{}, cfg: TunnelServerArgs{},
udpChn: make(chan UDPItem, 50000), udpChn: make(chan UDPItem, 50000),
serverID: utils.Uniqueid(), serverID: utils.Uniqueid(),
cm: utils.NewConnManager(), // cm: utils.NewConnManager(),
} }
} }
func (s *TunnelServerManager) Start(args interface{}) (err error) { func (s *TunnelServerManager) Start(args interface{}) (err error) {
@ -91,7 +91,7 @@ func (s *TunnelServerManager) Clean() {
s.StopService() s.StopService()
} }
func (s *TunnelServerManager) StopService() { func (s *TunnelServerManager) StopService() {
s.cm.RemoveAll() // s.cm.RemoveAll()
} }
func (s *TunnelServerManager) CheckArgs() { func (s *TunnelServerManager) CheckArgs() {
if *s.cfg.CertFile == "" || *s.cfg.KeyFile == "" { if *s.cfg.CertFile == "" || *s.cfg.KeyFile == "" {
@ -100,62 +100,63 @@ func (s *TunnelServerManager) CheckArgs() {
s.cfg.CertBytes, s.cfg.KeyBytes = utils.TlsBytes(*s.cfg.CertFile, *s.cfg.KeyFile) s.cfg.CertBytes, s.cfg.KeyBytes = utils.TlsBytes(*s.cfg.CertFile, *s.cfg.KeyFile)
} }
func (s *TunnelServerManager) InitService() { func (s *TunnelServerManager) InitService() {
s.InitHeartbeatDeamon() // s.InitHeartbeatDeamon()
}
func (s *TunnelServerManager) InitHeartbeatDeamon() {
log.Printf("heartbeat started")
go func() {
var heartbeatConn net.Conn
var ID string
for {
//close all connection
s.cm.Remove(ID)
utils.CloseConn(&heartbeatConn)
heartbeatConn, ID, err := s.GetOutConn(CONN_SERVER_HEARBEAT)
if err != nil {
log.Printf("heartbeat connection err: %s, retrying...", err)
time.Sleep(time.Second * 3)
utils.CloseConn(&heartbeatConn)
continue
}
log.Printf("heartbeat connection created,id:%s", ID)
writeDie := make(chan bool)
readDie := make(chan bool)
go func() {
for {
heartbeatConn.SetWriteDeadline(time.Now().Add(time.Second * 3))
_, err = heartbeatConn.Write([]byte{0x00})
heartbeatConn.SetWriteDeadline(time.Time{})
if err != nil {
log.Printf("heartbeat connection write err %s", err)
break
}
time.Sleep(time.Second * 3)
}
close(writeDie)
}()
go func() {
for {
signal := make([]byte, 1)
heartbeatConn.SetReadDeadline(time.Now().Add(time.Second * 6))
_, err := heartbeatConn.Read(signal)
heartbeatConn.SetReadDeadline(time.Time{})
if err != nil {
log.Printf("heartbeat connection read err: %s", err)
break
} else {
// log.Printf("heartbeat from bridge")
}
}
close(readDie)
}()
select {
case <-readDie:
case <-writeDie:
}
}
}()
} }
// func (s *TunnelServerManager) InitHeartbeatDeamon() {
// log.Printf("heartbeat started")
// go func() {
// var heartbeatConn net.Conn
// var ID string
// for {
// //close all connection
// s.cm.Remove(ID)
// utils.CloseConn(&heartbeatConn)
// heartbeatConn, ID, err := s.GetOutConn(CONN_SERVER_HEARBEAT)
// if err != nil {
// log.Printf("heartbeat connection err: %s, retrying...", err)
// time.Sleep(time.Second * 3)
// utils.CloseConn(&heartbeatConn)
// continue
// }
// log.Printf("heartbeat connection created,id:%s", ID)
// writeDie := make(chan bool)
// readDie := make(chan bool)
// go func() {
// for {
// heartbeatConn.SetWriteDeadline(time.Now().Add(time.Second * 3))
// _, err = heartbeatConn.Write([]byte{0x00})
// heartbeatConn.SetWriteDeadline(time.Time{})
// if err != nil {
// log.Printf("heartbeat connection write err %s", err)
// break
// }
// time.Sleep(time.Second * 3)
// }
// close(writeDie)
// }()
// go func() {
// for {
// signal := make([]byte, 1)
// heartbeatConn.SetReadDeadline(time.Now().Add(time.Second * 6))
// _, err := heartbeatConn.Read(signal)
// heartbeatConn.SetReadDeadline(time.Time{})
// if err != nil {
// log.Printf("heartbeat connection read err: %s", err)
// break
// } else {
// // log.Printf("heartbeat from bridge")
// }
// }
// close(readDie)
// }()
// select {
// case <-readDie:
// case <-writeDie:
// }
// }
// }()
// }
func (s *TunnelServerManager) GetOutConn(typ uint8) (outConn net.Conn, ID string, err error) { func (s *TunnelServerManager) GetOutConn(typ uint8) (outConn net.Conn, ID string, err error) {
outConn, err = s.GetConn() outConn, err = s.GetConn()
if err != nil { if err != nil {
@ -241,11 +242,11 @@ func (s *TunnelServer) Start(args interface{}) (err error) {
} }
} }
utils.IoBind(inConn, outConn, func(err interface{}) { utils.IoBind(inConn, outConn, func(err interface{}) {
s.cfg.Mgr.cm.RemoveOne(s.cfg.Mgr.serverID, ID) // s.cfg.Mgr.cm.RemoveOne(s.cfg.Mgr.serverID, ID)
log.Printf("%s conn %s released", *s.cfg.Key, ID) log.Printf("%s conn %s released", *s.cfg.Key, ID)
}) })
//add conn //add conn
s.cfg.Mgr.cm.Add(s.cfg.Mgr.serverID, ID, &inConn) // s.cfg.Mgr.cm.Add(s.cfg.Mgr.serverID, ID, &inConn)
log.Printf("%s conn %s created", *s.cfg.Key, ID) log.Printf("%s conn %s created", *s.cfg.Key, ID)
}) })
if err != nil { if err != nil {

6
utils/functions.go
View File

@ -42,7 +42,8 @@ func IoBind(dst io.ReadWriteCloser, src io.ReadWriteCloser, fn func(err interfac
log.Printf("bind crashed %s", err) log.Printf("bind crashed %s", err)
} }
}() }()
_, err := io.Copy(dst, src) //_, err := io.Copy(dst, src)
err := ioCopy(dst, src)
e1 <- err e1 <- err
}() }()
go func() { go func() {
@ -51,7 +52,8 @@ func IoBind(dst io.ReadWriteCloser, src io.ReadWriteCloser, fn func(err interfac
log.Printf("bind crashed %s", err) log.Printf("bind crashed %s", err)
} }
}() }()
_, err := io.Copy(src, dst) //_, err := io.Copy(src, dst)
err := ioCopy(src, dst)
e2 <- err e2 <- err
}() }()
var err interface{} var err interface{}