Apache Portable Runtime
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
44 extern "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 */
57 typedef 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 */
121 typedef 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  */
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. */
154  /** This bucket type represents metadata. */
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  */
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  */
224 struct apr_bucket {
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 */
533  int refcount;
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 */
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 */
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  */
681 APU_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,
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  */
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  */
893 APU_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  */
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  */
948 APU_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  */
958 APU_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  */
964 APU_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  */
974 APU_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  */
983 APU_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  */
989 APU_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  */
1127 APU_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  */
1137 APU_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  */
1147 APU_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  */
1157 APU_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  */
1169 APU_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  */
1186 APU_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  */
1192 APU_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  */
1196 APU_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  */
1201 APU_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  */
1206 APU_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  */
1213 APU_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  */
1217 APU_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  */
1223 APU_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  */
1229 APU_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  */
1233 APU_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  */
1249 APU_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  */
1262 APU_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  */
1282 APU_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  */
1294 APU_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  */
1307 APU_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  */
1319 APU_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  */
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  */
1350 APU_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  */
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  */
1368 APU_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  */
1377 APU_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  */
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  */
1399 APU_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  */
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  */
1428 APU_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  */
1441 APU_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  */
1454 APU_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  */
1467 APU_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  */
1481 APU_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  */
1495 APU_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  */
1506 APU_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  */
1514 APU_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  */
1523 APU_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  */
1532 APU_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  */
1551 APU_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  */
1567 APU_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  */
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  */
1591  apr_size_t size);
1592 
1593 /** @} */
1594 #ifdef __cplusplus
1595 }
1596 #endif
1597 
1598 #endif /* !APR_BUCKETS_H */
apr_bucket_mmap::mmap
apr_mmap_t * mmap
Definition: apr_buckets.h:603
apr_bucket_flush_make
apr_bucket * apr_bucket_flush_make(apr_bucket *b)
apr_bucket_type_mmap
const apr_bucket_type_t apr_bucket_type_mmap
apr_bucket_file::can_mmap
int can_mmap
Definition: apr_buckets.h:623
apr_bucket_brigade::bucket_alloc
apr_bucket_alloc_t * bucket_alloc
Definition: apr_buckets.h:275
apr_bucket_alloc
void * apr_bucket_alloc(apr_size_t size, apr_bucket_alloc_t *list)
apr_bucket_alloc_destroy
void apr_bucket_alloc_destroy(apr_bucket_alloc_t *list)
apr_brigade_printf
apr_status_t apr_brigade_printf(apr_bucket_brigade *b, apr_brigade_flush flush, void *ctx, const char *fmt,...)
APR_BLOCK_READ
@ APR_BLOCK_READ
Definition: apr_buckets.h:58
apr_bucket_pool_create
apr_bucket * apr_bucket_pool_create(const char *buf, apr_size_t length, apr_pool_t *pool, apr_bucket_alloc_t *list)
apr_bucket_file::readpool
apr_pool_t * readpool
Definition: apr_buckets.h:619
apr_bucket_type_immortal
const apr_bucket_type_t apr_bucket_type_immortal
apr_bucket_type_file
const apr_bucket_type_t apr_bucket_type_file
apr_errno.h
APR Error Codes.
apr_bucket_alloc_create
apr_bucket_alloc_t * apr_bucket_alloc_create(apr_pool_t *p)
apr_bucket_type_eos
const apr_bucket_type_t apr_bucket_type_eos
apr_bucket_simple_copy
apr_status_t apr_bucket_simple_copy(apr_bucket *a, apr_bucket **b)
apr_bucket_mmap_make
apr_bucket * apr_bucket_mmap_make(apr_bucket *b, apr_mmap_t *mm, apr_off_t start, apr_size_t length)
apr_bucket_file::fd
apr_file_t * fd
Definition: apr_buckets.h:616
apr_bucket_immortal_make
apr_bucket * apr_bucket_immortal_make(apr_bucket *b, const char *buf, apr_size_t nbyte)
apr_bucket_heap_make
apr_bucket * apr_bucket_heap_make(apr_bucket *b, const char *buf, apr_size_t nbyte, void(*free_func)(void *data))
apr_brigade_partition
apr_status_t apr_brigade_partition(apr_bucket_brigade *b, apr_off_t point, apr_bucket **after_point)
apr_bucket_socket_make
apr_bucket * apr_bucket_socket_make(apr_bucket *b, apr_socket_t *thissock)
apr_bucket_heap::base
char * base
Definition: apr_buckets.h:549
apr_allocator_t
struct apr_allocator_t apr_allocator_t
Definition: apr_allocator.h:41
apr_bucket_refcount::refcount
int refcount
Definition: apr_buckets.h:533
apr_bucket_split_notimpl
apr_status_t apr_bucket_split_notimpl(apr_bucket *data, apr_size_t point)
apr_bucket_structs::heap
apr_bucket_heap heap
Definition: apr_buckets.h:637
apr_bucket_type_t::name
const char * name
Definition: apr_buckets.h:135
apr_bucket_type_heap
const apr_bucket_type_t apr_bucket_type_heap
apr_bucket::length
apr_size_t length
Definition: apr_buckets.h:234
apr_brigade_create
apr_bucket_brigade * apr_brigade_create(apr_pool_t *p, apr_bucket_alloc_t *list)
apr_bucket_mmap_create
apr_bucket * apr_bucket_mmap_create(apr_mmap_t *mm, apr_off_t start, apr_size_t length, apr_bucket_alloc_t *list)
apr_brigade_length
apr_status_t apr_brigade_length(apr_bucket_brigade *bb, int read_all, apr_off_t *length)
apr_bucket::type
const apr_bucket_type_t * type
Definition: apr_buckets.h:228
apr_bucket_structs::mmap
apr_bucket_mmap mmap
Definition: apr_buckets.h:640
apr_bucket_setaside_noop
apr_status_t apr_bucket_setaside_noop(apr_bucket *data, apr_pool_t *pool)
apr_bucket_immortal_create
apr_bucket * apr_bucket_immortal_create(const char *buf, apr_size_t nbyte, apr_bucket_alloc_t *list)
apr_brigade_vputstrs
apr_status_t apr_brigade_vputstrs(apr_bucket_brigade *b, apr_brigade_flush flush, void *ctx, va_list va)
apr_brigade_flatten
apr_status_t apr_brigade_flatten(apr_bucket_brigade *bb, char *c, apr_size_t *len)
apr_brigade_puts
apr_status_t apr_brigade_puts(apr_bucket_brigade *bb, apr_brigade_flush flush, void *ctx, const char *str)
apr_brigade_cleanup
apr_status_t apr_brigade_cleanup(void *data)
apr_bucket_shared_destroy
int apr_bucket_shared_destroy(void *data)
apr_bucket_type_t::copy
apr_status_t(* copy)(apr_bucket *e, apr_bucket **c)
Definition: apr_buckets.h:211
apr_bucket_flush_create
apr_bucket * apr_bucket_flush_create(apr_bucket_alloc_t *list)
apr_brigade_split_ex
apr_bucket_brigade * apr_brigade_split_ex(apr_bucket_brigade *b, apr_bucket *e, apr_bucket_brigade *a)
apr_bucket_heap_create
apr_bucket * apr_bucket_heap_create(const char *buf, apr_size_t nbyte, void(*free_func)(void *data), apr_bucket_alloc_t *list)
apr_brigade_split_line
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_mmap.h
APR MMAP routines.
apr_bucket_type_t::APR_BUCKET_DATA
@ APR_BUCKET_DATA
Definition: apr_buckets.h:153
apr_bucket_type_flush
const apr_bucket_type_t apr_bucket_type_flush
apr_bucket_mmap
Definition: apr_buckets.h:599
apr_bucket_destroy_noop
void apr_bucket_destroy_noop(void *data)
apr_network_io.h
APR Network library.
apr_bucket_pipe_make
apr_bucket * apr_bucket_pipe_make(apr_bucket *b, apr_file_t *thispipe)
apr_bucket_pool::heap
apr_bucket_heap heap
Definition: apr_buckets.h:573
apr_brigade_write
apr_status_t apr_brigade_write(apr_bucket_brigade *b, apr_brigade_flush flush, void *ctx, const char *str, apr_size_t nbyte)
apr_bucket_type_t::APR_BUCKET_METADATA
@ APR_BUCKET_METADATA
Definition: apr_buckets.h:155
apr_bucket_type_t::setaside
apr_status_t(* setaside)(apr_bucket *e, apr_pool_t *pool)
Definition: apr_buckets.h:192
apr_bucket_structs::file
apr_bucket_file file
Definition: apr_buckets.h:642
apr_bucket_brigade
Definition: apr_buckets.h:258
apr_bucket_brigade::APR_RING_HEAD
APR_RING_HEAD(apr_bucket_list, apr_bucket) list
apr_bucket_pool::list
apr_bucket_alloc_t * list
Definition: apr_buckets.h:590
apr_bucket::data
void * data
Definition: apr_buckets.h:244
apr_bucket_eos_create
apr_bucket * apr_bucket_eos_create(apr_bucket_alloc_t *list)
apr_bucket_alloc_t
struct apr_bucket_alloc_t apr_bucket_alloc_t
Definition: apr_buckets.h:123
apr_bucket_type_t::destroy
void(* destroy)(void *data)
Definition: apr_buckets.h:164
apr_brigade_insert_file
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_bucket_transient_create
apr_bucket * apr_bucket_transient_create(const char *buf, apr_size_t nbyte, apr_bucket_alloc_t *list)
apr_ring.h
APR Rings.
apr_bucket::start
apr_off_t start
Definition: apr_buckets.h:242
apr.h
APR Platform Definitions.
apr_bucket_heap
Definition: apr_buckets.h:543
apr_bucket_pipe_create
apr_bucket * apr_bucket_pipe_create(apr_file_t *thispipe, apr_bucket_alloc_t *list)
apr_bucket::free
void(* free)(void *e)
Definition: apr_buckets.h:252
apr_bucket_heap::free_func
void(* free_func)(void *data)
Definition: apr_buckets.h:553
apr_bucket_structs::b
apr_bucket b
Definition: apr_buckets.h:636
apr_brigade_destroy
apr_status_t apr_brigade_destroy(apr_bucket_brigade *b)
apr_file_t
struct apr_file_t apr_file_t
Definition: apr_file_io.h:188
apr_bucket_socket_create
apr_bucket * apr_bucket_socket_create(apr_socket_t *thissock, apr_bucket_alloc_t *list)
apr_bucket_structs::pool
apr_bucket_pool pool
Definition: apr_buckets.h:638
apr_bucket_type_pool
const apr_bucket_type_t apr_bucket_type_pool
APR_NONBLOCK_READ
@ APR_NONBLOCK_READ
Definition: apr_buckets.h:59
apr_bucket_file::read_size
apr_size_t read_size
Definition: apr_buckets.h:626
apr_socket_t
struct apr_socket_t apr_socket_t
Definition: apr_network_io.h:219
apr_brigade_putc
apr_status_t apr_brigade_putc(apr_bucket_brigade *b, apr_brigade_flush flush, void *ctx, const char c)
apr_bucket_copy_notimpl
apr_status_t apr_bucket_copy_notimpl(apr_bucket *e, apr_bucket **c)
apr_mmap_t
Definition: apr_mmap.h:62
apr_file_io.h
APR File I/O Handling.
apr_bucket_file::refcount
apr_bucket_refcount refcount
Definition: apr_buckets.h:614
apr_bucket_heap::alloc_len
apr_size_t alloc_len
Definition: apr_buckets.h:551
apr_general.h
APR Miscellaneous library routines.
apr_bucket_shared_copy
apr_status_t apr_bucket_shared_copy(apr_bucket *a, apr_bucket **b)
apr_bucket_free
void apr_bucket_free(void *block)
apr_brigade_putstrs
apr_status_t apr_brigade_putstrs(apr_bucket_brigade *b, apr_brigade_flush flush, void *ctx,...)
apr_bucket_brigade::p
apr_pool_t * p
Definition: apr_buckets.h:264
apr_read_type_e
apr_read_type_e
Definition: apr_buckets.h:57
apr_bucket_type_t::is_metadata
enum apr_bucket_type_t::@0 is_metadata
apr_bucket_setaside_notimpl
apr_status_t apr_bucket_setaside_notimpl(apr_bucket *data, apr_pool_t *pool)
apr_bucket_shared_make
apr_bucket * apr_bucket_shared_make(apr_bucket *b, void *data, apr_off_t start, apr_size_t length)
apr_bucket_simple_split
apr_status_t apr_bucket_simple_split(apr_bucket *b, apr_size_t point)
apr_bucket_alloc_aligned_floor
apr_size_t apr_bucket_alloc_aligned_floor(apr_bucket_alloc_t *list, apr_size_t size)
apr_bucket_type_socket
const apr_bucket_type_t apr_bucket_type_socket
apr_status_t
int apr_status_t
Definition: apr_errno.h:44
apr_bucket_pool_make
apr_bucket * apr_bucket_pool_make(apr_bucket *b, const char *buf, apr_size_t length, apr_pool_t *pool)
apr_bucket_type_pipe
const apr_bucket_type_t apr_bucket_type_pipe
apr_bucket_pool
Definition: apr_buckets.h:561
apr_brigade_pflatten
apr_status_t apr_brigade_pflatten(apr_bucket_brigade *bb, char **c, apr_size_t *len, apr_pool_t *pool)
apr_bucket_alloc_create_ex
apr_bucket_alloc_t * apr_bucket_alloc_create_ex(apr_allocator_t *allocator)
apr_bucket_type_t
Definition: apr_buckets.h:131
apr_bucket_heap::refcount
apr_bucket_refcount refcount
Definition: apr_buckets.h:545
apr_bucket_file_set_buf_size
apr_status_t apr_bucket_file_set_buf_size(apr_bucket *e, apr_size_t size)
apr_bucket_type_transient
const apr_bucket_type_t apr_bucket_type_transient
apr_brigade_split
apr_bucket_brigade * apr_brigade_split(apr_bucket_brigade *b, apr_bucket *e)
apr_brigade_vprintf
apr_status_t apr_brigade_vprintf(apr_bucket_brigade *b, apr_brigade_flush flush, void *ctx, const char *fmt, va_list va)
apr_bucket_file
Definition: apr_buckets.h:612
apr_bucket_transient_make
apr_bucket * apr_bucket_transient_make(apr_bucket *b, const char *buf, apr_size_t nbyte)
apr_bucket_pool::pool
apr_pool_t * pool
Definition: apr_buckets.h:586
apr_brigade_writev
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_bucket_file_create
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_mmap::refcount
apr_bucket_refcount refcount
Definition: apr_buckets.h:601
apr_bucket_refcount
Definition: apr_buckets.h:531
apr_bucket_pool::base
const char * base
Definition: apr_buckets.h:579
apr_brigade_flush
apr_status_t(* apr_brigade_flush)(apr_bucket_brigade *bb, void *ctx)
Definition: apr_buckets.h:282
apr_bucket::list
apr_bucket_alloc_t * list
Definition: apr_buckets.h:254
apr_bucket_type_t::read
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_eos_make
apr_bucket * apr_bucket_eos_make(apr_bucket *b)
apr_bucket_type_t::split
apr_status_t(* split)(apr_bucket *e, apr_size_t point)
Definition: apr_buckets.h:203
apr_bucket_shared_split
apr_status_t apr_bucket_shared_split(apr_bucket *b, apr_size_t point)
apr_bucket
Definition: apr_buckets.h:224
apr_pool_t
struct apr_pool_t apr_pool_t
Definition: apr_pools.h:60
apr_bucket_structs
Definition: apr_buckets.h:635
apr_bucket_file_make
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::APR_RING_ENTRY
APR_RING_ENTRY(apr_bucket) link
apr_brigade_to_iovec
apr_status_t apr_brigade_to_iovec(apr_bucket_brigade *b, struct iovec *vec, int *nvec)
apr_bucket_type_t::num_func
int num_func
Definition: apr_buckets.h:140
apr_bucket_file_enable_mmap
apr_status_t apr_bucket_file_enable_mmap(apr_bucket *b, int enabled)