Apache Portable Runtime
 
Loading...
Searching...
No Matches
apr_buckets.h
Go to the documentation of this file.
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 */
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 */
120/** @see apr_bucket */
121typedef struct apr_bucket apr_bucket;
122/** @see apr_bucket_alloc_t */
124
125/** @see apr_bucket_type_t */
127
128/**
129 * Basic bucket type
130 */
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 */
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. */
154 /** This bucket type represents 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 */
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 */
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 */
225 /** Links to the rest of the brigade */
227 /** The type of bucket. */
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 */
255};
256
257/** A list of buckets */
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 */
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 */
276};
277
278
279/**
280 * Function called when a brigade should be flushed
281 */
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 */
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 */
532 /** The number of references to this bucket */
534};
535
536/* ***** Reference-counted bucket types ***** */
537
538/** @see apr_bucket_heap */
540/**
541 * A bucket referring to data allocated off the heap.
542 */
544 /** Number of buckets using this memory */
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 */
558/**
559 * A bucket referring to data allocated from a pool
560 */
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 */
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 */
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 */
591};
592
593#if APR_HAS_MMAP
594/** @see apr_bucket_mmap */
596/**
597 * A bucket referring to an mmap()ed file
598 */
600 /** Number of buckets using this memory */
602 /** The mmap this sub_bucket refers to */
604};
605#endif
606
607/** @see apr_bucket_file */
609/**
610 * A bucket referring to an file
611 */
613 /** Number of buckets using this memory */
615 /** The file this bucket refers to */
617 /** The pool into which any needed structures should
618 * be created while reading from this file bucket */
620#if APR_HAS_MMAP
621 /** Whether this bucket should be memory-mapped if
622 * a caller tries to read from it */
624#endif /* APR_HAS_MMAP */
625 /** File read block size */
626 apr_size_t read_size;
627};
628
629/** @see apr_bucket_structs */
631/**
632 * A union of all bucket structures so we know what
633 * the max size is.
634 */
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 */
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 */
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 */
699 apr_bucket *e,
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 apr_bucket *apr__d = (e); \
1001 apr__d->type->destroy(apr__d->data); \
1002 apr__d->free(apr__d); \
1003 } while (0)
1004
1005/**
1006 * Delete a bucket by removing it from its brigade (if any) and then
1007 * destroying it.
1008 * @remark This mainly acts as an aid in avoiding code verbosity. It is
1009 * the preferred exact equivalent to:
1010 * <pre>
1011 * APR_BUCKET_REMOVE(e);
1012 * apr_bucket_destroy(e);
1013 * </pre>
1014 * @param e The bucket to delete
1015 */
1016#define apr_bucket_delete(e) do { \
1017 apr_bucket *apr__b = (e); \
1018 APR_BUCKET_REMOVE(apr__b); \
1019 apr_bucket_destroy(apr__b); \
1020 } while (0)
1021
1022/**
1023 * Read some data from the bucket.
1024 *
1025 * The apr_bucket_read function returns a convenient amount of data
1026 * from the bucket provided, writing the address and length of the
1027 * data to the pointers provided by the caller. The function tries
1028 * as hard as possible to avoid a memory copy.
1029 *
1030 * Buckets are expected to be a member of a brigade at the time they
1031 * are read.
1032 *
1033 * In typical application code, buckets are read in a loop, and after
1034 * each bucket is read and processed, it is moved or deleted from the
1035 * brigade and the next bucket read.
1036 *
1037 * The definition of "convenient" depends on the type of bucket that
1038 * is being read, and is decided by APR. In the case of memory based
1039 * buckets such as heap and immortal buckets, a pointer will be
1040 * returned to the location of the buffer containing the complete
1041 * contents of the bucket.
1042 *
1043 * Some buckets, such as the socket bucket, might have no concept
1044 * of length. If an attempt is made to read such a bucket, the
1045 * apr_bucket_read function will read a convenient amount of data
1046 * from the socket. The socket bucket is magically morphed into a
1047 * heap bucket containing the just-read data, and a new socket bucket
1048 * is inserted just after this heap bucket.
1049 *
1050 * To understand why apr_bucket_read might do this, consider the loop
1051 * described above to read and process buckets. The current bucket
1052 * is magically morphed into a heap bucket and returned to the caller.
1053 * The caller processes the data, and deletes the heap bucket, moving
1054 * onto the next bucket, the new socket bucket. This process repeats,
1055 * giving the illusion of a bucket brigade that contains potentially
1056 * infinite amounts of data. It is up to the caller to decide at what
1057 * point to stop reading buckets.
1058 *
1059 * Some buckets, such as the file bucket, might have a fixed size,
1060 * but be significantly larger than is practical to store in RAM in
1061 * one go. As with the socket bucket, if an attempt is made to read
1062 * from a file bucket, the file bucket is magically morphed into a
1063 * heap bucket containing a convenient amount of data read from the
1064 * current offset in the file. During the read, the offset will be
1065 * moved forward on the file, and a new file bucket will be inserted
1066 * directly after the current bucket representing the remainder of the
1067 * file. If the heap bucket was large enough to store the whole
1068 * remainder of the file, no more file buckets are inserted, and the
1069 * file bucket will disappear completely.
1070 *
1071 * The pattern for reading buckets described above does create the
1072 * illusion that the code is willing to swallow buckets that might be
1073 * too large for the system to handle in one go. This however is just
1074 * an illusion: APR will always ensure that large (file) or infinite
1075 * (socket) buckets are broken into convenient bite sized heap buckets
1076 * before data is returned to the caller.
1077 *
1078 * There is a potential gotcha to watch for: if buckets are read in a
1079 * loop, and aren't deleted after being processed, the potentially large
1080 * bucket will slowly be converted into RAM resident heap buckets. If
1081 * the file is larger than available RAM, an out of memory condition
1082 * could be caused if the application is not careful to manage this.
1083 *
1084 * @param e The bucket to read from
1085 * @param str The location to store a pointer to the data in
1086 * @param len The location to store the amount of data read
1087 * @param block Whether the read function blocks
1088 */
1089#define apr_bucket_read(e,str,len,block) (e)->type->read(e, str, len, block)
1090
1091/**
1092 * Setaside data so that stack data is not destroyed on returning from
1093 * the function
1094 * @param e The bucket to setaside
1095 * @param p The pool to setaside into
1096 */
1097#define apr_bucket_setaside(e,p) (e)->type->setaside(e,p)
1098
1099/**
1100 * Split one bucket in two at the point provided.
1101 *
1102 * Once split, the original bucket becomes the first of the two new buckets.
1103 *
1104 * (It is assumed that the bucket is a member of a brigade when this
1105 * function is called).
1106 * @param e The bucket to split
1107 * @param point The offset to split the bucket at
1108 */
1109#define apr_bucket_split(e,point) (e)->type->split(e, point)
1110
1111/**
1112 * Copy a bucket.
1113 * @param e The bucket to copy
1114 * @param c Returns a pointer to the new bucket
1115 */
1116#define apr_bucket_copy(e,c) (e)->type->copy(e, c)
1117
1118/* Bucket type handling */
1119
1120/**
1121 * This function simply returns APR_SUCCESS to denote that the bucket does
1122 * not require anything to happen for its setaside() function. This is
1123 * appropriate for buckets that have "immortal" data -- the data will live
1124 * at least as long as the bucket.
1125 * @param data The bucket to setaside
1126 * @param pool The pool defining the desired lifetime of the bucket data
1127 * @return APR_SUCCESS
1128 */
1130 apr_pool_t *pool);
1131
1132/**
1133 * A place holder function that signifies that the setaside function was not
1134 * implemented for this bucket
1135 * @param data The bucket to setaside
1136 * @param pool The pool defining the desired lifetime of the bucket data
1137 * @return APR_ENOTIMPL
1138 */
1140 apr_pool_t *pool);
1141
1142/**
1143 * A place holder function that signifies that the split function was not
1144 * implemented for this bucket
1145 * @param data The bucket to split
1146 * @param point The location to split the bucket
1147 * @return APR_ENOTIMPL
1148 */
1150 apr_size_t point);
1151
1152/**
1153 * A place holder function that signifies that the copy function was not
1154 * implemented for this bucket
1155 * @param e The bucket to copy
1156 * @param c Returns a pointer to the new bucket
1157 * @return APR_ENOTIMPL
1158 */
1160 apr_bucket **c);
1161
1162/**
1163 * A place holder function that signifies that this bucket does not need
1164 * to do anything special to be destroyed. That's only the case for buckets
1165 * that either have no data (metadata buckets) or buckets whose data pointer
1166 * points to something that's not a bucket-type-specific structure, as with
1167 * simple buckets where data points to a string and pipe buckets where data
1168 * points directly to the apr_file_t.
1169 * @param data The bucket data to destroy
1170 */
1171APU_DECLARE_NONSTD(void) apr_bucket_destroy_noop(void *data);
1172
1173/**
1174 * There is no apr_bucket_destroy_notimpl, because destruction is required
1175 * to be implemented (it could be a noop, but only if that makes sense for
1176 * the bucket type)
1177 */
1178
1179/* There is no apr_bucket_read_notimpl, because it is a required function
1180 */
1181
1182
1183/* All of the bucket types implemented by the core */
1184/**
1185 * The flush bucket type. This signifies that all data should be flushed to
1186 * the next filter. The flush bucket should be sent with the other buckets.
1187 */
1188APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_flush;
1189/**
1190 * The EOS bucket type. This signifies that there will be no more data, ever.
1191 * All filters MUST send all data to the next filter when they receive a
1192 * bucket of this type
1193 */
1194APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_eos;
1195/**
1196 * The FILE bucket type. This bucket represents a file on disk
1197 */
1198APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_file;
1199/**
1200 * The HEAP bucket type. This bucket represents a data allocated from the
1201 * heap.
1202 */
1203APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_heap;
1204#if APR_HAS_MMAP
1205/**
1206 * The MMAP bucket type. This bucket represents an MMAP'ed file
1207 */
1208APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_mmap;
1209#endif
1210/**
1211 * The POOL bucket type. This bucket represents a data that was allocated
1212 * from a pool. IF this bucket is still available when the pool is cleared,
1213 * the data is copied on to the heap.
1214 */
1215APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pool;
1216/**
1217 * The PIPE bucket type. This bucket represents a pipe to another program.
1218 */
1219APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pipe;
1220/**
1221 * The IMMORTAL bucket type. This bucket represents a segment of data that
1222 * the creator is willing to take responsibility for. The core will do
1223 * nothing with the data in an immortal bucket
1224 */
1225APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_immortal;
1226/**
1227 * The TRANSIENT bucket type. This bucket represents a data allocated off
1228 * the stack. When the setaside function is called, this data is copied on
1229 * to the heap
1230 */
1231APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_transient;
1232/**
1233 * The SOCKET bucket type. This bucket represents a socket to another machine
1234 */
1235APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_socket;
1236
1237
1238/* ***** Simple buckets ***** */
1239
1240/**
1241 * Split a simple bucket into two at the given point. Most non-reference
1242 * counting buckets that allow multiple references to the same block of
1243 * data (eg transient and immortal) will use this as their split function
1244 * without any additional type-specific handling.
1245 * @param b The bucket to be split
1246 * @param point The offset of the first byte in the new bucket
1247 * @return APR_EINVAL if the point is not within the bucket;
1248 * APR_ENOMEM if allocation failed;
1249 * or APR_SUCCESS
1250 */
1252 apr_size_t point);
1253
1254/**
1255 * Copy a simple bucket. Most non-reference-counting buckets that allow
1256 * multiple references to the same block of data (eg transient and immortal)
1257 * will use this as their copy function without any additional type-specific
1258 * handling.
1259 * @param a The bucket to copy
1260 * @param b Returns a pointer to the new bucket
1261 * @return APR_ENOMEM if allocation failed;
1262 * or APR_SUCCESS
1263 */
1265 apr_bucket **b);
1266
1267
1268/* ***** Shared, reference-counted buckets ***** */
1269
1270/**
1271 * Initialize a bucket containing reference-counted data that may be
1272 * shared. The caller must allocate the bucket if necessary and
1273 * initialize its type-dependent fields, and allocate and initialize
1274 * its own private data structure. This function should only be called
1275 * by type-specific bucket creation functions.
1276 * @param b The bucket to initialize
1277 * @param data A pointer to the private data structure
1278 * with the reference count at the start
1279 * @param start The start of the data in the bucket
1280 * relative to the private base pointer
1281 * @param length The length of the data in the bucket
1282 * @return The new bucket, or NULL if allocation failed
1283 */
1284APU_DECLARE(apr_bucket *) apr_bucket_shared_make(apr_bucket *b, void *data,
1285 apr_off_t start,
1286 apr_size_t length);
1287
1288/**
1289 * Decrement the refcount of the data in the bucket. This function
1290 * should only be called by type-specific bucket destruction functions.
1291 * @param data The private data pointer from the bucket to be destroyed
1292 * @return TRUE or FALSE; TRUE if the reference count is now
1293 * zero, indicating that the shared resource itself can
1294 * be destroyed by the caller.
1295 */
1296APU_DECLARE(int) apr_bucket_shared_destroy(void *data);
1297
1298/**
1299 * Split a bucket into two at the given point, and adjust the refcount
1300 * to the underlying data. Most reference-counting bucket types will
1301 * be able to use this function as their split function without any
1302 * additional type-specific handling.
1303 * @param b The bucket to be split
1304 * @param point The offset of the first byte in the new bucket
1305 * @return APR_EINVAL if the point is not within the bucket;
1306 * APR_ENOMEM if allocation failed;
1307 * or APR_SUCCESS
1308 */
1310 apr_size_t point);
1311
1312/**
1313 * Copy a refcounted bucket, incrementing the reference count. Most
1314 * reference-counting bucket types will be able to use this function
1315 * as their copy function without any additional type-specific handling.
1316 * @param a The bucket to copy
1317 * @param b Returns a pointer to the new bucket
1318 * @return APR_ENOMEM if allocation failed;
1319 or APR_SUCCESS
1320 */
1322 apr_bucket **b);
1323
1324
1325/* ***** Functions to Create Buckets of varying types ***** */
1326/*
1327 * Each bucket type foo has two initialization functions:
1328 * apr_bucket_foo_make which sets up some already-allocated memory as a
1329 * bucket of type foo; and apr_bucket_foo_create which allocates memory
1330 * for the bucket, calls apr_bucket_make_foo, and initializes the
1331 * bucket's list pointers. The apr_bucket_foo_make functions are used
1332 * inside the bucket code to change the type of buckets in place;
1333 * other code should call apr_bucket_foo_create. All the initialization
1334 * functions change nothing if they fail.
1335 */
1336
1337/**
1338 * Create an End of Stream bucket. This indicates that there is no more data
1339 * coming from down the filter stack. All filters should flush at this point.
1340 * @param list The freelist from which this bucket should be allocated
1341 * @return The new bucket, or NULL if allocation failed
1342 */
1344
1345/**
1346 * Make the bucket passed in an EOS bucket. This indicates that there is no
1347 * more data coming from down the filter stack. All filters should flush at
1348 * this point.
1349 * @param b The bucket to make into an EOS bucket
1350 * @return The new bucket, or NULL if allocation failed
1351 */
1353
1354/**
1355 * Create a flush bucket. This indicates that filters should flush their
1356 * data. There is no guarantee that they will flush it, but this is the
1357 * best we can do.
1358 * @param list The freelist from which this bucket should be allocated
1359 * @return The new bucket, or NULL if allocation failed
1360 */
1362
1363/**
1364 * Make the bucket passed in a FLUSH bucket. This indicates that filters
1365 * should flush their data. There is no guarantee that they will flush it,
1366 * but this is the best we can do.
1367 * @param b The bucket to make into a FLUSH bucket
1368 * @return The new bucket, or NULL if allocation failed
1369 */
1371
1372/**
1373 * Create a bucket referring to long-lived data.
1374 * @param buf The data to insert into the bucket
1375 * @param nbyte The size of the data to insert.
1376 * @param list The freelist from which this bucket should be allocated
1377 * @return The new bucket, or NULL if allocation failed
1378 */
1379APU_DECLARE(apr_bucket *) apr_bucket_immortal_create(const char *buf,
1380 apr_size_t nbyte,
1381 apr_bucket_alloc_t *list);
1382
1383/**
1384 * Make the bucket passed in a bucket refer to long-lived data
1385 * @param b The bucket to make into a IMMORTAL bucket
1386 * @param buf The data to insert into the bucket
1387 * @param nbyte The size of the data to insert.
1388 * @return The new bucket, or NULL if allocation failed
1389 */
1391 const char *buf,
1392 apr_size_t nbyte);
1393
1394/**
1395 * Create a bucket referring to data on the stack.
1396 * @param buf The data to insert into the bucket
1397 * @param nbyte The size of the data to insert.
1398 * @param list The freelist from which this bucket should be allocated
1399 * @return The new bucket, or NULL if allocation failed
1400 */
1401APU_DECLARE(apr_bucket *) apr_bucket_transient_create(const char *buf,
1402 apr_size_t nbyte,
1403 apr_bucket_alloc_t *list);
1404
1405/**
1406 * Make the bucket passed in a bucket refer to stack data
1407 * @param b The bucket to make into a TRANSIENT bucket
1408 * @param buf The data to insert into the bucket
1409 * @param nbyte The size of the data to insert.
1410 * @return The new bucket, or NULL if allocation failed
1411 */
1413 const char *buf,
1414 apr_size_t nbyte);
1415
1416/**
1417 * Create a bucket referring to memory on the heap. If the caller asks
1418 * for the data to be copied, this function always allocates 4K of
1419 * memory so that more data can be added to the bucket without
1420 * requiring another allocation. Therefore not all the data may be put
1421 * into the bucket. If copying is not requested then the bucket takes
1422 * over responsibility for free()ing the memory.
1423 * @param buf The buffer to insert into the bucket
1424 * @param nbyte The size of the buffer to insert.
1425 * @param free_func Function to use to free the data; NULL indicates that the
1426 * bucket should make a copy of the data
1427 * @param list The freelist from which this bucket should be allocated
1428 * @return The new bucket, or NULL if allocation failed
1429 */
1430APU_DECLARE(apr_bucket *) apr_bucket_heap_create(const char *buf,
1431 apr_size_t nbyte,
1432 void (*free_func)(void *data),
1433 apr_bucket_alloc_t *list);
1434/**
1435 * Make the bucket passed in a bucket refer to heap data
1436 * @param b The bucket to make into a HEAP bucket
1437 * @param buf The buffer to insert into the bucket
1438 * @param nbyte The size of the buffer to insert.
1439 * @param free_func Function to use to free the data; NULL indicates that the
1440 * bucket should make a copy of the data
1441 * @return The new bucket, or NULL if allocation failed
1442 */
1443APU_DECLARE(apr_bucket *) apr_bucket_heap_make(apr_bucket *b, const char *buf,
1444 apr_size_t nbyte,
1445 void (*free_func)(void *data));
1446
1447/**
1448 * Create a bucket referring to memory allocated from a pool.
1449 *
1450 * @param buf The buffer to insert into the bucket
1451 * @param length The number of bytes referred to by this bucket
1452 * @param pool The pool the memory was allocated from
1453 * @param list The freelist from which this bucket should be allocated
1454 * @return The new bucket, or NULL if allocation failed
1455 */
1456APU_DECLARE(apr_bucket *) apr_bucket_pool_create(const char *buf,
1457 apr_size_t length,
1458 apr_pool_t *pool,
1459 apr_bucket_alloc_t *list);
1460
1461/**
1462 * Make the bucket passed in a bucket refer to pool data
1463 * @param b The bucket to make into a pool bucket
1464 * @param buf The buffer to insert into the bucket
1465 * @param length The number of bytes referred to by this bucket
1466 * @param pool The pool the memory was allocated from
1467 * @return The new bucket, or NULL if allocation failed
1468 */
1469APU_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b, const char *buf,
1470 apr_size_t length,
1471 apr_pool_t *pool);
1472
1473#if APR_HAS_MMAP
1474/**
1475 * Create a bucket referring to mmap()ed memory.
1476 * @param mm The mmap to insert into the bucket
1477 * @param start The offset of the first byte in the mmap
1478 * that this bucket refers to
1479 * @param length The number of bytes referred to by this bucket
1480 * @param list The freelist from which this bucket should be allocated
1481 * @return The new bucket, or NULL if allocation failed
1482 */
1484 apr_off_t start,
1485 apr_size_t length,
1486 apr_bucket_alloc_t *list);
1487
1488/**
1489 * Make the bucket passed in a bucket refer to an MMAP'ed file
1490 * @param b The bucket to make into a MMAP bucket
1491 * @param mm The mmap to insert into the bucket
1492 * @param start The offset of the first byte in the mmap
1493 * that this bucket refers to
1494 * @param length The number of bytes referred to by this bucket
1495 * @return The new bucket, or NULL if allocation failed
1496 */
1498 apr_off_t start,
1499 apr_size_t length);
1500#endif
1501
1502/**
1503 * Create a bucket referring to a socket.
1504 * @param thissock The socket to put in the bucket
1505 * @param list The freelist from which this bucket should be allocated
1506 * @return The new bucket, or NULL if allocation failed
1507 */
1509 apr_bucket_alloc_t *list);
1510/**
1511 * Make the bucket passed in a bucket refer to a socket
1512 * @param b The bucket to make into a SOCKET bucket
1513 * @param thissock The socket to put in the bucket
1514 * @return The new bucket, or NULL if allocation failed
1515 */
1517 apr_socket_t *thissock);
1518
1519/**
1520 * Create a bucket referring to a pipe.
1521 * @param thispipe The pipe to put in the bucket
1522 * @param list The freelist from which this bucket should be allocated
1523 * @return The new bucket, or NULL if allocation failed
1524 */
1526 apr_bucket_alloc_t *list);
1527
1528/**
1529 * Make the bucket passed in a bucket refer to a pipe
1530 * @param b The bucket to make into a PIPE bucket
1531 * @param thispipe The pipe to put in the bucket
1532 * @return The new bucket, or NULL if allocation failed
1533 */
1535 apr_file_t *thispipe);
1536
1537/**
1538 * Create a bucket referring to a file.
1539 * @param fd The file to put in the bucket
1540 * @param offset The offset where the data of interest begins in the file
1541 * @param len The amount of data in the file we are interested in
1542 * @param p The pool into which any needed structures should be created
1543 * while reading from this file bucket
1544 * @param list The freelist from which this bucket should be allocated
1545 * @return The new bucket, or NULL if allocation failed
1546 * @remark If the file is truncated such that the segment of the file
1547 * referenced by the bucket no longer exists, an attempt to read
1548 * from the bucket will fail with APR_EOF.
1549 * @remark apr_brigade_insert_file() should generally be used to
1550 * insert files into brigades, since that function can correctly
1551 * handle large file issues.
1552 */
1554 apr_off_t offset,
1555 apr_size_t len,
1556 apr_pool_t *p,
1557 apr_bucket_alloc_t *list);
1558
1559/**
1560 * Make the bucket passed in a bucket refer to a file
1561 * @param b The bucket to make into a FILE bucket
1562 * @param fd The file to put in the bucket
1563 * @param offset The offset where the data of interest begins in the file
1564 * @param len The amount of data in the file we are interested in
1565 * @param p The pool into which any needed structures should be created
1566 * while reading from this file bucket
1567 * @return The new bucket, or NULL if allocation failed
1568 */
1570 apr_off_t offset,
1571 apr_size_t len, apr_pool_t *p);
1572
1573/**
1574 * Enable or disable memory-mapping for a FILE bucket (default is enabled)
1575 * @param b The bucket
1576 * @param enabled Whether memory-mapping should be enabled
1577 * @return APR_SUCCESS normally, or an error code if the operation fails
1578 */
1580 int enabled);
1581
1582/**
1583 * Set the size of the read buffer allocated by a FILE bucket (default
1584 * is @a APR_BUCKET_BUFF_SIZE)
1585 * memory-mapping is disabled only)
1586 * @param b The bucket
1587 * @param size Size of the allocated buffers
1588 * @return APR_SUCCESS normally, or an error code if the operation fails
1589 * @remark Relevant/used only when memory-mapping is disabled (@see
1590 * apr_bucket_file_enable_mmap)
1591 */
1593 apr_size_t size);
1594
1595/** @} */
1596#ifdef __cplusplus
1597}
1598#endif
1599
1600#endif /* !APR_BUCKETS_H */
APR Platform Definitions.
APR Error Codes.
APR File I/O Handling.
APR Miscellaneous library routines.
APR MMAP routines.
APR Network library.
APR Rings.
apr_bucket * apr_bucket_eos_make(apr_bucket *b)
void apr_bucket_destroy_noop(void *data)
apr_status_t apr_bucket_simple_copy(apr_bucket *a, apr_bucket **b)
apr_bucket * apr_bucket_pool_make(apr_bucket *b, const char *buf, apr_size_t length, apr_pool_t *pool)
const apr_bucket_type_t apr_bucket_type_transient
apr_bucket * apr_bucket_socket_make(apr_bucket *b, apr_socket_t *thissock)
apr_status_t apr_brigade_putstrs(apr_bucket_brigade *b, apr_brigade_flush flush, void *ctx,...)
apr_bucket * apr_bucket_flush_make(apr_bucket *b)
apr_bucket * apr_bucket_socket_create(apr_socket_t *thissock, apr_bucket_alloc_t *list)
apr_bucket * apr_brigade_insert_file(apr_bucket_brigade *bb, apr_file_t *f, apr_off_t start, apr_off_t len, apr_pool_t *p)
apr_status_t apr_brigade_split_line(apr_bucket_brigade *bbOut, apr_bucket_brigade *bbIn, apr_read_type_e block, apr_off_t maxbytes)
apr_bucket * apr_bucket_pipe_create(apr_file_t *thispipe, apr_bucket_alloc_t *list)
apr_bucket * apr_bucket_heap_create(const char *buf, apr_size_t nbyte, void(*free_func)(void *data), apr_bucket_alloc_t *list)
const apr_bucket_type_t apr_bucket_type_heap
apr_bucket * apr_bucket_immortal_make(apr_bucket *b, const char *buf, apr_size_t nbyte)
apr_status_t apr_brigade_puts(apr_bucket_brigade *bb, apr_brigade_flush flush, void *ctx, const char *str)
apr_status_t apr_bucket_shared_copy(apr_bucket *a, apr_bucket **b)
apr_status_t apr_brigade_destroy(apr_bucket_brigade *b)
apr_status_t apr_brigade_flatten(apr_bucket_brigade *bb, char *c, apr_size_t *len)
apr_status_t apr_bucket_split_notimpl(apr_bucket *data, apr_size_t point)
const apr_bucket_type_t apr_bucket_type_pipe
apr_status_t apr_brigade_putc(apr_bucket_brigade *b, apr_brigade_flush flush, void *ctx, const char c)
apr_status_t apr_brigade_vputstrs(apr_bucket_brigade *b, apr_brigade_flush flush, void *ctx, va_list va)
const apr_bucket_type_t apr_bucket_type_immortal
apr_bucket_brigade * apr_brigade_split(apr_bucket_brigade *b, apr_bucket *e)
apr_bucket * apr_bucket_transient_make(apr_bucket *b, const char *buf, apr_size_t nbyte)
apr_bucket * apr_bucket_mmap_create(apr_mmap_t *mm, apr_off_t start, apr_size_t length, apr_bucket_alloc_t *list)
apr_status_t apr_brigade_printf(apr_bucket_brigade *b, apr_brigade_flush flush, void *ctx, const char *fmt,...)
int apr_bucket_shared_destroy(void *data)
apr_bucket * apr_bucket_heap_make(apr_bucket *b, const char *buf, apr_size_t nbyte, void(*free_func)(void *data))
apr_status_t apr_brigade_partition(apr_bucket_brigade *b, apr_off_t point, apr_bucket **after_point)
apr_bucket * apr_bucket_flush_create(apr_bucket_alloc_t *list)
const apr_bucket_type_t apr_bucket_type_file
apr_bucket * apr_bucket_pipe_make(apr_bucket *b, apr_file_t *thispipe)
apr_status_t apr_bucket_copy_notimpl(apr_bucket *e, apr_bucket **c)
apr_bucket * apr_bucket_shared_make(apr_bucket *b, void *data, apr_off_t start, apr_size_t length)
const apr_bucket_type_t apr_bucket_type_mmap
apr_status_t apr_brigade_length(apr_bucket_brigade *bb, int read_all, apr_off_t *length)
apr_status_t apr_brigade_write(apr_bucket_brigade *b, apr_brigade_flush flush, void *ctx, const char *str, apr_size_t nbyte)
apr_read_type_e
Definition apr_buckets.h:57
apr_bucket_alloc_t * apr_bucket_alloc_create(apr_pool_t *p)
apr_bucket * apr_bucket_mmap_make(apr_bucket *b, apr_mmap_t *mm, apr_off_t start, apr_size_t length)
apr_bucket * apr_bucket_file_make(apr_bucket *b, apr_file_t *fd, apr_off_t offset, apr_size_t len, apr_pool_t *p)
apr_bucket_brigade * apr_brigade_create(apr_pool_t *p, apr_bucket_alloc_t *list)
const apr_bucket_type_t apr_bucket_type_eos
apr_status_t apr_bucket_shared_split(apr_bucket *b, apr_size_t point)
const apr_bucket_type_t apr_bucket_type_pool
apr_bucket_brigade * apr_brigade_split_ex(apr_bucket_brigade *b, apr_bucket *e, apr_bucket_brigade *a)
void * apr_bucket_alloc(apr_size_t size, apr_bucket_alloc_t *list)
apr_status_t apr_brigade_to_iovec(apr_bucket_brigade *b, struct iovec *vec, int *nvec)
void apr_bucket_free(void *block)
struct apr_bucket_alloc_t apr_bucket_alloc_t
Definition apr_buckets.h:123
apr_status_t apr_brigade_vprintf(apr_bucket_brigade *b, apr_brigade_flush flush, void *ctx, const char *fmt, va_list va)
apr_status_t apr_bucket_simple_split(apr_bucket *b, apr_size_t point)
apr_status_t apr_brigade_pflatten(apr_bucket_brigade *bb, char **c, apr_size_t *len, apr_pool_t *pool)
const apr_bucket_type_t apr_bucket_type_socket
apr_status_t apr_bucket_file_set_buf_size(apr_bucket *b, apr_size_t size)
apr_size_t apr_bucket_alloc_aligned_floor(apr_bucket_alloc_t *list, apr_size_t size)
apr_status_t apr_bucket_file_enable_mmap(apr_bucket *b, int enabled)
apr_bucket * apr_bucket_eos_create(apr_bucket_alloc_t *list)
apr_bucket * apr_bucket_file_create(apr_file_t *fd, apr_off_t offset, apr_size_t len, apr_pool_t *p, apr_bucket_alloc_t *list)
apr_bucket * apr_bucket_pool_create(const char *buf, apr_size_t length, apr_pool_t *pool, apr_bucket_alloc_t *list)
apr_bucket * apr_bucket_immortal_create(const char *buf, apr_size_t nbyte, apr_bucket_alloc_t *list)
apr_status_t apr_bucket_setaside_notimpl(apr_bucket *data, apr_pool_t *pool)
apr_bucket_alloc_t * apr_bucket_alloc_create_ex(apr_allocator_t *allocator)
apr_status_t apr_bucket_setaside_noop(apr_bucket *data, apr_pool_t *pool)
const apr_bucket_type_t apr_bucket_type_flush
void apr_bucket_alloc_destroy(apr_bucket_alloc_t *list)
apr_bucket * apr_bucket_transient_create(const char *buf, apr_size_t nbyte, apr_bucket_alloc_t *list)
apr_status_t(* apr_brigade_flush)(apr_bucket_brigade *bb, void *ctx)
Definition apr_buckets.h:282
apr_status_t apr_brigade_writev(apr_bucket_brigade *b, apr_brigade_flush flush, void *ctx, const struct iovec *vec, apr_size_t nvec)
apr_status_t apr_brigade_cleanup(void *data)
@ APR_BLOCK_READ
Definition apr_buckets.h:58
@ APR_NONBLOCK_READ
Definition apr_buckets.h:59
struct apr_allocator_t apr_allocator_t
Definition apr_allocator.h:41
int apr_status_t
Definition apr_errno.h:44
struct apr_file_t apr_file_t
Definition apr_file_io.h:188
struct apr_socket_t apr_socket_t
Definition apr_network_io.h:219
struct apr_pool_t apr_pool_t
Definition apr_pools.h:60
Definition apr_buckets.h:258
APR_RING_HEAD(apr_bucket_list, apr_bucket) list
apr_pool_t * p
Definition apr_buckets.h:264
apr_bucket_alloc_t * bucket_alloc
Definition apr_buckets.h:275
Definition apr_buckets.h:612
apr_pool_t * readpool
Definition apr_buckets.h:619
int can_mmap
Definition apr_buckets.h:623
apr_size_t read_size
Definition apr_buckets.h:626
apr_file_t * fd
Definition apr_buckets.h:616
apr_bucket_refcount refcount
Definition apr_buckets.h:614
Definition apr_buckets.h:543
apr_bucket_refcount refcount
Definition apr_buckets.h:545
char * base
Definition apr_buckets.h:549
void(* free_func)(void *data)
Definition apr_buckets.h:553
apr_size_t alloc_len
Definition apr_buckets.h:551
Definition apr_buckets.h:599
apr_mmap_t * mmap
Definition apr_buckets.h:603
apr_bucket_refcount refcount
Definition apr_buckets.h:601
Definition apr_buckets.h:561
apr_bucket_heap heap
Definition apr_buckets.h:573
apr_bucket_alloc_t * list
Definition apr_buckets.h:590
const char * base
Definition apr_buckets.h:579
apr_pool_t * pool
Definition apr_buckets.h:586
Definition apr_buckets.h:531
int refcount
Definition apr_buckets.h:533
Definition apr_buckets.h:131
apr_status_t(* split)(apr_bucket *e, apr_size_t point)
Definition apr_buckets.h:203
enum apr_bucket_type_t::@275002372233073243202132265245302134137372222015 is_metadata
apr_status_t(* copy)(apr_bucket *e, apr_bucket **c)
Definition apr_buckets.h:211
apr_status_t(* read)(apr_bucket *b, const char **str, apr_size_t *len, apr_read_type_e block)
Definition apr_buckets.h:176
@ APR_BUCKET_DATA
Definition apr_buckets.h:153
@ APR_BUCKET_METADATA
Definition apr_buckets.h:155
const char * name
Definition apr_buckets.h:135
int num_func
Definition apr_buckets.h:140
apr_status_t(* setaside)(apr_bucket *e, apr_pool_t *pool)
Definition apr_buckets.h:192
void(* destroy)(void *data)
Definition apr_buckets.h:164
Definition apr_buckets.h:224
apr_size_t length
Definition apr_buckets.h:234
void(* free)(void *e)
Definition apr_buckets.h:252
apr_off_t start
Definition apr_buckets.h:242
apr_bucket_alloc_t * list
Definition apr_buckets.h:254
void * data
Definition apr_buckets.h:244
APR_RING_ENTRY(apr_bucket) link
const apr_bucket_type_t * type
Definition apr_buckets.h:228
Definition apr_mmap.h:62
Definition apr_buckets.h:635
apr_bucket_heap heap
Definition apr_buckets.h:637
apr_bucket_mmap mmap
Definition apr_buckets.h:640
apr_bucket b
Definition apr_buckets.h:636
apr_bucket_file file
Definition apr_buckets.h:642
apr_bucket_pool pool
Definition apr_buckets.h:638