Main Page | Modules | Namespace List | Data Structures | File List | Data Fields | Globals | Related Pages

apr_buckets.h

Go to the documentation of this file.
00001 /* ====================================================================
00002  * The Apache Software License, Version 1.1
00003  *
00004  * Copyright (c) 2000-2003 The Apache Software Foundation.  All rights
00005  * reserved.
00006  *
00007  * Redistribution and use in source and binary forms, with or without
00008  * modification, are permitted provided that the following conditions
00009  * are met:
00010  *
00011  * 1. Redistributions of source code must retain the above copyright
00012  *    notice, this list of conditions and the following disclaimer.
00013  *
00014  * 2. Redistributions in binary form must reproduce the above copyright
00015  *    notice, this list of conditions and the following disclaimer in
00016  *    the documentation and/or other materials provided with the
00017  *    distribution.
00018  *
00019  * 3. The end-user documentation included with the redistribution,
00020  *    if any, must include the following acknowledgment:
00021  *       "This product includes software developed by the
00022  *        Apache Software Foundation (http://www.apache.org/)."
00023  *    Alternately, this acknowledgment may appear in the software itself,
00024  *    if and wherever such third-party acknowledgments normally appear.
00025  *
00026  * 4. The names "Apache" and "Apache Software Foundation" must
00027  *    not be used to endorse or promote products derived from this
00028  *    software without prior written permission. For written
00029  *    permission, please contact apache@apache.org.
00030  *
00031  * 5. Products derived from this software may not be called "Apache",
00032  *    nor may "Apache" appear in their name, without prior written
00033  *    permission of the Apache Software Foundation.
00034  *
00035  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
00036  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
00037  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00038  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
00039  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00040  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00041  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
00042  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
00043  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00044  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
00045  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
00046  * SUCH DAMAGE.
00047  * ====================================================================
00048  *
00049  * This software consists of voluntary contributions made by many
00050  * individuals on behalf of the Apache Software Foundation.  For more
00051  * information on the Apache Software Foundation, please see
00052  * <http://www.apache.org/>.
00053  */
00059 #ifndef APR_BUCKETS_H
00060 #define APR_BUCKETS_H
00061 
00062 #if defined(APR_BUCKET_DEBUG) && !defined(APR_RING_DEBUG)
00063 #define APR_RING_DEBUG
00064 #endif
00065 
00066 #include "apu.h"
00067 #include "apr_network_io.h"
00068 #include "apr_file_io.h"
00069 #include "apr_general.h"
00070 #include "apr_mmap.h"
00071 #include "apr_errno.h"
00072 #include "apr_ring.h"
00073 #include "apr.h"
00074 #if APR_HAVE_SYS_UIO_H
00075 #include <sys/uio.h>    /* for struct iovec */
00076 #endif
00077 #if APR_HAVE_STDARG_H
00078 #include <stdarg.h>
00079 #endif
00080 
00081 #ifdef __cplusplus
00082 extern "C" {
00083 #endif
00084 
00092 #define APR_BUCKET_BUFF_SIZE 8000
00093 
00095 typedef enum {
00096     APR_BLOCK_READ,   
00097     APR_NONBLOCK_READ 
00098 } apr_read_type_e;
00099 
00152 /*
00153  * Forward declaration of the main types.
00154  */
00155 
00157 typedef struct apr_bucket_brigade apr_bucket_brigade;
00159 typedef struct apr_bucket apr_bucket;
00161 typedef struct apr_bucket_alloc_t apr_bucket_alloc_t;
00162 
00164 typedef struct apr_bucket_type_t apr_bucket_type_t;
00165 
00169 struct apr_bucket_type_t {
00173     const char *name;
00178     int num_func;
00189     enum {
00191         APR_BUCKET_DATA = 0,
00193         APR_BUCKET_METADATA = 1
00194     } is_metadata;
00202     void (*destroy)(void *data);
00203 
00214     apr_status_t (*read)(apr_bucket *b, const char **str, apr_size_t *len, 
00215                          apr_read_type_e block);
00216     
00230     apr_status_t (*setaside)(apr_bucket *e, apr_pool_t *pool);
00231 
00241     apr_status_t (*split)(apr_bucket *e, apr_size_t point);
00242 
00249     apr_status_t (*copy)(apr_bucket *e, apr_bucket **c);
00250 
00251 };
00252 
00262 struct apr_bucket {
00264     APR_RING_ENTRY(apr_bucket) link;
00266     const apr_bucket_type_t *type;
00272     apr_size_t length;
00280     apr_off_t start;
00282     void *data; 
00290     void (*free)(void *e);
00292     apr_bucket_alloc_t *list;
00293 };
00294 
00296 struct apr_bucket_brigade {
00302     apr_pool_t *p;
00304     /*
00305      * The apr_bucket_list structure doesn't actually need a name tag
00306      * because it has no existence independent of struct apr_bucket_brigade;
00307      * the ring macros are designed so that you can leave the name tag
00308      * argument empty in this situation but apparently the Windows compiler
00309      * doesn't like that.
00310      */
00311     APR_RING_HEAD(apr_bucket_list, apr_bucket) list;
00313     apr_bucket_alloc_t *bucket_alloc;
00314 };
00315 
00316 
00320 typedef apr_status_t (*apr_brigade_flush)(apr_bucket_brigade *bb, void *ctx);
00321 
00322 /*
00323  * define APR_BUCKET_DEBUG if you want your brigades to be checked for
00324  * validity at every possible instant.  this will slow your code down
00325  * substantially but is a very useful debugging tool.
00326  */
00327 #ifdef APR_BUCKET_DEBUG
00328 
00329 #define APR_BRIGADE_CHECK_CONSISTENCY(b)                                \
00330         APR_RING_CHECK_CONSISTENCY(&(b)->list, apr_bucket, link)
00331 
00332 #define APR_BUCKET_CHECK_CONSISTENCY(e)                                 \
00333         APR_RING_CHECK_ELEM_CONSISTENCY((e), apr_bucket, link)
00334 
00335 #else
00342 #define APR_BRIGADE_CHECK_CONSISTENCY(b)
00349 #define APR_BUCKET_CHECK_CONSISTENCY(e)
00350 #endif
00351 
00352 
00369 #define APR_BRIGADE_SENTINEL(b) APR_RING_SENTINEL(&(b)->list, apr_bucket, link)
00370 
00376 #define APR_BRIGADE_EMPTY(b)    APR_RING_EMPTY(&(b)->list, apr_bucket, link)
00377 
00383 #define APR_BRIGADE_FIRST(b)    APR_RING_FIRST(&(b)->list)
00389 #define APR_BRIGADE_LAST(b)     APR_RING_LAST(&(b)->list)
00390 
00432 #define APR_BRIGADE_FOREACH(e, b)                                       \
00433         APR_RING_FOREACH((e), &(b)->list, apr_bucket, link)
00434 
00440 #define APR_BRIGADE_INSERT_HEAD(b, e) do {                              \
00441         apr_bucket *ap__b = (e);                                        \
00442         APR_RING_INSERT_HEAD(&(b)->list, ap__b, apr_bucket, link);      \
00443         APR_BRIGADE_CHECK_CONSISTENCY((b));                             \
00444     } while (0)
00445 
00451 #define APR_BRIGADE_INSERT_TAIL(b, e) do {                              \
00452         apr_bucket *ap__b = (e);                                        \
00453         APR_RING_INSERT_TAIL(&(b)->list, ap__b, apr_bucket, link);      \
00454         APR_BRIGADE_CHECK_CONSISTENCY((b));                             \
00455     } while (0)
00456 
00462 #define APR_BRIGADE_CONCAT(a, b) do {                                   \
00463         APR_RING_CONCAT(&(a)->list, &(b)->list, apr_bucket, link);      \
00464         APR_BRIGADE_CHECK_CONSISTENCY((a));                             \
00465     } while (0)
00466 
00472 #define APR_BRIGADE_PREPEND(a, b) do {                                  \
00473         APR_RING_PREPEND(&(a)->list, &(b)->list, apr_bucket, link);     \
00474         APR_BRIGADE_CHECK_CONSISTENCY((a));                             \
00475     } while (0)
00476 
00482 #define APR_BUCKET_INSERT_BEFORE(a, b) do {                             \
00483         apr_bucket *ap__a = (a), *ap__b = (b);                          \
00484         APR_RING_INSERT_BEFORE(ap__a, ap__b, link);                     \
00485         APR_BUCKET_CHECK_CONSISTENCY(ap__a);                            \
00486     } while (0)
00487 
00493 #define APR_BUCKET_INSERT_AFTER(a, b) do {                              \
00494         apr_bucket *ap__a = (a), *ap__b = (b);                          \
00495         APR_RING_INSERT_AFTER(ap__a, ap__b, link);                      \
00496         APR_BUCKET_CHECK_CONSISTENCY(ap__a);                            \
00497     } while (0)
00498 
00504 #define APR_BUCKET_NEXT(e)      APR_RING_NEXT((e), link)
00505 
00510 #define APR_BUCKET_PREV(e)      APR_RING_PREV((e), link)
00511 
00516 #define APR_BUCKET_REMOVE(e)    APR_RING_REMOVE((e), link)
00517 
00522 #define APR_BUCKET_INIT(e)      APR_RING_ELEM_INIT((e), link)
00523 
00530 #define APR_BUCKET_IS_METADATA(e)    ((e)->type->is_metadata)
00531 
00537 #define APR_BUCKET_IS_FLUSH(e)       ((e)->type == &apr_bucket_type_flush)
00538 
00543 #define APR_BUCKET_IS_EOS(e)         ((e)->type == &apr_bucket_type_eos)
00544 
00549 #define APR_BUCKET_IS_FILE(e)        ((e)->type == &apr_bucket_type_file)
00550 
00555 #define APR_BUCKET_IS_PIPE(e)        ((e)->type == &apr_bucket_type_pipe)
00556 
00561 #define APR_BUCKET_IS_SOCKET(e)      ((e)->type == &apr_bucket_type_socket)
00562 
00567 #define APR_BUCKET_IS_HEAP(e)        ((e)->type == &apr_bucket_type_heap)
00568 
00573 #define APR_BUCKET_IS_TRANSIENT(e)   ((e)->type == &apr_bucket_type_transient)
00574 
00579 #define APR_BUCKET_IS_IMMORTAL(e)    ((e)->type == &apr_bucket_type_immortal)
00580 #if APR_HAS_MMAP
00581 
00586 #define APR_BUCKET_IS_MMAP(e)        ((e)->type == &apr_bucket_type_mmap)
00587 #endif
00588 
00593 #define APR_BUCKET_IS_POOL(e)        ((e)->type == &apr_bucket_type_pool)
00594 
00595 /*
00596  * General-purpose reference counting for the various bucket types.
00597  *
00598  * Any bucket type that keeps track of the resources it uses (i.e.
00599  * most of them except for IMMORTAL, TRANSIENT, and EOS) needs to
00600  * attach a reference count to the resource so that it can be freed
00601  * when the last bucket that uses it goes away. Resource-sharing may
00602  * occur because of bucket splits or buckets that refer to globally
00603  * cached data. */
00604 
00606 typedef struct apr_bucket_refcount apr_bucket_refcount;
00613 struct apr_bucket_refcount {
00615     int          refcount;
00616 };
00617 
00618 /*  *****  Reference-counted bucket types  *****  */
00619 
00621 typedef struct apr_bucket_heap apr_bucket_heap;
00625 struct apr_bucket_heap {
00627     apr_bucket_refcount  refcount;
00631     char    *base;
00633     apr_size_t  alloc_len;
00635     void (*free_func)(void *data);
00636 };
00637 
00639 typedef struct apr_bucket_pool apr_bucket_pool;
00643 struct apr_bucket_pool {
00655     apr_bucket_heap  heap;
00661     const char *base;
00668     apr_pool_t *pool;
00672     apr_bucket_alloc_t *list;
00673 };
00674 
00675 #if APR_HAS_MMAP
00676 
00677 typedef struct apr_bucket_mmap apr_bucket_mmap;
00681 struct apr_bucket_mmap {
00683     apr_bucket_refcount  refcount;
00685     apr_mmap_t *mmap;
00686 };
00687 #endif
00688 
00690 typedef struct apr_bucket_file apr_bucket_file;
00694 struct apr_bucket_file {
00696     apr_bucket_refcount  refcount;
00698     apr_file_t *fd;
00701     apr_pool_t *readpool;
00702 #if APR_HAS_MMAP
00703 
00705     int can_mmap;
00706 #endif /* APR_HAS_MMAP */
00707 };
00708 
00710 typedef union apr_bucket_structs apr_bucket_structs;
00715 union apr_bucket_structs {
00716     apr_bucket      b;      
00717     apr_bucket_heap heap;   
00718     apr_bucket_pool pool;   
00719 #if APR_HAS_MMAP
00720     apr_bucket_mmap mmap;   
00721 #endif
00722     apr_bucket_file file;   
00723 };
00724 
00730 #define APR_BUCKET_ALLOC_SIZE  APR_ALIGN_DEFAULT(2*sizeof(apr_bucket_structs))
00731 
00732 /*  *****  Bucket Brigade Functions  *****  */
00740 APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p,
00741                                                      apr_bucket_alloc_t *list);
00742 
00748 APU_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b);
00749 
00761 APU_DECLARE(apr_status_t) apr_brigade_cleanup(void *data);
00762 
00772 APU_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b,
00773                                                     apr_bucket *e);
00774 
00783 APU_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b,
00784                                                 apr_off_t point,
00785                                                 apr_bucket **after_point);
00786 
00787 #if APR_NOT_DONE_YET
00794 APU_DECLARE(void) apr_brigade_consume(apr_bucket_brigade *b,
00795                                       apr_off_t nbytes);
00796 #endif
00797 
00805 APU_DECLARE(apr_status_t) apr_brigade_length(apr_bucket_brigade *bb,
00806                                              int read_all,
00807                                              apr_off_t *length);
00808 
00816 APU_DECLARE(apr_status_t) apr_brigade_flatten(apr_bucket_brigade *bb,
00817                                               char *c,
00818                                               apr_size_t *len);
00819 
00827 APU_DECLARE(apr_status_t) apr_brigade_pflatten(apr_bucket_brigade *bb, 
00828                                                char **c,
00829                                                apr_size_t *len,
00830                                                apr_pool_t *pool);
00831 
00840 APU_DECLARE(apr_status_t) apr_brigade_split_line(apr_bucket_brigade *bbOut,
00841                                                  apr_bucket_brigade *bbIn,
00842                                                  apr_read_type_e block,
00843                                                  apr_off_t maxbytes);
00844 
00854 APU_DECLARE(apr_status_t) apr_brigade_to_iovec(apr_bucket_brigade *b, 
00855                                                struct iovec *vec, int *nvec);
00856 
00865 APU_DECLARE(apr_status_t) apr_brigade_vputstrs(apr_bucket_brigade *b,
00866                                                apr_brigade_flush flush,
00867                                                void *ctx,
00868                                                va_list va);
00869 
00879 APU_DECLARE(apr_status_t) apr_brigade_write(apr_bucket_brigade *b,
00880                                             apr_brigade_flush flush, void *ctx,
00881                                             const char *str, apr_size_t nbyte);
00882 
00892 APU_DECLARE(apr_status_t) apr_brigade_writev(apr_bucket_brigade *b,
00893                                              apr_brigade_flush flush,
00894                                              void *ctx,
00895                                              const struct iovec *vec,
00896                                              apr_size_t nvec);
00897 
00906 APU_DECLARE(apr_status_t) apr_brigade_puts(apr_bucket_brigade *bb,
00907                                            apr_brigade_flush flush, void *ctx,
00908                                            const char *str);
00909 
00918 APU_DECLARE(apr_status_t) apr_brigade_putc(apr_bucket_brigade *b,
00919                                            apr_brigade_flush flush, void *ctx,
00920                                            const char c);
00921 
00930 APU_DECLARE_NONSTD(apr_status_t) apr_brigade_putstrs(apr_bucket_brigade *b,
00931                                                      apr_brigade_flush flush,
00932                                                      void *ctx, ...);
00933 
00944 APU_DECLARE_NONSTD(apr_status_t) apr_brigade_printf(apr_bucket_brigade *b, 
00945                                                     apr_brigade_flush flush,
00946                                                     void *ctx,
00947                                                     const char *fmt, ...)
00948         __attribute__((format(printf,4,5)));
00949 
00960 APU_DECLARE(apr_status_t) apr_brigade_vprintf(apr_bucket_brigade *b, 
00961                                               apr_brigade_flush flush,
00962                                               void *ctx,
00963                                               const char *fmt, va_list va);
00964 
00965 /*  *****  Bucket freelist functions *****  */
00979 APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create(apr_pool_t *p);
00980 
00989 APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create_ex(apr_allocator_t *allocator);
00990 
00995 APU_DECLARE_NONSTD(void) apr_bucket_alloc_destroy(apr_bucket_alloc_t *list);
00996 
01002 APU_DECLARE_NONSTD(void *) apr_bucket_alloc(apr_size_t size, apr_bucket_alloc_t *list);
01003 
01008 APU_DECLARE_NONSTD(void) apr_bucket_free(void *block);
01009 
01010 
01011 /*  *****  Bucket Functions  *****  */
01018 #define apr_bucket_destroy(e) do {                                      \
01019         (e)->type->destroy((e)->data);                                  \
01020         (e)->free(e);                                                   \
01021     } while (0)
01022 
01034 #define apr_bucket_delete(e) do {                                       \
01035         APR_BUCKET_REMOVE(e);                                           \
01036         apr_bucket_destroy(e);                                          \
01037     } while (0)
01038 
01046 #define apr_bucket_read(e,str,len,block) (e)->type->read(e, str, len, block)
01047 
01054 #define apr_bucket_setaside(e,p) (e)->type->setaside(e,p)
01055 
01061 #define apr_bucket_split(e,point) (e)->type->split(e, point)
01062 
01068 #define apr_bucket_copy(e,c) (e)->type->copy(e, c)
01069 
01070 /* Bucket type handling */
01071 
01081 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_noop(apr_bucket *data,
01082                                                           apr_pool_t *pool);
01083 
01091 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_notimpl(apr_bucket *data,
01092                                                              apr_pool_t *pool);
01093 
01101 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_split_notimpl(apr_bucket *data,
01102                                                           apr_size_t point);
01103 
01111 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_notimpl(apr_bucket *e,
01112                                                          apr_bucket **c);
01113 
01123 APU_DECLARE_NONSTD(void) apr_bucket_destroy_noop(void *data);
01124 
01131 /* There is no apr_bucket_read_notimpl, because it is a required function
01132  */
01133 
01134 
01135 /* All of the bucket types implemented by the core */
01140 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_flush;
01146 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_eos;
01150 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_file;
01155 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_heap;
01156 #if APR_HAS_MMAP
01160 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_mmap;
01161 #endif
01167 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pool;
01171 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pipe;
01177 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_immortal;
01183 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_transient;
01187 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_socket;
01188 
01189 
01190 /*  *****  Simple buckets  *****  */
01191 
01203 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_split(apr_bucket *b,
01204                                                          apr_size_t point);
01205 
01216 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_copy(apr_bucket *a,
01217                                                         apr_bucket **b);
01218 
01219 
01220 /*  *****  Shared, reference-counted buckets  *****  */
01221 
01236 APU_DECLARE(apr_bucket *) apr_bucket_shared_make(apr_bucket *b, void *data,
01237                                                  apr_off_t start, 
01238                                                  apr_size_t length);
01239 
01248 APU_DECLARE(int) apr_bucket_shared_destroy(void *data);
01249 
01261 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_split(apr_bucket *b,
01262                                                          apr_size_t point);
01263 
01273 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_copy(apr_bucket *a,
01274                                                         apr_bucket **b);
01275 
01276 
01277 /*  *****  Functions to Create Buckets of varying types  *****  */
01278 /*
01279  * Each bucket type foo has two initialization functions:
01280  * apr_bucket_foo_make which sets up some already-allocated memory as a
01281  * bucket of type foo; and apr_bucket_foo_create which allocates memory
01282  * for the bucket, calls apr_bucket_make_foo, and initializes the
01283  * bucket's list pointers. The apr_bucket_foo_make functions are used
01284  * inside the bucket code to change the type of buckets in place;
01285  * other code should call apr_bucket_foo_create. All the initialization
01286  * functions change nothing if they fail.
01287  */
01288 
01295 APU_DECLARE(apr_bucket *) apr_bucket_eos_create(apr_bucket_alloc_t *list);
01296 
01304 APU_DECLARE(apr_bucket *) apr_bucket_eos_make(apr_bucket *b);
01305 
01313 APU_DECLARE(apr_bucket *) apr_bucket_flush_create(apr_bucket_alloc_t *list);
01314 
01322 APU_DECLARE(apr_bucket *) apr_bucket_flush_make(apr_bucket *b);
01323 
01331 APU_DECLARE(apr_bucket *) apr_bucket_immortal_create(const char *buf, 
01332                                                      apr_size_t nbyte,
01333                                                      apr_bucket_alloc_t *list);
01334 
01342 APU_DECLARE(apr_bucket *) apr_bucket_immortal_make(apr_bucket *b, 
01343                                                    const char *buf, 
01344                                                    apr_size_t nbyte);
01345 
01353 APU_DECLARE(apr_bucket *) apr_bucket_transient_create(const char *buf, 
01354                                                       apr_size_t nbyte,
01355                                                       apr_bucket_alloc_t *list);
01356 
01364 APU_DECLARE(apr_bucket *) apr_bucket_transient_make(apr_bucket *b, 
01365                                                     const char *buf,
01366                                                     apr_size_t nbyte);
01367 
01382 APU_DECLARE(apr_bucket *) apr_bucket_heap_create(const char *buf, 
01383                                                  apr_size_t nbyte,
01384                                                  void (*free_func)(void *data),
01385                                                  apr_bucket_alloc_t *list);
01395 APU_DECLARE(apr_bucket *) apr_bucket_heap_make(apr_bucket *b, const char *buf,
01396                                                apr_size_t nbyte,
01397                                                void (*free_func)(void *data));
01398 
01408 APU_DECLARE(apr_bucket *) apr_bucket_pool_create(const char *buf, 
01409                                                  apr_size_t length,
01410                                                  apr_pool_t *pool,
01411                                                  apr_bucket_alloc_t *list);
01412 
01421 APU_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b, const char *buf,
01422                                                apr_size_t length, 
01423                                                apr_pool_t *pool);
01424 
01425 #if APR_HAS_MMAP
01435 APU_DECLARE(apr_bucket *) apr_bucket_mmap_create(apr_mmap_t *mm, 
01436                                                  apr_off_t start,
01437                                                  apr_size_t length,
01438                                                  apr_bucket_alloc_t *list);
01439 
01449 APU_DECLARE(apr_bucket *) apr_bucket_mmap_make(apr_bucket *b, apr_mmap_t *mm,
01450                                                apr_off_t start, 
01451                                                apr_size_t length);
01452 #endif
01453 
01460 APU_DECLARE(apr_bucket *) apr_bucket_socket_create(apr_socket_t *thissock,
01461                                                    apr_bucket_alloc_t *list);
01468 APU_DECLARE(apr_bucket *) apr_bucket_socket_make(apr_bucket *b, 
01469                                                  apr_socket_t *thissock);
01470 
01477 APU_DECLARE(apr_bucket *) apr_bucket_pipe_create(apr_file_t *thispipe,
01478                                                  apr_bucket_alloc_t *list);
01479 
01486 APU_DECLARE(apr_bucket *) apr_bucket_pipe_make(apr_bucket *b, 
01487                                                apr_file_t *thispipe);
01488 
01499 APU_DECLARE(apr_bucket *) apr_bucket_file_create(apr_file_t *fd,
01500                                                  apr_off_t offset,
01501                                                  apr_size_t len, 
01502                                                  apr_pool_t *p,
01503                                                  apr_bucket_alloc_t *list);
01504 
01515 APU_DECLARE(apr_bucket *) apr_bucket_file_make(apr_bucket *b, apr_file_t *fd,
01516                                                apr_off_t offset,
01517                                                apr_size_t len, apr_pool_t *p);
01518 
01525 APU_DECLARE(apr_status_t) apr_bucket_file_enable_mmap(apr_bucket *b,
01526                                                       int enabled);
01527 
01529 #ifdef __cplusplus
01530 }
01531 #endif
01532 
01533 #endif /* !APR_BUCKETS_H */

Generated on Wed Dec 8 00:35:22 2010 for Apache Portable Runtime Utility Library by  doxygen 1.3.9.1