delete app

Change-Id: Id4c572809969ebe89e946e88063eaed262cff3f2
Signed-off-by: hongbotian <hongbo.tianhongbo@huawei.com>

1 files changed, 0 insertions, 1495 deletions

diff --git a/rubbos/app/httpd-2.0.64/srclib/apr-util/include/apr_buckets.h b/rubbos/app/httpd-2.0.64/srclib/apr-util/include/apr_buckets.h
deleted file mode 100644
index 7f1b05ff..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr-util/include/apr_buckets.h
+++ /dev/null
@@ -1,1495 +0,0 @@
-/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
- * applicable.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * @file apr_buckets.h
- * @brief APR-UTIL Buckets/Bucket Brigades
- */
-
-#ifndef APR_BUCKETS_H
-#define APR_BUCKETS_H
-
-#if defined(APR_BUCKET_DEBUG) && !defined(APR_RING_DEBUG)
-#define APR_RING_DEBUG
-#endif
-
-#include "apu.h"
-#include "apr_network_io.h"
-#include "apr_file_io.h"
-#include "apr_general.h"
-#include "apr_mmap.h"
-#include "apr_errno.h"
-#include "apr_ring.h"
-#include "apr.h"
-#if APR_HAVE_SYS_UIO_H
-#include <sys/uio.h>	/* for struct iovec */
-#endif
-#if APR_HAVE_STDARG_H
-#include <stdarg.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @defgroup APR_Util_Bucket_Brigades Bucket Brigades
- * @ingroup APR_Util
- * @{ 
- */
-
-/** default bucket buffer size - 8KB minus room for memory allocator headers */
-#define APR_BUCKET_BUFF_SIZE 8000
-
-/** Determines how a bucket or brigade should be read */
-typedef enum {
-    APR_BLOCK_READ,   /**< block until data becomes available */
-    APR_NONBLOCK_READ /**< return immediately if no data is available */
-} apr_read_type_e;
-
-/**
- * The one-sentence buzzword-laden overview: Bucket brigades represent
- * a complex data stream that can be passed through a layered IO
- * system without unnecessary copying. A longer overview follows...
- *
- * A bucket brigade is a doubly linked list (ring) of buckets, so we
- * aren't limited to inserting at the front and removing at the end.
- * Buckets are only passed around as members of a brigade, although
- * singleton buckets can occur for short periods of time.
- *
- * Buckets are data stores of various types. They can refer to data in
- * memory, or part of a file or mmap area, or the output of a process,
- * etc. Buckets also have some type-dependent accessor functions:
- * read, split, copy, setaside, and destroy.
- *
- * read returns the address and size of the data in the bucket. If the
- * data isn't in memory then it is read in and the bucket changes type
- * so that it can refer to the new location of the data. If all the
- * data doesn't fit in the bucket then a new bucket is inserted into
- * the brigade to hold the rest of it.
- *
- * split divides the data in a bucket into two regions. After a split
- * the original bucket refers to the first part of the data and a new
- * bucket inserted into the brigade after the original bucket refers
- * to the second part of the data. Reference counts are maintained as
- * necessary.
- *
- * setaside ensures that the data in the bucket has a long enough
- * lifetime. Sometimes it is convenient to create a bucket referring
- * to data on the stack in the expectation that it will be consumed
- * (output to the network) before the stack is unwound. If that
- * expectation turns out not to be valid, the setaside function is
- * called to move the data somewhere safer.
- *
- * copy makes a duplicate of the bucket structure as long as it's
- * possible to have multiple references to a single copy of the
- * data itself.  Not all bucket types can be copied.
- *
- * destroy maintains the reference counts on the resources used by a
- * bucket and frees them if necessary.
- *
- * Note: all of the above functions have wrapper macros (apr_bucket_read(),
- * apr_bucket_destroy(), etc), and those macros should be used rather
- * than using the function pointers directly.
- *
- * To write a bucket brigade, they are first made into an iovec, so that we
- * don't write too little data at one time.  Currently we ignore compacting the
- * buckets into as few buckets as possible, but if we really want good
- * performance, then we need to compact the buckets before we convert to an
- * iovec, or possibly while we are converting to an iovec.
- */
-
-/*
- * Forward declaration of the main types.
- */
-
-/** @see apr_bucket_brigade */
-typedef struct apr_bucket_brigade apr_bucket_brigade;
-/** @see apr_bucket */
-typedef struct apr_bucket apr_bucket;
-/** @see apr_bucket_alloc_t */
-typedef struct apr_bucket_alloc_t apr_bucket_alloc_t;
-
-/** @see apr_bucket_type_t */
-typedef struct apr_bucket_type_t apr_bucket_type_t;
-
-/**
- * Basic bucket type
- */
-struct apr_bucket_type_t {
-    /**
-     * The name of the bucket type
-     */
-    const char *name;
-    /** 
-     * The number of functions this bucket understands.  Can not be less than
-     * five.
-     */
-    int num_func;
-    /**
-     * Whether the bucket contains metadata (ie, information that
-     * describes the regular contents of the brigade).  The metadata
-     * is not returned by apr_bucket_read() and is not indicated by
-     * the ->length of the apr_bucket itself.  In other words, an
-     * empty bucket is safe to arbitrarily remove if and only if it
-     * contains no metadata.  In this sense, "data" is just raw bytes
-     * that are the "content" of the brigade and "metadata" describes
-     * that data but is not a proper part of it.
-     */
-    enum {
-        /** This bucket type represents actual data to send to the client. */
-        APR_BUCKET_DATA = 0,
-        /** This bucket type represents metadata. */
-        APR_BUCKET_METADATA = 1
-    } is_metadata;
-    /**
-     * Free the private data and any resources used by the bucket (if they
-     *  aren't shared with another bucket).  This function is required to be
-     *  implemented for all bucket types, though it might be a no-op on some
-     *  of them (namely ones that never allocate any private data structures).
-     * @param data The private data pointer from the bucket to be destroyed
-     */
-    void (*destroy)(void *data);
-
-    /**
-     * Read the data from the bucket. This is required to be implemented
-     *  for all bucket types.
-     * @param b The bucket to read from
-     * @param str A place to store the data read.  Allocation should only be
-     *            done if absolutely necessary. 
-     * @param len The amount of data read.
-     * @param block Should this read function block if there is more data that
-     *              cannot be read immediately.
-     */
-    apr_status_t (*read)(apr_bucket *b, const char **str, apr_size_t *len, 
-                         apr_read_type_e block);
-    
-    /**
-     * Make it possible to set aside the data for at least as long as the
-     *  given pool. Buckets containing data that could potentially die before
-     *  this pool (e.g. the data resides on the stack, in a child pool of
-     *  the given pool, or in a disjoint pool) must somehow copy, shift, or
-     *  transform the data to have the proper lifetime.
-     * @param e The bucket to convert
-     * @remark Some bucket types contain data that will always outlive the
-     *         bucket itself. For example no data (EOS and FLUSH), or the data
-     *         resides in global, constant memory (IMMORTAL), or the data is on
-     *      the heap (HEAP). For these buckets, apr_bucket_setaside_noop can
-     *      be used.
-     */
-    apr_status_t (*setaside)(apr_bucket *e, apr_pool_t *pool);
-
-    /**
-     * Split one bucket in two at the specified position by duplicating
-     *  the bucket structure (not the data) and modifying any necessary
-     *  start/end/offset information.  If it's not possible to do this
-     *  for the bucket type (perhaps the length of the data is indeterminate,
-     *  as with pipe and socket buckets), then APR_ENOTIMPL is returned.
-     * @param e The bucket to split
-     * @param point The offset of the first byte in the new bucket
-     */
-    apr_status_t (*split)(apr_bucket *e, apr_size_t point);
-
-    /**
-     * Copy the bucket structure (not the data), assuming that this is
-     *  possible for the bucket type. If it's not, APR_ENOTIMPL is returned.
-     * @param e The bucket to copy
-     * @param c Returns a pointer to the new bucket
-     */
-    apr_status_t (*copy)(apr_bucket *e, apr_bucket **c);
-
-};
-
-/**
- * apr_bucket structures are allocated on the malloc() heap and
- * their lifetime is controlled by the parent apr_bucket_brigade
- * structure. Buckets can move from one brigade to another e.g. by
- * calling APR_BRIGADE_CONCAT(). In general the data in a bucket has
- * the same lifetime as the bucket and is freed when the bucket is
- * destroyed; if the data is shared by more than one bucket (e.g.
- * after a split) the data is freed when the last bucket goes away.
- */
-struct apr_bucket {
-    /** Links to the rest of the brigade */
-    APR_RING_ENTRY(apr_bucket) link;
-    /** The type of bucket.  */
-    const apr_bucket_type_t *type;
-    /** The length of the data in the bucket.  This could have been implemented
-     *  with a function, but this is an optimization, because the most
-     *  common thing to do will be to get the length.  If the length is unknown,
-     *  the value of this field will be (apr_size_t)(-1).
-     */
-    apr_size_t length;
-    /** The start of the data in the bucket relative to the private base
-     *  pointer.  The vast majority of bucket types allow a fixed block of
-     *  data to be referenced by multiple buckets, each bucket pointing to
-     *  a different segment of the data.  That segment starts at base+start
-     *  and ends at base+start+length.  
-     *  If the length == (apr_size_t)(-1), then start == -1.
-     */
-    apr_off_t start;
-    /** type-dependent data hangs off this pointer */
-    void *data;	
-    /**
-     * Pointer to function used to free the bucket. This function should
-     * always be defined and it should be consistent with the memory
-     * function used to allocate the bucket. For example, if malloc() is 
-     * used to allocate the bucket, this pointer should point to free().
-     * @param e Pointer to the bucket being freed
-     */
-    void (*free)(void *e);
-    /** The freelist from which this bucket was allocated */
-    apr_bucket_alloc_t *list;
-};
-
-/** A list of buckets */
-struct apr_bucket_brigade {
-    /** The pool to associate the brigade with.  The data is not allocated out
-     *  of the pool, but a cleanup is registered with this pool.  If the 
-     *  brigade is destroyed by some mechanism other than pool destruction,
-     *  the destroying function is responsible for killing the cleanup.
-     */
-    apr_pool_t *p;
-    /** The buckets in the brigade are on this list. */
-    /*
-     * The apr_bucket_list structure doesn't actually need a name tag
-     * because it has no existence independent of struct apr_bucket_brigade;
-     * the ring macros are designed so that you can leave the name tag
-     * argument empty in this situation but apparently the Windows compiler
-     * doesn't like that.
-     */
-    APR_RING_HEAD(apr_bucket_list, apr_bucket) list;
-    /** The freelist from which this bucket was allocated */
-    apr_bucket_alloc_t *bucket_alloc;
-};
-
-
-/**
- * Function called when a brigade should be flushed
- */
-typedef apr_status_t (*apr_brigade_flush)(apr_bucket_brigade *bb, void *ctx);
-
-/*
- * define APR_BUCKET_DEBUG if you want your brigades to be checked for
- * validity at every possible instant.  this will slow your code down
- * substantially but is a very useful debugging tool.
- */
-#ifdef APR_BUCKET_DEBUG
-
-#define APR_BRIGADE_CHECK_CONSISTENCY(b)				\
-        APR_RING_CHECK_CONSISTENCY(&(b)->list, apr_bucket, link)
-
-#define APR_BUCKET_CHECK_CONSISTENCY(e)					\
-        APR_RING_CHECK_ELEM_CONSISTENCY((e), apr_bucket, link)
-
-#else
-/**
- * checks the ring pointers in a bucket brigade for consistency.  an
- * abort() will be triggered if any inconsistencies are found.
- *   note: this is a no-op unless APR_BUCKET_DEBUG is defined.
- * @param b The brigade
- */
-#define APR_BRIGADE_CHECK_CONSISTENCY(b)
-/**
- * checks the brigade a bucket is in for ring consistency.  an
- * abort() will be triggered if any inconsistencies are found.
- *   note: this is a no-op unless APR_BUCKET_DEBUG is defined.
- * @param e The bucket
- */
-#define APR_BUCKET_CHECK_CONSISTENCY(e)
-#endif
-
-
-/**
- * Wrappers around the RING macros to reduce the verbosity of the code
- * that handles bucket brigades.
- */
-/**
- * The magic pointer value that indicates the head of the brigade
- * @remark This is used to find the beginning and end of the brigade, eg:
- * <pre>
- *      while (e != APR_BRIGADE_SENTINEL(b)) {
- *          ...
- *          e = APR_BUCKET_NEXT(e);
- *      }
- * </pre>
- * @param  b The brigade
- * @return The magic pointer value
- */
-#define APR_BRIGADE_SENTINEL(b)	APR_RING_SENTINEL(&(b)->list, apr_bucket, link)
-
-/**
- * Determine if the bucket brigade is empty
- * @param b The brigade to check
- * @return true or false
- */
-#define APR_BRIGADE_EMPTY(b)	APR_RING_EMPTY(&(b)->list, apr_bucket, link)
-
-/**
- * Return the first bucket in a brigade
- * @param b The brigade to query
- * @return The first bucket in the brigade
- */
-#define APR_BRIGADE_FIRST(b)	APR_RING_FIRST(&(b)->list)
-/**
- * Return the last bucket in a brigade
- * @param b The brigade to query
- * @return The last bucket in the brigade
- */
-#define APR_BRIGADE_LAST(b)	APR_RING_LAST(&(b)->list)
-
-/**
- * Iterate through a bucket brigade
- * @param e The current bucket
- * @param b The brigade to iterate over
- * @remark This is the same as either:
- * <pre>
- *	e = APR_BRIGADE_FIRST(b);
- * 	while (e != APR_BRIGADE_SENTINEL(b)) {
- *	    ...
- * 	    e = APR_BUCKET_NEXT(e);
- * 	}
- *  OR
- * 	for (e = APR_BRIGADE_FIRST(b);
- *           e != APR_BRIGADE_SENTINEL(b);
- *           e = APR_BUCKET_NEXT(e)) {
- *	    ...
- * 	}
- * </pre>
- * @warning Be aware that you cannot change the value of e within
- * the foreach loop, nor can you destroy the bucket it points to.
- * Modifying the prev and next pointers of the bucket is dangerous
- * but can be done if you're careful.  If you change e's value or
- * destroy the bucket it points to, then APR_BRIGADE_FOREACH
- * will have no way to find out what bucket to use for its next
- * iteration.  The reason for this can be seen by looking closely
- * at the equivalent loops given in the tip above.  So, for example,
- * if you are writing a loop that empties out a brigade one bucket
- * at a time, APR_BRIGADE_FOREACH just won't work for you.  Do it
- * by hand, like so:
- * <pre>
- *      while (!APR_BRIGADE_EMPTY(b)) {
- *          e = APR_BRIGADE_FIRST(b);
- *          ...
- *          apr_bucket_delete(e);
- *      }
- * </pre>
- * @deprecated This macro causes more headaches than it's worth.  Use
- * one of the alternatives documented here instead; the clarity gained
- * in what's really going on is well worth the extra line or two of code.
- * This macro will be removed at some point in the future.
- */
-#define APR_BRIGADE_FOREACH(e, b)					\
-	APR_RING_FOREACH((e), &(b)->list, apr_bucket, link)
-
-/**
- * Insert a list of buckets at the front of a brigade
- * @param b The brigade to add to
- * @param e The first bucket in a list of buckets to insert
- */
-#define APR_BRIGADE_INSERT_HEAD(b, e) do {				\
-	apr_bucket *ap__b = (e);                                        \
-	APR_RING_INSERT_HEAD(&(b)->list, ap__b, apr_bucket, link);	\
-        APR_BRIGADE_CHECK_CONSISTENCY((b));				\
-    } while (0)
-
-/**
- * Insert a list of buckets at the end of a brigade
- * @param b The brigade to add to
- * @param e The first bucket in a list of buckets to insert
- */
-#define APR_BRIGADE_INSERT_TAIL(b, e) do {				\
-	apr_bucket *ap__b = (e);					\
-	APR_RING_INSERT_TAIL(&(b)->list, ap__b, apr_bucket, link);	\
-        APR_BRIGADE_CHECK_CONSISTENCY((b));				\
-    } while (0)
-
-/**
- * Concatenate brigade b onto the end of brigade a, leaving brigade b empty
- * @param a The first brigade
- * @param b The second brigade
- */
-#define APR_BRIGADE_CONCAT(a, b) do {					\
-        APR_RING_CONCAT(&(a)->list, &(b)->list, apr_bucket, link);	\
-        APR_BRIGADE_CHECK_CONSISTENCY((a));				\
-    } while (0)
-
-/**
- * Prepend brigade b onto the beginning of brigade a, leaving brigade b empty
- * @param a The first brigade
- * @param b The second brigade
- */
-#define APR_BRIGADE_PREPEND(a, b) do {					\
-        APR_RING_PREPEND(&(a)->list, &(b)->list, apr_bucket, link);	\
-        APR_BRIGADE_CHECK_CONSISTENCY((a));				\
-    } while (0)
-
-/**
- * Insert a list of buckets before a specified bucket
- * @param a The bucket to insert before
- * @param b The buckets to insert
- */
-#define APR_BUCKET_INSERT_BEFORE(a, b) do {				\
-	apr_bucket *ap__a = (a), *ap__b = (b);				\
-	APR_RING_INSERT_BEFORE(ap__a, ap__b, link);			\
-        APR_BUCKET_CHECK_CONSISTENCY(ap__a);				\
-    } while (0)
-
-/**
- * Insert a list of buckets after a specified bucket
- * @param a The bucket to insert after
- * @param b The buckets to insert
- */
-#define APR_BUCKET_INSERT_AFTER(a, b) do {				\
-	apr_bucket *ap__a = (a), *ap__b = (b);				\
-	APR_RING_INSERT_AFTER(ap__a, ap__b, link);			\
-        APR_BUCKET_CHECK_CONSISTENCY(ap__a);				\
-    } while (0)
-
-/**
- * Get the next bucket in the list
- * @param e The current bucket
- * @return The next bucket
- */
-#define APR_BUCKET_NEXT(e)	APR_RING_NEXT((e), link)
-/**
- * Get the previous bucket in the list
- * @param e The current bucket
- * @return The previous bucket
- */
-#define APR_BUCKET_PREV(e)	APR_RING_PREV((e), link)
-
-/**
- * Remove a bucket from its bucket brigade
- * @param e The bucket to remove
- */
-#define APR_BUCKET_REMOVE(e)	APR_RING_REMOVE((e), link)
-
-/**
- * Initialize a new bucket's prev/next pointers
- * @param e The bucket to initialize
- */
-#define APR_BUCKET_INIT(e)	APR_RING_ELEM_INIT((e), link)
-
-/**
- * Determine if a bucket contains metadata.  An empty bucket is
- * safe to arbitrarily remove if and only if this is false.
- * @param e The bucket to inspect
- * @return true or false
- */
-#define APR_BUCKET_IS_METADATA(e)    ((e)->type->is_metadata)
-
-/**
- * Determine if a bucket is a FLUSH bucket
- * @param e The bucket to inspect
- * @return true or false
- */
-#define APR_BUCKET_IS_FLUSH(e)       ((e)->type == &apr_bucket_type_flush)
-/**
- * Determine if a bucket is an EOS bucket
- * @param e The bucket to inspect
- * @return true or false
- */
-#define APR_BUCKET_IS_EOS(e)         ((e)->type == &apr_bucket_type_eos)
-/**
- * Determine if a bucket is a FILE bucket
- * @param e The bucket to inspect
- * @return true or false
- */
-#define APR_BUCKET_IS_FILE(e)        ((e)->type == &apr_bucket_type_file)
-/**
- * Determine if a bucket is a PIPE bucket
- * @param e The bucket to inspect
- * @return true or false
- */
-#define APR_BUCKET_IS_PIPE(e)        ((e)->type == &apr_bucket_type_pipe)
-/**
- * Determine if a bucket is a SOCKET bucket
- * @param e The bucket to inspect
- * @return true or false
- */
-#define APR_BUCKET_IS_SOCKET(e)      ((e)->type == &apr_bucket_type_socket)
-/**
- * Determine if a bucket is a HEAP bucket
- * @param e The bucket to inspect
- * @return true or false
- */
-#define APR_BUCKET_IS_HEAP(e)        ((e)->type == &apr_bucket_type_heap)
-/**
- * Determine if a bucket is a TRANSIENT bucket
- * @param e The bucket to inspect
- * @return true or false
- */
-#define APR_BUCKET_IS_TRANSIENT(e)   ((e)->type == &apr_bucket_type_transient)
-/**
- * Determine if a bucket is a IMMORTAL bucket
- * @param e The bucket to inspect
- * @return true or false
- */
-#define APR_BUCKET_IS_IMMORTAL(e)    ((e)->type == &apr_bucket_type_immortal)
-#if APR_HAS_MMAP
-/**
- * Determine if a bucket is a MMAP bucket
- * @param e The bucket to inspect
- * @return true or false
- */
-#define APR_BUCKET_IS_MMAP(e)        ((e)->type == &apr_bucket_type_mmap)
-#endif
-/**
- * Determine if a bucket is a POOL bucket
- * @param e The bucket to inspect
- * @return true or false
- */
-#define APR_BUCKET_IS_POOL(e)        ((e)->type == &apr_bucket_type_pool)
-
-/*
- * General-purpose reference counting for the various bucket types.
- *
- * Any bucket type that keeps track of the resources it uses (i.e.
- * most of them except for IMMORTAL, TRANSIENT, and EOS) needs to
- * attach a reference count to the resource so that it can be freed
- * when the last bucket that uses it goes away. Resource-sharing may
- * occur because of bucket splits or buckets that refer to globally
- * cached data. */
-
-/** @see apr_bucket_refcount */
-typedef struct apr_bucket_refcount apr_bucket_refcount;
-/**
- * The structure used to manage the shared resource must start with an
- * apr_bucket_refcount which is updated by the general-purpose refcount
- * code. A pointer to the bucket-type-dependent private data structure
- * can be cast to a pointer to an apr_bucket_refcount and vice versa.
- */
-struct apr_bucket_refcount {
-    /** The number of references to this bucket */
-    int          refcount;
-};
-
-/*  *****  Reference-counted bucket types  *****  */
-
-/** @see apr_bucket_heap */
-typedef struct apr_bucket_heap apr_bucket_heap;
-/**
- * A bucket referring to data allocated off the heap.
- */
-struct apr_bucket_heap {
-    /** Number of buckets using this memory */
-    apr_bucket_refcount  refcount;
-    /** The start of the data actually allocated.  This should never be
-     * modified, it is only used to free the bucket.
-     */
-    char    *base;
-    /** how much memory was allocated */
-    apr_size_t  alloc_len;
-    /** function to use to delete the data */
-    void (*free_func)(void *data);
-};
-
-/** @see apr_bucket_pool */
-typedef struct apr_bucket_pool apr_bucket_pool;
-/**
- * A bucket referring to data allocated from a pool
- */
-struct apr_bucket_pool {
-    /** The pool bucket must be able to be easily morphed to a heap
-     * bucket if the pool gets cleaned up before all references are
-     * destroyed.  This apr_bucket_heap structure is populated automatically
-     * when the pool gets cleaned up, and subsequent calls to pool_read()
-     * will result in the apr_bucket in question being morphed into a
-     * regular heap bucket.  (To avoid having to do many extra refcount
-     * manipulations and b->data manipulations, the apr_bucket_pool
-     * struct actually *contains* the apr_bucket_heap struct that it
-     * will become as its first element; the two share their
-     * apr_bucket_refcount members.)
-     */
-    apr_bucket_heap  heap;
-    /** The block of data actually allocated from the pool.
-     * Segments of this block are referenced by adjusting
-     * the start and length of the apr_bucket accordingly.
-     * This will be NULL after the pool gets cleaned up.
-     */
-    const char *base;
-    /** The pool the data was allocated from.  When the pool
-     * is cleaned up, this gets set to NULL as an indicator
-     * to pool_read() that the data is now on the heap and
-     * so it should morph the bucket into a regular heap
-     * bucket before continuing.
-     */
-    apr_pool_t *pool;
-    /** The freelist this structure was allocated from, which is
-     * needed in the cleanup phase in order to allocate space on the heap
-     */
-    apr_bucket_alloc_t *list;
-};
-
-#if APR_HAS_MMAP
-/** @see apr_bucket_mmap */
-typedef struct apr_bucket_mmap apr_bucket_mmap;
-/**
- * A bucket referring to an mmap()ed file
- */
-struct apr_bucket_mmap {
-    /** Number of buckets using this memory */
-    apr_bucket_refcount  refcount;
-    /** The mmap this sub_bucket refers to */
-    apr_mmap_t *mmap;
-};
-#endif
-
-/** @see apr_bucket_file */
-typedef struct apr_bucket_file apr_bucket_file;
-/**
- * A bucket referring to an file
- */
-struct apr_bucket_file {
-    /** Number of buckets using this memory */
-    apr_bucket_refcount  refcount;
-    /** The file this bucket refers to */
-    apr_file_t *fd;
-    /** The pool into which any needed structures should
-     *  be created while reading from this file bucket */
-    apr_pool_t *readpool;
-#if APR_HAS_MMAP
-    /** Whether this bucket should be memory-mapped if
-     *  a caller tries to read from it */
-    int can_mmap;
-#endif /* APR_HAS_MMAP */
-};
-
-/** @see apr_bucket_structs */
-typedef union apr_bucket_structs apr_bucket_structs;
-/**
- * A union of all bucket structures so we know what
- * the max size is.
- */
-union apr_bucket_structs {
-    apr_bucket      b;      /**< Bucket */
-    apr_bucket_heap heap;   /**< Heap */
-    apr_bucket_pool pool;   /**< Pool */
-#if APR_HAS_MMAP
-    apr_bucket_mmap mmap;   /**< MMap */
-#endif
-    apr_bucket_file file;   /**< File */
-};
-
-/**
- * The amount that apr_bucket_alloc() should allocate in the common case.
- * Note: this is twice as big as apr_bucket_structs to allow breathing
- * room for third-party bucket types.
- */
-#define APR_BUCKET_ALLOC_SIZE  APR_ALIGN_DEFAULT(2*sizeof(apr_bucket_structs))
-
-/*  *****  Bucket Brigade Functions  *****  */
-/**
- * Create a new bucket brigade.  The bucket brigade is originally empty.
- * @param p The pool to associate with the brigade.  Data is not allocated out
- *          of the pool, but a cleanup is registered.
- * @param list The bucket allocator to use
- * @return The empty bucket brigade
- */
-APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p,
-                                                     apr_bucket_alloc_t *list);
-
-/**
- * destroy an entire bucket brigade.  This includes destroying all of the
- * buckets within the bucket brigade's bucket list. 
- * @param b The bucket brigade to destroy
- */
-APU_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b);
-
-/**
- * empty out an entire bucket brigade.  This includes destroying all of the
- * buckets within the bucket brigade's bucket list.  This is similar to
- * apr_brigade_destroy(), except that it does not deregister the brigade's
- * pool cleanup function.
- * @param data The bucket brigade to clean up
- * @remark Generally, you should use apr_brigade_destroy().  This function
- *         can be useful in situations where you have a single brigade that
- *         you wish to reuse many times by destroying all of the buckets in
- *         the brigade and putting new buckets into it later.
- */
-APU_DECLARE(apr_status_t) apr_brigade_cleanup(void *data);
-
-/**
- * Split a bucket brigade into two, such that the given bucket is the
- * first in the new bucket brigade. This function is useful when a
- * filter wants to pass only the initial part of a brigade to the next
- * filter.
- * @param b The brigade to split
- * @param e The first element of the new brigade
- * @return The new brigade
- */
-APU_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b,
-                                                    apr_bucket *e);
-
-/**
- * Partition a bucket brigade at a given offset (in bytes from the start of
- * the brigade).  This is useful whenever a filter wants to use known ranges
- * of bytes from the brigade; the ranges can even overlap.
- * @param b The brigade to partition
- * @param point The offset at which to partition the brigade
- * @param after_point Returns a pointer to the first bucket after the partition
- */
-APU_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b,
-                                                apr_off_t point,
-                                                apr_bucket **after_point);
-
-#if APR_NOT_DONE_YET
-/**
- * consume nbytes from beginning of b -- call apr_bucket_destroy as
- * appropriate, and/or modify start on last element 
- * @param b The brigade to consume data from
- * @param nbytes The number of bytes to consume
- */
-APU_DECLARE(void) apr_brigade_consume(apr_bucket_brigade *b,
-                                      apr_off_t nbytes);
-#endif
-
-/**
- * Return the total length of the brigade.
- * @param bb The brigade to compute the length of
- * @param read_all Read unknown-length buckets to force a size
- * @param length Returns the length of the brigade, or -1 if the brigade has
- *               buckets of indeterminate length and read_all is 0.
- */
-APU_DECLARE(apr_status_t) apr_brigade_length(apr_bucket_brigade *bb,
-                                             int read_all,
-                                             apr_off_t *length);
-
-/**
- * Take a bucket brigade and store the data in a flat char*
- * @param bb The bucket brigade to create the char* from
- * @param c The char* to write into
- * @param len The maximum length of the char array. On return, it is the
- *            actual length of the char array.
- */
-APU_DECLARE(apr_status_t) apr_brigade_flatten(apr_bucket_brigade *bb,
-                                              char *c,
-                                              apr_size_t *len);
-
-/**
- * Creates a pool-allocated string representing a flat bucket brigade
- * @param bb The bucket brigade to create the char array from
- * @param c On return, the allocated char array
- * @param len On return, the length of the char array.
- * @param pool The pool to allocate the string from.
- */
-APU_DECLARE(apr_status_t) apr_brigade_pflatten(apr_bucket_brigade *bb, 
-                                               char **c,
-                                               apr_size_t *len,
-                                               apr_pool_t *pool);
-
-/**
- * Split a brigade to represent one LF line.
- * @param bbOut The bucket brigade that will have the LF line appended to.
- * @param bbIn The input bucket brigade to search for a LF-line.
- * @param block The blocking mode to be used to split the line.
- * @param maxbytes The maximum bytes to read.  If this many bytes are seen
- *                 without a LF, the brigade will contain a partial line.
- */
-APU_DECLARE(apr_status_t) apr_brigade_split_line(apr_bucket_brigade *bbOut,
-                                                 apr_bucket_brigade *bbIn,
-                                                 apr_read_type_e block,
-                                                 apr_off_t maxbytes);
-
-/**
- * create an iovec of the elements in a bucket_brigade... return number 
- * of elements used.  This is useful for writing to a file or to the
- * network efficiently.
- * @param b The bucket brigade to create the iovec from
- * @param vec The iovec to create
- * @param nvec The number of elements in the iovec. On return, it is the
- *             number of iovec elements actually filled out.
- */
-APU_DECLARE(apr_status_t) apr_brigade_to_iovec(apr_bucket_brigade *b, 
-                                               struct iovec *vec, int *nvec);
-
-/**
- * This function writes a list of strings into a bucket brigade. 
- * @param b The bucket brigade to add to
- * @param flush The flush function to use if the brigade is full
- * @param ctx The structure to pass to the flush function
- * @param va A list of strings to add
- * @return APR_SUCCESS or error code.
- */
-APU_DECLARE(apr_status_t) apr_brigade_vputstrs(apr_bucket_brigade *b,
-                                               apr_brigade_flush flush,
-                                               void *ctx,
-                                               va_list va);
-
-/**
- * This function writes a string into a bucket brigade.
- * @param b The bucket brigade to add to
- * @param flush The flush function to use if the brigade is full
- * @param ctx The structure to pass to the flush function
- * @param str The string to add
- * @param nbyte The number of bytes to write
- * @return APR_SUCCESS or error code
- */
-APU_DECLARE(apr_status_t) apr_brigade_write(apr_bucket_brigade *b,
-                                            apr_brigade_flush flush, void *ctx,
-                                            const char *str, apr_size_t nbyte);
-
-/**
- * This function writes multiple strings into a bucket brigade.
- * @param b The bucket brigade to add to
- * @param flush The flush function to use if the brigade is full
- * @param ctx The structure to pass to the flush function
- * @param vec The strings to add (address plus length for each)
- * @param nvec The number of entries in iovec
- * @return APR_SUCCESS or error code
- */
-APU_DECLARE(apr_status_t) apr_brigade_writev(apr_bucket_brigade *b,
-                                             apr_brigade_flush flush,
-                                             void *ctx,
-                                             const struct iovec *vec,
-                                             apr_size_t nvec);
-
-/**
- * This function writes a string into a bucket brigade.
- * @param bb The bucket brigade to add to
- * @param flush The flush function to use if the brigade is full
- * @param ctx The structure to pass to the flush function
- * @param str The string to add
- * @return APR_SUCCESS or error code
- */
-APU_DECLARE(apr_status_t) apr_brigade_puts(apr_bucket_brigade *bb,
-                                           apr_brigade_flush flush, void *ctx,
-                                           const char *str);
-
-/**
- * This function writes a character into a bucket brigade.
- * @param b The bucket brigade to add to
- * @param flush The flush function to use if the brigade is full
- * @param ctx The structure to pass to the flush function
- * @param c The character to add
- * @return APR_SUCCESS or error code
- */
-APU_DECLARE(apr_status_t) apr_brigade_putc(apr_bucket_brigade *b,
-                                           apr_brigade_flush flush, void *ctx,
-                                           const char c);
-
-/**
- * This function writes an unspecified number of strings into a bucket brigade.
- * @param b The bucket brigade to add to
- * @param flush The flush function to use if the brigade is full
- * @param ctx The structure to pass to the flush function
- * @param ... The strings to add
- * @return APR_SUCCESS or error code
- */
-APU_DECLARE_NONSTD(apr_status_t) apr_brigade_putstrs(apr_bucket_brigade *b,
-                                                     apr_brigade_flush flush,
-                                                     void *ctx, ...);
-
-/**
- * Evaluate a printf and put the resulting string at the end 
- * of the bucket brigade.
- * @param b The brigade to write to
- * @param flush The flush function to use if the brigade is full
- * @param ctx The structure to pass to the flush function
- * @param fmt The format of the string to write
- * @param ... The arguments to fill out the format
- * @return APR_SUCCESS or error code
- */
-APU_DECLARE_NONSTD(apr_status_t) apr_brigade_printf(apr_bucket_brigade *b, 
-                                                    apr_brigade_flush flush,
-                                                    void *ctx,
-                                                    const char *fmt, ...)
-        __attribute__((format(printf,4,5)));
-
-/**
- * Evaluate a printf and put the resulting string at the end 
- * of the bucket brigade.
- * @param b The brigade to write to
- * @param flush The flush function to use if the brigade is full
- * @param ctx The structure to pass to the flush function
- * @param fmt The format of the string to write
- * @param va The arguments to fill out the format
- * @return APR_SUCCESS or error code
- */
-APU_DECLARE(apr_status_t) apr_brigade_vprintf(apr_bucket_brigade *b, 
-                                              apr_brigade_flush flush,
-                                              void *ctx,
-                                              const char *fmt, va_list va);
-
-/*  *****  Bucket freelist functions *****  */
-/**
- * Create a bucket allocator.
- * @param p This pool's underlying apr_allocator_t is used to allocate memory
- *          for the bucket allocator.  When the pool is destroyed, the bucket
- *          allocator's cleanup routine will free all memory that has been
- *          allocated from it.
- * @remark  The reason the allocator gets its memory from the pool's
- *          apr_allocator_t rather than from the pool itself is because
- *          the bucket allocator will free large memory blocks back to the
- *          allocator when it's done with them, thereby preventing memory
- *          footprint growth that would occur if we allocated from the pool.
- * @warning The allocator must never be used by more than one thread at a time.
- */
-APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create(apr_pool_t *p);
-
-/**
- * Create a bucket allocator.
- * @param allocator This apr_allocator_t is used to allocate both the bucket
- *          allocator and all memory handed out by the bucket allocator.  The
- *          caller is responsible for destroying the bucket allocator and the
- *          apr_allocator_t -- no automatic cleanups will happen.
- * @warning The allocator must never be used by more than one thread at a time.
- */
-APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create_ex(apr_allocator_t *allocator);
-
-/**
- * Destroy a bucket allocator.
- * @param list The allocator to be destroyed
- */
-APU_DECLARE_NONSTD(void) apr_bucket_alloc_destroy(apr_bucket_alloc_t *list);
-
-/**
- * Allocate memory for use by the buckets.
- * @param size The amount to allocate.
- * @param list The allocator from which to allocate the memory.
- */
-APU_DECLARE_NONSTD(void *) apr_bucket_alloc(apr_size_t size, apr_bucket_alloc_t *list);
-
-/**
- * Free memory previously allocated with apr_bucket_alloc().
- * @param block The block of memory to be freed.
- */
-APU_DECLARE_NONSTD(void) apr_bucket_free(void *block);
-
-
-/*  *****  Bucket Functions  *****  */
-/**
- * Free the resources used by a bucket. If multiple buckets refer to
- * the same resource it is freed when the last one goes away.
- * @see apr_bucket_delete()
- * @param e The bucket to destroy
- */
-#define apr_bucket_destroy(e) do {					\
-        (e)->type->destroy((e)->data);					\
-        (e)->free(e);							\
-    } while (0)
-
-/**
- * Delete a bucket by removing it from its brigade (if any) and then
- * destroying it.
- * @remark This mainly acts as an aid in avoiding code verbosity.  It is
- * the preferred exact equivalent to:
- * <pre>
- *      APR_BUCKET_REMOVE(e);
- *      apr_bucket_destroy(e);
- * </pre>
- * @param e The bucket to delete
- */
-#define apr_bucket_delete(e) do {					\
-        APR_BUCKET_REMOVE(e);						\
-        apr_bucket_destroy(e);						\
-    } while (0)
-
-/**
- * read the data from the bucket
- * @param e The bucket to read from
- * @param str The location to store the data in
- * @param len The amount of data read
- * @param block Whether the read function blocks
- */
-#define apr_bucket_read(e,str,len,block) (e)->type->read(e, str, len, block)
-
-/**
- * Setaside data so that stack data is not destroyed on returning from
- * the function
- * @param e The bucket to setaside
- * @param p The pool to setaside into
- */
-#define apr_bucket_setaside(e,p) (e)->type->setaside(e,p)
-
-/**
- * Split one bucket in two.
- * @param e The bucket to split
- * @param point The offset to split the bucket at
- */
-#define apr_bucket_split(e,point) (e)->type->split(e, point)
-
-/**
- * Copy a bucket.
- * @param e The bucket to copy
- * @param c Returns a pointer to the new bucket
- */
-#define apr_bucket_copy(e,c) (e)->type->copy(e, c)
-
-/* Bucket type handling */
-
-/**
- * This function simply returns APR_SUCCESS to denote that the bucket does
- * not require anything to happen for its setaside() function. This is
- * appropriate for buckets that have "immortal" data -- the data will live
- * at least as long as the bucket.
- * @param data The bucket to setaside
- * @param pool The pool defining the desired lifetime of the bucket data
- * @return APR_SUCCESS
- */ 
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_noop(apr_bucket *data,
-                                                          apr_pool_t *pool);
-
-/**
- * A place holder function that signifies that the setaside function was not
- * implemented for this bucket
- * @param data The bucket to setaside
- * @param pool The pool defining the desired lifetime of the bucket data
- * @return APR_ENOTIMPL
- */ 
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_notimpl(apr_bucket *data,
-                                                             apr_pool_t *pool);
-
-/**
- * A place holder function that signifies that the split function was not
- * implemented for this bucket
- * @param data The bucket to split
- * @param point The location to split the bucket
- * @return APR_ENOTIMPL
- */ 
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_split_notimpl(apr_bucket *data,
-                                                          apr_size_t point);
-
-/**
- * A place holder function that signifies that the copy function was not
- * implemented for this bucket
- * @param e The bucket to copy
- * @param c Returns a pointer to the new bucket
- * @return APR_ENOTIMPL
- */
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_notimpl(apr_bucket *e,
-                                                         apr_bucket **c);
-
-/**
- * A place holder function that signifies that this bucket does not need
- * to do anything special to be destroyed.  That's only the case for buckets
- * that either have no data (metadata buckets) or buckets whose data pointer
- * points to something that's not a bucket-type-specific structure, as with
- * simple buckets where data points to a string and pipe buckets where data
- * points directly to the apr_file_t.
- * @param data The bucket data to destroy
- */ 
-APU_DECLARE_NONSTD(void) apr_bucket_destroy_noop(void *data);
-
-/**
- * There is no apr_bucket_destroy_notimpl, because destruction is required
- * to be implemented (it could be a noop, but only if that makes sense for
- * the bucket type)
- */
-
-/* There is no apr_bucket_read_notimpl, because it is a required function
- */
-
-
-/* All of the bucket types implemented by the core */
-/**
- * The flush bucket type.  This signifies that all data should be flushed to
- * the next filter.  The flush bucket should be sent with the other buckets.
- */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_flush;
-/**
- * The EOS bucket type.  This signifies that there will be no more data, ever.
- * All filters MUST send all data to the next filter when they receive a
- * bucket of this type
- */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_eos;
-/**
- * The FILE bucket type.  This bucket represents a file on disk
- */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_file;
-/**
- * The HEAP bucket type.  This bucket represents a data allocated from the
- * heap.
- */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_heap;
-#if APR_HAS_MMAP
-/**
- * The MMAP bucket type.  This bucket represents an MMAP'ed file
- */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_mmap;
-#endif
-/**
- * The POOL bucket type.  This bucket represents a data that was allocated
- * from a pool.  IF this bucket is still available when the pool is cleared,
- * the data is copied on to the heap.
- */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pool;
-/**
- * The PIPE bucket type.  This bucket represents a pipe to another program.
- */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pipe;
-/**
- * The IMMORTAL bucket type.  This bucket represents a segment of data that
- * the creator is willing to take responsibility for.  The core will do
- * nothing with the data in an immortal bucket
- */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_immortal;
-/**
- * The TRANSIENT bucket type.  This bucket represents a data allocated off
- * the stack.  When the setaside function is called, this data is copied on
- * to the heap
- */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_transient;
-/**
- * The SOCKET bucket type.  This bucket represents a socket to another machine
- */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_socket;
-
-
-/*  *****  Simple buckets  *****  */
-
-/**
- * Split a simple bucket into two at the given point.  Most non-reference
- * counting buckets that allow multiple references to the same block of
- * data (eg transient and immortal) will use this as their split function
- * without any additional type-specific handling.
- * @param b The bucket to be split
- * @param point The offset of the first byte in the new bucket
- * @return APR_EINVAL if the point is not within the bucket;
- *         APR_ENOMEM if allocation failed;
- *         or APR_SUCCESS
- */
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_split(apr_bucket *b,
-                                                         apr_size_t point);
-
-/**
- * Copy a simple bucket.  Most non-reference-counting buckets that allow
- * multiple references to the same block of data (eg transient and immortal)
- * will use this as their copy function without any additional type-specific
- * handling.
- * @param a The bucket to copy
- * @param b Returns a pointer to the new bucket
- * @return APR_ENOMEM if allocation failed;
- *         or APR_SUCCESS
- */
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_copy(apr_bucket *a,
-                                                        apr_bucket **b);
-
-
-/*  *****  Shared, reference-counted buckets  *****  */
-
-/**
- * Initialize a bucket containing reference-counted data that may be
- * shared. The caller must allocate the bucket if necessary and
- * initialize its type-dependent fields, and allocate and initialize
- * its own private data structure. This function should only be called
- * by type-specific bucket creation functions.
- * @param b The bucket to initialize
- * @param data A pointer to the private data structure
- *             with the reference count at the start
- * @param start The start of the data in the bucket
- *              relative to the private base pointer
- * @param length The length of the data in the bucket
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_shared_make(apr_bucket *b, void *data,
-				                 apr_off_t start, 
-                                                 apr_size_t length);
-
-/**
- * Decrement the refcount of the data in the bucket. This function
- * should only be called by type-specific bucket destruction functions.
- * @param data The private data pointer from the bucket to be destroyed
- * @return TRUE or FALSE; TRUE if the reference count is now
- *         zero, indicating that the shared resource itself can
- *         be destroyed by the caller.
- */
-APU_DECLARE(int) apr_bucket_shared_destroy(void *data);
-
-/**
- * Split a bucket into two at the given point, and adjust the refcount
- * to the underlying data. Most reference-counting bucket types will
- * be able to use this function as their split function without any
- * additional type-specific handling.
- * @param b The bucket to be split
- * @param point The offset of the first byte in the new bucket
- * @return APR_EINVAL if the point is not within the bucket;
- *         APR_ENOMEM if allocation failed;
- *         or APR_SUCCESS
- */
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_split(apr_bucket *b,
-                                                         apr_size_t point);
-
-/**
- * Copy a refcounted bucket, incrementing the reference count. Most
- * reference-counting bucket types will be able to use this function
- * as their copy function without any additional type-specific handling.
- * @param a The bucket to copy
- * @param b Returns a pointer to the new bucket
- * @return APR_ENOMEM if allocation failed;
-           or APR_SUCCESS
- */
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_copy(apr_bucket *a,
-                                                        apr_bucket **b);
-
-
-/*  *****  Functions to Create Buckets of varying types  *****  */
-/*
- * Each bucket type foo has two initialization functions:
- * apr_bucket_foo_make which sets up some already-allocated memory as a
- * bucket of type foo; and apr_bucket_foo_create which allocates memory
- * for the bucket, calls apr_bucket_make_foo, and initializes the
- * bucket's list pointers. The apr_bucket_foo_make functions are used
- * inside the bucket code to change the type of buckets in place;
- * other code should call apr_bucket_foo_create. All the initialization
- * functions change nothing if they fail.
- */
-
-/**
- * Create an End of Stream bucket.  This indicates that there is no more data
- * coming from down the filter stack.  All filters should flush at this point.
- * @param list The freelist from which this bucket should be allocated
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_eos_create(apr_bucket_alloc_t *list);
-
-/**
- * Make the bucket passed in an EOS bucket.  This indicates that there is no 
- * more data coming from down the filter stack.  All filters should flush at 
- * this point.
- * @param b The bucket to make into an EOS bucket
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_eos_make(apr_bucket *b);
-
-/**
- * Create a flush  bucket.  This indicates that filters should flush their
- * data.  There is no guarantee that they will flush it, but this is the
- * best we can do.
- * @param list The freelist from which this bucket should be allocated
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_flush_create(apr_bucket_alloc_t *list);
-
-/**
- * Make the bucket passed in a FLUSH  bucket.  This indicates that filters 
- * should flush their data.  There is no guarantee that they will flush it, 
- * but this is the best we can do.
- * @param b The bucket to make into a FLUSH bucket
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_flush_make(apr_bucket *b);
-
-/**
- * Create a bucket referring to long-lived data.
- * @param buf The data to insert into the bucket
- * @param nbyte The size of the data to insert.
- * @param list The freelist from which this bucket should be allocated
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_immortal_create(const char *buf, 
-                                                     apr_size_t nbyte,
-                                                     apr_bucket_alloc_t *list);
-
-/**
- * Make the bucket passed in a bucket refer to long-lived data
- * @param b The bucket to make into a IMMORTAL bucket
- * @param buf The data to insert into the bucket
- * @param nbyte The size of the data to insert.
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_immortal_make(apr_bucket *b, 
-                                                   const char *buf, 
-                                                   apr_size_t nbyte);
-
-/**
- * Create a bucket referring to data on the stack.
- * @param buf The data to insert into the bucket
- * @param nbyte The size of the data to insert.
- * @param list The freelist from which this bucket should be allocated
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_transient_create(const char *buf, 
-                                                      apr_size_t nbyte,
-                                                      apr_bucket_alloc_t *list);
-
-/**
- * Make the bucket passed in a bucket refer to stack data
- * @param b The bucket to make into a TRANSIENT bucket
- * @param buf The data to insert into the bucket
- * @param nbyte The size of the data to insert.
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_transient_make(apr_bucket *b, 
-                                                    const char *buf,
-                                                    apr_size_t nbyte);
-
-/**
- * Create a bucket referring to memory on the heap. If the caller asks
- * for the data to be copied, this function always allocates 4K of
- * memory so that more data can be added to the bucket without
- * requiring another allocation. Therefore not all the data may be put
- * into the bucket. If copying is not requested then the bucket takes
- * over responsibility for free()ing the memory.
- * @param buf The buffer to insert into the bucket
- * @param nbyte The size of the buffer to insert.
- * @param free_func Function to use to free the data; NULL indicates that the
- *                  bucket should make a copy of the data
- * @param list The freelist from which this bucket should be allocated
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_heap_create(const char *buf, 
-                                                 apr_size_t nbyte,
-                                                 void (*free_func)(void *data),
-                                                 apr_bucket_alloc_t *list);
-/**
- * Make the bucket passed in a bucket refer to heap data
- * @param b The bucket to make into a HEAP bucket
- * @param buf The buffer to insert into the bucket
- * @param nbyte The size of the buffer to insert.
- * @param free_func Function to use to free the data; NULL indicates that the
- *                  bucket should make a copy of the data
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_heap_make(apr_bucket *b, const char *buf,
-                                               apr_size_t nbyte,
-                                               void (*free_func)(void *data));
-
-/**
- * Create a bucket referring to memory allocated from a pool.
- *
- * @param buf The buffer to insert into the bucket
- * @param length The number of bytes referred to by this bucket
- * @param pool The pool the memory was allocated from
- * @param list The freelist from which this bucket should be allocated
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_pool_create(const char *buf, 
-                                                 apr_size_t length,
-                                                 apr_pool_t *pool,
-                                                 apr_bucket_alloc_t *list);
-
-/**
- * Make the bucket passed in a bucket refer to pool data
- * @param b The bucket to make into a pool bucket
- * @param buf The buffer to insert into the bucket
- * @param length The number of bytes referred to by this bucket
- * @param pool The pool the memory was allocated from
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b, const char *buf,
-                                               apr_size_t length, 
-                                               apr_pool_t *pool);
-
-#if APR_HAS_MMAP
-/**
- * Create a bucket referring to mmap()ed memory.
- * @param mm The mmap to insert into the bucket
- * @param start The offset of the first byte in the mmap
- *              that this bucket refers to
- * @param length The number of bytes referred to by this bucket
- * @param list The freelist from which this bucket should be allocated
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_mmap_create(apr_mmap_t *mm, 
-                                                 apr_off_t start,
-                                                 apr_size_t length,
-                                                 apr_bucket_alloc_t *list);
-
-/**
- * Make the bucket passed in a bucket refer to an MMAP'ed file
- * @param b The bucket to make into a MMAP bucket
- * @param mm The mmap to insert into the bucket
- * @param start The offset of the first byte in the mmap
- *              that this bucket refers to
- * @param length The number of bytes referred to by this bucket
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_mmap_make(apr_bucket *b, apr_mmap_t *mm,
-                                               apr_off_t start, 
-                                               apr_size_t length);
-#endif
-
-/**
- * Create a bucket referring to a socket.
- * @param thissock The socket to put in the bucket
- * @param list The freelist from which this bucket should be allocated
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_socket_create(apr_socket_t *thissock,
-                                                   apr_bucket_alloc_t *list);
-/**
- * Make the bucket passed in a bucket refer to a socket
- * @param b The bucket to make into a SOCKET bucket
- * @param thissock The socket to put in the bucket
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_socket_make(apr_bucket *b, 
-                                                 apr_socket_t *thissock);
-
-/**
- * Create a bucket referring to a pipe.
- * @param thispipe The pipe to put in the bucket
- * @param list The freelist from which this bucket should be allocated
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_pipe_create(apr_file_t *thispipe,
-                                                 apr_bucket_alloc_t *list);
-
-/**
- * Make the bucket passed in a bucket refer to a pipe
- * @param b The bucket to make into a PIPE bucket
- * @param thispipe The pipe to put in the bucket
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(apr_bucket *) apr_bucket_pipe_make(apr_bucket *b, 
-                                               apr_file_t *thispipe);
-
-/**
- * Create a bucket referring to a file.
- * @param fd The file to put in the bucket
- * @param offset The offset where the data of interest begins in the file
- * @param len The amount of data in the file we are interested in
- * @param p The pool into which any needed structures should be created
- *          while reading from this file bucket
- * @param list The freelist from which this bucket should be allocated
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(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);
-
-/**
- * Make the bucket passed in a bucket refer to a file
- * @param b The bucket to make into a FILE bucket
- * @param fd The file to put in the bucket
- * @param offset The offset where the data of interest begins in the file
- * @param len The amount of data in the file we are interested in
- * @param p The pool into which any needed structures should be created
- *          while reading from this file bucket
- * @return The new bucket, or NULL if allocation failed
- */
-APU_DECLARE(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);
-
-/**
- * Enable or disable memory-mapping for a FILE bucket (default is enabled)
- * @param b The bucket
- * @param enabled Whether memory-mapping should be enabled
- * @return APR_SUCCESS normally, or an error code if the operation fails
- */
-APU_DECLARE(apr_status_t) apr_bucket_file_enable_mmap(apr_bucket *b,
-                                                      int enabled);
-
-/** @} */
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !APR_BUCKETS_H */