conn.go 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270
  1. package tcpprox
  2. import (
  3. "errors"
  4. "io"
  5. "log"
  6. "net"
  7. "strconv"
  8. "sync"
  9. "time"
  10. )
  11. func isValidIP(ip string) bool {
  12. parsedIP := net.ParseIP(ip)
  13. return parsedIP != nil
  14. }
  15. func isValidPort(port string) bool {
  16. portInt, err := strconv.Atoi(port)
  17. if err != nil {
  18. return false
  19. }
  20. if portInt < 1 || portInt > 65535 {
  21. return false
  22. }
  23. return true
  24. }
  25. func isReachable(target string) bool {
  26. timeout := time.Duration(2 * time.Second) // Set the timeout value as per your requirement
  27. conn, err := net.DialTimeout("tcp", target, timeout)
  28. if err != nil {
  29. return false
  30. }
  31. defer conn.Close()
  32. return true
  33. }
  34. func connCopy(conn1 net.Conn, conn2 net.Conn, wg *sync.WaitGroup, accumulator *int64) {
  35. io.Copy(conn1, conn2)
  36. conn1.Close()
  37. log.Println("[←]", "close the connect at local:["+conn1.LocalAddr().String()+"] and remote:["+conn1.RemoteAddr().String()+"]")
  38. //conn2.Close()
  39. //log.Println("[←]", "close the connect at local:["+conn2.LocalAddr().String()+"] and remote:["+conn2.RemoteAddr().String()+"]")
  40. wg.Done()
  41. }
  42. func forward(conn1 net.Conn, conn2 net.Conn, accumulator *int64) {
  43. log.Printf("[+] start transmit. [%s],[%s] <-> [%s],[%s] \n", conn1.LocalAddr().String(), conn1.RemoteAddr().String(), conn2.LocalAddr().String(), conn2.RemoteAddr().String())
  44. var wg sync.WaitGroup
  45. // wait tow goroutines
  46. wg.Add(2)
  47. go connCopy(conn1, conn2, &wg, accumulator)
  48. go connCopy(conn2, conn1, &wg, accumulator)
  49. //blocking when the wg is locked
  50. wg.Wait()
  51. }
  52. func accept(listener net.Listener) (net.Conn, error) {
  53. conn, err := listener.Accept()
  54. if err != nil {
  55. return nil, err
  56. }
  57. log.Println("[√]", "accept a new client. remote address:["+conn.RemoteAddr().String()+"], local address:["+conn.LocalAddr().String()+"]")
  58. return conn, err
  59. }
  60. func startListener(address string) (net.Listener, error) {
  61. log.Println("[+]", "try to start server on:["+address+"]")
  62. server, err := net.Listen("tcp", address)
  63. if err != nil {
  64. return nil, errors.New("listen address [" + address + "] faild")
  65. }
  66. log.Println("[√]", "start listen at address:["+address+"]")
  67. return server, nil
  68. }
  69. // Config validator
  70. func (c *ProxyRelayConfig) ValidateConfigs() error {
  71. if c.Mode == ProxyMode_Transport {
  72. //Port2Host: PortA int, PortB string
  73. if !isValidPort(c.PortA) {
  74. return errors.New("first address must be a valid port number")
  75. }
  76. if !isReachable(c.PortB) {
  77. return errors.New("second address is unreachable")
  78. }
  79. return nil
  80. } else if c.Mode == ProxyMode_Listen {
  81. //Port2Port: Both port are port number
  82. if !isValidPort(c.PortA) {
  83. return errors.New("first address is not a valid port number")
  84. }
  85. if !isValidPort(c.PortB) {
  86. return errors.New("second address is not a valid port number")
  87. }
  88. return nil
  89. } else if c.Mode == ProxyMode_Starter {
  90. //Host2Host: Both have to be hosts
  91. if !isReachable(c.PortA) {
  92. return errors.New("first address is unreachable")
  93. }
  94. if !isReachable(c.PortB) {
  95. return errors.New("second address is unreachable")
  96. }
  97. return nil
  98. } else {
  99. return errors.New("invalid mode given")
  100. }
  101. }
  102. /*
  103. portA -> server
  104. portB -> server
  105. */
  106. func (c *ProxyRelayConfig) Port2port(port1 string, port2 string, stopChan chan bool) error {
  107. //Trim the Prefix of : if exists
  108. listen1, err := startListener("0.0.0.0:" + port1)
  109. if err != nil {
  110. return err
  111. }
  112. listen2, err := startListener("0.0.0.0:" + port2)
  113. if err != nil {
  114. return err
  115. }
  116. log.Println("[√]", "listen port:", port1, "and", port2, "success. waiting for client...")
  117. c.Running = true
  118. go func() {
  119. <-stopChan
  120. log.Println("[x]", "Received stop signal. Exiting Port to Port forwarder")
  121. c.Running = false
  122. listen1.Close()
  123. listen2.Close()
  124. }()
  125. for {
  126. conn1, err := accept(listen1)
  127. if err != nil {
  128. if !c.Running {
  129. return nil
  130. }
  131. continue
  132. }
  133. conn2, err := accept(listen2)
  134. if err != nil {
  135. if !c.Running {
  136. return nil
  137. }
  138. continue
  139. }
  140. if conn1 == nil || conn2 == nil {
  141. log.Println("[x]", "accept client faild. retry in ", c.Timeout, " seconds. ")
  142. time.Sleep(time.Duration(c.Timeout) * time.Second)
  143. continue
  144. }
  145. forward(conn1, conn2, &c.accumulatedByteTransfered)
  146. }
  147. }
  148. /*
  149. portA -> server
  150. server -> portB
  151. */
  152. func (c *ProxyRelayConfig) Port2host(allowPort string, targetAddress string, stopChan chan bool) error {
  153. server, err := startListener("0.0.0.0:" + allowPort)
  154. if err != nil {
  155. return err
  156. }
  157. //Start stop handler
  158. go func() {
  159. <-stopChan
  160. log.Println("[x]", "Received stop signal. Exiting Port to Host forwarder")
  161. c.Running = false
  162. server.Close()
  163. }()
  164. //Start blocking loop for accepting connections
  165. for {
  166. conn, err := accept(server)
  167. if conn == nil || err != nil {
  168. if !c.Running {
  169. //Terminate by stop chan. Exit listener loop
  170. return nil
  171. }
  172. //Connection error. Retry
  173. continue
  174. }
  175. go func(targetAddress string) {
  176. log.Println("[+]", "start connect host:["+targetAddress+"]")
  177. target, err := net.Dial("tcp", targetAddress)
  178. if err != nil {
  179. // temporarily unavailable, don't use fatal.
  180. log.Println("[x]", "connect target address ["+targetAddress+"] faild. retry in ", c.Timeout, "seconds. ")
  181. conn.Close()
  182. log.Println("[←]", "close the connect at local:["+conn.LocalAddr().String()+"] and remote:["+conn.RemoteAddr().String()+"]")
  183. time.Sleep(time.Duration(c.Timeout) * time.Second)
  184. return
  185. }
  186. log.Println("[→]", "connect target address ["+targetAddress+"] success.")
  187. forward(target, conn, &c.accumulatedByteTransfered)
  188. }(targetAddress)
  189. }
  190. }
  191. /*
  192. server -> portA
  193. server -> portB
  194. */
  195. func (c *ProxyRelayConfig) Host2host(address1, address2 string, stopChan chan bool) error {
  196. c.Running = true
  197. go func() {
  198. <-stopChan
  199. log.Println("[x]", "Received stop signal. Exiting Host to Host forwarder")
  200. c.Running = false
  201. }()
  202. for c.Running {
  203. log.Println("[+]", "try to connect host:["+address1+"] and ["+address2+"]")
  204. var host1, host2 net.Conn
  205. var err error
  206. for {
  207. d := net.Dialer{Timeout: time.Duration(c.Timeout)}
  208. host1, err = d.Dial("tcp", address1)
  209. if err == nil {
  210. log.Println("[→]", "connect ["+address1+"] success.")
  211. break
  212. } else {
  213. log.Println("[x]", "connect target address ["+address1+"] faild. retry in ", c.Timeout, " seconds. ")
  214. time.Sleep(time.Duration(c.Timeout) * time.Second)
  215. }
  216. if !c.Running {
  217. return nil
  218. }
  219. }
  220. for {
  221. d := net.Dialer{Timeout: time.Duration(c.Timeout)}
  222. host2, err = d.Dial("tcp", address2)
  223. if err == nil {
  224. log.Println("[→]", "connect ["+address2+"] success.")
  225. break
  226. } else {
  227. log.Println("[x]", "connect target address ["+address2+"] faild. retry in ", c.Timeout, " seconds. ")
  228. time.Sleep(time.Duration(c.Timeout) * time.Second)
  229. }
  230. if !c.Running {
  231. return nil
  232. }
  233. }
  234. forward(host1, host2, &c.accumulatedByteTransfered)
  235. }
  236. return nil
  237. }