fcgi_buf.c

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