lasker-2.2.3/src/network.c

   1 /*
   2    Copyright (c) 1993 Richard V. Nash.
   3    Copyright (c) 2000 Dan Papasian
   4    Copyright (C) Andrew Tridgell 2002
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 extern int errno;
  24
  25 /* Index == fd, for sparse array, quick lookups! wasted memory :( */
  26 static int findConnection(int fd)
  27 {
  28         if (fd == -1 || net_globals.con[fd]->status == NETSTAT_EMPTY)
  29                 return -1;
  30         else
  31                 return fd;
  32 }
  33
  34
  35 static void set_sndbuf(int fd, int len)
  36 {
  37         net_globals.con[fd]->sndbufpos = len;
  38         if (len < net_globals.con[fd]->sndbufsize) {
  39                 net_globals.con[fd]->sndbuf[len] = 0;
  40         }
  41 }
  42
  43 static int net_addConnection(int fd, struct in_addr fromHost)
  44 {
  45         int noblock = 1;
  46
  47         /* possibly expand the connections array */
  48         if (fd >= net_globals.no_file) {
  49                 int i;
  50                 net_globals.con = (struct connection_t **)realloc(net_globals.con,
  51                                                                   (fd+1) * sizeof(struct connection_t *));
  52                 for (i=net_globals.no_file;i<fd+1;i++) {
  53                         net_globals.con[i] = (struct connection_t *)calloc(1,
  54                                                                            sizeof(struct connection_t));
  55                         net_globals.con[i]->status = NETSTAT_EMPTY;
  56                 }
  57                 net_globals.no_file = fd+1;
  58         }
  59
  60         if (findConnection(fd) >= 0) {
  61                 d_printf( "CHESSD: FD already in connection table!\n");
  62                 return -1;
  63         }
  64         if (ioctl(fd, FIONBIO, &noblock) == -1) {
  65                 d_printf( "Error setting nonblocking mode errno=%d\n", errno);
  66         }
  67         net_globals.con[fd]->fd = fd;
  68         if (fd != 0)
  69                 net_globals.con[fd]->outFd = fd;
  70         else
  71                 net_globals.con[fd]->outFd = 1;
  72         net_globals.con[fd]->fromHost = fromHost;
  73         net_globals.con[fd]->status = NETSTAT_CONNECTED;
  74         net_globals.con[fd]->timeseal = 0;
  75         net_globals.con[fd]->timeseal_init = 1;
  76         net_globals.con[fd]->time = 0;
  77         net_globals.con[fd]->numPending = 0;
  78         net_globals.con[fd]->inBuf[0] = 0;
  79         net_globals.con[fd]->processed = 0;
  80         net_globals.con[fd]->outPos = 0;
  81         if (net_globals.con[fd]->sndbuf == NULL) {
  82 #ifdef DEBUG
  83                 d_printf( "CHESSD: nac(%d) allocating sndbuf.\n", fd);
  84 #endif
  85                 net_globals.con[fd]->sndbufpos = 0;
  86                 net_globals.con[fd]->sndbufsize = MAX_STRING_LENGTH;
  87                 net_globals.con[fd]->sndbuf = malloc(MAX_STRING_LENGTH);
  88         } else {
  89 #ifdef DEBUG
  90                 d_printf( "CHESSD: nac(%d) reusing old sndbuf size %d pos %d.\n", fd, net_globals.con[fd].sndbufsize, net_globals.con[fd].sndbufpos);
  91 #endif
  92         }
  93         net_globals.con[fd]->state = 0;
  94         net_globals.numConnections++;
  95
  96 #ifdef DEBUG
  97         d_printf( "CHESSD: fd: %d connections: %d  descriptors: %d \n", fd, numConnections, getdtablesize());   /* sparky 3/13/95 */
  98 #endif
  99
 100         return 0;
 101 }
 102
 103 static int remConnection(int fd)
 104 {
 105         int which, i;
 106         if ((which = findConnection(fd)) < 0) {
 107                 d_printf( "remConnection: Couldn't find fd to close.\n");
 108                 return -1;
 109         }
 110         net_globals.numConnections--;
 111         net_globals.con[fd]->status = NETSTAT_EMPTY;
 112         if (net_globals.con[fd]->sndbuf == NULL) {
 113                 d_printf( "CHESSD: remcon(%d) SNAFU, this shouldn't happen.\n", fd);
 114         } else {
 115                 if (net_globals.con[fd]->sndbufsize > MAX_STRING_LENGTH) {
 116                         net_globals.con[fd]->sndbufsize = MAX_STRING_LENGTH;
 117                         net_globals.con[fd]->sndbuf = realloc(net_globals.con[fd]->sndbuf, MAX_STRING_LENGTH);
 118                 }
 119                 if (net_globals.con[fd]->sndbufpos) {   /* didn't send everything, bummer */
 120                         set_sndbuf(fd, 0);
 121                 }
 122         }
 123
 124         /* see if we can shrink the con array */
 125         for (i=fd;i<net_globals.no_file;i++) {
 126                 if (net_globals.con[i]->status != NETSTAT_EMPTY) {
 127                         return 0;
 128                 }
 129         }
 130
 131         /* yep! shrink it */
 132         for (i=fd;i<net_globals.no_file;i++) {
 133                 FREE(net_globals.con[i]->sndbuf);
 134                 FREE(net_globals.con[i]);
 135         }
 136         net_globals.no_file = fd;
 137         net_globals.con = (struct connection_t **)realloc(net_globals.con,
 138                                                           net_globals.no_file * sizeof(struct connection_t *));
 139
 140         return 0;
 141 }
 142
 143 static void net_flushme(int which)
 144 {
 145   int sent;
 146
 147   sent = send(net_globals.con[which]->outFd, net_globals.con[which]->sndbuf, net_globals.con[which]->sndbufpos, 0);
 148   if (sent == -1) {
 149     if (errno != EPIPE)         /* EPIPE = they've disconnected */
 150       d_printf( "CHESSD: net_flushme(%d) couldn't send, errno=%d.\n", which, errno);
 151     set_sndbuf(which, 0);
 152   } else {
 153     net_globals.con[which]->sndbufpos -= sent;
 154     if (net_globals.con[which]->sndbufpos)
 155       memmove(net_globals.con[which]->sndbuf, net_globals.con[which]->sndbuf + sent, net_globals.con[which]->sndbufpos);
 156   }
 157   if (net_globals.con[which]->sndbufsize > MAX_STRING_LENGTH && net_globals.con[which]->sndbufpos < MAX_STRING_LENGTH) {
 158     /* time to shrink the buffer */
 159     net_globals.con[which]->sndbuf = realloc(net_globals.con[which]->sndbuf, MAX_STRING_LENGTH);
 160     net_globals.con[which]->sndbufsize = MAX_STRING_LENGTH;
 161   }
 162   set_sndbuf(which, net_globals.con[which]->sndbufpos);
 163 }
 164
 165 static void net_flush_all_connections(void)
 166 {
 167         int which;
 168         fd_set writefds;
 169         struct timeval to;
 170
 171         FD_ZERO(&writefds);
 172         for (which = 0; which < net_globals.no_file; which++) {
 173                 if (net_globals.con[which]->status == NETSTAT_CONNECTED &&
 174                     net_globals.con[which]->sndbufpos){
 175                         FD_SET(net_globals.con[which]->outFd, &writefds);
 176                 }
 177         }
 178
 179         to.tv_usec = 0;
 180         to.tv_sec = 0;
 181         select(net_globals.no_file, NULL, &writefds, NULL, &to);
 182         for (which = 0; which < net_globals.no_file; which++) {
 183                 if (FD_ISSET(net_globals.con[which]->outFd, &writefds)) {
 184                         net_flushme(which);
 185                 }
 186         }
 187 }
 188
 189 static void net_flush_connection(int fd)
 190 {
 191   int which;
 192   fd_set writefds;
 193   struct timeval to;
 194
 195   if (((which = findConnection(fd)) >= 0) && (net_globals.con[which]->sndbufpos)) {
 196     FD_ZERO(&writefds);
 197     FD_SET(net_globals.con[which]->outFd, &writefds);
 198     to.tv_usec = 0;
 199     to.tv_sec = 0;
 200     select(net_globals.no_file, NULL, &writefds, NULL, &to);
 201     if (FD_ISSET(net_globals.con[which]->outFd, &writefds)) {
 202       net_flushme(which);
 203     }
 204   }
 205 }
 206
 207 static int sendme(int which, char *str, int len)
 208 {
 209   int i, count;
 210   fd_set writefds;
 211   struct timeval to;
 212   count = len;
 213
 214   while ((i = ((net_globals.con[which]->sndbufsize - net_globals.con[which]->sndbufpos) < len) ? (net_globals.con[which]->sndbufsize - net_globals.con[which]->sndbufpos) : len) > 0) {
 215     memmove(net_globals.con[which]->sndbuf + net_globals.con[which]->sndbufpos, str, i);
 216     net_globals.con[which]->sndbufpos += i;
 217     if (net_globals.con[which]->sndbufpos == net_globals.con[which]->sndbufsize) {
 218
 219       FD_ZERO(&writefds);
 220       FD_SET(net_globals.con[which]->outFd, &writefds);
 221       to.tv_usec = 0;
 222       to.tv_sec = 0;
 223       select(net_globals.no_file, NULL, &writefds, NULL, &to);
 224       if (FD_ISSET(net_globals.con[which]->outFd, &writefds)) {
 225         net_flushme(which);
 226       } else {
 227         /* time to grow the buffer */
 228         net_globals.con[which]->sndbufsize += MAX_STRING_LENGTH;
 229         net_globals.con[which]->sndbuf = realloc(net_globals.con[which]->sndbuf, net_globals.con[which]->sndbufsize);
 230       }
 231     }
 232     str += i;
 233     len -= i;
 234   }
 235   set_sndbuf(which, net_globals.con[which]->sndbufpos);
 236   return count;
 237 }
 238
 239 /*
 240  * -1 for an error other than EWOULDBLOCK.
 241  * Put <lf> after every <cr> and put \ at the end of overlength lines.
 242  * Doesn't send anything unless the buffer fills, output waits until
 243  * flushed
 244 */
 245 /* width here is terminal width = width var + 1 at presnt) */
 246 int net_send_string(int fd, char *str, int format, int width)
 247 {
 248   int which, i, j;
 249
 250   if ((which = findConnection(fd)) < 0) {
 251     return -1;
 252   }
 253   while (*str) {
 254     for (i = 0; str[i] >= ' '; i++);
 255     if (i) {
 256       if (format && (i >= (j = width - net_globals.con[which]->outPos))) {      /* word wrap */
 257         i = j-1;
 258         while (i > 0 && str[i - 1] != ' ')
 259           i--;
 260 /*
 261         while (i > 0 && str[i - 1] == ' ')
 262           i--;
 263 */
 264         if (i == 0)
 265           i = j - 1;
 266         sendme(which, str, i);
 267         sendme(which, "\n\r\\   ", 6);
 268         net_globals.con[which]->outPos = 4;
 269         while (str[i] == ' ')   /* eat the leading spaces after we wrap */
 270           i++;
 271       } else {
 272         sendme(which, str, i);
 273         net_globals.con[which]->outPos += i;
 274       }
 275       str += i;
 276     } else {                    /* non-printable stuff handled here */
 277       switch (*str) {
 278       case '\t':
 279         sendme(which, "        ", 8 - (net_globals.con[which]->outPos & 7));
 280         net_globals.con[which]->outPos &= ~7;
 281         if (net_globals.con[which]->outPos += 8 >= width)
 282           net_globals.con[which]->outPos = 0;
 283         break;
 284       case '\n':
 285         sendme(which, "\n\r", 2);
 286         net_globals.con[which]->outPos = 0;
 287         break;
 288       case '\033':
 289         net_globals.con[which]->outPos -= 3;
 290       default:
 291         sendme(which, str, 1);
 292       }
 293       str++;
 294     }
 295   }
 296   return 0;
 297 }
 298
 299 /* if we get a complete line (something terminated by \n), copy it to com
 300    and return 1.
 301    if we don't get a complete line, but there is no error, return 0.
 302    if some error, return -1.
 303  */
 304 static int readline2(char *com, int who)
 305 {
 306   unsigned char *start, *s, *d;
 307   int howmany, state, fd, pending;
 308
 309   const unsigned char will_tm[] = {IAC, WILL, TELOPT_TM, '\0'};
 310   const unsigned char will_sga[] = {IAC, WILL, TELOPT_SGA, '\0'};
 311   const unsigned char ayt[] = "[Responding to AYT: Yes, I'm here.]\n";
 312
 313   state = net_globals.con[who]->state;
 314   if ((state == 2) || (state > 4)) {
 315     d_printf( "CHESSD: state screwed for net_globals.con[%d], this is a bug.\n", who);
 316     state = 0;
 317   }
 318   s = start = net_globals.con[who]->inBuf;
 319   pending = net_globals.con[who]->numPending;
 320   fd = net_globals.con[who]->fd;
 321
 322   howmany = recv(fd, start + pending, MAX_STRING_LENGTH - 1 - pending, 0);
 323   if (howmany == 0)             /* error: they've disconnected */
 324     return (-1);
 325   else if (howmany == -1) {
 326     if (errno != EWOULDBLOCK) { /* some other error */
 327       return (-1);
 328     } else if (net_globals.con[who]->processed) {       /* nothing new and nothing old */
 329       return (0);
 330     } else {                    /* nothing new, but some unprocessed old */
 331       howmany = 0;
 332     }
 333   }
 334   if (net_globals.con[who]->processed)
 335     s += pending;
 336   else
 337     howmany += pending;
 338   d = s;
 339
 340   for (; howmany-- > 0; s++) {
 341     switch (state) {
 342     case 0:                     /* Haven't skipped over any control chars or
 343                                    telnet commands */
 344       if (*s == IAC) {
 345         d = s;
 346         state = 1;
 347       } else if (*s == '\n') {
 348         *s = '\0';
 349         strcpy(com, start);
 350         if (howmany)
 351           bcopy(s + 1, start, howmany);
 352         net_globals.con[who]->state = 0;
 353         net_globals.con[who]->numPending = howmany;
 354         net_globals.con[who]->inBuf[howmany] = 0;
 355         net_globals.con[who]->processed = 0;
 356         net_globals.con[who]->outPos = 0;
 357         return (1);
 358 /*
 359  Cannot strip ^? yet otherwise timeseal probs occur
 360 */
 361       } else if (*s == '\010') { /* ^H lets delete */
 362         if (s > start)
 363           d = s-1;
 364         else
 365           d = s;
 366         state = 2;
 367       } else if ((*s > (0xff - 0x20)) || (*s < 0x20)) {
 368         d = s;
 369         state = 2;
 370       }
 371       break;
 372     case 1:                     /* got telnet IAC */
 373       if (*s == IP)
 374         return (-1);            /* ^C = logout */
 375       else if (*s == DO)
 376         state = 4;
 377       else if ((*s == WILL) || (*s == DONT) || (*s == WONT))
 378         state = 3;              /* this is cheesy, but we aren't using em */
 379       else if (*s == AYT) {
 380         send(fd, (char *) ayt, strlen((char *) ayt), 0);
 381         state = 2;
 382       } else if (*s == EL) {    /* erase line */
 383         d = start;
 384         state = 2;
 385       } else                    /* dunno what it is, so ignore it */
 386         state = 2;
 387       break;
 388     case 2:                     /* we've skipped over something, need to
 389                                    shuffle processed chars down */
 390       if (*s == IAC)
 391         state = 1;
 392       else if (*s == '\n') {
 393         *d = '\0';
 394         strcpy(com, start);
 395         if (howmany)
 396           memmove(start, s + 1, howmany);
 397         net_globals.con[who]->state = 0;
 398         net_globals.con[who]->numPending = howmany;
 399         net_globals.con[who]->inBuf[howmany] = 0;
 400         net_globals.con[who]->processed = 0;
 401         net_globals.con[who]->outPos = 0;
 402         return (1);
 403 /*
 404  Cannot strip ^? yet otherwise timeseal probs occur
 405 */
 406       } else if (*s == '\010') { /* ^H lets delete */
 407         if (d > start)
 408           d = d-1;
 409       } else if (*s >= 0x20)
 410         *(d++) = *s;
 411       break;
 412     case 3:                     /* some telnet junk we're ignoring */
 413       state = 2;
 414       break;
 415     case 4:                     /* got IAC DO */
 416       if (*s == TELOPT_TM)
 417         send(fd, (char *) will_tm, strlen((char *) will_tm), 0);
 418       else if (*s == TELOPT_SGA)
 419         send(fd, (char *) will_sga, strlen((char *) will_sga), 0);
 420       state = 2;
 421       break;
 422     }
 423   }
 424   if (state == 0)
 425     d = s;
 426   else if (state == 2)
 427     state = 0;
 428   net_globals.con[who]->state = state;
 429   net_globals.con[who]->numPending = d - start;
 430   net_globals.con[who]->inBuf[d-start] = 0;
 431   net_globals.con[who]->processed = 1;
 432   if (net_globals.con[who]->numPending == MAX_STRING_LENGTH - 1) {      /* buffer full */
 433     *d = '\0';
 434     strcpy(com, start);
 435     net_globals.con[who]->state = 0;
 436     net_globals.con[who]->numPending = 0;
 437     net_globals.con[who]->inBuf[0] = 0;
 438     net_globals.con[who]->processed = 0;
 439     return (1);
 440   }
 441   return (0);
 442 }
 443
 444 int net_init(int port)
 445 {
 446   int opt;
 447   struct sockaddr_in serv_addr;
 448   struct linger lingeropt;
 449
 450   net_globals.no_file = 0;
 451   net_globals.con = NULL;
 452
 453   /* Open a TCP socket (an Internet stream socket). */
 454   if ((net_globals.sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
 455     d_printf( "CHESSD: can't open stream socket\n");
 456     return -1;
 457   }
 458   /* Bind our local address so that the client can send to us */
 459   memset((char *) &serv_addr, 0, sizeof(serv_addr));
 460   serv_addr.sin_family = AF_INET;
 461   serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 462   serv_addr.sin_port = htons(port);
 463
 464   /** added in an attempt to allow rebinding to the port **/
 465
 466   opt = 1;
 467   setsockopt(net_globals.sockfd, SOL_SOCKET, SO_REUSEADDR, (char *) &opt, sizeof(opt));
 468   opt = 1;
 469   setsockopt(net_globals.sockfd, SOL_SOCKET, SO_KEEPALIVE, (char *) &opt, sizeof(opt));
 470   lingeropt.l_onoff = 0;
 471   lingeropt.l_linger = 0;
 472   setsockopt(net_globals.sockfd, SOL_SOCKET, SO_LINGER, (char *) &lingeropt, sizeof(lingeropt));
 473
 474 /*
 475 #ifdef DEBUG
 476   opt = 1;
 477   setsockopt(sockfd, SOL_SOCKET, SO_DEBUG, (char *)&opt, sizeof(opt));
 478 #endif
 479 */
 480
 481   if (bind(net_globals.sockfd, (struct sockaddr *) & serv_addr, sizeof(serv_addr)) < 0) {
 482     d_printf( "CHESSD: can't bind local address.  errno=%d\n", errno);
 483     return -1;
 484   }
 485   opt = 1;
 486   ioctl(net_globals.sockfd, FIONBIO, &opt);
 487   fcntl(net_globals.sockfd, F_SETFD, 1);
 488   listen(net_globals.sockfd, 5);
 489   return 0;
 490 }
 491
 492 void net_close(void)
 493 {
 494         int i;
 495         for (i = 0; i < net_globals.no_file; i++) {
 496                 if (net_globals.con[i]->status != NETSTAT_EMPTY)
 497                         net_close_connection(net_globals.con[i]->fd);
 498         }
 499 }
 500
 501 void net_close_connection(int fd)
 502 {
 503   if (net_globals.con[fd]->status == NETSTAT_CONNECTED)
 504     net_flush_connection(fd);
 505   else
 506     d_printf( "Trying to close an unconnected socket?!?!\n");
 507
 508   if (!remConnection(fd)) {
 509     if (fd > 2)
 510       if (close(fd) < 0) {
 511         d_printf( "Couldn't close socket %d - errno %d\n", fd, errno);
 512       }
 513   } else {
 514     d_printf( "Failed to remove connection (Socket %d)\n", fd);
 515   }
 516 }
 517
 518 void turn_echo_on(int fd)
 519 {
 520         const unsigned char wont_echo[] = {IAC, WONT, TELOPT_ECHO, '\0'};
 521
 522         send(fd, (char *) wont_echo, strlen((char *) wont_echo), 0);
 523 }
 524
 525 void turn_echo_off(int fd)
 526 {
 527   static unsigned char will_echo[] = {IAC, WILL, TELOPT_ECHO, '\0'};
 528
 529   send(fd, (char *) will_echo, strlen((char *) will_echo), 0);
 530 }
 531
 532 static struct in_addr net_connected_host(int fd)
 533 {
 534         int which;
 535
 536         if ((which = findConnection(fd)) < 0) {
 537                 static struct in_addr ip_zero;
 538                 d_printf( "CHESSD: FD not in connection table!\n");
 539                 return ip_zero;
 540         }
 541         return net_globals.con[which]->fromHost;
 542 }
 543
 544 void select_loop(void )
 545 {
 546         char com[MAX_STRING_LENGTH];
 547         struct sockaddr_in cli_addr;
 548         int cli_len = (int) sizeof(struct sockaddr_in);
 549         int fd, loop, nfound, lineComplete;
 550         fd_set readfds;
 551         struct timeval to;
 552         int current_socket;
 553         int timeout = 2;
 554
 555 #if 0
 556         m_check_all();
 557 #endif
 558
 559         /* we only want to get signals here. This tries to
 560            ensure a clean shutdown on 'kill' */
 561         unblock_signal(SIGTERM);
 562         block_signal(SIGTERM);
 563
 564         while ((fd = accept(net_globals.sockfd, (struct sockaddr *) & cli_addr, &cli_len)) != -1) {
 565                 if (net_addConnection(fd, cli_addr.sin_addr)) {
 566                         d_printf( "FICS is full.  fd = %d.\n", fd);
 567                         psend_raw_file(fd, MESS_DIR, MESS_FULL);
 568                         close(fd);
 569                 } else {
 570                         if (fd >= net_globals.no_file)
 571                                 d_printf("FICS (ngc2): Out of range fd!\n");
 572                         else {
 573                                 fcntl(fd, F_SETFD, 1);
 574                                 process_new_connection(fd, net_connected_host(fd));
 575                         }
 576                 }
 577         }
 578
 579         if (errno != EWOULDBLOCK)
 580                 d_printf( "CHESSD: Problem with accept().  errno=%d\n", errno);
 581
 582         net_flush_all_connections();
 583
 584         if (net_globals.numConnections == 0) {
 585                 sleep(1); /* prevent the server spinning */
 586         }
 587
 588         FD_ZERO(&readfds);
 589         for (loop = 0; loop < net_globals.no_file; loop++)
 590                 if (net_globals.con[loop]->status != NETSTAT_EMPTY)
 591                         FD_SET(net_globals.con[loop]->fd, &readfds);
 592
 593         to.tv_usec = 0;
 594         to.tv_sec = timeout;
 595         nfound = select(net_globals.no_file, &readfds, NULL, NULL, &to);
 596         for (loop = 0; loop < net_globals.no_file; loop++) {
 597                 if (net_globals.con[loop]->status != NETSTAT_EMPTY) {
 598                         fd = net_globals.con[loop]->fd;
 599                 more_commands:
 600                         lineComplete = readline2(com, fd);
 601                         if (lineComplete == 0)  /* partial line: do nothing with it */
 602                                 continue;
 603                         if (lineComplete > 0) { /* complete line: process it */
 604                                 if (!timeseal_parse(com, net_globals.con[loop])) continue;
 605                                 if (process_input(fd, com) != COM_LOGOUT) {
 606                                         net_flush_connection(fd);
 607                                         goto more_commands;
 608                                 }
 609                         }
 610                         /* Disconnect anyone who gets here */
 611                         process_disconnection(fd);
 612                         net_close_connection(fd);
 613                 }
 614         }
 615
 616         if (process_heartbeat(&current_socket) == COM_LOGOUT) {
 617                 process_disconnection(current_socket);
 618                 net_close_connection(current_socket);
 619         }
 620 }
 621