fcgi_buf.c

   1 /*
   2  * $Id: fcgi_buf.c,v 1.16 2002/10/22 01:02:18 robs Exp $
   3  */
   4
   5 #include "fcgi.h"
   6
   7 #ifdef WIN32
   8 #pragma warning( disable : 4127 )
   9 #else
  10 #ifdef APACHE2
  11 #include <unistd.h>
  12 #endif
  13 #endif
  14
  15 /*******************************************************************************
  16  * Check buffer consistency with assertions.
  17  */
  18 void fcgi_buf_check(Buffer *buf)
  19 {
  20     ap_assert(buf->size > 0);
  21     ap_assert(buf->length >= 0);
  22     ap_assert(buf->length <= buf->size);
  23
  24     ap_assert(buf->begin >= buf->data);
  25     ap_assert(buf->begin < buf->data + buf->size);
  26     ap_assert(buf->end >= buf->data);
  27     ap_assert(buf->end < buf->data + buf->size);
  28
  29     ap_assert(((buf->end - buf->begin + buf->size) % buf->size)
  30             == (buf->length % buf->size));
  31 }
  32
  33 /*******************************************************************************
  34  * Reset buffer, losing any data that's in it.
  35  */
  36 void fcgi_buf_reset(Buffer *buf)
  37 {
  38     buf->length = 0;
  39     buf->begin = buf->end = buf->data;
  40 }
  41
  42 /*******************************************************************************
  43  * Allocate and intialize a new buffer of the specified size.
  44  */
  45 Buffer *fcgi_buf_new(pool *p, int size)
  46 {
  47     Buffer *buf;
  48
  49     buf = (Buffer *)ap_pcalloc(p, sizeof(Buffer) + size);
  50     buf->size = size;
  51     fcgi_buf_reset(buf);
  52     return buf;
  53 }
  54
  55 void fcgi_buf_removed(Buffer * const b, unsigned int len)
  56 {
  57     b->length -= len;
  58     b->begin += len;
  59
  60     if (b->length == 0)
  61     {
  62         b->begin = b->end = b->data;
  63     }
  64     else if (b->begin >= b->data + b->size)
  65     {
  66         b->begin -= b->size;
  67     }
  68 }
  69
  70 void fcgi_buf_added(Buffer * const b, const unsigned int len)
  71 {
  72     b->length += len;
  73     b->end += len;
  74
  75     if (b->end >= b->data + b->size)
  76     {
  77         b->end -= b->size;
  78     }
  79 }
  80
  81 #ifdef WIN32
  82
  83 static int socket_recv(SOCKET fd, char *buf, int len)
  84 {
  85     int bytes_read = recv(fd, buf, len, 0);
  86
  87     if (bytes_read == SOCKET_ERROR)
  88     {
  89         return -1;
  90     }
  91     return bytes_read;
  92 }
  93
  94 static int socket_send(SOCKET fd, char * buf, int len)
  95 {
  96     int bytes_sent = send(fd, buf, len, 0);
  97
  98     if (bytes_sent == SOCKET_ERROR)
  99     {
 100         return -1;
 101     }
 102     return bytes_sent;
 103 }
 104
 105 #else /* !WIN32 */
 106
 107 static int socket_recv(int fd, char * buf, int len)
 108 {
 109     int bytes_read;
 110
 111     do {
 112         bytes_read = read(fd, buf, len);
 113
 114         if (bytes_read < 0)
 115         {
 116 #ifdef EWOULDBLOCK
 117             ap_assert(errno != EWOULDBLOCK);
 118 #endif
 119 #ifdef EAGAIN
 120             ap_assert(errno != EAGAIN);
 121 #endif
 122         }
 123     } while (bytes_read == -1 && errno == EINTR);
 124
 125     return bytes_read;
 126 }
 127
 128 static int socket_send(int fd, char * buf, int len)
 129 {
 130     int bytes_sent;
 131
 132     do {
 133         bytes_sent = write(fd, buf, len);
 134
 135         if (bytes_sent < 0)
 136         {
 137 #ifdef EWOULDBLOCK
 138             ap_assert(errno != EWOULDBLOCK);
 139 #endif
 140 #ifdef EAGAIN
 141             ap_assert(errno != EAGAIN);
 142 #endif
 143         }
 144     }
 145     while (bytes_sent == -1 && errno == EINTR);
 146
 147     return bytes_sent;
 148 }
 149
 150 #endif /* !WIN32 */
 151
 152 /*******************************************************************************
 153  * Read from an open file descriptor into buffer.
 154  *
 155  * The caller should disable the default Apache SIGPIPE handler,
 156  * otherwise a bad script could cause the request to abort and appear
 157  * as though the client's fd caused it.
 158  *
 159  * Results:
 160  *      <0 error, errno is set
 161  *      =0 EOF reached
 162  *      >0 successful read or no room in buffer (NOT # of bytes read)
 163  */
 164 int fcgi_buf_socket_recv(Buffer *buf, SOCKET fd)
 165 {
 166     int len;
 167
 168     fcgi_buf_check(buf);
 169
 170     if (buf->length == buf->size)
 171         /* there's no room in the buffer, return "success" */
 172         return 1;
 173
 174     if (buf->length == 0)
 175         /* the buffer is empty so defrag */
 176         buf->begin = buf->end = buf->data;
 177
 178     len = min(buf->size - buf->length, buf->data + buf->size - buf->end);
 179
 180 #ifndef NO_WRITEV
 181
 182     /* assume there is a readv() since there is a writev() */
 183     if (len == buf->size - buf->length)
 184     {
 185 #endif
 186
 187         len = socket_recv(fd, buf->end, len);
 188
 189 #ifndef NO_WRITEV
 190     }
 191     else
 192     {
 193         /* the buffer is wrapped, use readv() */
 194         struct iovec vec[2];
 195
 196         vec[0].iov_base = buf->end;
 197         vec[0].iov_len = len;
 198         vec[1].iov_base = buf->data;
 199         vec[1].iov_len = buf->size - buf->length - len;
 200
 201         ap_assert(len);
 202         ap_assert(vec[1].iov_len);
 203
 204         do
 205         {
 206             len = readv(fd, vec, 2);
 207         }
 208         while (len == -1 && errno == EINTR);
 209     }
 210 #endif
 211
 212     if (len <= 0) return len;
 213
 214     fcgi_buf_added(buf, len);
 215
 216     return len;     /* this may not contain the number of bytes read */
 217 }
 218
 219
 220 /*******************************************************************************
 221  * Write from the buffer to an open file descriptor.
 222  *
 223  * The caller should disable the default Apache SIGPIPE handler,
 224  * otherwise a bad script could cause the request to abort appearing
 225  * as though the client's fd caused it.
 226  *
 227  * Results:
 228  *      <0 if an error occured (bytes may or may not have been written)
 229  *      =0 if no bytes were written
 230  *      >0 successful write
 231  */
 232 int fcgi_buf_socket_send(Buffer *buf, SOCKET fd)
 233 {
 234     int len;
 235
 236     fcgi_buf_check(buf);
 237
 238     if (buf->length == 0)
 239         return 0;
 240
 241     len = min(buf->length, buf->data + buf->size - buf->begin);
 242
 243 #ifndef NO_WRITEV
 244     if (len == buf->length)
 245     {
 246 #endif
 247
 248         len = socket_send(fd, buf->begin, len);
 249
 250 #ifndef NO_WRITEV
 251     }
 252     else
 253     {
 254         struct iovec vec[2];
 255
 256         vec[0].iov_base = buf->begin;
 257         vec[0].iov_len = len;
 258         vec[1].iov_base = buf->data;
 259         vec[1].iov_len = buf->length - len;
 260
 261         do
 262         {
 263             len = writev(fd, vec, 2);
 264         }
 265         while (len == -1 && errno == EINTR);
 266     }
 267 #endif
 268
 269     if (len <= 0) return len;
 270
 271     fcgi_buf_removed(buf, len);
 272
 273     return len;
 274 }
 275
 276 /*******************************************************************************
 277  * Return the data block start address and the length of the block.
 278  */
 279 void fcgi_buf_get_block_info(Buffer *buf, char **beginPtr, int *countPtr)
 280 {
 281     fcgi_buf_check(buf);
 282
 283     *beginPtr = buf->begin;
 284     *countPtr = min(buf->length, buf->data + buf->size - buf->begin);
 285 }
 286
 287 /*******************************************************************************
 288  * Throw away bytes from buffer.
 289  */
 290 void fcgi_buf_toss(Buffer *buf, int count)
 291 {
 292     fcgi_buf_check(buf);
 293     ap_assert(count >= 0);
 294     ap_assert(count <= buf->length);
 295
 296     buf->length -= count;
 297     buf->begin += count;
 298     if(buf->begin >= buf->data + buf->size) {
 299         buf->begin -= buf->size;
 300     }
 301 }
 302
 303 /*******************************************************************************
 304  * Return the free data block start address and the length of the block.
 305  */
 306 void fcgi_buf_get_free_block_info(Buffer *buf, char **endPtr, int *countPtr)
 307 {
 308     fcgi_buf_check(buf);
 309
 310     *endPtr = buf->end;
 311     *countPtr = min(buf->size - buf->length,
 312                     buf->data + buf->size - buf->end);
 313 }
 314
 315 /*******************************************************************************
 316  * Updates the buf to reflect recently added data.
 317  */
 318 void fcgi_buf_add_update(Buffer *buf, int count)
 319 {
 320     fcgi_buf_check(buf);
 321     ap_assert(count >= 0);
 322     ap_assert(count <= BufferFree(buf));
 323
 324     buf->length += count;
 325     buf->end += count;
 326     if(buf->end >= buf->data + buf->size) {
 327         buf->end -= buf->size;
 328     }
 329
 330     fcgi_buf_check(buf);
 331 }
 332
 333 /*******************************************************************************
 334  * Adds a block of data to a buffer, returning the number of bytes added.
 335  */
 336 int fcgi_buf_add_block(Buffer *buf, char *data, int datalen)
 337 {
 338     char *end;
 339     int copied = 0;     /* Number of bytes actually copied. */
 340     int canCopy;        /* Number of bytes to copy in a given op. */
 341
 342     ap_assert(data != NULL);
 343     ap_assert(datalen >= 0);
 344
 345     if(datalen == 0) {
 346         return 0;
 347     }
 348
 349     ap_assert(datalen > 0);
 350     fcgi_buf_check(buf);
 351     end = buf->data + buf->size;
 352
 353     /*
 354      * Copy the first part of the data:  from here to the end of the
 355      * buffer, or the end of the data, whichever comes first.
 356      */
 357     datalen = min(BufferFree(buf), datalen);
 358     canCopy = min(datalen, end - buf->end);
 359     memcpy(buf->end, data, canCopy);
 360     buf->length += canCopy;
 361     buf->end += canCopy;
 362     copied += canCopy;
 363     if (buf->end >= end) {
 364         buf->end = buf->data;
 365     }
 366     datalen -= canCopy;
 367
 368     /*
 369      * If there's more to go, copy the second part starting from the
 370      * beginning of the buffer.
 371      */
 372     if (datalen > 0) {
 373         data += canCopy;
 374         memcpy(buf->end, data, datalen);
 375         buf->length += datalen;
 376         buf->end += datalen;
 377         copied += datalen;
 378     }
 379     return(copied);
 380 }
 381
 382 /*******************************************************************************
 383  * Add a string to a buffer, returning the number of bytes added.
 384  */
 385 int fcgi_buf_add_string(Buffer *buf, char *str)
 386 {
 387     return fcgi_buf_add_block(buf, str, strlen(str));
 388 }
 389
 390 /*******************************************************************************
 391  * Gets a data block from a buffer, returning the number of bytes copied.
 392  */
 393 int fcgi_buf_get_to_block(Buffer *buf, char *data, int datalen)
 394 {
 395     char *end;
 396     int copied = 0;                /* Number of bytes actually copied. */
 397     int canCopy;                   /* Number of bytes to copy in a given op. */
 398
 399     ap_assert(data != NULL);
 400     ap_assert(datalen > 0);
 401     fcgi_buf_check(buf);
 402
 403     end = buf->data + buf->size;
 404
 405     /*
 406      * Copy the first part out of the buffer: from here to the end
 407      * of the buffer, or all of the requested data.
 408      */
 409     canCopy = min(buf->length, datalen);
 410     canCopy = min(canCopy, end - buf->begin);
 411
 412     memcpy(data, buf->begin, canCopy);
 413
 414     buf->length -= canCopy;
 415     buf->begin += canCopy;
 416     copied += canCopy;
 417     if (buf->begin >= end) {
 418         buf->begin = buf->data;
 419     }
 420
 421     /*
 422      * If there's more to go, copy the second part starting from the
 423      * beginning of the buffer.
 424      */
 425     if (copied < datalen && buf->length > 0) {
 426         data += copied;
 427         canCopy = min(buf->length, datalen - copied);
 428
 429         memcpy(data, buf->begin, canCopy);
 430
 431         buf->length -= canCopy;
 432         buf->begin += canCopy;
 433         copied += canCopy;
 434     }
 435
 436     fcgi_buf_check(buf);
 437     return(copied);
 438 }
 439
 440 /*******************************************************************************
 441  * Move 'len' bytes from 'src' buffer to 'dest' buffer.  There must be at
 442  * least 'len' bytes available in the source buffer and space for 'len'
 443  * bytes in the destination buffer.
 444  */
 445 void fcgi_buf_get_to_buf(Buffer *dest, Buffer *src, int len)
 446 {
 447     char *dest_end, *src_begin;
 448     int dest_len, src_len, move_len;
 449
 450     ap_assert(len > 0);
 451     ap_assert(BufferLength(src) >= len);
 452     ap_assert(BufferFree(dest) >= len);
 453
 454     fcgi_buf_check(src);
 455     fcgi_buf_check(dest);
 456
 457     for (;;) {
 458         if (len == 0)
 459             return;
 460
 461         fcgi_buf_get_free_block_info(dest, &dest_end, &dest_len);
 462         fcgi_buf_get_block_info(src, &src_begin, &src_len);
 463
 464         move_len = min(dest_len, src_len);
 465         move_len = min(move_len, len);
 466
 467         if (move_len == 0)
 468             return;
 469
 470         memcpy(dest_end, src_begin, move_len);
 471         fcgi_buf_toss(src, move_len);
 472         fcgi_buf_add_update(dest, move_len);
 473         len -= move_len;
 474     }
 475 }
 476
 477 static void array_grow(array_header *arr, int n)
 478 {
 479     if (n <= 0)
 480         return;
 481
 482     if (arr->nelts + n > arr->nalloc) {
 483         char *new_elts;
 484         int new_nalloc = (arr->nalloc <= 0) ? n : arr->nelts + n;
 485
 486         new_elts = ap_pcalloc(arr->pool, arr->elt_size * new_nalloc);
 487         memcpy(new_elts, arr->elts, arr->nelts * arr->elt_size);
 488
 489         arr->elts = new_elts;
 490         arr->nalloc = new_nalloc;
 491     }
 492 }
 493
 494 static void array_cat_block(array_header *arr, void *block, int n)
 495 {
 496     array_grow(arr, n);
 497     memcpy(arr->elts + arr->nelts * arr->elt_size, block, n * arr->elt_size);
 498     arr->nelts += n;
 499 }
 500
 501 /*----------------------------------------------------------------------
 502  * Append "len" bytes from "buf" into "arr".  Apache arrays are used
 503  * whenever the data being handled is binary (may contain null chars).
 504  */
 505 void fcgi_buf_get_to_array(Buffer *buf, array_header *arr, int len)
 506 {
 507     int len1 = min(buf->length, buf->data + buf->size - buf->begin);
 508
 509     fcgi_buf_check(buf);
 510     ap_assert(len > 0);
 511     ap_assert(len <= BufferLength(buf));
 512
 513     array_grow(arr, len);
 514
 515     len1 = min(len1, len);
 516     array_cat_block(arr, buf->begin, len1);
 517
 518     if (len1 < len)
 519         array_cat_block(arr, buf->data, len - len1);
 520
 521     fcgi_buf_toss(buf, len);
 522 }