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 protoent *p;
 402         struct sockaddr_in sin;
 403         int s, i;
 404
 405         memset(&sin, 0, sizeof(sin));
 406         sin.sin_family = AF_INET;
 407         if (ip_addr == NULL) {
 408                 sin.sin_addr.s_addr = INADDR_ANY;
 409         } else {
 410                 sin.sin_addr.s_addr = inet_addr(ip_addr);
 411         }
 412
 413         if (sin.sin_addr.s_addr == INADDR_NONE) {
 414                 sin.sin_addr.s_addr = INADDR_ANY;
 415         }
 416
 417         if (port_number == 0) {
 418                 lprintf(1, "Cannot start: no port number specified.\n");
 419                 exit(WC_EXIT_BIND);
 420         }
 421         sin.sin_port = htons((u_short) port_number);
 422
 423         p = getprotobyname("tcp");
 424
 425         s = socket(PF_INET, SOCK_STREAM, (p->p_proto));
 426         if (s < 0) {
 427                 lprintf(1, "Can't create a socket: %s\n", strerror(errno));
 428                 exit(WC_EXIT_BIND);
 429         }
 430         /* Set some socket options that make sense. */
 431         i = 1;
 432         setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));
 433
 434         #ifndef __APPLE__
 435         fcntl(s, F_SETFL, O_NONBLOCK); /* maide: this statement is incorrect
 436                                           there should be a preceding F_GETFL
 437                                           and a bitwise OR with the previous
 438                                           fd flags */
 439         #endif
 440
 441         if (bind(s, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
 442                 lprintf(1, "Can't bind: %s\n", strerror(errno));
 443                 exit(WC_EXIT_BIND);
 444         }
 445         if (listen(s, queue_len) < 0) {
 446                 lprintf(1, "Can't listen: %s\n", strerror(errno));
 447                 exit(WC_EXIT_BIND);
 448         }
 449         return (s);
 450 }
 451
 452
 453
 454 /*
 455  * Create a Unix domain socket and listen on it
 456  * sockpath - file name of the unix domain socket
 457  * queue_len - Number of incoming connections to allow in the queue
 458  */
 459 int ig_uds_server(char *sockpath, int queue_len)
 460 {
 461         struct sockaddr_un addr;
 462         int s;
 463         int i;
 464         int actual_queue_len;
 465
 466         actual_queue_len = queue_len;
 467         if (actual_queue_len < 5) actual_queue_len = 5;
 468
 469         i = unlink(sockpath);
 470         if ((i != 0) && (errno != ENOENT)) {
 471                 lprintf(1, "webcit: can't unlink %s: %s\n",
 472                         sockpath, strerror(errno));
 473                 exit(WC_EXIT_BIND);
 474         }
 475
 476         memset(&addr, 0, sizeof(addr));
 477         addr.sun_family = AF_UNIX;
 478         safestrncpy(addr.sun_path, sockpath, sizeof addr.sun_path);
 479
 480         s = socket(AF_UNIX, SOCK_STREAM, 0);
 481         if (s < 0) {
 482                 lprintf(1, "webcit: Can't create a socket: %s\n",
 483                         strerror(errno));
 484                 exit(WC_EXIT_BIND);
 485         }
 486
 487         if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 488                 lprintf(1, "webcit: Can't bind: %s\n",
 489                         strerror(errno));
 490                 exit(WC_EXIT_BIND);
 491         }
 492
 493         if (listen(s, actual_queue_len) < 0) {
 494                 lprintf(1, "webcit: Can't listen: %s\n",
 495                         strerror(errno));
 496                 exit(WC_EXIT_BIND);
 497         }
 498
 499         chmod(sockpath, 0777);
 500         return(s);
 501 }
 502
 503
 504
 505
 506 /*
 507  * Read data from the client socket.
 508  *
 509  * sock         socket fd to read from
 510  * buf          buffer to read into
 511  * bytes        number of bytes to read
 512  * timeout      Number of seconds to wait before timing out
 513  *
 514  * Possible return values:
 515  *      1       Requested number of bytes has been read.
 516  *      0       Request timed out.
 517  *      -1      Connection is broken, or other error.
 518  */
 519 int client_read_to(ParsedHttpHdrs *Hdr, StrBuf *Target, int bytes, int timeout)
 520 {
 521         const char *Error;
 522         int retval = 0;
 523
 524 #ifdef HAVE_OPENSSL
 525         if (is_https) {
 526                 long bufremain;
 527
 528                 if (Hdr->Pos == NULL)
 529                         Hdr->Pos = ChrPtr(Hdr->ReadBuf);
 530                 bufremain = StrLength(Hdr->ReadBuf) - (Hdr->Pos - ChrPtr(Hdr->ReadBuf));
 531
 532                 if (bytes < bufremain)
 533                         bufremain = bytes;
 534                 StrBufAppendBufPlain(Target, Hdr->Pos, bufremain, 0);
 535                 StrBufCutLeft(Hdr->ReadBuf, bufremain);
 536
 537                 if (bytes > bufremain)
 538                 {
 539                         while ((StrLength(Hdr->ReadBuf) + StrLength(Target) < bytes) &&
 540                                (retval >= 0))
 541                                 retval = client_read_sslbuffer(Hdr->ReadBuf, timeout);
 542                         if (retval >= 0) {
 543                                 StrBufAppendBuf(Target, Hdr->ReadBuf, 0); /* todo: Buf > bytes? */
 544 #ifdef HTTP_TRACING
 545                                 write(2, "\033[32m", 5);
 546                                 write(2, buf, bytes);
 547                                 write(2, "\033[30m", 5);
 548 #endif
 549                                 return 1;
 550                         }
 551                         else {
 552                                 lprintf(2, "client_read_ssl() failed\n");
 553                                 return -1;
 554                         }
 555                 }
 556                 else
 557                         return 1;
 558         }
 559 #endif
 560
 561         retval = StrBufReadBLOBBuffered(Target,
 562                                         Hdr->ReadBuf,
 563                                         &Hdr->Pos,
 564                                         &Hdr->http_sock,
 565                                         1,
 566                                         bytes,
 567                                         O_TERM,
 568                                         &Error);
 569         if (retval < 0) {
 570                 lprintf(2, "client_read() failed: %s\n",
 571                         Error);
 572                 return retval;
 573         }
 574
 575 #ifdef HTTP_TRACING
 576         write(2, "\033[32m", 5);
 577         write(2, buf, bytes);
 578         write(2, "\033[30m", 5);
 579 #endif
 580         return 1;
 581 }
 582
 583
 584 /*
 585  * Begin buffering HTTP output so we can transmit it all in one write operation later.
 586  */
 587 void begin_burst(void)
 588 {
 589         if (WC->WBuf == NULL) {
 590                 WC->WBuf = NewStrBufPlain(NULL, 32768);
 591         }
 592 }
 593
 594
 595 /*
 596  * Finish buffering HTTP output.  [Compress using zlib and] output with a Content-Length: header.
 597  */
 598 long end_burst(void)
 599 {
 600         wcsession *WCC = WC;
 601         const char *ptr, *eptr;
 602         long count;
 603         ssize_t res;
 604         fd_set wset;
 605         int fdflags;
 606
 607         if (!DisableGzip && (WCC->Hdr->HR.gzip_ok) && CompressBuffer(WCC->WBuf))
 608         {
 609                 hprintf("Content-encoding: gzip\r\n");
 610         }
 611
 612         if (WCC->Hdr->HR.prohibit_caching)
 613                 hprintf("Pragma: no-cache\r\nCache-Control: no-store\r\nExpires:-1\r\n");
 614         hprintf("Content-length: %d\r\n\r\n", StrLength(WCC->WBuf));
 615
 616         ptr = ChrPtr(WCC->HBuf);
 617         count = StrLength(WCC->HBuf);
 618         eptr = ptr + count;
 619
 620 #ifdef HAVE_OPENSSL
 621         if (is_https) {
 622                 client_write_ssl(WCC->HBuf);
 623                 client_write_ssl(WCC->WBuf);
 624                 return (count);
 625         }
 626 #endif
 627
 628
 629 #ifdef HTTP_TRACING
 630
 631         write(2, "\033[34m", 5);
 632         write(2, ptr, StrLength(WCC->WBuf));
 633         write(2, "\033[30m", 5);
 634 #endif
 635         fdflags = fcntl(WC->Hdr->http_sock, F_GETFL);
 636
 637         while (ptr < eptr) {
 638                 if ((fdflags & O_NONBLOCK) == O_NONBLOCK) {
 639                         FD_ZERO(&wset);
 640                         FD_SET(WCC->Hdr->http_sock, &wset);
 641                         if (select(WCC->Hdr->http_sock + 1, NULL, &wset, NULL, NULL) == -1) {
 642                                 lprintf(2, "client_write: Socket select failed (%s)\n", strerror(errno));
 643                                 return -1;
 644                         }
 645                 }
 646
 647                 if ((res = write(WCC->Hdr->http_sock,
 648                                  ptr,
 649                                  count)) == -1) {
 650                         lprintf(2, "client_write: Socket write failed (%s)\n", strerror(errno));
 651                         wc_backtrace();
 652                         return res;
 653                 }
 654                 count -= res;
 655                 ptr += res;
 656         }
 657
 658         ptr = ChrPtr(WCC->WBuf);
 659         count = StrLength(WCC->WBuf);
 660         eptr = ptr + count;
 661
 662 #ifdef HTTP_TRACING
 663
 664         write(2, "\033[34m", 5);
 665         write(2, ptr, StrLength(WCC->WBuf));
 666         write(2, "\033[30m", 5);
 667 #endif
 668
 669         while (ptr < eptr) {
 670                 if ((fdflags & O_NONBLOCK) == O_NONBLOCK) {
 671                         FD_ZERO(&wset);
 672                         FD_SET(WCC->Hdr->http_sock, &wset);
 673                         if (select(WCC->Hdr->http_sock + 1, NULL, &wset, NULL, NULL) == -1) {
 674                                 lprintf(2, "client_write: Socket select failed (%s)\n", strerror(errno));
 675                                 return -1;
 676                         }
 677                 }
 678
 679                 if ((res = write(WCC->Hdr->http_sock,
 680                                  ptr,
 681                                  count)) == -1) {
 682                         lprintf(2, "client_write: Socket write failed (%s)\n", strerror(errno));
 683                         wc_backtrace();
 684                         return res;
 685                 }
 686                 count -= res;
 687                 ptr += res;
 688         }
 689
 690         return StrLength(WCC->WBuf);
 691 }
 692
 693
 694 /*
 695  * lingering_close() a`la Apache. see
 696  * http://www.apache.org/docs/misc/fin_wait_2.html for rationale
 697  */
 698 int lingering_close(int fd)
 699 {
 700         char buf[SIZ];
 701         int i;
 702         fd_set set;
 703         struct timeval tv, start;
 704
 705         gettimeofday(&start, NULL);
 706         shutdown(fd, 1);
 707         do {
 708                 do {
 709                         gettimeofday(&tv, NULL);
 710                         tv.tv_sec = SLEEPING - (tv.tv_sec - start.tv_sec);
 711                         tv.tv_usec = start.tv_usec - tv.tv_usec;
 712                         if (tv.tv_usec < 0) {
 713                                 tv.tv_sec--;
 714                                 tv.tv_usec += 1000000;
 715                         }
 716                         FD_ZERO(&set);
 717                         FD_SET(fd, &set);
 718                         i = select(fd + 1, &set, NULL, NULL, &tv);
 719                 } while (i == -1 && errno == EINTR);
 720
 721                 if (i <= 0)
 722                         break;
 723
 724                 i = read(fd, buf, sizeof buf);
 725         } while (i != 0 && (i != -1 || errno == EINTR));
 726
 727         return close(fd);
 728 }
 729
 730 void
 731 HttpNewModule_TCPSOCKETS
 732 (ParsedHttpHdrs *httpreq)
 733 {
 734
 735         httpreq->ReadBuf = NewStrBufPlain(NULL, SIZ * 4);
 736 }
 737
 738 void
 739 HttpDetachModule_TCPSOCKETS
 740 (ParsedHttpHdrs *httpreq)
 741 {
 742
 743         FlushStrBuf(httpreq->ReadBuf);
 744         ReAdjustEmptyBuf(httpreq->ReadBuf, 4 * SIZ, SIZ);
 745 }
 746
 747 void
 748 HttpDestroyModule_TCPSOCKETS
 749 (ParsedHttpHdrs *httpreq)
 750 {
 751
 752         FreeStrBuf(&httpreq->ReadBuf);
 753 }
 754
 755
 756 void
 757 SessionNewModule_TCPSOCKETS
 758 (wcsession *sess)
 759 {
 760         sess->CLineBuf = NewStrBuf();
 761         sess->MigrateReadLineBuf = NewStrBuf();
 762 }
 763
 764 void
 765 SessionDestroyModule_TCPSOCKETS
 766 (wcsession *sess)
 767 {
 768         FreeStrBuf(&sess->CLineBuf);
 769         FreeStrBuf(&sess->ReadBuf);
 770         FreeStrBuf(&sess->MigrateReadLineBuf);
 771         if (sess->serv_sock > 0)
 772                 close(sess->serv_sock);
 773 }