1/* Licensed to the Apache Software Foundation (ASF) under one or more 2 * contributor license agreements. See the NOTICE file distributed with 3 * this work for additional information regarding copyright ownership. 4 * The ASF licenses this file to You under the Apache License, Version 2.0 5 * (the "License"); you may not use this file except in compliance with 6 * the License. You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16/** 17 * @file apr_buckets.h 18 * @brief APR-UTIL Buckets/Bucket Brigades 19 */ 20 21#ifndef APR_BUCKETS_H 22#define APR_BUCKETS_H 23 24#if defined(APR_BUCKET_DEBUG) && !defined(APR_RING_DEBUG) 25#define APR_RING_DEBUG 26#endif 27 28#include "apu.h" 29#include "apr_network_io.h" 30#include "apr_file_io.h" 31#include "apr_general.h" 32#include "apr_mmap.h" 33#include "apr_errno.h" 34#include "apr_ring.h" 35#include "apr.h" 36#if APR_HAVE_SYS_UIO_H 37#include <sys/uio.h> /* for struct iovec */ 38#endif 39#if APR_HAVE_STDARG_H 40#include <stdarg.h> 41#endif 42 43#ifdef __cplusplus 44extern "C" { 45#endif 46 47/** 48 * @defgroup APR_Util_Bucket_Brigades Bucket Brigades 49 * @ingroup APR_Util 50 * @{ 51 */ 52 53/** default bucket buffer size - 8KB minus room for memory allocator headers */ 54#define APR_BUCKET_BUFF_SIZE 8000 55 56/** Determines how a bucket or brigade should be read */ 57typedef enum { 58 APR_BLOCK_READ, /**< block until data becomes available */ 59 APR_NONBLOCK_READ /**< return immediately if no data is available */ 60} apr_read_type_e; 61 62/** 63 * The one-sentence buzzword-laden overview: Bucket brigades represent 64 * a complex data stream that can be passed through a layered IO 65 * system without unnecessary copying. A longer overview follows... 66 * 67 * A bucket brigade is a doubly linked list (ring) of buckets, so we 68 * aren't limited to inserting at the front and removing at the end. 69 * Buckets are only passed around as members of a brigade, although 70 * singleton buckets can occur for short periods of time. 71 * 72 * Buckets are data stores of various types. They can refer to data in 73 * memory, or part of a file or mmap area, or the output of a process, 74 * etc. Buckets also have some type-dependent accessor functions: 75 * read, split, copy, setaside, and destroy. 76 * 77 * read returns the address and size of the data in the bucket. If the 78 * data isn't in memory then it is read in and the bucket changes type 79 * so that it can refer to the new location of the data. If all the 80 * data doesn't fit in the bucket then a new bucket is inserted into 81 * the brigade to hold the rest of it. 82 * 83 * split divides the data in a bucket into two regions. After a split 84 * the original bucket refers to the first part of the data and a new 85 * bucket inserted into the brigade after the original bucket refers 86 * to the second part of the data. Reference counts are maintained as 87 * necessary. 88 * 89 * setaside ensures that the data in the bucket has a long enough 90 * lifetime. Sometimes it is convenient to create a bucket referring 91 * to data on the stack in the expectation that it will be consumed 92 * (output to the network) before the stack is unwound. If that 93 * expectation turns out not to be valid, the setaside function is 94 * called to move the data somewhere safer. 95 * 96 * copy makes a duplicate of the bucket structure as long as it's 97 * possible to have multiple references to a single copy of the 98 * data itself. Not all bucket types can be copied. 99 * 100 * destroy maintains the reference counts on the resources used by a 101 * bucket and frees them if necessary. 102 * 103 * Note: all of the above functions have wrapper macros (apr_bucket_read(), 104 * apr_bucket_destroy(), etc), and those macros should be used rather 105 * than using the function pointers directly. 106 * 107 * To write a bucket brigade, they are first made into an iovec, so that we 108 * don't write too little data at one time. Currently we ignore compacting the 109 * buckets into as few buckets as possible, but if we really want good 110 * performance, then we need to compact the buckets before we convert to an 111 * iovec, or possibly while we are converting to an iovec. 112 */ 113 114/* 115 * Forward declaration of the main types. 116 */ 117 118/** @see apr_bucket_brigade */ 119typedef struct apr_bucket_brigade apr_bucket_brigade; 120/** @see apr_bucket */ 121typedef struct apr_bucket apr_bucket; 122/** @see apr_bucket_alloc_t */ 123typedef struct apr_bucket_alloc_t apr_bucket_alloc_t; 124 125/** @see apr_bucket_type_t */ 126typedef struct apr_bucket_type_t apr_bucket_type_t; 127 128/** 129 * Basic bucket type 130 */ 131struct apr_bucket_type_t { 132 /** 133 * The name of the bucket type 134 */ 135 const char *name; 136 /** 137 * The number of functions this bucket understands. Can not be less than 138 * five. 139 */ 140 int num_func; 141 /** 142 * Whether the bucket contains metadata (ie, information that 143 * describes the regular contents of the brigade). The metadata 144 * is not returned by apr_bucket_read() and is not indicated by 145 * the ->length of the apr_bucket itself. In other words, an 146 * empty bucket is safe to arbitrarily remove if and only if it 147 * contains no metadata. In this sense, "data" is just raw bytes 148 * that are the "content" of the brigade and "metadata" describes 149 * that data but is not a proper part of it. 150 */ 151 enum { 152 /** This bucket type represents actual data to send to the client. */ 153 APR_BUCKET_DATA = 0, 154 /** This bucket type represents metadata. */ 155 APR_BUCKET_METADATA = 1 156 } is_metadata; 157 /** 158 * Free the private data and any resources used by the bucket (if they 159 * aren't shared with another bucket). This function is required to be 160 * implemented for all bucket types, though it might be a no-op on some 161 * of them (namely ones that never allocate any private data structures). 162 * @param data The private data pointer from the bucket to be destroyed 163 */ 164 void (*destroy)(void *data); 165 166 /** 167 * Read the data from the bucket. This is required to be implemented 168 * for all bucket types. 169 * @param b The bucket to read from 170 * @param str A place to store the data read. Allocation should only be 171 * done if absolutely necessary. 172 * @param len The amount of data read. 173 * @param block Should this read function block if there is more data that 174 * cannot be read immediately. 175 */ 176 apr_status_t (*read)(apr_bucket *b, const char **str, apr_size_t *len, 177 apr_read_type_e block); 178 179 /** 180 * Make it possible to set aside the data for at least as long as the 181 * given pool. Buckets containing data that could potentially die before 182 * this pool (e.g. the data resides on the stack, in a child pool of 183 * the given pool, or in a disjoint pool) must somehow copy, shift, or 184 * transform the data to have the proper lifetime. 185 * @param e The bucket to convert 186 * @remark Some bucket types contain data that will always outlive the 187 * bucket itself. For example no data (EOS and FLUSH), or the data 188 * resides in global, constant memory (IMMORTAL), or the data is on 189 * the heap (HEAP). For these buckets, apr_bucket_setaside_noop can 190 * be used. 191 */ 192 apr_status_t (*setaside)(apr_bucket *e, apr_pool_t *pool); 193 194 /** 195 * Split one bucket in two at the specified position by duplicating 196 * the bucket structure (not the data) and modifying any necessary 197 * start/end/offset information. If it's not possible to do this 198 * for the bucket type (perhaps the length of the data is indeterminate, 199 * as with pipe and socket buckets), then APR_ENOTIMPL is returned. 200 * @param e The bucket to split 201 * @param point The offset of the first byte in the new bucket 202 */ 203 apr_status_t (*split)(apr_bucket *e, apr_size_t point); 204 205 /** 206 * Copy the bucket structure (not the data), assuming that this is 207 * possible for the bucket type. If it's not, APR_ENOTIMPL is returned. 208 * @param e The bucket to copy 209 * @param c Returns a pointer to the new bucket 210 */ 211 apr_status_t (*copy)(apr_bucket *e, apr_bucket **c); 212 213}; 214 215/** 216 * apr_bucket structures are allocated on the malloc() heap and 217 * their lifetime is controlled by the parent apr_bucket_brigade 218 * structure. Buckets can move from one brigade to another e.g. by 219 * calling APR_BRIGADE_CONCAT(). In general the data in a bucket has 220 * the same lifetime as the bucket and is freed when the bucket is 221 * destroyed; if the data is shared by more than one bucket (e.g. 222 * after a split) the data is freed when the last bucket goes away. 223 */ 224struct apr_bucket { 225 /** Links to the rest of the brigade */ 226 APR_RING_ENTRY(apr_bucket) link; 227 /** The type of bucket. */ 228 const apr_bucket_type_t *type; 229 /** The length of the data in the bucket. This could have been implemented 230 * with a function, but this is an optimization, because the most 231 * common thing to do will be to get the length. If the length is unknown, 232 * the value of this field will be (apr_size_t)(-1). 233 */ 234 apr_size_t length; 235 /** The start of the data in the bucket relative to the private base 236 * pointer. The vast majority of bucket types allow a fixed block of 237 * data to be referenced by multiple buckets, each bucket pointing to 238 * a different segment of the data. That segment starts at base+start 239 * and ends at base+start+length. 240 * If the length == (apr_size_t)(-1), then start == -1. 241 */ 242 apr_off_t start; 243 /** type-dependent data hangs off this pointer */ 244 void *data; 245 /** 246 * Pointer to function used to free the bucket. This function should 247 * always be defined and it should be consistent with the memory 248 * function used to allocate the bucket. For example, if malloc() is 249 * used to allocate the bucket, this pointer should point to free(). 250 * @param e Pointer to the bucket being freed 251 */ 252 void (*free)(void *e); 253 /** The freelist from which this bucket was allocated */ 254 apr_bucket_alloc_t *list; 255}; 256 257/** A list of buckets */ 258struct apr_bucket_brigade { 259 /** The pool to associate the brigade with. The data is not allocated out 260 * of the pool, but a cleanup is registered with this pool. If the 261 * brigade is destroyed by some mechanism other than pool destruction, 262 * the destroying function is responsible for killing the cleanup. 263 */ 264 apr_pool_t *p; 265 /** The buckets in the brigade are on this list. */ 266 /* 267 * The apr_bucket_list structure doesn't actually need a name tag 268 * because it has no existence independent of struct apr_bucket_brigade; 269 * the ring macros are designed so that you can leave the name tag 270 * argument empty in this situation but apparently the Windows compiler 271 * doesn't like that. 272 */ 273 APR_RING_HEAD(apr_bucket_list, apr_bucket) list; 274 /** The freelist from which this bucket was allocated */ 275 apr_bucket_alloc_t *bucket_alloc; 276}; 277 278 279/** 280 * Function called when a brigade should be flushed 281 */ 282typedef apr_status_t (*apr_brigade_flush)(apr_bucket_brigade *bb, void *ctx); 283 284/* 285 * define APR_BUCKET_DEBUG if you want your brigades to be checked for 286 * validity at every possible instant. this will slow your code down 287 * substantially but is a very useful debugging tool. 288 */ 289#ifdef APR_BUCKET_DEBUG 290 291#define APR_BRIGADE_CHECK_CONSISTENCY(b) \ 292 APR_RING_CHECK_CONSISTENCY(&(b)->list, apr_bucket, link) 293 294#define APR_BUCKET_CHECK_CONSISTENCY(e) \ 295 APR_RING_CHECK_ELEM_CONSISTENCY((e), apr_bucket, link) 296 297#else 298/** 299 * checks the ring pointers in a bucket brigade for consistency. an 300 * abort() will be triggered if any inconsistencies are found. 301 * note: this is a no-op unless APR_BUCKET_DEBUG is defined. 302 * @param b The brigade 303 */ 304#define APR_BRIGADE_CHECK_CONSISTENCY(b) 305/** 306 * checks the brigade a bucket is in for ring consistency. an 307 * abort() will be triggered if any inconsistencies are found. 308 * note: this is a no-op unless APR_BUCKET_DEBUG is defined. 309 * @param e The bucket 310 */ 311#define APR_BUCKET_CHECK_CONSISTENCY(e) 312#endif 313 314 315/** 316 * Wrappers around the RING macros to reduce the verbosity of the code 317 * that handles bucket brigades. 318 */ 319/** 320 * The magic pointer value that indicates the head of the brigade 321 * @remark This is used to find the beginning and end of the brigade, eg: 322 * <pre> 323 * while (e != APR_BRIGADE_SENTINEL(b)) { 324 * ... 325 * e = APR_BUCKET_NEXT(e); 326 * } 327 * </pre> 328 * @param b The brigade 329 * @return The magic pointer value 330 */ 331#define APR_BRIGADE_SENTINEL(b) APR_RING_SENTINEL(&(b)->list, apr_bucket, link) 332 333/** 334 * Determine if the bucket brigade is empty 335 * @param b The brigade to check 336 * @return true or false 337 */ 338#define APR_BRIGADE_EMPTY(b) APR_RING_EMPTY(&(b)->list, apr_bucket, link) 339 340/** 341 * Return the first bucket in a brigade 342 * @param b The brigade to query 343 * @return The first bucket in the brigade 344 */ 345#define APR_BRIGADE_FIRST(b) APR_RING_FIRST(&(b)->list) 346/** 347 * Return the last bucket in a brigade 348 * @param b The brigade to query 349 * @return The last bucket in the brigade 350 */ 351#define APR_BRIGADE_LAST(b) APR_RING_LAST(&(b)->list) 352 353/** 354 * Insert a single bucket at the front of a brigade 355 * @param b The brigade to add to 356 * @param e The bucket to insert 357 */ 358#define APR_BRIGADE_INSERT_HEAD(b, e) do { \ 359 apr_bucket *ap__b = (e); \ 360 APR_RING_INSERT_HEAD(&(b)->list, ap__b, apr_bucket, link); \ 361 APR_BRIGADE_CHECK_CONSISTENCY((b)); \ 362 } while (0) 363 364/** 365 * Insert a single bucket at the end of a brigade 366 * @param b The brigade to add to 367 * @param e The bucket to insert 368 */ 369#define APR_BRIGADE_INSERT_TAIL(b, e) do { \ 370 apr_bucket *ap__b = (e); \ 371 APR_RING_INSERT_TAIL(&(b)->list, ap__b, apr_bucket, link); \ 372 APR_BRIGADE_CHECK_CONSISTENCY((b)); \ 373 } while (0) 374 375/** 376 * Concatenate brigade b onto the end of brigade a, leaving brigade b empty 377 * @param a The first brigade 378 * @param b The second brigade 379 */ 380#define APR_BRIGADE_CONCAT(a, b) do { \ 381 APR_RING_CONCAT(&(a)->list, &(b)->list, apr_bucket, link); \ 382 APR_BRIGADE_CHECK_CONSISTENCY((a)); \ 383 } while (0) 384 385/** 386 * Prepend brigade b onto the beginning of brigade a, leaving brigade b empty 387 * @param a The first brigade 388 * @param b The second brigade 389 */ 390#define APR_BRIGADE_PREPEND(a, b) do { \ 391 APR_RING_PREPEND(&(a)->list, &(b)->list, apr_bucket, link); \ 392 APR_BRIGADE_CHECK_CONSISTENCY((a)); \ 393 } while (0) 394 395/** 396 * Insert a single bucket before a specified bucket 397 * @param a The bucket to insert before 398 * @param b The bucket to insert 399 */ 400#define APR_BUCKET_INSERT_BEFORE(a, b) do { \ 401 apr_bucket *ap__a = (a), *ap__b = (b); \ 402 APR_RING_INSERT_BEFORE(ap__a, ap__b, link); \ 403 APR_BUCKET_CHECK_CONSISTENCY(ap__a); \ 404 } while (0) 405 406/** 407 * Insert a single bucket after a specified bucket 408 * @param a The bucket to insert after 409 * @param b The bucket to insert 410 */ 411#define APR_BUCKET_INSERT_AFTER(a, b) do { \ 412 apr_bucket *ap__a = (a), *ap__b = (b); \ 413 APR_RING_INSERT_AFTER(ap__a, ap__b, link); \ 414 APR_BUCKET_CHECK_CONSISTENCY(ap__a); \ 415 } while (0) 416 417/** 418 * Get the next bucket in the list 419 * @param e The current bucket 420 * @return The next bucket 421 */ 422#define APR_BUCKET_NEXT(e) APR_RING_NEXT((e), link) 423/** 424 * Get the previous bucket in the list 425 * @param e The current bucket 426 * @return The previous bucket 427 */ 428#define APR_BUCKET_PREV(e) APR_RING_PREV((e), link) 429 430/** 431 * Remove a bucket from its bucket brigade 432 * @param e The bucket to remove 433 */ 434#define APR_BUCKET_REMOVE(e) APR_RING_REMOVE((e), link) 435 436/** 437 * Initialize a new bucket's prev/next pointers 438 * @param e The bucket to initialize 439 */ 440#define APR_BUCKET_INIT(e) APR_RING_ELEM_INIT((e), link) 441 442/** 443 * Determine if a bucket contains metadata. An empty bucket is 444 * safe to arbitrarily remove if and only if this is false. 445 * @param e The bucket to inspect 446 * @return true or false 447 */ 448#define APR_BUCKET_IS_METADATA(e) ((e)->type->is_metadata) 449 450/** 451 * Determine if a bucket is a FLUSH bucket 452 * @param e The bucket to inspect 453 * @return true or false 454 */ 455#define APR_BUCKET_IS_FLUSH(e) ((e)->type == &apr_bucket_type_flush) 456/** 457 * Determine if a bucket is an EOS bucket 458 * @param e The bucket to inspect 459 * @return true or false 460 */ 461#define APR_BUCKET_IS_EOS(e) ((e)->type == &apr_bucket_type_eos) 462/** 463 * Determine if a bucket is a FILE bucket 464 * @param e The bucket to inspect 465 * @return true or false 466 */ 467#define APR_BUCKET_IS_FILE(e) ((e)->type == &apr_bucket_type_file) 468/** 469 * Determine if a bucket is a PIPE bucket 470 * @param e The bucket to inspect 471 * @return true or false 472 */ 473#define APR_BUCKET_IS_PIPE(e) ((e)->type == &apr_bucket_type_pipe) 474/** 475 * Determine if a bucket is a SOCKET bucket 476 * @param e The bucket to inspect 477 * @return true or false 478 */ 479#define APR_BUCKET_IS_SOCKET(e) ((e)->type == &apr_bucket_type_socket) 480/** 481 * Determine if a bucket is a HEAP bucket 482 * @param e The bucket to inspect 483 * @return true or false 484 */ 485#define APR_BUCKET_IS_HEAP(e) ((e)->type == &apr_bucket_type_heap) 486/** 487 * Determine if a bucket is a TRANSIENT bucket 488 * @param e The bucket to inspect 489 * @return true or false 490 */ 491#define APR_BUCKET_IS_TRANSIENT(e) ((e)->type == &apr_bucket_type_transient) 492/** 493 * Determine if a bucket is a IMMORTAL bucket 494 * @param e The bucket to inspect 495 * @return true or false 496 */ 497#define APR_BUCKET_IS_IMMORTAL(e) ((e)->type == &apr_bucket_type_immortal) 498#if APR_HAS_MMAP 499/** 500 * Determine if a bucket is a MMAP bucket 501 * @param e The bucket to inspect 502 * @return true or false 503 */ 504#define APR_BUCKET_IS_MMAP(e) ((e)->type == &apr_bucket_type_mmap) 505#endif 506/** 507 * Determine if a bucket is a POOL bucket 508 * @param e The bucket to inspect 509 * @return true or false 510 */ 511#define APR_BUCKET_IS_POOL(e) ((e)->type == &apr_bucket_type_pool) 512 513/* 514 * General-purpose reference counting for the various bucket types. 515 * 516 * Any bucket type that keeps track of the resources it uses (i.e. 517 * most of them except for IMMORTAL, TRANSIENT, and EOS) needs to 518 * attach a reference count to the resource so that it can be freed 519 * when the last bucket that uses it goes away. Resource-sharing may 520 * occur because of bucket splits or buckets that refer to globally 521 * cached data. */ 522 523/** @see apr_bucket_refcount */ 524typedef struct apr_bucket_refcount apr_bucket_refcount; 525/** 526 * The structure used to manage the shared resource must start with an 527 * apr_bucket_refcount which is updated by the general-purpose refcount 528 * code. A pointer to the bucket-type-dependent private data structure 529 * can be cast to a pointer to an apr_bucket_refcount and vice versa. 530 */ 531struct apr_bucket_refcount { 532 /** The number of references to this bucket */ 533 int refcount; 534}; 535 536/* ***** Reference-counted bucket types ***** */ 537 538/** @see apr_bucket_heap */ 539typedef struct apr_bucket_heap apr_bucket_heap; 540/** 541 * A bucket referring to data allocated off the heap. 542 */ 543struct apr_bucket_heap { 544 /** Number of buckets using this memory */ 545 apr_bucket_refcount refcount; 546 /** The start of the data actually allocated. This should never be 547 * modified, it is only used to free the bucket. 548 */ 549 char *base; 550 /** how much memory was allocated */ 551 apr_size_t alloc_len; 552 /** function to use to delete the data */ 553 void (*free_func)(void *data); 554}; 555 556/** @see apr_bucket_pool */ 557typedef struct apr_bucket_pool apr_bucket_pool; 558/** 559 * A bucket referring to data allocated from a pool 560 */ 561struct apr_bucket_pool { 562 /** The pool bucket must be able to be easily morphed to a heap 563 * bucket if the pool gets cleaned up before all references are 564 * destroyed. This apr_bucket_heap structure is populated automatically 565 * when the pool gets cleaned up, and subsequent calls to pool_read() 566 * will result in the apr_bucket in question being morphed into a 567 * regular heap bucket. (To avoid having to do many extra refcount 568 * manipulations and b->data manipulations, the apr_bucket_pool 569 * struct actually *contains* the apr_bucket_heap struct that it 570 * will become as its first element; the two share their 571 * apr_bucket_refcount members.) 572 */ 573 apr_bucket_heap heap; 574 /** The block of data actually allocated from the pool. 575 * Segments of this block are referenced by adjusting 576 * the start and length of the apr_bucket accordingly. 577 * This will be NULL after the pool gets cleaned up. 578 */ 579 const char *base; 580 /** The pool the data was allocated from. When the pool 581 * is cleaned up, this gets set to NULL as an indicator 582 * to pool_read() that the data is now on the heap and 583 * so it should morph the bucket into a regular heap 584 * bucket before continuing. 585 */ 586 apr_pool_t *pool; 587 /** The freelist this structure was allocated from, which is 588 * needed in the cleanup phase in order to allocate space on the heap 589 */ 590 apr_bucket_alloc_t *list; 591}; 592 593#if APR_HAS_MMAP 594/** @see apr_bucket_mmap */ 595typedef struct apr_bucket_mmap apr_bucket_mmap; 596/** 597 * A bucket referring to an mmap()ed file 598 */ 599struct apr_bucket_mmap { 600 /** Number of buckets using this memory */ 601 apr_bucket_refcount refcount; 602 /** The mmap this sub_bucket refers to */ 603 apr_mmap_t *mmap; 604}; 605#endif 606 607/** @see apr_bucket_file */ 608typedef struct apr_bucket_file apr_bucket_file; 609/** 610 * A bucket referring to an file 611 */ 612struct apr_bucket_file { 613 /** Number of buckets using this memory */ 614 apr_bucket_refcount refcount; 615 /** The file this bucket refers to */ 616 apr_file_t *fd; 617 /** The pool into which any needed structures should 618 * be created while reading from this file bucket */ 619 apr_pool_t *readpool; 620#if APR_HAS_MMAP 621 /** Whether this bucket should be memory-mapped if 622 * a caller tries to read from it */ 623 int can_mmap; 624#endif /* APR_HAS_MMAP */ 625 /** File read block size */ 626 apr_size_t read_size; 627}; 628 629/** @see apr_bucket_structs */ 630typedef union apr_bucket_structs apr_bucket_structs; 631/** 632 * A union of all bucket structures so we know what 633 * the max size is. 634 */ 635union apr_bucket_structs { 636 apr_bucket b; /**< Bucket */ 637 apr_bucket_heap heap; /**< Heap */ 638 apr_bucket_pool pool; /**< Pool */ 639#if APR_HAS_MMAP 640 apr_bucket_mmap mmap; /**< MMap */ 641#endif 642 apr_bucket_file file; /**< File */ 643}; 644 645/** 646 * The amount that apr_bucket_alloc() should allocate in the common case. 647 * Note: this is twice as big as apr_bucket_structs to allow breathing 648 * room for third-party bucket types. 649 */ 650#define APR_BUCKET_ALLOC_SIZE APR_ALIGN_DEFAULT(2*sizeof(apr_bucket_structs)) 651 652/* ***** Bucket Brigade Functions ***** */ 653/** 654 * Create a new bucket brigade. The bucket brigade is originally empty. 655 * @param p The pool to associate with the brigade. Data is not allocated out 656 * of the pool, but a cleanup is registered. 657 * @param list The bucket allocator to use 658 * @return The empty bucket brigade 659 */ 660APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p, 661 apr_bucket_alloc_t *list); 662 663/** 664 * destroy an entire bucket brigade. This includes destroying all of the 665 * buckets within the bucket brigade's bucket list. 666 * @param b The bucket brigade to destroy 667 */ 668APU_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b); 669 670/** 671 * empty out an entire bucket brigade. This includes destroying all of the 672 * buckets within the bucket brigade's bucket list. This is similar to 673 * apr_brigade_destroy(), except that it does not deregister the brigade's 674 * pool cleanup function. 675 * @param data The bucket brigade to clean up 676 * @remark Generally, you should use apr_brigade_destroy(). This function 677 * can be useful in situations where you have a single brigade that 678 * you wish to reuse many times by destroying all of the buckets in 679 * the brigade and putting new buckets into it later. 680 */ 681APU_DECLARE(apr_status_t) apr_brigade_cleanup(void *data); 682 683/** 684 * Move the buckets from the tail end of the existing brigade @a b into 685 * the brigade @a a. If @a a is NULL a new brigade is created. Buckets 686 * from @a e to the last bucket (inclusively) of brigade @a b are moved 687 * from @a b to the returned brigade @a a. 688 * 689 * @param b The brigade to split 690 * @param e The first bucket to move 691 * @param a The brigade which should be used for the result or NULL if 692 * a new brigade should be created. The brigade @a a will be 693 * cleared if it is not empty. 694 * @return The brigade supplied in @a a or a new one if @a a was NULL. 695 * @warning Note that this function allocates a new brigade if @a a is 696 * NULL so memory consumption should be carefully considered. 697 */ 698APU_DECLARE(apr_bucket_brigade *) apr_brigade_split_ex(apr_bucket_brigade *b, 699 apr_bucket *e, 700 apr_bucket_brigade *a); 701 702/** 703 * Create a new bucket brigade and move the buckets from the tail end 704 * of an existing brigade into the new brigade. Buckets from 705 * @a e to the last bucket (inclusively) of brigade @a b 706 * are moved from @a b to the returned brigade. 707 * @param b The brigade to split 708 * @param e The first bucket to move 709 * @return The new brigade 710 * @warning Note that this function always allocates a new brigade 711 * so memory consumption should be carefully considered. 712 */ 713APU_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b, 714 apr_bucket *e); 715 716/** 717 * Partition a bucket brigade at a given offset (in bytes from the start of 718 * the brigade). This is useful whenever a filter wants to use known ranges 719 * of bytes from the brigade; the ranges can even overlap. 720 * @param b The brigade to partition 721 * @param point The offset at which to partition the brigade 722 * @param after_point Returns a pointer to the first bucket after the partition 723 * @return APR_SUCCESS on success, APR_INCOMPLETE if the contents of the 724 * brigade were shorter than @a point, or an error code. 725 * @remark if APR_INCOMPLETE is returned, @a after_point will be set to 726 * the brigade sentinel. 727 */ 728APU_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b, 729 apr_off_t point, 730 apr_bucket **after_point); 731 732/** 733 * Return the total length of the brigade. 734 * @param bb The brigade to compute the length of 735 * @param read_all Read unknown-length buckets to force a size 736 * @param length Returns the length of the brigade (up to the end, or up 737 * to a bucket read error), or -1 if the brigade has buckets 738 * of indeterminate length and read_all is 0. 739 */ 740APU_DECLARE(apr_status_t) apr_brigade_length(apr_bucket_brigade *bb, 741 int read_all, 742 apr_off_t *length); 743 744/** 745 * Take a bucket brigade and store the data in a flat char* 746 * @param bb The bucket brigade to create the char* from 747 * @param c The char* to write into 748 * @param len The maximum length of the char array. On return, it is the 749 * actual length of the char array. 750 */ 751APU_DECLARE(apr_status_t) apr_brigade_flatten(apr_bucket_brigade *bb, 752 char *c, 753 apr_size_t *len); 754 755/** 756 * Creates a pool-allocated string representing a flat bucket brigade 757 * @param bb The bucket brigade to create the char array from 758 * @param c On return, the allocated char array 759 * @param len On return, the length of the char array. 760 * @param pool The pool to allocate the string from. 761 */ 762APU_DECLARE(apr_status_t) apr_brigade_pflatten(apr_bucket_brigade *bb, 763 char **c, 764 apr_size_t *len, 765 apr_pool_t *pool); 766 767/** 768 * Split a brigade to represent one LF line. 769 * @param bbOut The bucket brigade that will have the LF line appended to. 770 * @param bbIn The input bucket brigade to search for a LF-line. 771 * @param block The blocking mode to be used to split the line. 772 * @param maxbytes The maximum bytes to read. If this many bytes are seen 773 * without a LF, the brigade will contain a partial line. 774 */ 775APU_DECLARE(apr_status_t) apr_brigade_split_line(apr_bucket_brigade *bbOut, 776 apr_bucket_brigade *bbIn, 777 apr_read_type_e block, 778 apr_off_t maxbytes); 779 780/** 781 * Create an iovec of the elements in a bucket_brigade... return number 782 * of elements used. This is useful for writing to a file or to the 783 * network efficiently. 784 * @param b The bucket brigade to create the iovec from 785 * @param vec The iovec to create 786 * @param nvec The number of elements in the iovec. On return, it is the 787 * number of iovec elements actually filled out. 788 */ 789APU_DECLARE(apr_status_t) apr_brigade_to_iovec(apr_bucket_brigade *b, 790 struct iovec *vec, int *nvec); 791 792/** 793 * This function writes a list of strings into a bucket brigade. 794 * @param b The bucket brigade to add to 795 * @param flush The flush function to use if the brigade is full 796 * @param ctx The structure to pass to the flush function 797 * @param va A list of strings to add 798 * @return APR_SUCCESS or error code. 799 */ 800APU_DECLARE(apr_status_t) apr_brigade_vputstrs(apr_bucket_brigade *b, 801 apr_brigade_flush flush, 802 void *ctx, 803 va_list va); 804 805/** 806 * This function writes a string into a bucket brigade. 807 * 808 * The apr_brigade_write function attempts to be efficient with the 809 * handling of heap buckets. Regardless of the amount of data stored 810 * inside a heap bucket, heap buckets are a fixed size to promote their 811 * reuse. 812 * 813 * If an attempt is made to write a string to a brigade that already 814 * ends with a heap bucket, this function will attempt to pack the 815 * string into the remaining space in the previous heap bucket, before 816 * allocating a new heap bucket. 817 * 818 * This function always returns APR_SUCCESS, unless a flush function is 819 * passed, in which case the return value of the flush function will be 820 * returned if used. 821 * @param b The bucket brigade to add to 822 * @param flush The flush function to use if the brigade is full 823 * @param ctx The structure to pass to the flush function 824 * @param str The string to add 825 * @param nbyte The number of bytes to write 826 * @return APR_SUCCESS or error code 827 */ 828APU_DECLARE(apr_status_t) apr_brigade_write(apr_bucket_brigade *b, 829 apr_brigade_flush flush, void *ctx, 830 const char *str, apr_size_t nbyte); 831 832/** 833 * This function writes multiple strings into a bucket brigade. 834 * @param b The bucket brigade to add to 835 * @param flush The flush function to use if the brigade is full 836 * @param ctx The structure to pass to the flush function 837 * @param vec The strings to add (address plus length for each) 838 * @param nvec The number of entries in iovec 839 * @return APR_SUCCESS or error code 840 */ 841APU_DECLARE(apr_status_t) apr_brigade_writev(apr_bucket_brigade *b, 842 apr_brigade_flush flush, 843 void *ctx, 844 const struct iovec *vec, 845 apr_size_t nvec); 846 847/** 848 * This function writes a string into a bucket brigade. 849 * @param bb The bucket brigade to add to 850 * @param flush The flush function to use if the brigade is full 851 * @param ctx The structure to pass to the flush function 852 * @param str The string to add 853 * @return APR_SUCCESS or error code 854 */ 855APU_DECLARE(apr_status_t) apr_brigade_puts(apr_bucket_brigade *bb, 856 apr_brigade_flush flush, void *ctx, 857 const char *str); 858 859/** 860 * This function writes a character into a bucket brigade. 861 * @param b The bucket brigade to add to 862 * @param flush The flush function to use if the brigade is full 863 * @param ctx The structure to pass to the flush function 864 * @param c The character to add 865 * @return APR_SUCCESS or error code 866 */ 867APU_DECLARE(apr_status_t) apr_brigade_putc(apr_bucket_brigade *b, 868 apr_brigade_flush flush, void *ctx, 869 const char c); 870 871/** 872 * This function writes an unspecified number of strings into a bucket brigade. 873 * @param b The bucket brigade to add to 874 * @param flush The flush function to use if the brigade is full 875 * @param ctx The structure to pass to the flush function 876 * @param ... The strings to add 877 * @return APR_SUCCESS or error code 878 */ 879APU_DECLARE_NONSTD(apr_status_t) apr_brigade_putstrs(apr_bucket_brigade *b, 880 apr_brigade_flush flush, 881 void *ctx, ...); 882 883/** 884 * Evaluate a printf and put the resulting string at the end 885 * of the bucket brigade. 886 * @param b The brigade to write to 887 * @param flush The flush function to use if the brigade is full 888 * @param ctx The structure to pass to the flush function 889 * @param fmt The format of the string to write 890 * @param ... The arguments to fill out the format 891 * @return APR_SUCCESS or error code 892 */ 893APU_DECLARE_NONSTD(apr_status_t) apr_brigade_printf(apr_bucket_brigade *b, 894 apr_brigade_flush flush, 895 void *ctx, 896 const char *fmt, ...) 897 __attribute__((format(printf,4,5))); 898 899/** 900 * Evaluate a printf and put the resulting string at the end 901 * of the bucket brigade. 902 * @param b The brigade to write to 903 * @param flush The flush function to use if the brigade is full 904 * @param ctx The structure to pass to the flush function 905 * @param fmt The format of the string to write 906 * @param va The arguments to fill out the format 907 * @return APR_SUCCESS or error code 908 */ 909APU_DECLARE(apr_status_t) apr_brigade_vprintf(apr_bucket_brigade *b, 910 apr_brigade_flush flush, 911 void *ctx, 912 const char *fmt, va_list va); 913 914/** 915 * Utility function to insert a file (or a segment of a file) onto the 916 * end of the brigade. The file is split into multiple buckets if it 917 * is larger than the maximum size which can be represented by a 918 * single bucket. 919 * @param bb the brigade to insert into 920 * @param f the file to insert 921 * @param start the offset of the start of the segment 922 * @param len the length of the segment of the file to insert 923 * @param p pool from which file buckets are allocated 924 * @return the last bucket inserted 925 */ 926APU_DECLARE(apr_bucket *) apr_brigade_insert_file(apr_bucket_brigade *bb, 927 apr_file_t *f, 928 apr_off_t start, 929 apr_off_t len, 930 apr_pool_t *p); 931 932 933 934/* ***** Bucket freelist functions ***** */ 935/** 936 * Create a bucket allocator. 937 * @param p This pool's underlying apr_allocator_t is used to allocate memory 938 * for the bucket allocator. When the pool is destroyed, the bucket 939 * allocator's cleanup routine will free all memory that has been 940 * allocated from it. 941 * @remark The reason the allocator gets its memory from the pool's 942 * apr_allocator_t rather than from the pool itself is because 943 * the bucket allocator will free large memory blocks back to the 944 * allocator when it's done with them, thereby preventing memory 945 * footprint growth that would occur if we allocated from the pool. 946 * @warning The allocator must never be used by more than one thread at a time. 947 */ 948APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create(apr_pool_t *p); 949 950/** 951 * Create a bucket allocator. 952 * @param allocator This apr_allocator_t is used to allocate both the bucket 953 * allocator and all memory handed out by the bucket allocator. The 954 * caller is responsible for destroying the bucket allocator and the 955 * apr_allocator_t -- no automatic cleanups will happen. 956 * @warning The allocator must never be used by more than one thread at a time. 957 */ 958APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create_ex(apr_allocator_t *allocator); 959 960/** 961 * Destroy a bucket allocator. 962 * @param list The allocator to be destroyed 963 */ 964APU_DECLARE_NONSTD(void) apr_bucket_alloc_destroy(apr_bucket_alloc_t *list); 965 966/** 967 * Get the aligned size corresponding to the requested size, but minus the 968 * allocator(s) overhead such that the allocation would remain in the 969 * same boundary. 970 * @param list The allocator from which to the memory would be allocated. 971 * @param size The requested size. 972 * @return The corresponding aligned/floored size. 973 */ 974APU_DECLARE_NONSTD(apr_size_t) apr_bucket_alloc_aligned_floor(apr_bucket_alloc_t *list, 975 apr_size_t size) 976 __attribute__((nonnull(1))); 977 978/** 979 * Allocate memory for use by the buckets. 980 * @param size The amount to allocate. 981 * @param list The allocator from which to allocate the memory. 982 */ 983APU_DECLARE_NONSTD(void *) apr_bucket_alloc(apr_size_t size, apr_bucket_alloc_t *list); 984 985/** 986 * Free memory previously allocated with apr_bucket_alloc(). 987 * @param block The block of memory to be freed. 988 */ 989APU_DECLARE_NONSTD(void) apr_bucket_free(void *block); 990 991 992/* ***** Bucket Functions ***** */ 993/** 994 * Free the resources used by a bucket. If multiple buckets refer to 995 * the same resource it is freed when the last one goes away. 996 * @see apr_bucket_delete() 997 * @param e The bucket to destroy 998 */ 999#define apr_bucket_destroy(e) do { \ 1000 (e)->type->destroy((e)->data); \ 1001 (e)->free(e); \ 1002 } while (0) 1003 1004/** 1005 * Delete a bucket by removing it from its brigade (if any) and then 1006 * destroying it. 1007 * @remark This mainly acts as an aid in avoiding code verbosity. It is 1008 * the preferred exact equivalent to: 1009 * <pre> 1010 * APR_BUCKET_REMOVE(e); 1011 * apr_bucket_destroy(e); 1012 * </pre> 1013 * @param e The bucket to delete 1014 */ 1015#define apr_bucket_delete(e) do { \ 1016 APR_BUCKET_REMOVE(e); \ 1017 apr_bucket_destroy(e); \ 1018 } while (0) 1019 1020/** 1021 * Read some data from the bucket. 1022 * 1023 * The apr_bucket_read function returns a convenient amount of data 1024 * from the bucket provided, writing the address and length of the 1025 * data to the pointers provided by the caller. The function tries 1026 * as hard as possible to avoid a memory copy. 1027 * 1028 * Buckets are expected to be a member of a brigade at the time they 1029 * are read. 1030 * 1031 * In typical application code, buckets are read in a loop, and after 1032 * each bucket is read and processed, it is moved or deleted from the 1033 * brigade and the next bucket read. 1034 * 1035 * The definition of "convenient" depends on the type of bucket that 1036 * is being read, and is decided by APR. In the case of memory based 1037 * buckets such as heap and immortal buckets, a pointer will be 1038 * returned to the location of the buffer containing the complete 1039 * contents of the bucket. 1040 * 1041 * Some buckets, such as the socket bucket, might have no concept 1042 * of length. If an attempt is made to read such a bucket, the 1043 * apr_bucket_read function will read a convenient amount of data 1044 * from the socket. The socket bucket is magically morphed into a 1045 * heap bucket containing the just-read data, and a new socket bucket 1046 * is inserted just after this heap bucket. 1047 * 1048 * To understand why apr_bucket_read might do this, consider the loop 1049 * described above to read and process buckets. The current bucket 1050 * is magically morphed into a heap bucket and returned to the caller. 1051 * The caller processes the data, and deletes the heap bucket, moving 1052 * onto the next bucket, the new socket bucket. This process repeats, 1053 * giving the illusion of a bucket brigade that contains potentially 1054 * infinite amounts of data. It is up to the caller to decide at what 1055 * point to stop reading buckets. 1056 * 1057 * Some buckets, such as the file bucket, might have a fixed size, 1058 * but be significantly larger than is practical to store in RAM in 1059 * one go. As with the socket bucket, if an attempt is made to read 1060 * from a file bucket, the file bucket is magically morphed into a 1061 * heap bucket containing a convenient amount of data read from the 1062 * current offset in the file. During the read, the offset will be 1063 * moved forward on the file, and a new file bucket will be inserted 1064 * directly after the current bucket representing the remainder of the 1065 * file. If the heap bucket was large enough to store the whole 1066 * remainder of the file, no more file buckets are inserted, and the 1067 * file bucket will disappear completely. 1068 * 1069 * The pattern for reading buckets described above does create the 1070 * illusion that the code is willing to swallow buckets that might be 1071 * too large for the system to handle in one go. This however is just 1072 * an illusion: APR will always ensure that large (file) or infinite 1073 * (socket) buckets are broken into convenient bite sized heap buckets 1074 * before data is returned to the caller. 1075 * 1076 * There is a potential gotcha to watch for: if buckets are read in a 1077 * loop, and aren't deleted after being processed, the potentially large 1078 * bucket will slowly be converted into RAM resident heap buckets. If 1079 * the file is larger than available RAM, an out of memory condition 1080 * could be caused if the application is not careful to manage this. 1081 * 1082 * @param e The bucket to read from 1083 * @param str The location to store a pointer to the data in 1084 * @param len The location to store the amount of data read 1085 * @param block Whether the read function blocks 1086 */ 1087#define apr_bucket_read(e,str,len,block) (e)->type->read(e, str, len, block) 1088 1089/** 1090 * Setaside data so that stack data is not destroyed on returning from 1091 * the function 1092 * @param e The bucket to setaside 1093 * @param p The pool to setaside into 1094 */ 1095#define apr_bucket_setaside(e,p) (e)->type->setaside(e,p) 1096 1097/** 1098 * Split one bucket in two at the point provided. 1099 * 1100 * Once split, the original bucket becomes the first of the two new buckets. 1101 * 1102 * (It is assumed that the bucket is a member of a brigade when this 1103 * function is called). 1104 * @param e The bucket to split 1105 * @param point The offset to split the bucket at 1106 */ 1107#define apr_bucket_split(e,point) (e)->type->split(e, point) 1108 1109/** 1110 * Copy a bucket. 1111 * @param e The bucket to copy 1112 * @param c Returns a pointer to the new bucket 1113 */ 1114#define apr_bucket_copy(e,c) (e)->type->copy(e, c) 1115 1116/* Bucket type handling */ 1117 1118/** 1119 * This function simply returns APR_SUCCESS to denote that the bucket does 1120 * not require anything to happen for its setaside() function. This is 1121 * appropriate for buckets that have "immortal" data -- the data will live 1122 * at least as long as the bucket. 1123 * @param data The bucket to setaside 1124 * @param pool The pool defining the desired lifetime of the bucket data 1125 * @return APR_SUCCESS 1126 */ 1127APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_noop(apr_bucket *data, 1128 apr_pool_t *pool); 1129 1130/** 1131 * A place holder function that signifies that the setaside function was not 1132 * implemented for this bucket 1133 * @param data The bucket to setaside 1134 * @param pool The pool defining the desired lifetime of the bucket data 1135 * @return APR_ENOTIMPL 1136 */ 1137APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_notimpl(apr_bucket *data, 1138 apr_pool_t *pool); 1139 1140/** 1141 * A place holder function that signifies that the split function was not 1142 * implemented for this bucket 1143 * @param data The bucket to split 1144 * @param point The location to split the bucket 1145 * @return APR_ENOTIMPL 1146 */ 1147APU_DECLARE_NONSTD(apr_status_t) apr_bucket_split_notimpl(apr_bucket *data, 1148 apr_size_t point); 1149 1150/** 1151 * A place holder function that signifies that the copy function was not 1152 * implemented for this bucket 1153 * @param e The bucket to copy 1154 * @param c Returns a pointer to the new bucket 1155 * @return APR_ENOTIMPL 1156 */ 1157APU_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_notimpl(apr_bucket *e, 1158 apr_bucket **c); 1159 1160/** 1161 * A place holder function that signifies that this bucket does not need 1162 * to do anything special to be destroyed. That's only the case for buckets 1163 * that either have no data (metadata buckets) or buckets whose data pointer 1164 * points to something that's not a bucket-type-specific structure, as with 1165 * simple buckets where data points to a string and pipe buckets where data 1166 * points directly to the apr_file_t. 1167 * @param data The bucket data to destroy 1168 */ 1169APU_DECLARE_NONSTD(void) apr_bucket_destroy_noop(void *data); 1170 1171/** 1172 * There is no apr_bucket_destroy_notimpl, because destruction is required 1173 * to be implemented (it could be a noop, but only if that makes sense for 1174 * the bucket type) 1175 */ 1176 1177/* There is no apr_bucket_read_notimpl, because it is a required function 1178 */ 1179 1180 1181/* All of the bucket types implemented by the core */ 1182/** 1183 * The flush bucket type. This signifies that all data should be flushed to 1184 * the next filter. The flush bucket should be sent with the other buckets. 1185 */ 1186APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_flush; 1187/** 1188 * The EOS bucket type. This signifies that there will be no more data, ever. 1189 * All filters MUST send all data to the next filter when they receive a 1190 * bucket of this type 1191 */ 1192APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_eos; 1193/** 1194 * The FILE bucket type. This bucket represents a file on disk 1195 */ 1196APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_file; 1197/** 1198 * The HEAP bucket type. This bucket represents a data allocated from the 1199 * heap. 1200 */ 1201APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_heap; 1202#if APR_HAS_MMAP 1203/** 1204 * The MMAP bucket type. This bucket represents an MMAP'ed file 1205 */ 1206APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_mmap; 1207#endif 1208/** 1209 * The POOL bucket type. This bucket represents a data that was allocated 1210 * from a pool. IF this bucket is still available when the pool is cleared, 1211 * the data is copied on to the heap. 1212 */ 1213APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pool; 1214/** 1215 * The PIPE bucket type. This bucket represents a pipe to another program. 1216 */ 1217APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pipe; 1218/** 1219 * The IMMORTAL bucket type. This bucket represents a segment of data that 1220 * the creator is willing to take responsibility for. The core will do 1221 * nothing with the data in an immortal bucket 1222 */ 1223APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_immortal; 1224/** 1225 * The TRANSIENT bucket type. This bucket represents a data allocated off 1226 * the stack. When the setaside function is called, this data is copied on 1227 * to the heap 1228 */ 1229APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_transient; 1230/** 1231 * The SOCKET bucket type. This bucket represents a socket to another machine 1232 */ 1233APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_socket; 1234 1235 1236/* ***** Simple buckets ***** */ 1237 1238/** 1239 * Split a simple bucket into two at the given point. Most non-reference 1240 * counting buckets that allow multiple references to the same block of 1241 * data (eg transient and immortal) will use this as their split function 1242 * without any additional type-specific handling. 1243 * @param b The bucket to be split 1244 * @param point The offset of the first byte in the new bucket 1245 * @return APR_EINVAL if the point is not within the bucket; 1246 * APR_ENOMEM if allocation failed; 1247 * or APR_SUCCESS 1248 */ 1249APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_split(apr_bucket *b, 1250 apr_size_t point); 1251 1252/** 1253 * Copy a simple bucket. Most non-reference-counting buckets that allow 1254 * multiple references to the same block of data (eg transient and immortal) 1255 * will use this as their copy function without any additional type-specific 1256 * handling. 1257 * @param a The bucket to copy 1258 * @param b Returns a pointer to the new bucket 1259 * @return APR_ENOMEM if allocation failed; 1260 * or APR_SUCCESS 1261 */ 1262APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_copy(apr_bucket *a, 1263 apr_bucket **b); 1264 1265 1266/* ***** Shared, reference-counted buckets ***** */ 1267 1268/** 1269 * Initialize a bucket containing reference-counted data that may be 1270 * shared. The caller must allocate the bucket if necessary and 1271 * initialize its type-dependent fields, and allocate and initialize 1272 * its own private data structure. This function should only be called 1273 * by type-specific bucket creation functions. 1274 * @param b The bucket to initialize 1275 * @param data A pointer to the private data structure 1276 * with the reference count at the start 1277 * @param start The start of the data in the bucket 1278 * relative to the private base pointer 1279 * @param length The length of the data in the bucket 1280 * @return The new bucket, or NULL if allocation failed 1281 */ 1282APU_DECLARE(apr_bucket *) apr_bucket_shared_make(apr_bucket *b, void *data, 1283 apr_off_t start, 1284 apr_size_t length); 1285 1286/** 1287 * Decrement the refcount of the data in the bucket. This function 1288 * should only be called by type-specific bucket destruction functions. 1289 * @param data The private data pointer from the bucket to be destroyed 1290 * @return TRUE or FALSE; TRUE if the reference count is now 1291 * zero, indicating that the shared resource itself can 1292 * be destroyed by the caller. 1293 */ 1294APU_DECLARE(int) apr_bucket_shared_destroy(void *data); 1295 1296/** 1297 * Split a bucket into two at the given point, and adjust the refcount 1298 * to the underlying data. Most reference-counting bucket types will 1299 * be able to use this function as their split function without any 1300 * additional type-specific handling. 1301 * @param b The bucket to be split 1302 * @param point The offset of the first byte in the new bucket 1303 * @return APR_EINVAL if the point is not within the bucket; 1304 * APR_ENOMEM if allocation failed; 1305 * or APR_SUCCESS 1306 */ 1307APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_split(apr_bucket *b, 1308 apr_size_t point); 1309 1310/** 1311 * Copy a refcounted bucket, incrementing the reference count. Most 1312 * reference-counting bucket types will be able to use this function 1313 * as their copy function without any additional type-specific handling. 1314 * @param a The bucket to copy 1315 * @param b Returns a pointer to the new bucket 1316 * @return APR_ENOMEM if allocation failed; 1317 or APR_SUCCESS 1318 */ 1319APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_copy(apr_bucket *a, 1320 apr_bucket **b); 1321 1322 1323/* ***** Functions to Create Buckets of varying types ***** */ 1324/* 1325 * Each bucket type foo has two initialization functions: 1326 * apr_bucket_foo_make which sets up some already-allocated memory as a 1327 * bucket of type foo; and apr_bucket_foo_create which allocates memory 1328 * for the bucket, calls apr_bucket_make_foo, and initializes the 1329 * bucket's list pointers. The apr_bucket_foo_make functions are used 1330 * inside the bucket code to change the type of buckets in place; 1331 * other code should call apr_bucket_foo_create. All the initialization 1332 * functions change nothing if they fail. 1333 */ 1334 1335/** 1336 * Create an End of Stream bucket. This indicates that there is no more data 1337 * coming from down the filter stack. All filters should flush at this point. 1338 * @param list The freelist from which this bucket should be allocated 1339 * @return The new bucket, or NULL if allocation failed 1340 */ 1341APU_DECLARE(apr_bucket *) apr_bucket_eos_create(apr_bucket_alloc_t *list); 1342 1343/** 1344 * Make the bucket passed in an EOS bucket. This indicates that there is no 1345 * more data coming from down the filter stack. All filters should flush at 1346 * this point. 1347 * @param b The bucket to make into an EOS bucket 1348 * @return The new bucket, or NULL if allocation failed 1349 */ 1350APU_DECLARE(apr_bucket *) apr_bucket_eos_make(apr_bucket *b); 1351 1352/** 1353 * Create a flush bucket. This indicates that filters should flush their 1354 * data. There is no guarantee that they will flush it, but this is the 1355 * best we can do. 1356 * @param list The freelist from which this bucket should be allocated 1357 * @return The new bucket, or NULL if allocation failed 1358 */ 1359APU_DECLARE(apr_bucket *) apr_bucket_flush_create(apr_bucket_alloc_t *list); 1360 1361/** 1362 * Make the bucket passed in a FLUSH bucket. This indicates that filters 1363 * should flush their data. There is no guarantee that they will flush it, 1364 * but this is the best we can do. 1365 * @param b The bucket to make into a FLUSH bucket 1366 * @return The new bucket, or NULL if allocation failed 1367 */ 1368APU_DECLARE(apr_bucket *) apr_bucket_flush_make(apr_bucket *b); 1369 1370/** 1371 * Create a bucket referring to long-lived data. 1372 * @param buf The data to insert into the bucket 1373 * @param nbyte The size of the data to insert. 1374 * @param list The freelist from which this bucket should be allocated 1375 * @return The new bucket, or NULL if allocation failed 1376 */ 1377APU_DECLARE(apr_bucket *) apr_bucket_immortal_create(const char *buf, 1378 apr_size_t nbyte, 1379 apr_bucket_alloc_t *list); 1380 1381/** 1382 * Make the bucket passed in a bucket refer to long-lived data 1383 * @param b The bucket to make into a IMMORTAL bucket 1384 * @param buf The data to insert into the bucket 1385 * @param nbyte The size of the data to insert. 1386 * @return The new bucket, or NULL if allocation failed 1387 */ 1388APU_DECLARE(apr_bucket *) apr_bucket_immortal_make(apr_bucket *b, 1389 const char *buf, 1390 apr_size_t nbyte); 1391 1392/** 1393 * Create a bucket referring to data on the stack. 1394 * @param buf The data to insert into the bucket 1395 * @param nbyte The size of the data to insert. 1396 * @param list The freelist from which this bucket should be allocated 1397 * @return The new bucket, or NULL if allocation failed 1398 */ 1399APU_DECLARE(apr_bucket *) apr_bucket_transient_create(const char *buf, 1400 apr_size_t nbyte, 1401 apr_bucket_alloc_t *list); 1402 1403/** 1404 * Make the bucket passed in a bucket refer to stack data 1405 * @param b The bucket to make into a TRANSIENT bucket 1406 * @param buf The data to insert into the bucket 1407 * @param nbyte The size of the data to insert. 1408 * @return The new bucket, or NULL if allocation failed 1409 */ 1410APU_DECLARE(apr_bucket *) apr_bucket_transient_make(apr_bucket *b, 1411 const char *buf, 1412 apr_size_t nbyte); 1413 1414/** 1415 * Create a bucket referring to memory on the heap. If the caller asks 1416 * for the data to be copied, this function always allocates 4K of 1417 * memory so that more data can be added to the bucket without 1418 * requiring another allocation. Therefore not all the data may be put 1419 * into the bucket. If copying is not requested then the bucket takes 1420 * over responsibility for free()ing the memory. 1421 * @param buf The buffer to insert into the bucket 1422 * @param nbyte The size of the buffer to insert. 1423 * @param free_func Function to use to free the data; NULL indicates that the 1424 * bucket should make a copy of the data 1425 * @param list The freelist from which this bucket should be allocated 1426 * @return The new bucket, or NULL if allocation failed 1427 */ 1428APU_DECLARE(apr_bucket *) apr_bucket_heap_create(const char *buf, 1429 apr_size_t nbyte, 1430 void (*free_func)(void *data), 1431 apr_bucket_alloc_t *list); 1432/** 1433 * Make the bucket passed in a bucket refer to heap data 1434 * @param b The bucket to make into a HEAP bucket 1435 * @param buf The buffer to insert into the bucket 1436 * @param nbyte The size of the buffer to insert. 1437 * @param free_func Function to use to free the data; NULL indicates that the 1438 * bucket should make a copy of the data 1439 * @return The new bucket, or NULL if allocation failed 1440 */ 1441APU_DECLARE(apr_bucket *) apr_bucket_heap_make(apr_bucket *b, const char *buf, 1442 apr_size_t nbyte, 1443 void (*free_func)(void *data)); 1444 1445/** 1446 * Create a bucket referring to memory allocated from a pool. 1447 * 1448 * @param buf The buffer to insert into the bucket 1449 * @param length The number of bytes referred to by this bucket 1450 * @param pool The pool the memory was allocated from 1451 * @param list The freelist from which this bucket should be allocated 1452 * @return The new bucket, or NULL if allocation failed 1453 */ 1454APU_DECLARE(apr_bucket *) apr_bucket_pool_create(const char *buf, 1455 apr_size_t length, 1456 apr_pool_t *pool, 1457 apr_bucket_alloc_t *list); 1458 1459/** 1460 * Make the bucket passed in a bucket refer to pool data 1461 * @param b The bucket to make into a pool bucket 1462 * @param buf The buffer to insert into the bucket 1463 * @param length The number of bytes referred to by this bucket 1464 * @param pool The pool the memory was allocated from 1465 * @return The new bucket, or NULL if allocation failed 1466 */ 1467APU_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b, const char *buf, 1468 apr_size_t length, 1469 apr_pool_t *pool); 1470 1471#if APR_HAS_MMAP 1472/** 1473 * Create a bucket referring to mmap()ed memory. 1474 * @param mm The mmap to insert into the bucket 1475 * @param start The offset of the first byte in the mmap 1476 * that this bucket refers to 1477 * @param length The number of bytes referred to by this bucket 1478 * @param list The freelist from which this bucket should be allocated 1479 * @return The new bucket, or NULL if allocation failed 1480 */ 1481APU_DECLARE(apr_bucket *) apr_bucket_mmap_create(apr_mmap_t *mm, 1482 apr_off_t start, 1483 apr_size_t length, 1484 apr_bucket_alloc_t *list); 1485 1486/** 1487 * Make the bucket passed in a bucket refer to an MMAP'ed file 1488 * @param b The bucket to make into a MMAP bucket 1489 * @param mm The mmap to insert into the bucket 1490 * @param start The offset of the first byte in the mmap 1491 * that this bucket refers to 1492 * @param length The number of bytes referred to by this bucket 1493 * @return The new bucket, or NULL if allocation failed 1494 */ 1495APU_DECLARE(apr_bucket *) apr_bucket_mmap_make(apr_bucket *b, apr_mmap_t *mm, 1496 apr_off_t start, 1497 apr_size_t length); 1498#endif 1499 1500/** 1501 * Create a bucket referring to a socket. 1502 * @param thissock The socket to put in the bucket 1503 * @param list The freelist from which this bucket should be allocated 1504 * @return The new bucket, or NULL if allocation failed 1505 */ 1506APU_DECLARE(apr_bucket *) apr_bucket_socket_create(apr_socket_t *thissock, 1507 apr_bucket_alloc_t *list); 1508/** 1509 * Make the bucket passed in a bucket refer to a socket 1510 * @param b The bucket to make into a SOCKET bucket 1511 * @param thissock The socket to put in the bucket 1512 * @return The new bucket, or NULL if allocation failed 1513 */ 1514APU_DECLARE(apr_bucket *) apr_bucket_socket_make(apr_bucket *b, 1515 apr_socket_t *thissock); 1516 1517/** 1518 * Create a bucket referring to a pipe. 1519 * @param thispipe The pipe to put in the bucket 1520 * @param list The freelist from which this bucket should be allocated 1521 * @return The new bucket, or NULL if allocation failed 1522 */ 1523APU_DECLARE(apr_bucket *) apr_bucket_pipe_create(apr_file_t *thispipe, 1524 apr_bucket_alloc_t *list); 1525 1526/** 1527 * Make the bucket passed in a bucket refer to a pipe 1528 * @param b The bucket to make into a PIPE bucket 1529 * @param thispipe The pipe to put in the bucket 1530 * @return The new bucket, or NULL if allocation failed 1531 */ 1532APU_DECLARE(apr_bucket *) apr_bucket_pipe_make(apr_bucket *b, 1533 apr_file_t *thispipe); 1534 1535/** 1536 * Create a bucket referring to a file. 1537 * @param fd The file to put in the bucket 1538 * @param offset The offset where the data of interest begins in the file 1539 * @param len The amount of data in the file we are interested in 1540 * @param p The pool into which any needed structures should be created 1541 * while reading from this file bucket 1542 * @param list The freelist from which this bucket should be allocated 1543 * @return The new bucket, or NULL if allocation failed 1544 * @remark If the file is truncated such that the segment of the file 1545 * referenced by the bucket no longer exists, an attempt to read 1546 * from the bucket will fail with APR_EOF. 1547 * @remark apr_brigade_insert_file() should generally be used to 1548 * insert files into brigades, since that function can correctly 1549 * handle large file issues. 1550 */ 1551APU_DECLARE(apr_bucket *) apr_bucket_file_create(apr_file_t *fd, 1552 apr_off_t offset, 1553 apr_size_t len, 1554 apr_pool_t *p, 1555 apr_bucket_alloc_t *list); 1556 1557/** 1558 * Make the bucket passed in a bucket refer to a file 1559 * @param b The bucket to make into a FILE bucket 1560 * @param fd The file to put in the bucket 1561 * @param offset The offset where the data of interest begins in the file 1562 * @param len The amount of data in the file we are interested in 1563 * @param p The pool into which any needed structures should be created 1564 * while reading from this file bucket 1565 * @return The new bucket, or NULL if allocation failed 1566 */ 1567APU_DECLARE(apr_bucket *) apr_bucket_file_make(apr_bucket *b, apr_file_t *fd, 1568 apr_off_t offset, 1569 apr_size_t len, apr_pool_t *p); 1570 1571/** 1572 * Enable or disable memory-mapping for a FILE bucket (default is enabled) 1573 * @param b The bucket 1574 * @param enabled Whether memory-mapping should be enabled 1575 * @return APR_SUCCESS normally, or an error code if the operation fails 1576 */ 1577APU_DECLARE(apr_status_t) apr_bucket_file_enable_mmap(apr_bucket *b, 1578 int enabled); 1579 1580/** 1581 * Set the size of the read buffer allocated by a FILE bucket (default 1582 * is @a APR_BUCKET_BUFF_SIZE) 1583 * memory-mapping is disabled only) 1584 * @param b The bucket 1585 * @param size Size of the allocated buffers 1586 * @return APR_SUCCESS normally, or an error code if the operation fails 1587 * @remark Relevant/used only when memory-mapping is disabled (@see 1588 * apr_bucket_file_enable_mmap) 1589 */ 1590APU_DECLARE(apr_status_t) apr_bucket_file_set_buf_size(apr_bucket *e, 1591 apr_size_t size); 1592 1593/** @} */ 1594#ifdef __cplusplus 1595} 1596#endif 1597 1598#endif /* !APR_BUCKETS_H */ 1599