fcgi_buf.c

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