Why Dial doesn't block until the connection is accepted? Or is there any way that I can detect that the connection was not accepted so that I can avoid draining my server resources? If I try to read the connection I get blocked forever (as the connection was not accepted) and I might loose the opportunity to connect/dial with the server when it decides to accept my connection too. If I launch new go routines to read from each connection returned by Dial the server gets exhausted (i.e. it can't handle thousands of go routines per second).
package main
import (
"log"
"net"
"time"
)
func main() {
go listen()
// wait the listener
time.Sleep(1)
dial()
}
func listen() {
dstNet := &net.TCPAddr{IP: net.ParseIP("0.0.0.0"), Port: 9090}
// Listen on the dstNet
_, err := net.ListenTCP("tcp", dstNet)
if err != nil {
panic(err)
}
time.Sleep(30 * time.Second)
}
func dial() {
dstNet := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 9090}
for {
log.Printf("dialing")
conn, err := net.DialTCP("tcp", nil, dstNet)
if err != nil {
panic(err)
//return
}
log.Printf("new conn %v", conn)
}
}
//Reason why I need dial to block call:
I'm trying to implement a reverse socks server:
server x behind NAT
connects to -> server y internet
client z from internet
connects to -> server y
so the issue is that the server behind NAT gets a lot of connections(due non-blocking Dial) even if server y
didn't accept any.