fcgi_buf.c

   1 /*
   2  * $Id: fcgi_buf.c,v 1.14 2002/03/04 22:20:57 robs Exp $
   3  */
   4
   5 #include "fcgi.h"
   6
   7 #ifdef WIN32
   8 #pragma warning( disable : 4127 )
   9 #endif
  10
  11 /*******************************************************************************
  12  * Check buffer consistency with assertions.
  13  */
  14 void fcgi_buf_check(Buffer *buf)
  15 {
  16     ap_assert(buf->size > 0);
  17     ap_assert(buf->length >= 0);
  18     ap_assert(buf->length <= buf->size);
  19
  20     ap_assert(buf->begin >= buf->data);
  21     ap_assert(buf->begin < buf->data + buf->size);
  22     ap_assert(buf->end >= buf->data);
  23     ap_assert(buf->end < buf->data + buf->size);
  24
  25     ap_assert(((buf->end - buf->begin + buf->size) % buf->size)
  26             == (buf->length % buf->size));
  27 }
  28
  29 /*******************************************************************************
  30  * Reset buffer, losing any data that's in it.
  31  */
  32 void fcgi_buf_reset(Buffer *buf)
  33 {
  34     buf->length = 0;
  35     buf->begin = buf->end = buf->data;
  36 }
  37
  38 /*******************************************************************************
  39  * Allocate and intialize a new buffer of the specified size.
  40  */
  41 Buffer *fcgi_buf_new(pool *p, int size)
  42 {
  43     Buffer *buf;
  44
  45     buf = (Buffer *)ap_pcalloc(p, sizeof(Buffer) + size);
  46     buf->size = size;
  47     fcgi_buf_reset(buf);
  48     return buf;
  49 }
  50
  51 #ifdef WIN32
  52
  53 static int fd_read(SOCKET fd, char *buf, int len)
  54 {
  55     DWORD bytes_read;
  56
  57     ap_assert(len);
  58
  59     // HACK - we don't know if its a pipe or socket..
  60     if (ReadFile((HANDLE) fd, buf, len, &bytes_read, NULL))
  61     {
  62         return (int) bytes_read;
  63     }
  64     else
  65     {
  66         int rv = GetLastError();
  67
  68         if (rv == ERROR_PIPE_NOT_CONNECTED)
  69         {
  70             return 0;
  71         }
  72         else if (rv == ERROR_INVALID_PARAMETER)
  73         {
  74             // Then it must be a real socket
  75
  76             WSASetLastError(ERROR_SUCCESS);
  77
  78             rv = recv(fd, buf, len, 0);
  79             if (rv == SOCKET_ERROR)
  80             {
  81                 errno = WSAGetLastError();
  82                 return -1;
  83             }
  84
  85             return rv;
  86         }
  87         else
  88         {
  89             errno = rv;
  90             return -1;
  91         }
  92     }
  93 }
  94
  95 #else
  96
  97 static int fd_read(int fd, char * buf, int len)
  98 {
  99     int bytes_read;
 100
 101     ap_assert(len);
 102
 103     do {
 104         bytes_read = read(fd, buf, len);
 105     } while (bytes_read == -1 && errno == EINTR);
 106     return bytes_read;
 107 }
 108
 109 #endif
 110
 111 /*******************************************************************************
 112  * Read from an open file descriptor into buffer.
 113  *
 114  * The caller should disable the default Apache SIGPIPE handler,
 115  * otherwise a bad script could cause the request to abort and appear
 116  * as though the client's fd caused it.
 117  *
 118  * Results:
 119  *      <0 error, errno is set
 120  *      =0 EOF reached
 121  *      >0 successful read or no room in buffer (NOT # of bytes read)
 122  */
 123 #ifdef WIN32
 124 int fcgi_buf_add_fd(Buffer *buf, SOCKET fd)
 125 #else
 126 int fcgi_buf_add_fd(Buffer *buf, int fd)
 127 #endif
 128 {
 129     int len;
 130
 131     fcgi_buf_check(buf);
 132
 133     if (buf->length == buf->size)
 134         /* there's no room in the buffer, return "success" */
 135         return 1;
 136
 137     if (buf->length == 0)
 138         /* the buffer is empty so defrag */
 139         buf->begin = buf->end = buf->data;
 140
 141     len = min(buf->size - buf->length, buf->data + buf->size - buf->end);
 142
 143 #ifndef NO_WRITEV
 144     /* assume there is a readv() if there is a writev() */
 145     if (len == buf->size - buf->length) {
 146         /* its not wrapped, use read() instead of readv() */
 147 #endif
 148
 149     len = fd_read(fd, buf->end, len);
 150
 151     if (len <= 0)
 152         return len;
 153
 154     buf->end += len;
 155     buf->length += len;
 156
 157     if (buf->end == (buf->data + buf->size)) {
 158         /* the buffer needs to be wrapped */
 159         buf->end = buf->data;
 160 #ifndef NO_WRITEV
 161     }
 162     } else {
 163         /* the buffer is wrapped, use readv() */
 164         struct iovec vec[2];
 165
 166         vec[0].iov_base = buf->end;
 167         vec[0].iov_len = len;
 168         vec[1].iov_base = buf->data;
 169         vec[1].iov_len = buf->size - buf->length - len;
 170
 171         ap_assert(len);
 172         ap_assert(vec[1].iov_len);
 173
 174         do
 175         len = readv(fd, vec, 2);
 176         while (len == -1 && errno == EINTR);
 177
 178         if (len <= 0)
 179             return len;
 180
 181         buf->end += len;
 182         if (buf->end >= (buf->data + buf->size))
 183             buf->end -= buf->size;
 184
 185         buf->length += len;
 186     }
 187
 188 #else
 189         if (buf->length < buf->size) {
 190             /* There's still more buffer space to read into. */
 191
 192             fd_set  read_set;
 193             int     status;
 194             int     numFDs = fd + 1;
 195             struct timeval timeOut;
 196
 197             FD_ZERO(&read_set);
 198             FD_SET(fd, &read_set);
 199
 200             timeOut.tv_sec = 0;
 201             timeOut.tv_usec = 0;
 202
 203             status = ap_select(numFDs, &read_set, NULL, NULL, &timeOut);
 204
 205             if (status < 0) {
 206 #ifdef WIN32
 207                 // More hackery
 208                 if (WSAGetLastError() == WSAENOTSOCK)
 209                 {
 210                     DWORD bytesavail=0;
 211                     if (PeekNamedPipe((HANDLE) fd, NULL, 0, NULL, &bytesavail, NULL))
 212                     {
 213                         if (bytesavail > 0)
 214                         {
 215                             len = fd_read(fd, buf->end, buf->size - buf->length);
 216
 217                             if (len <= 0)
 218                                 return len;
 219
 220                             buf->end += len;
 221                             buf->length += len;
 222                         }
 223                         return len;
 224                     }
 225                 }
 226 #endif
 227                 return status;  /* error, errno is set */
 228             }
 229
 230             if (status > 0 && FD_ISSET(fd, &read_set)) {
 231
 232                 len = fd_read(fd, buf->end, buf->size - buf->length);
 233
 234                 if (len <= 0)
 235                     return len;
 236
 237                 buf->end += len;
 238                 buf->length += len;
 239             }
 240         }
 241     }
 242 #endif
 243
 244     return len;     /* this may not contain the number of bytes read */
 245 }
 246
 247 #ifdef WIN32
 248
 249 static int fd_write(SOCKET fd, char * buf, int len)
 250 {
 251     DWORD bytes_sent;
 252
 253     // HACK - We don't know if its a pipe or socket..
 254     if (WriteFile((HANDLE) fd, buf, len, &bytes_sent, NULL))
 255     {
 256         return (int) bytes_sent;
 257     }
 258     else
 259     {
 260         int rv = GetLastError();
 261
 262         if (rv == ERROR_INVALID_PARAMETER)
 263         {
 264             // Then it must be a real socket..
 265
 266             SetLastError(ERROR_SUCCESS);
 267
 268             rv = send(fd, buf, len, 0);
 269
 270             if (rv == SOCKET_ERROR)
 271             {
 272                 rv = WSAGetLastError();
 273                 if (rv == WSAEWOULDBLOCK)
 274                 {
 275                     return 0;;
 276                 }
 277                 else
 278                 {
 279                     errno = rv;
 280                     return -1;
 281                 }
 282             }
 283
 284             return rv;
 285         }
 286         else if (rv == WSAEWOULDBLOCK)
 287         {
 288             return 0;
 289         }
 290         else
 291         {
 292             errno = rv;
 293             return -1;
 294         }
 295     }
 296 }
 297
 298 #else
 299
 300 static int fd_write(int fd, char * buf, int len)
 301 {
 302     int bytes_sent;
 303
 304     do {
 305         bytes_sent = write(fd, buf, len);
 306
 307 #ifdef EWOULDBLOCK
 308         if (bytes_sent == -1 && errno == EWOULDBLOCK) {
 309             bytes_sent = 0;
 310         }
 311 #endif
 312     } while (bytes_sent == -1 && errno == EINTR);
 313
 314     return bytes_sent;
 315 }
 316
 317 #endif
 318
 319 /*******************************************************************************
 320  * Write from the buffer to an open file descriptor.
 321  *
 322  * The caller should disable the default Apache SIGPIPE handler,
 323  * otherwise a bad script could cause the request to abort appearing
 324  * as though the client's fd caused it.
 325  *
 326  * Results:
 327  *      <0 if an error occured (bytes may or may not have been written)
 328  *      =0 if no bytes were written
 329  *      >0 successful write
 330  */
 331 #ifdef WIN32
 332 int fcgi_buf_get_to_fd(Buffer *buf, SOCKET fd)
 333 #else
 334 int fcgi_buf_get_to_fd(Buffer *buf, int fd)
 335 #endif
 336 {
 337     int len;
 338
 339     fcgi_buf_check(buf);
 340
 341     if (buf->length == 0)
 342         return 0;
 343
 344     len = min(buf->length, buf->data + buf->size - buf->begin);
 345
 346 #ifndef NO_WRITEV
 347     if (len == buf->length) {
 348         /* the buffer is not wrapped, we don't need to use writev() */
 349 #endif
 350
 351     len = fd_write(fd, buf->begin, len);
 352
 353     if (len <= 0)
 354         goto Return;
 355
 356     buf->begin += len;
 357     buf->length -= len;
 358
 359     if (buf->begin == buf->data + buf->size) {
 360         /* the buffer needs to be wrapped */
 361         buf->begin = buf->data;
 362
 363 #ifndef NO_WRITEV
 364     }
 365     } else {
 366         /* the buffer is wrapped, use writev() */
 367         struct iovec vec[2];
 368
 369         vec[0].iov_base = buf->begin;
 370         vec[0].iov_len = len;
 371         vec[1].iov_base = buf->data;
 372         vec[1].iov_len = buf->length - len;
 373
 374         do
 375         len = writev(fd, vec, 2);
 376         while (len == -1 && errno == EINTR);
 377
 378         if (len <= 0)
 379             goto Return;
 380
 381         buf->begin += len;
 382         buf->length -= len;
 383
 384         if (buf->begin >= buf->data + buf->size)
 385             buf->begin -= buf->size;
 386     }
 387 #else
 388         if (buf->length > 0) {
 389             /* there's still more data to write */
 390
 391             fd_set  write_set;
 392             int     status;
 393             int     numFDs = fd + 1;
 394             struct timeval timeOut;
 395
 396             FD_ZERO(&write_set);
 397             FD_SET(fd, &write_set);
 398
 399             timeOut.tv_sec = 0;
 400             timeOut.tv_usec = 0;
 401
 402             status = ap_select(numFDs, NULL, &write_set, NULL, &timeOut);
 403
 404             if (status < 0) {
 405                 len = status;  /* error, errno is set */
 406                 goto Return;
 407             }
 408
 409             if (status > 0 && FD_ISSET(fd, &write_set)) {
 410                 int len2;
 411
 412                 len2 = fd_write(fd, buf->begin, buf->length);
 413
 414                 if (len2 < 0) {
 415                     len = len2;
 416                     goto Return;
 417                 }
 418
 419                 if (len2 > 0) {
 420                     buf->begin += len2;
 421                     buf->length -= len2;
 422                     len += len2;
 423                 }
 424             }
 425         }
 426     }
 427 #endif
 428
 429 Return:
 430     if (buf->length == 0)
 431         buf->begin = buf->end = buf->data;
 432
 433     return len;
 434 }
 435
 436 /*******************************************************************************
 437  * Return the data block start address and the length of the block.
 438  */
 439 void fcgi_buf_get_block_info(Buffer *buf, char **beginPtr, int *countPtr)
 440 {
 441     fcgi_buf_check(buf);
 442
 443     *beginPtr = buf->begin;
 444     *countPtr = min(buf->length, buf->data + buf->size - buf->begin);
 445 }
 446
 447 /*******************************************************************************
 448  * Throw away bytes from buffer.
 449  */
 450 void fcgi_buf_toss(Buffer *buf, int count)
 451 {
 452     fcgi_buf_check(buf);
 453     ap_assert(count >= 0);
 454     ap_assert(count <= buf->length);
 455
 456     buf->length -= count;
 457     buf->begin += count;
 458     if(buf->begin >= buf->data + buf->size) {
 459         buf->begin -= buf->size;
 460     }
 461 }
 462
 463 /*******************************************************************************
 464  * Return the free data block start address and the length of the block.
 465  */
 466 void fcgi_buf_get_free_block_info(Buffer *buf, char **endPtr, int *countPtr)
 467 {
 468     fcgi_buf_check(buf);
 469
 470     *endPtr = buf->end;
 471     *countPtr = min(buf->size - buf->length,
 472                     buf->data + buf->size - buf->end);
 473 }
 474
 475 /*******************************************************************************
 476  * Updates the buf to reflect recently added data.
 477  */
 478 void fcgi_buf_add_update(Buffer *buf, int count)
 479 {
 480     fcgi_buf_check(buf);
 481     ap_assert(count >= 0);
 482     ap_assert(count <= BufferFree(buf));
 483
 484     buf->length += count;
 485     buf->end += count;
 486     if(buf->end >= buf->data + buf->size) {
 487         buf->end -= buf->size;
 488     }
 489
 490     fcgi_buf_check(buf);
 491 }
 492
 493 /*******************************************************************************
 494  * Adds a block of data to a buffer, returning the number of bytes added.
 495  */
 496 int fcgi_buf_add_block(Buffer *buf, char *data, int datalen)
 497 {
 498     char *end;
 499     int copied = 0;     /* Number of bytes actually copied. */
 500     int canCopy;        /* Number of bytes to copy in a given op. */
 501
 502     ap_assert(data != NULL);
 503     ap_assert(datalen >= 0);
 504
 505     if(datalen == 0) {
 506         return 0;
 507     }
 508
 509     ap_assert(datalen > 0);
 510     fcgi_buf_check(buf);
 511     end = buf->data + buf->size;
 512
 513     /*
 514      * Copy the first part of the data:  from here to the end of the
 515      * buffer, or the end of the data, whichever comes first.
 516      */
 517     datalen = min(BufferFree(buf), datalen);
 518     canCopy = min(datalen, end - buf->end);
 519     memcpy(buf->end, data, canCopy);
 520     buf->length += canCopy;
 521     buf->end += canCopy;
 522     copied += canCopy;
 523     if (buf->end >= end) {
 524         buf->end = buf->data;
 525     }
 526     datalen -= canCopy;
 527
 528     /*
 529      * If there's more to go, copy the second part starting from the
 530      * beginning of the buffer.
 531      */
 532     if (datalen > 0) {
 533         data += canCopy;
 534         memcpy(buf->end, data, datalen);
 535         buf->length += datalen;
 536         buf->end += datalen;
 537         copied += datalen;
 538     }
 539     return(copied);
 540 }
 541
 542 /*******************************************************************************
 543  * Add a string to a buffer, returning the number of bytes added.
 544  */
 545 int fcgi_buf_add_string(Buffer *buf, char *str)
 546 {
 547     return fcgi_buf_add_block(buf, str, strlen(str));
 548 }
 549
 550 /*******************************************************************************
 551  * Gets a data block from a buffer, returning the number of bytes copied.
 552  */
 553 int fcgi_buf_get_to_block(Buffer *buf, char *data, int datalen)
 554 {
 555     char *end;
 556     int copied = 0;                /* Number of bytes actually copied. */
 557     int canCopy;                   /* Number of bytes to copy in a given op. */
 558
 559     ap_assert(data != NULL);
 560     ap_assert(datalen > 0);
 561     fcgi_buf_check(buf);
 562
 563     end = buf->data + buf->size;
 564
 565     /*
 566      * Copy the first part out of the buffer: from here to the end
 567      * of the buffer, or all of the requested data.
 568      */
 569     canCopy = min(buf->length, datalen);
 570     canCopy = min(canCopy, end - buf->begin);
 571
 572     memcpy(data, buf->begin, canCopy);
 573
 574     buf->length -= canCopy;
 575     buf->begin += canCopy;
 576     copied += canCopy;
 577     if (buf->begin >= end) {
 578         buf->begin = buf->data;
 579     }
 580
 581     /*
 582      * If there's more to go, copy the second part starting from the
 583      * beginning of the buffer.
 584      */
 585     if (copied < datalen && buf->length > 0) {
 586         data += copied;
 587         canCopy = min(buf->length, datalen - copied);
 588
 589         memcpy(data, buf->begin, canCopy);
 590
 591         buf->length -= canCopy;
 592         buf->begin += canCopy;
 593         copied += canCopy;
 594     }
 595
 596     fcgi_buf_check(buf);
 597     return(copied);
 598 }
 599
 600 /*******************************************************************************
 601  * Move 'len' bytes from 'src' buffer to 'dest' buffer.  There must be at
 602  * least 'len' bytes available in the source buffer and space for 'len'
 603  * bytes in the destination buffer.
 604  */
 605 void fcgi_buf_get_to_buf(Buffer *dest, Buffer *src, int len)
 606 {
 607     char *dest_end, *src_begin;
 608     int dest_len, src_len, move_len;
 609
 610     ap_assert(len > 0);
 611     ap_assert(BufferLength(src) >= len);
 612     ap_assert(BufferFree(dest) >= len);
 613
 614     fcgi_buf_check(src);
 615     fcgi_buf_check(dest);
 616
 617     for (;;) {
 618         if (len == 0)
 619             return;
 620
 621         fcgi_buf_get_free_block_info(dest, &dest_end, &dest_len);
 622         fcgi_buf_get_block_info(src, &src_begin, &src_len);
 623
 624         move_len = min(dest_len, src_len);
 625         move_len = min(move_len, len);
 626
 627         if (move_len == 0)
 628             return;
 629
 630         memcpy(dest_end, src_begin, move_len);
 631         fcgi_buf_toss(src, move_len);
 632         fcgi_buf_add_update(dest, move_len);
 633         len -= move_len;
 634     }
 635 }
 636
 637 static void array_grow(array_header *arr, int n)
 638 {
 639     if (n <= 0)
 640         return;
 641
 642     if (arr->nelts + n > arr->nalloc) {
 643         char *new_elts;
 644         int new_nalloc = (arr->nalloc <= 0) ? n : arr->nelts + n;
 645
 646         new_elts = ap_pcalloc(arr->pool, arr->elt_size * new_nalloc);
 647         memcpy(new_elts, arr->elts, arr->nelts * arr->elt_size);
 648
 649         arr->elts = new_elts;
 650         arr->nalloc = new_nalloc;
 651     }
 652 }
 653
 654 static void array_cat_block(array_header *arr, void *block, int n)
 655 {
 656     array_grow(arr, n);
 657     memcpy(arr->elts + arr->nelts * arr->elt_size, block, n * arr->elt_size);
 658     arr->nelts += n;
 659 }
 660
 661 /*----------------------------------------------------------------------
 662  * Append "len" bytes from "buf" into "arr".  Apache arrays are used
 663  * whenever the data being handled is binary (may contain null chars).
 664  */
 665 void fcgi_buf_get_to_array(Buffer *buf, array_header *arr, int len)
 666 {
 667     int len1 = min(buf->length, buf->data + buf->size - buf->begin);
 668
 669     fcgi_buf_check(buf);
 670     ap_assert(len > 0);
 671     ap_assert(len <= BufferLength(buf));
 672
 673     array_grow(arr, len);
 674
 675     len1 = min(len1, len);
 676     array_cat_block(arr, buf->begin, len1);
 677
 678     if (len1 < len)
 679         array_cat_block(arr, buf->data, len - len1);
 680
 681     fcgi_buf_toss(buf, len);
 682 }