webcit/tcp_sockets.c

   1 /*
   2  * $Id$
   3  */
   4
   5 /*
   6  * Uncomment this to log all communications with the Citadel server
   7 #define SERV_TRACE 1
   8  */
   9
  10
  11 #include "webcit.h"
  12 #include "webserver.h"
  13
  14 extern int DisableGzip;
  15
  16 /*
  17  *  register the timeout
  18  *  signum signalhandler number
  19  * \return signals
  20  */
  21 RETSIGTYPE timeout(int signum)
  22 {
  23         lprintf(1, "Connection timed out; unable to reach citserver\n");
  24         /* no exit here, since we need to server the connection unreachable thing. exit(3); */
  25 }
  26
  27
  28 /*
  29  *  Connect a unix domain socket
  30  *  sockpath where to open a unix domain socket
  31  */
  32 int uds_connectsock(char *sockpath)
  33 {
  34         struct sockaddr_un addr;
  35         int s;
  36
  37         memset(&addr, 0, sizeof(addr));
  38         addr.sun_family = AF_UNIX;
  39         strncpy(addr.sun_path, sockpath, sizeof addr.sun_path);
  40
  41         s = socket(AF_UNIX, SOCK_STREAM, 0);
  42         if (s < 0) {
  43                 lprintf(1, "Can't create socket[%s]: %s\n",
  44                         sockpath,
  45                         strerror(errno));
  46                 return(-1);
  47         }
  48
  49         if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
  50                 lprintf(1, "Can't connect [%s]: %s\n",
  51                         sockpath,
  52                         strerror(errno));
  53                 close(s);
  54                 return(-1);
  55         }
  56
  57         return s;
  58 }
  59
  60
  61 /*
  62  *  Connect a TCP/IP socket
  63  *  host the host to connect to
  64  *  service the service on the host to call
  65  */
  66 int tcp_connectsock(char *host, char *service)
  67 {
  68         int fdflags;
  69         struct hostent *phe;
  70         struct servent *pse;
  71         struct protoent *ppe;
  72         struct sockaddr_in sin;
  73         int s;
  74
  75         memset(&sin, 0, sizeof(sin));
  76         sin.sin_family = AF_INET;
  77
  78         pse = getservbyname(service, "tcp");
  79         if (pse) {
  80                 sin.sin_port = pse->s_port;
  81         } else if ((sin.sin_port = htons((u_short) atoi(service))) == 0) {
  82                 lprintf(1, "Can't get %s service entry\n", service);
  83                 return (-1);
  84         }
  85         phe = gethostbyname(host);
  86         if (phe) {
  87                 memcpy(&sin.sin_addr, phe->h_addr, phe->h_length);
  88         } else if ((sin.sin_addr.s_addr = inet_addr(host)) == INADDR_NONE) {
  89                 lprintf(1, "Can't get %s host entry: %s\n",
  90                         host, strerror(errno));
  91                 return (-1);
  92         }
  93         if ((ppe = getprotobyname("tcp")) == 0) {
  94                 lprintf(1, "Can't get TCP protocol entry: %s\n",
  95                         strerror(errno));
  96                 return (-1);
  97         }
  98
  99         s = socket(PF_INET, SOCK_STREAM, ppe->p_proto);
 100         if (s < 0) {
 101                 lprintf(1, "Can't create socket: %s\n", strerror(errno));
 102                 return (-1);
 103         }
 104
 105         fdflags = fcntl(s, F_GETFL);
 106         if (fdflags < 0)
 107                 lprintf(1, "unable to get socket flags!  %s.%s: %s \n",
 108                         host, service, strerror(errno));
 109         fdflags = fdflags | O_NONBLOCK;
 110         if (fcntl(s, F_SETFD, fdflags) < 0)
 111                 lprintf(1, "unable to set socket nonblocking flags!  %s.%s: %s \n",
 112                         host, service, strerror(errno));
 113
 114         signal(SIGALRM, timeout);
 115         alarm(30);
 116
 117         if (connect(s, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
 118                 lprintf(1, "Can't connect to %s.%s: %s\n",
 119                         host, service, strerror(errno));
 120                 close(s);
 121                 return (-1);
 122         }
 123         alarm(0);
 124         signal(SIGALRM, SIG_IGN);
 125
 126         fdflags = fcntl(s, F_GETFL);
 127         if (fdflags < 0)
 128                 lprintf(1, "unable to get socket flags!  %s.%s: %s \n",
 129                         host, service, strerror(errno));
 130         fdflags = fdflags | O_NONBLOCK;
 131         if (fcntl(s, F_SETFD, fdflags) < 0)
 132                 lprintf(1, "unable to set socket nonblocking flags!  %s.%s: %s \n",
 133                         host, service, strerror(errno));
 134         return (s);
 135 }
 136
 137
 138
 139 /*
 140  *  input string from pipe
 141  */
 142 int serv_getln(char *strbuf, int bufsize)
 143 {
 144         wcsession *WCC = WC;
 145         int len;
 146
 147         *strbuf = '\0';
 148         StrBuf_ServGetln(WCC->MigrateReadLineBuf);
 149         len = StrLength(WCC->MigrateReadLineBuf);
 150         if (len > bufsize)
 151                 len = bufsize - 1;
 152         memcpy(strbuf, ChrPtr(WCC->MigrateReadLineBuf), len);
 153         FlushStrBuf(WCC->MigrateReadLineBuf);
 154         strbuf[len] = '\0';
 155 #ifdef SERV_TRACE
 156         lprintf(9, "%3d>%s\n", WC->serv_sock, strbuf);
 157 #endif
 158         return len;
 159 }
 160
 161
 162 int StrBuf_ServGetln(StrBuf *buf)
 163 {
 164         wcsession *WCC = WC;
 165         const char *ErrStr = NULL;
 166         int rc;
 167
 168         rc = StrBufTCP_read_buffered_line_fast(buf,
 169                                                WCC->ReadBuf,
 170                                                &WCC->ReadPos,
 171                                                &WCC->serv_sock,
 172                                                5, 1,
 173                                                &ErrStr);
 174         if (rc < 0)
 175         {
 176                 lprintf(1, "Server connection broken: %s\n",
 177                         ErrStr);
 178                 wc_backtrace();
 179                 WCC->serv_sock = (-1);
 180                 WCC->connected = 0;
 181                 WCC->logged_in = 0;
 182         }
 183         return rc;
 184 }
 185
 186 int StrBuf_ServGetBLOBBuffered(StrBuf *buf, long BlobSize)
 187 {
 188         wcsession *WCC = WC;
 189         const char *Err;
 190         int rc;
 191
 192         rc = StrBufReadBLOBBuffered(buf,
 193                                     WCC->ReadBuf,
 194                                     &WCC->ReadPos,
 195                                     &WCC->serv_sock,
 196                                     1,
 197                                     BlobSize,
 198                                     NNN_TERM,
 199                                     &Err);
 200         if (rc < 0)
 201         {
 202                 lprintf(1, "Server connection broken: %s\n",
 203                         Err);
 204                 wc_backtrace();
 205                 WCC->serv_sock = (-1);
 206                 WCC->connected = 0;
 207                 WCC->logged_in = 0;
 208         }
 209         return rc;
 210 }
 211
 212 int StrBuf_ServGetBLOB(StrBuf *buf, long BlobSize)
 213 {
 214         wcsession *WCC = WC;
 215         const char *Err;
 216         int rc;
 217
 218         WCC->ReadPos = NULL;
 219         rc = StrBufReadBLOB(buf, &WCC->serv_sock, 1, BlobSize, &Err);
 220         if (rc < 0)
 221         {
 222                 lprintf(1, "Server connection broken: %s\n",
 223                         Err);
 224                 wc_backtrace();
 225                 WCC->serv_sock = (-1);
 226                 WCC->connected = 0;
 227                 WCC->logged_in = 0;
 228         }
 229         return rc;
 230 }
 231
 232 /*
 233  *  send binary to server
 234  *  buf the buffer to write to citadel server
 235  *  nbytes how many bytes to send to citadel server
 236  */
 237 void serv_write(const char *buf, int nbytes)
 238 {
 239         wcsession *WCC = WC;
 240         int bytes_written = 0;
 241         int retval;
 242
 243         FlushStrBuf(WCC->ReadBuf);
 244         WCC->ReadPos = NULL;
 245         while (bytes_written < nbytes) {
 246                 retval = write(WCC->serv_sock, &buf[bytes_written],
 247                                nbytes - bytes_written);
 248                 if (retval < 1) {
 249                         lprintf(1, "Server connection broken: %s\n",
 250                                 strerror(errno));
 251                         close(WCC->serv_sock);
 252                         WCC->serv_sock = (-1);
 253                         WCC->connected = 0;
 254                         WCC->logged_in = 0;
 255                         return;
 256                 }
 257                 bytes_written = bytes_written + retval;
 258         }
 259 }
 260
 261
 262 /*
 263  *  send line to server
 264  *  string the line to send to the citadel server
 265  */
 266 void serv_puts(const char *string)
 267 {
 268         wcsession *WCC = WC;
 269 #ifdef SERV_TRACE
 270         lprintf(9, "%3d<%s\n", WC->serv_sock, string);
 271 #endif
 272         FlushStrBuf(WCC->ReadBuf);
 273         WCC->ReadPos = NULL;
 274
 275         serv_write(string, strlen(string));
 276         serv_write("\n", 1);
 277 }
 278
 279 /*
 280  *  send line to server
 281  *  string the line to send to the citadel server
 282  */
 283 void serv_putbuf(const StrBuf *string)
 284 {
 285         wcsession *WCC = WC;
 286 #ifdef SERV_TRACE
 287         lprintf(9, "%3d<%s\n", WC->serv_sock, ChrPtr(string));
 288 #endif
 289         FlushStrBuf(WCC->ReadBuf);
 290         WCC->ReadPos = NULL;
 291
 292         serv_write(ChrPtr(string), StrLength(string));
 293         serv_write("\n", 1);
 294 }
 295
 296
 297 /*
 298  *  convenience function to send stuff to the server
 299  *  format the formatstring
 300  *  ... the entities to insert into format
 301  */
 302 void serv_printf(const char *format,...)
 303 {
 304         wcsession *WCC = WC;
 305         va_list arg_ptr;
 306         char buf[SIZ];
 307         size_t len;
 308
 309         FlushStrBuf(WCC->ReadBuf);
 310         WCC->ReadPos = NULL;
 311
 312         va_start(arg_ptr, format);
 313         vsnprintf(buf, sizeof buf, format, arg_ptr);
 314         va_end(arg_ptr);
 315
 316         len = strlen(buf);
 317         buf[len++] = '\n';
 318         buf[len] = '\0';
 319         serv_write(buf, len);
 320 #ifdef SERV_TRACE
 321         lprintf(9, "<%s", buf);
 322 #endif
 323 }
 324
 325
 326
 327
 328 int ClientGetLine(ParsedHttpHdrs *Hdr, StrBuf *Target)
 329 {
 330         const char *Error, *pch, *pchs;
 331         int rlen, len, retval = 0;
 332
 333 #ifdef HAVE_OPENSSL
 334         if (is_https) {
 335                 int ntries = 0;
 336                 if (StrLength(Hdr->ReadBuf) > 0) {
 337                         pchs = ChrPtr(Hdr->ReadBuf);
 338                         pch = strchr(pchs, '\n');
 339                         if (pch != NULL) {
 340                                 rlen = 0;
 341                                 len = pch - pchs;
 342                                 if (len > 0 && (*(pch - 1) == '\r') )
 343                                         rlen ++;
 344                                 StrBufSub(Target, Hdr->ReadBuf, 0, len - rlen);
 345                                 StrBufCutLeft(Hdr->ReadBuf, len + 1);
 346                                 return len - rlen;
 347                         }
 348                 }
 349
 350                 while (retval == 0) {
 351                                 pch = NULL;
 352                                 pchs = ChrPtr(Hdr->ReadBuf);
 353                                 if (*pchs != '\0')
 354                                         pch = strchr(pchs, '\n');
 355                                 if (pch == NULL) {
 356                                         retval = client_read_sslbuffer(Hdr->ReadBuf, SLEEPING);
 357                                         pchs = ChrPtr(Hdr->ReadBuf);
 358                                         pch = strchr(pchs, '\n');
 359                                 }
 360                                 if (retval == 0) {
 361                                         sleeeeeeeeeep(1);
 362                                         ntries ++;
 363                                 }
 364                                 if (ntries > 10)
 365                                         return 0;
 366                 }
 367                 if ((retval > 0) && (pch != NULL)) {
 368                         rlen = 0;
 369                         len = pch - pchs;
 370                         if (len > 0 && (*(pch - 1) == '\r') )
 371                                 rlen ++;
 372                         StrBufSub(Target, Hdr->ReadBuf, 0, len - rlen);
 373                         StrBufCutLeft(Hdr->ReadBuf, len + 1);
 374                         return len - rlen;
 375
 376                 }
 377                 else
 378                         return -1;
 379         }
 380         else
 381 #endif
 382                 return StrBufTCP_read_buffered_line_fast(Target,
 383                                                          Hdr->ReadBuf,
 384                                                          &Hdr->Pos,
 385                                                          &Hdr->http_sock,
 386                                                          5,
 387                                                          1,
 388                                                          &Error);
 389 }
 390
 391 /*
 392  * This is a generic function to set up a master socket for listening on
 393  * a TCP port.  The server shuts down if the bind fails.
 394  *
 395  * ip_addr      IP address to bind
 396  * port_number  port number to bind
 397  * queue_len    number of incoming connections to allow in the queue
 398  */
 399 int ig_tcp_server(char *ip_addr, int port_number, int queue_len)
 400 {
 401         struct sockaddr_in sin;
 402         int s, i;
 403
 404         memset(&sin, 0, sizeof(sin));
 405         sin.sin_family = AF_INET;
 406         if (ip_addr == NULL) {
 407                 sin.sin_addr.s_addr = INADDR_ANY;
 408         } else {
 409                 sin.sin_addr.s_addr = inet_addr(ip_addr);
 410         }
 411
 412         if (sin.sin_addr.s_addr == INADDR_NONE) {
 413                 sin.sin_addr.s_addr = INADDR_ANY;
 414         }
 415
 416         if (port_number == 0) {
 417                 lprintf(1, "Cannot start: no port number specified.\n");
 418                 exit(WC_EXIT_BIND);
 419         }
 420         sin.sin_port = htons((u_short) port_number);
 421
 422         s = socket(PF_INET, SOCK_STREAM, (getprotobyname("tcp")->p_proto));
 423         if (s < 0) {
 424                 lprintf(1, "Can't create a socket: %s\n", strerror(errno));
 425                 exit(WC_EXIT_BIND);
 426         }
 427         /* Set some socket options that make sense. */
 428         i = 1;
 429         setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));
 430
 431         #ifndef __APPLE__
 432         fcntl(s, F_SETFL, O_NONBLOCK); /* maide: this statement is incorrect
 433                                           there should be a preceding F_GETFL
 434                                           and a bitwise OR with the previous
 435                                           fd flags */
 436         #endif
 437
 438         if (bind(s, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
 439                 lprintf(1, "Can't bind: %s\n", strerror(errno));
 440                 exit(WC_EXIT_BIND);
 441         }
 442         if (listen(s, queue_len) < 0) {
 443                 lprintf(1, "Can't listen: %s\n", strerror(errno));
 444                 exit(WC_EXIT_BIND);
 445         }
 446         return (s);
 447 }
 448
 449
 450
 451 /*
 452  * Create a Unix domain socket and listen on it
 453  * sockpath - file name of the unix domain socket
 454  * queue_len - Number of incoming connections to allow in the queue
 455  */
 456 int ig_uds_server(char *sockpath, int queue_len)
 457 {
 458         struct sockaddr_un addr;
 459         int s;
 460         int i;
 461         int actual_queue_len;
 462
 463         actual_queue_len = queue_len;
 464         if (actual_queue_len < 5) actual_queue_len = 5;
 465
 466         i = unlink(sockpath);
 467         if ((i != 0) && (errno != ENOENT)) {
 468                 lprintf(1, "webcit: can't unlink %s: %s\n",
 469                         sockpath, strerror(errno));
 470                 exit(WC_EXIT_BIND);
 471         }
 472
 473         memset(&addr, 0, sizeof(addr));
 474         addr.sun_family = AF_UNIX;
 475         safestrncpy(addr.sun_path, sockpath, sizeof addr.sun_path);
 476
 477         s = socket(AF_UNIX, SOCK_STREAM, 0);
 478         if (s < 0) {
 479                 lprintf(1, "webcit: Can't create a socket: %s\n",
 480                         strerror(errno));
 481                 exit(WC_EXIT_BIND);
 482         }
 483
 484         if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 485                 lprintf(1, "webcit: Can't bind: %s\n",
 486                         strerror(errno));
 487                 exit(WC_EXIT_BIND);
 488         }
 489
 490         if (listen(s, actual_queue_len) < 0) {
 491                 lprintf(1, "webcit: Can't listen: %s\n",
 492                         strerror(errno));
 493                 exit(WC_EXIT_BIND);
 494         }
 495
 496         chmod(sockpath, 0777);
 497         return(s);
 498 }
 499
 500
 501
 502
 503 /*
 504  * Read data from the client socket.
 505  *
 506  * sock         socket fd to read from
 507  * buf          buffer to read into
 508  * bytes        number of bytes to read
 509  * timeout      Number of seconds to wait before timing out
 510  *
 511  * Possible return values:
 512  *      1       Requested number of bytes has been read.
 513  *      0       Request timed out.
 514  *      -1      Connection is broken, or other error.
 515  */
 516 int client_read_to(ParsedHttpHdrs *Hdr, StrBuf *Target, int bytes, int timeout)
 517 {
 518         const char *Error;
 519         int retval = 0;
 520
 521 #ifdef HAVE_OPENSSL
 522         if (is_https) {
 523                 long bufremain = StrLength(Hdr->ReadBuf) - (Hdr->Pos - ChrPtr(Hdr->ReadBuf));
 524                 StrBufAppendBufPlain(Target, Hdr->Pos, bufremain, 0);
 525                 Hdr->Pos = NULL;
 526                 FlushStrBuf(Hdr->ReadBuf);
 527
 528                 while ((StrLength(Hdr->ReadBuf) + StrLength(Target) < bytes) &&
 529                        (retval >= 0))
 530                         retval = client_read_sslbuffer(Hdr->ReadBuf, timeout);
 531                 if (retval >= 0) {
 532                         StrBufAppendBuf(Target, Hdr->ReadBuf, 0); /* todo: Buf > bytes? */
 533 #ifdef HTTP_TRACING
 534                         write(2, "\033[32m", 5);
 535                         write(2, buf, bytes);
 536                         write(2, "\033[30m", 5);
 537 #endif
 538                         return 1;
 539                 }
 540                 else {
 541                         lprintf(2, "client_read_ssl() failed\n");
 542                         return -1;
 543                 }
 544         }
 545 #endif
 546
 547         retval = StrBufReadBLOBBuffered(Target,
 548                                         Hdr->ReadBuf,
 549                                         &Hdr->Pos,
 550                                         &Hdr->http_sock,
 551                                         1,
 552                                         bytes,
 553                                         O_TERM,
 554                                         &Error);
 555         if (retval < 0) {
 556                 lprintf(2, "client_read() failed: %s\n",
 557                         Error);
 558                 return retval;
 559         }
 560
 561 #ifdef HTTP_TRACING
 562         write(2, "\033[32m", 5);
 563         write(2, buf, bytes);
 564         write(2, "\033[30m", 5);
 565 #endif
 566         return 1;
 567 }
 568
 569
 570 /*
 571  * Begin buffering HTTP output so we can transmit it all in one write operation later.
 572  */
 573 void begin_burst(void)
 574 {
 575         if (WC->WBuf == NULL) {
 576                 WC->WBuf = NewStrBufPlain(NULL, 32768);
 577         }
 578 }
 579
 580
 581 /*
 582  * Finish buffering HTTP output.  [Compress using zlib and] output with a Content-Length: header.
 583  */
 584 long end_burst(void)
 585 {
 586         wcsession *WCC = WC;
 587         const char *ptr, *eptr;
 588         long count;
 589         ssize_t res;
 590         fd_set wset;
 591         int fdflags;
 592
 593         if (!DisableGzip && (WCC->Hdr->HR.gzip_ok) && CompressBuffer(WCC->WBuf))
 594         {
 595                 hprintf("Content-encoding: gzip\r\n");
 596         }
 597
 598         hprintf("Content-length: %d\r\n\r\n", StrLength(WCC->WBuf));
 599
 600         ptr = ChrPtr(WCC->HBuf);
 601         count = StrLength(WCC->HBuf);
 602         eptr = ptr + count;
 603
 604 #ifdef HAVE_OPENSSL
 605         if (is_https) {
 606                 client_write_ssl(WCC->HBuf);
 607                 client_write_ssl(WCC->WBuf);
 608                 return (count);
 609         }
 610 #endif
 611
 612
 613 #ifdef HTTP_TRACING
 614
 615         write(2, "\033[34m", 5);
 616         write(2, ptr, StrLength(WCC->WBuf));
 617         write(2, "\033[30m", 5);
 618 #endif
 619         fdflags = fcntl(WC->Hdr->http_sock, F_GETFL);
 620
 621         while (ptr < eptr) {
 622                 if ((fdflags & O_NONBLOCK) == O_NONBLOCK) {
 623                         FD_ZERO(&wset);
 624                         FD_SET(WCC->Hdr->http_sock, &wset);
 625                         if (select(WCC->Hdr->http_sock + 1, NULL, &wset, NULL, NULL) == -1) {
 626                                 lprintf(2, "client_write: Socket select failed (%s)\n", strerror(errno));
 627                                 return -1;
 628                         }
 629                 }
 630
 631                 if ((res = write(WCC->Hdr->http_sock,
 632                                  ptr,
 633                                  count)) == -1) {
 634                         lprintf(2, "client_write: Socket write failed (%s)\n", strerror(errno));
 635                         wc_backtrace();
 636                         return res;
 637                 }
 638                 count -= res;
 639                 ptr += res;
 640         }
 641
 642         ptr = ChrPtr(WCC->WBuf);
 643         count = StrLength(WCC->WBuf);
 644         eptr = ptr + count;
 645
 646 #ifdef HTTP_TRACING
 647
 648         write(2, "\033[34m", 5);
 649         write(2, ptr, StrLength(WCC->WBuf));
 650         write(2, "\033[30m", 5);
 651 #endif
 652
 653         while (ptr < eptr) {
 654                 if ((fdflags & O_NONBLOCK) == O_NONBLOCK) {
 655                         FD_ZERO(&wset);
 656                         FD_SET(WCC->Hdr->http_sock, &wset);
 657                         if (select(WCC->Hdr->http_sock + 1, NULL, &wset, NULL, NULL) == -1) {
 658                                 lprintf(2, "client_write: Socket select failed (%s)\n", strerror(errno));
 659                                 return -1;
 660                         }
 661                 }
 662
 663                 if ((res = write(WCC->Hdr->http_sock,
 664                                  ptr,
 665                                  count)) == -1) {
 666                         lprintf(2, "client_write: Socket write failed (%s)\n", strerror(errno));
 667                         wc_backtrace();
 668                         return res;
 669                 }
 670                 count -= res;
 671                 ptr += res;
 672         }
 673
 674         return StrLength(WCC->WBuf);
 675 }
 676
 677
 678 /*
 679  * lingering_close() a`la Apache. see
 680  * http://www.apache.org/docs/misc/fin_wait_2.html for rationale
 681  */
 682 int lingering_close(int fd)
 683 {
 684         char buf[SIZ];
 685         int i;
 686         fd_set set;
 687         struct timeval tv, start;
 688
 689         gettimeofday(&start, NULL);
 690         shutdown(fd, 1);
 691         do {
 692                 do {
 693                         gettimeofday(&tv, NULL);
 694                         tv.tv_sec = SLEEPING - (tv.tv_sec - start.tv_sec);
 695                         tv.tv_usec = start.tv_usec - tv.tv_usec;
 696                         if (tv.tv_usec < 0) {
 697                                 tv.tv_sec--;
 698                                 tv.tv_usec += 1000000;
 699                         }
 700                         FD_ZERO(&set);
 701                         FD_SET(fd, &set);
 702                         i = select(fd + 1, &set, NULL, NULL, &tv);
 703                 } while (i == -1 && errno == EINTR);
 704
 705                 if (i <= 0)
 706                         break;
 707
 708                 i = read(fd, buf, sizeof buf);
 709         } while (i != 0 && (i != -1 || errno == EINTR));
 710
 711         return close(fd);
 712 }
 713
 714
 715 void
 716 SessionNewModule_TCPSOCKETS
 717 (wcsession *sess)
 718 {
 719         sess->CLineBuf = NewStrBuf();
 720         sess->MigrateReadLineBuf = NewStrBuf();
 721 }
 722
 723 void
 724 SessionDestroyModule_TCPSOCKETS
 725 (wcsession *sess)
 726 {
 727         FreeStrBuf(&sess->CLineBuf);
 728         FreeStrBuf(&sess->ReadBuf);
 729         FreeStrBuf(&sess->MigrateReadLineBuf);
 730         if (sess->serv_sock > 0)
 731                 close(sess->serv_sock);
 732 }