title: Why net.Dial is not blocking until the connection is accepted?
body: <p>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).</p>
  
  <pre><code>package main
  
  import (
      "log"
      "net"
      "time"
  )
  
  func main() {
      go listen()
      // wait the listener
      time.Sleep(1)
      dial()
  }
  func listen() {
      dstNet := &amp;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 := &amp;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)
      }
  }
  </code></pre>
  
  <p>//Reason why I need dial to block call:</p>
  
  <p>I'm trying to implement a reverse socks server:</p>
  
  <p><code>server x behind NAT</code> connects to -> <code>server y internet</code></p>
  
  <p><code>client z from internet</code> connects to -> server y</p>
  
  <p>so the issue is that the server behind NAT gets a lot of connections(due non-blocking Dial) even if <code>server y</code> didn't accept any. </p>