title: TCP based hole punching
body: <p>I've been attempting TCP hole punching for a while now and forums don't seem be helping much when it comes to TCP based approach and C programming language. Following were the main references from internet,</p>
  
  <p>a. <a href="http://www.brynosaurus.com/pub/net/p2pnat/" rel="nofollow">http://www.brynosaurus.com/pub/net/p2pnat/</a><br>
  b. <a href="https://wuyongzheng.wordpress.com/2013/01/31/experiment-on-tcp-hole-punching/" rel="nofollow">https://wuyongzheng.wordpress.com/2013/01/31/experiment-on-tcp-hole-punching/</a></p>
  
  <p>My setup is<br>
   Client A -- NAT-A -- Internet -- NAT-B -- Client B. </p>
  
  <p>Assuming that client A knows B's public and private endpoint, and B knows A's endpoints ( I have written a server 'S' that exchanges endpoint information among peers), and given that both the NATs are NOT symmetric, will it suffice (to achieve TCP hole punching), if both the clients attempt to connect() to each other's public endpoint ( for the above setup) repeatedly?</p>
  
  <p>If not, what exactly has to be done to achieve tcp hole punching?</p>
  
  <p>I have two threads on each clients , one that makes a connect call repeatedly to other client, and the other that listens to incoming connection from other client. I have made sure that sockets in both the threads are bound to the local port that was given to the peer. Also, I see that both the NATs preserve port mapping i.e., local and public ports are same. Yet, my program isn't working.</p>
  
  <p>Is it so that the rendezvous server 'S' that I mentioned above has a role to play in punching a hole or creating a NAT mapping that will allow SYN requests to pass through, to the peers. If yes, what has to be done?</p>
  
  <p>Relevant sections of the code are attached.<br>
  connect_with_peer() is the entry point, after server 'S' provides the peer's public ip:port tuple, which is given to this function along with local port to which binding is done. This function spawns a thread ( accept_handler() ) which also binds to the  local port and listens for incoming connection from the peer.
  connect_with_peer() returns a socket , if connect() [ main thread ] or accept() [ child thread ], is successful.</p>
  
  <p>Thanks,<br>
  Dinkar</p>
  
  <pre><code>volatile int quit_connecting=0;
  
  void *accept_handler(void *arg)
  {
      int i,psock,cnt=0;
      int port = *((int *)arg);
      ssize_t len;
      int asock,opt,fdmax;
      char str[BUF_SIZE];
      struct sockaddr_in peer,local;
      socklen_t peer_len = sizeof(peer);
      fd_set master,read_fds;    // master file descriptor list
      struct timeval tv = {10, 0}; // 10 sec timeout
      int *ret_sock = NULL;
      struct linger lin;
      lin.l_onoff=1;
      lin.l_linger=0;
  
      opt=1;
      //Create socket
      asock = socket(AF_INET , SOCK_STREAM, IPPROTO_TCP);
  
      if (asock == -1)
      {
          fprintf(stderr,"Could not create socket");
          goto quit_ah;
      }
      else if (setsockopt(asock, SOL_SOCKET, SO_LINGER, &amp;lin,
                          (socklen_t) sizeof lin) &lt; 0)
      {
          fprintf(stderr,"\nTCP set linger socket options failure");
          goto quit_ah;
      }
      else if (setsockopt(asock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &amp;opt,
                          (socklen_t) sizeof opt) &lt; 0)
      {
          fprintf(stderr,"\nTCP set csock options failure");
          goto quit_ah;
      }
  
  
      local.sin_family = AF_INET;         /* host byte order */
      local.sin_port = htons(port);     /* short, network byte order */
      local.sin_addr.s_addr = INADDR_ANY; /* auto-fill with my IP */
      bzero(&amp;(local.sin_zero), 8);        /* zero the rest of the struct */
  
  fprintf(stderr,"\naccept_handler: binding to port %d",port);
  
      if (bind(asock, (struct sockaddr *)&amp;local, sizeof(struct sockaddr)) == -1) {
          perror("accept_handler bind error :");
          goto quit_ah;
      }
  
      if (listen(asock, 1) == -1) {
          perror(" accept_handler listen");
          goto quit_ah;
      }
  
      memset(&amp;peer, 0, sizeof(peer));
      peer.sin_addr.s_addr = inet_addr(peer_global_address);
      peer.sin_family = AF_INET;
      peer.sin_port = htons( peer_global_port );
  
      FD_ZERO(&amp;master);    // clear the master and temp sets
      FD_SET(asock, &amp;master);
      fdmax = asock; // so far, it's this one
  
      // Try accept
      fprintf(stderr,"\n listen done; accepting next ... ");
  
      while(quit_connecting == 0){
          read_fds = master; // copy it
          if (select(fdmax+1, &amp;read_fds, NULL, NULL, &amp;tv) == -1) {
              perror("accept_handler select");
              break;
          }
          // run through the existing connections looking for data to read
          for(i = 0; i &lt;= fdmax; i++) {
              if (FD_ISSET(i, &amp;read_fds)) { // we got one!!
                  if (i == asock) {
                      // handle new connections
                      psock = accept(asock, (struct sockaddr *)&amp;peer, (socklen_t*)&amp;peer_len);
  
                      if (psock == -1) {
                          perror("accept_handler accept");
                      } else {
                          fprintf(stderr,"\n Punch accept in thread succeeded soc=%d....",psock);
                          quit_connecting = 1;
  
                          ret_sock = malloc(sizeof(int));
                          if(ret_sock){
                              *ret_sock = psock;
                          }
  
                      }
                  }
              }
          } // end for
      }
  
  
  quit_ah:
  
      if(asock&gt;=0) {
          shutdown(asock,2);
          close(asock);
      }
      pthread_exit((void *)ret_sock);
  
      return (NULL);
  }
  
  
  
  int connect_with_peer(char *ip, int port, int lport)
  {
      int retval=-1, csock=-1;
      int *psock=NULL;
      int attempts=0, cnt=0;
      int rc=0, opt;
      ssize_t len=0;
      struct sockaddr_in peer, apeer;
      struct sockaddr_storage from;
      socklen_t peer_len = sizeof(peer);
      socklen_t fromLen = sizeof(from);
      char str[64];
      int connected = 0;
      pthread_t accept_thread;
      long arg;
      struct timeval tv;
      fd_set myset;
      int so_error;
  
      struct linger lin;
      lin.l_onoff=1;
      lin.l_linger=0;
  
      opt=1;
  
      //Create socket
      csock = socket(AF_INET , SOCK_STREAM, IPPROTO_TCP);
  
      if (csock == -1)
      {
          fprintf(stderr,"Could not create socket");
          return -1;
      }
      else if (setsockopt(csock, SOL_SOCKET, SO_LINGER, &amp;lin,
                          (socklen_t) sizeof lin) &lt; 0)
      {
          fprintf(stderr,"\nTCP set linger socket options failure");
      }
  
  #if 1
      else if (setsockopt(csock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &amp;opt,
                          (socklen_t) sizeof opt) &lt; 0)
      {
          fprintf(stderr,"\nTCP set csock options failure");
      }
  #endif
  
      quit_connecting = 0;
  
  ///////////
  
      if( pthread_create( &amp;accept_thread , NULL ,  accept_handler , &amp;lport) &lt; 0)
      {
          perror("could not create thread");
          return 1;
      }
      sleep(2); // wait for listen/accept to begin in accept_thread.
  
  ///////////
      peer.sin_family = AF_INET;         /* host byte order */
      peer.sin_port = htons(lport);     /* short, network byte order */
      peer.sin_addr.s_addr = INADDR_ANY; /* auto-fill with my IP */
      bzero(&amp;(peer.sin_zero), 8);        /* zero the rest of the struct */
  
  fprintf(stderr,"\n connect_with_peer: binding to port %d",lport);
  
      if (bind(csock, (struct sockaddr *)&amp;peer, sizeof(struct sockaddr)) == -1) {
          perror("connect_with_peer bind error :");
          goto quit_connect_with_peer;
      }
  
      // Set non-blocking 
      arg = fcntl(csock, F_GETFL, NULL); 
      arg |= O_NONBLOCK; 
      fcntl(csock, F_SETFL, arg); 
  
      memset(&amp;peer, 0, sizeof(peer));
      peer.sin_addr.s_addr = inet_addr(ip);
      peer.sin_family = AF_INET;
      peer.sin_port = htons( port );
  
      //Connect to remote server
      fprintf(stderr,"\n Attempting to connect/punch to %s; attempt=%d",ip,attempts);
      rc = connect(csock , (struct sockaddr *)&amp;peer , peer_len);
  
      if(rc == 0){ //succeeded
          fprintf(stderr,"\n Punch Connect succeeded first time....");
      } else { 
          if (errno == EINPROGRESS) { 
  
  
              while((attempts&lt;5) &amp;&amp; (quit_connecting==0)){
              tv.tv_sec = 10; 
              tv.tv_usec = 0; 
              FD_ZERO(&amp;myset); 
              FD_SET(csock, &amp;myset); 
                  if (select(csock+1, NULL, &amp;myset, NULL, &amp;tv) &gt; 0) { 
  
                      len = sizeof(so_error);
                      getsockopt(csock, SOL_SOCKET, SO_ERROR, &amp;so_error, (socklen_t *)&amp;len);
  
                      if (so_error == 0) {
                          fprintf(stderr,"\n Punch Connect succeeded ....");
                          // Set it back to blocking mode
                          arg = fcntl(csock, F_GETFL, NULL); 
                          arg &amp;= ~(O_NONBLOCK); 
                          fcntl(csock, F_SETFL, arg);
  
                          quit_connecting=1;
                          retval = csock;
                      } else { // error
                          fprintf(stderr,"\n Punch select error: %s\n", strerror(so_error));
                          goto quit_connect_with_peer;
                      }
  
                  } else { 
                      fprintf(stderr,"\n Punch select timeout: %s\n", strerror(so_error));
                  } 
                  attempts++;
              }// end while
  
          } else { //errorno is not EINPROGRESS
              fprintf(stderr, "\n Punch connect error: %s\n", strerror(errno)); 
          } 
      } 
  
  quit_connect_with_peer:
  
      quit_connecting=1;
      fprintf(stderr,"\n Waiting for accept_thread to close..");
      pthread_join(accept_thread,(void **)&amp;psock);
  
      if(retval == -1 ) {
          if(psock &amp;&amp; ((*psock) != -1)){
              retval = (*psock); // Success from accept socket
          }
      }
  
      fprintf(stderr,"\n After accept_thread psock = %d csock=%d, retval=%d",psock?(*psock):-1,csock,retval);
  
      if(psock) free(psock); // Free the socket pointer , not the socket.
  
      if((retval != csock) &amp;&amp; (csock&gt;=0)){ // close connect socket if accept succeeded
          shutdown(csock,2);
          close(csock);
      }
  
      return retval;
  }
  </code></pre>