title: Why "Address already in use" happens
body: <p>I am making an C++ socket application.</p>
  
  <p>It connects with android device.</p>
  
  <p>When I close connection on phone during receiving data..</p>
  
  <pre><code>Framebuffer Ready
  [PCast] Waiting for connection
  [PCast] Connected
  ....
  [PCast] Data arrived
  [PCast] *** Downloading mode ***
  [PCast] Downloading file. Please wait...
  [PCast:sock2file] Downloading...
  [PCast:sock2file] Disconnection detected. Exiting sock2file.
  [PCast] Disconnected
  (Close client socket descriptor)
  
  [PCast] Waiting for connection
  </code></pre>
  
  <p>It looks like the connection is successfully closed. but When I restart server..</p>
  
  <pre><code>Framebuffer Ready
  [PCast] Socket bind failed: Address already in use
  </code></pre>
  
  <p>When my android app tries to connect(Server is not running), It says that it is connected to server.(Data transfer does not working)</p>
  
  <p>When I run</p>
  
  <pre><code>netstat -anp
  </code></pre>
  
  <p>I can see that my port is in CLOSE_WAIT status.</p>
  
  <pre><code>...
  tcp        1      0 172.30.1.3:5520         172.30.1.2:47144        CLOSE_WAIT  -               
  tcp        0      0 172.30.1.3:22           172.30.1.1:50598        ESTABLISHED -               
  tcp        1      0 172.30.1.3:5520         172.30.1.2:47202        CLOSE_WAIT  -     
  ...
  </code></pre>
  
  <p>Code(Omitting logging, korean comment...):</p>
  
  <pre><code>#include &lt;sys/types.h&gt;
  #include &lt;sys/stat.h&gt;
  #include &lt;sys/socket.h&gt;
  #include &lt;unistd.h&gt;
  #include &lt;netinet/in.h&gt;
  #include &lt;arpa/inet.h&gt;
  #include &lt;cstdio&gt;
  #include &lt;cstdlib&gt;
  #include &lt;cstring&gt;
  #include &lt;string&gt;
  #include &lt;ctime&gt;
  #include &lt;cmath&gt;
  #include &lt;linux/fb.h&gt;
  #include &lt;fcntl.h&gt;
  #include &lt;sys/mman.h&gt;
  #include &lt;sys/ioctl.h&gt;
  #include &lt;signal.h&gt;
  #include "imgs.h"
  
  using std::string;
  
  #define FBDEV "/dev/fb0"
  int scrsize, width, height;
  int basesize;
  
  #define CMD_GET_IP_ETH "/home/pi/scripts/ip.sh eth"
  #define CMD_GET_IP_WLN "/home/pi/scripts/ip.sh wlan"
  
  #define getPercent(total, current) (current / total) * 100
  #define getLargeValue(org, b) (org * b) / 320
  
  short *display;
  short org[320*240];
  
  //Convert images to char map
  char strmap[128][5*5];
  
  bool debug = false;
  
  void cons_log(string message){
      printf("%s\n", message.c_str());
  }
  
  void drawPixel(int x, int y, short col){
      if((width * y + x) &lt; width * height){
          display[width*y+x] = col;
      }
  }
  
  short mkcolor(int r, int g, int b){
      return ((r &gt;&gt; 3) &lt;&lt; 11) | ((g &gt;&gt; 2) &lt;&lt; 5) | (b &gt;&gt; 3);
  }
  
  void writeImage(int sx, int sy, char img[], int size){
      size *= basesize;
      for(int y = 0; y &lt; 5; y++) for(int x = 0; x &lt; 5; x++){
          int prtx = sx + x * size, prty = sy + y * size;
          for(int rx = 0; rx &lt; size; rx++) for(int ry = 0; ry &lt; size; ry++){
              drawPixel(prtx + rx, prty + ry, img[5*y+x] * 0xffff);
          }
      }
  }
  
  void writeImage(char img[], int size){
      int centerX = width / 2 - 5 * size / 2;
      int centerY = height / 2 - 5 * size / 2;
      writeImage(centerX, centerY, img, size);
  }
  
  void writeMessage(int x, int y, string s, int size){
      size *= basesize;
      y += height / 2 - size * 5;
      for(int i = 0; i &lt; s.length(); i++){
          int prtx = x + i * (size * 5);
          writeImage(prtx, y, strmap[s.at(i)], size / basesize);
      }
  }
  
  void writeMessage(int y, string s, int size){
      size *= basesize;
      int x = width / 2 - ((s.length()) * (size * 5)) / 2;
      y += height / 2 - size * 5;
      for(int i = 0; i &lt; s.length(); i++){
          int prtx = x + i * (size * 5);
          writeImage(prtx, y, strmap[s.at(i)], size / basesize);
      }
  }
  
  void writeMessage(string s, int size){
      writeMessage(0, s, size);
  }
  
  void clear(){
      for(int i = 0; i &lt; width * height; i++) display[i] = 0;
  }
  
  #define img_height(size) size * 5 * basesize
  
  void printStandBy(bool connected){
      clear();
      writeMessage("pcast", 2);
      char buffer[100];
      FILE* pipe;
      pipe = popen("sh /home/pi/scripts/ip.sh eth", "r");
      fgets(buffer, 100, pipe);
      pclose(pipe);
      writeMessage(img_height(2) + 10, buffer, 1);
      memset(buffer, 0, 100);
      pipe = popen("sh /home/pi/scripts/ip.sh wlan", "r");
      fgets(buffer, 100, pipe);
      pclose(pipe);
      writeMessage(img_height(2) * 2 + 10, buffer, 1);
      if(connected){
          writeMessage(img_height(2) * 3 + 10, "connected", 1);
      }else{
          writeMessage(img_height(2) * 3 + 10, "not connected", 1);
      }
  }
  
  void printDownloading(){
      clear();
      writeImage(IMG_DOWNLOAD, 2);
      writeMessage(img_height(2) + 10, "downloading", 1);
  }
  
  int server_sockfd, client_sockfd;
  
  void endHandler(int signo){
      if(client_sockfd != NULL) close(client_sockfd);
      if(server_sockfd != NULL) close(server_sockfd);
      exit(0);
  }
  
  bool sock2file(int socket){
      system("sudo rm /tmp/tmp");
      int count = 0;
      int file = open("/tmp/tmp", O_WRONLY | O_CREAT, 0644);
      int totalBytes = 0;
      while(true){
          char buffer[1024*1024];
          int recvBytes = recv(socket, buffer, 1024*1024, MSG_DONTWAIT);
          if(recvBytes == 0){
              return false;
          }else if(recvBytes == -1){
              if(count == 5000){
                  char send[] = {1, NULL};
                  write(socket, send, 1);
                  break;
              }else{
                  usleep(1000);
                  count++;
              }
          }else{
              count = 0;
              char send[] = {0, NULL};
              write(socket, send, 1);
              write(file, buffer, recvBytes);
              totalBytes += recvBytes;
              //byte to B/KB/MB/GB
              int displaySize = totalBytes;
              char sizeUnit = 'b';
              if(displaySize &gt; 1024){
                  displaySize /= 1024;
                  sizeUnit = 'k';
              }
              if(displaySize &gt; 1024){
                  displaySize /= 1024;
                  sizeUnit = 'm';
              }
              //Print current status
              char buf[100];
              sprintf(buf, "received %d%c    ", displaySize, sizeUnit);
              string status(buf);
              writeMessage(0, img_height(2) * 2 + 10, status, 1);
          }
      }
      return true;
  }
  
  int main(int argc, char **argv){
      if(argc == 2){
          if(!strcmp(argv[0], "d")) debug = true;
      }
      signal(SIGTERM, endHandler);
      signal(SIGINT, endHandler);
      memcpy(strmap['0'], IMG_0, 5*5);
      memcpy(strmap['1'], IMG_1, 5*5);
      memcpy(strmap['2'], IMG_2, 5*5);
      memcpy(strmap['3'], IMG_3, 5*5);
      memcpy(strmap['4'], IMG_4, 5*5);
      memcpy(strmap['5'], IMG_5, 5*5);
      memcpy(strmap['6'], IMG_6, 5*5);
      memcpy(strmap['7'], IMG_7, 5*5);
      memcpy(strmap['8'], IMG_8, 5*5);
      memcpy(strmap['9'], IMG_9, 5*5);
      memcpy(strmap['.'], IMG_DOT, 5*5);
      memcpy(strmap[':'], IMG_DOBULE_DOT, 5*5);
      memcpy(strmap['a'], IMG_A, 5*5);
      memcpy(strmap['b'], IMG_B, 5*5);
      memcpy(strmap['c'], IMG_C, 5*5);
      memcpy(strmap['d'], IMG_D, 5*5);
      memcpy(strmap['e'], IMG_E, 5*5);
      memcpy(strmap['f'], IMG_F, 5*5);
      memcpy(strmap['g'], IMG_G, 5*5);
      memcpy(strmap['h'], IMG_H, 5*5);
      memcpy(strmap['i'], IMG_I, 5*5);
      memcpy(strmap['j'], IMG_J, 5*5);
      memcpy(strmap['k'], IMG_K, 5*5);
      memcpy(strmap['m'], IMG_M, 5*5);
      memcpy(strmap['n'], IMG_N, 5*5);
      memcpy(strmap['l'], IMG_L, 5*5);
      memcpy(strmap['o'], IMG_O, 5*5);
      memcpy(strmap['p'], IMG_P, 5*5);
      memcpy(strmap['q'], IMG_Q, 5*5);
      memcpy(strmap['r'], IMG_R, 5*5);
      memcpy(strmap['s'], IMG_S, 5*5);
      memcpy(strmap['t'], IMG_T, 5*5);
      memcpy(strmap['u'], IMG_U, 5*5);
      memcpy(strmap['v'], IMG_V, 5*5);
      memcpy(strmap['w'], IMG_W, 5*5);
      memcpy(strmap['x'], IMG_X, 5*5);
      memcpy(strmap['y'], IMG_Y, 5*5);
      memcpy(strmap['z'], IMG_Z, 5*5);
      memcpy(strmap[' '], IMG_SPACE, 5*5);
  
      //Framebuffer Setup
      int fb_fd;
      fb_fd = open(FBDEV, O_RDWR);
      if(!fb_fd){
          exit(1);
      }
      fb_var_screeninfo fvsInfo;
      if(ioctl(fb_fd, FBIOGET_VSCREENINFO, &amp;fvsInfo)){
          exit(1);
      }
      width = fvsInfo.xres;
      height = fvsInfo.yres;
      scrsize = width * height * 2;
      basesize = (width + height) / 2 / 100;
      display = (short *)mmap(0, scrsize, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);
      if((int *)display == -1){
          exit(1);
      }
      printStandBy(false);
      //Socket setup
      int state, client_len;
      int pid;
      struct sockaddr_in siClient, siServer;
      state = 0;
      client_len = sizeof(siClient);
      if((server_sockfd = socket(AF_INET, SOCK_STREAM, 0)) &lt; 0){
          exit(0);
      }
      bzero(&amp;siServer, sizeof(siServer));
      siServer.sin_family = AF_INET;
      siServer.sin_addr.s_addr = htonl(INADDR_ANY);
      siServer.sin_port = htons(5520);
      state = bind(server_sockfd , (struct sockaddr *)&amp;siServer, sizeof(siServer));
      if (state == -1){
          exit(0);
      }
      state = listen(server_sockfd, 5);
      if (state == -1){
          exit(0);
      }
      while(1){
          client_sockfd = accept(server_sockfd, (struct sockaddr *)&amp;siClient,
                                 &amp;client_len);
          if (client_sockfd == -1){
              exit(0);
          }
          printStandBy(true);
          int avg;
          int orgtime = time(NULL);
          while(1){
              char datainfo[2];
              int recvBytes = recv(client_sockfd, datainfo, 2, MSG_WAITALL);
              if(recvBytes == 0 || recvBytes == -1) break;
              else{
                  system("sudo killall omxplayer*");
                  write(client_sockfd, datainfo, 2);
                  //*** Downloading mode ***
                  printDownloading();
                  bool status = sock2file(client_sockfd);
                  if(!status) break;
                  printStandBy(true);
                  system("nohup omxplayer /tmp/tmp &amp;");
              }
          }
          printStandBy(false);
          close(client_sockfd);
      }
  }
  </code></pre>
  
  <ul>
  <li><p>The program wasn't crashed. I exited with Ctrl + C(As you can see, there's a handler for Ctrl + C, kill signal...)</p></li>
  <li><p>My android app closes connection when application exits.</p></li>
  <li><p>Sorry for poor english.</p></li>
  </ul>