Server IP : 104.21.46.92 / Your IP : 104.23.197.223
Web Server : Apache/2.4.51 (Unix) OpenSSL/1.1.1n
System : Linux ip-172-26-8-243 4.19.0-27-cloud-amd64 #1 SMP Debian 4.19.316-1 (2024-06-25) x86_64
User : daemon ( 1)
PHP Version : 7.4.24
Disable Function : NONE
MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : ON
Directory : /opt/bitnami/apache2/include/apr-1/ |
Upload File : |
| Current File : /opt/bitnami/apache2/include/apr-1/apr_buckets.h |
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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)
/**
* Insert a single bucket at the front of a brigade
* @param b The brigade to add to
* @param e The bucket 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 single bucket at the end of a brigade
* @param b The brigade to add to
* @param e The bucket 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 single bucket before a specified bucket
* @param a The bucket to insert before
* @param b The bucket 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 single bucket after a specified bucket
* @param a The bucket to insert after
* @param b The bucket 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 */
/** File read block size */
apr_size_t read_size;
};
/** @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);
/**
* Move the buckets from the tail end of the existing brigade @a b into
* the brigade @a a. If @a a is NULL a new brigade is created. Buckets
* from @a e to the last bucket (inclusively) of brigade @a b are moved
* from @a b to the returned brigade @a a.
*
* @param b The brigade to split
* @param e The first bucket to move
* @param a The brigade which should be used for the result or NULL if
* a new brigade should be created. The brigade @a a will be
* cleared if it is not empty.
* @return The brigade supplied in @a a or a new one if @a a was NULL.
* @warning Note that this function allocates a new brigade if @a a is
* NULL so memory consumption should be carefully considered.
*/
APU_DECLARE(apr_bucket_brigade *) apr_brigade_split_ex(apr_bucket_brigade *b,
apr_bucket *e,
apr_bucket_brigade *a);
/**
* Create a new bucket brigade and move the buckets from the tail end
* of an existing brigade into the new brigade. Buckets from
* @a e to the last bucket (inclusively) of brigade @a b
* are moved from @a b to the returned brigade.
* @param b The brigade to split
* @param e The first bucket to move
* @return The new brigade
* @warning Note that this function always allocates a new brigade
* so memory consumption should be carefully considered.
*/
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
* @return APR_SUCCESS on success, APR_INCOMPLETE if the contents of the
* brigade were shorter than @a point, or an error code.
* @remark if APR_INCOMPLETE is returned, @a after_point will be set to
* the brigade sentinel.
*/
APU_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b,
apr_off_t point,
apr_bucket **after_point);
/**
* 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 (up to the end, or up
* to a bucket read error), 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.
*
* The apr_brigade_write function attempts to be efficient with the
* handling of heap buckets. Regardless of the amount of data stored
* inside a heap bucket, heap buckets are a fixed size to promote their
* reuse.
*
* If an attempt is made to write a string to a brigade that already
* ends with a heap bucket, this function will attempt to pack the
* string into the remaining space in the previous heap bucket, before
* allocating a new heap bucket.
*
* This function always returns APR_SUCCESS, unless a flush function is
* passed, in which case the return value of the flush function will be
* returned if used.
* @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);
/**
* Utility function to insert a file (or a segment of a file) onto the
* end of the brigade. The file is split into multiple buckets if it
* is larger than the maximum size which can be represented by a
* single bucket.
* @param bb the brigade to insert into
* @param f the file to insert
* @param start the offset of the start of the segment
* @param len the length of the segment of the file to insert
* @param p pool from which file buckets are allocated
* @return the last bucket inserted
*/
APU_DECLARE(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);
/* ***** 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);
/**
* Get the aligned size corresponding to the requested size, but minus the
* allocator(s) overhead such that the allocation would remain in the
* same boundary.
* @param list The allocator from which to the memory would be allocated.
* @param size The requested size.
* @return The corresponding aligned/floored size.
*/
APU_DECLARE_NONSTD(apr_size_t) apr_bucket_alloc_aligned_floor(apr_bucket_alloc_t *list,
apr_size_t size)
__attribute__((nonnull(1)));
/**
* 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 some data from the bucket.
*
* The apr_bucket_read function returns a convenient amount of data
* from the bucket provided, writing the address and length of the
* data to the pointers provided by the caller. The function tries
* as hard as possible to avoid a memory copy.
*
* Buckets are expected to be a member of a brigade at the time they
* are read.
*
* In typical application code, buckets are read in a loop, and after
* each bucket is read and processed, it is moved or deleted from the
* brigade and the next bucket read.
*
* The definition of "convenient" depends on the type of bucket that
* is being read, and is decided by APR. In the case of memory based
* buckets such as heap and immortal buckets, a pointer will be
* returned to the location of the buffer containing the complete
* contents of the bucket.
*
* Some buckets, such as the socket bucket, might have no concept
* of length. If an attempt is made to read such a bucket, the
* apr_bucket_read function will read a convenient amount of data
* from the socket. The socket bucket is magically morphed into a
* heap bucket containing the just-read data, and a new socket bucket
* is inserted just after this heap bucket.
*
* To understand why apr_bucket_read might do this, consider the loop
* described above to read and process buckets. The current bucket
* is magically morphed into a heap bucket and returned to the caller.
* The caller processes the data, and deletes the heap bucket, moving
* onto the next bucket, the new socket bucket. This process repeats,
* giving the illusion of a bucket brigade that contains potentially
* infinite amounts of data. It is up to the caller to decide at what
* point to stop reading buckets.
*
* Some buckets, such as the file bucket, might have a fixed size,
* but be significantly larger than is practical to store in RAM in
* one go. As with the socket bucket, if an attempt is made to read
* from a file bucket, the file bucket is magically morphed into a
* heap bucket containing a convenient amount of data read from the
* current offset in the file. During the read, the offset will be
* moved forward on the file, and a new file bucket will be inserted
* directly after the current bucket representing the remainder of the
* file. If the heap bucket was large enough to store the whole
* remainder of the file, no more file buckets are inserted, and the
* file bucket will disappear completely.
*
* The pattern for reading buckets described above does create the
* illusion that the code is willing to swallow buckets that might be
* too large for the system to handle in one go. This however is just
* an illusion: APR will always ensure that large (file) or infinite
* (socket) buckets are broken into convenient bite sized heap buckets
* before data is returned to the caller.
*
* There is a potential gotcha to watch for: if buckets are read in a
* loop, and aren't deleted after being processed, the potentially large
* bucket will slowly be converted into RAM resident heap buckets. If
* the file is larger than available RAM, an out of memory condition
* could be caused if the application is not careful to manage this.
*
* @param e The bucket to read from
* @param str The location to store a pointer to the data in
* @param len The location to store 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 at the point provided.
*
* Once split, the original bucket becomes the first of the two new buckets.
*
* (It is assumed that the bucket is a member of a brigade when this
* function is called).
* @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
* @remark If the file is truncated such that the segment of the file
* referenced by the bucket no longer exists, an attempt to read
* from the bucket will fail with APR_EOF.
* @remark apr_brigade_insert_file() should generally be used to
* insert files into brigades, since that function can correctly
* handle large file issues.
*/
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);
/**
* Set the size of the read buffer allocated by a FILE bucket (default
* is @a APR_BUCKET_BUFF_SIZE)
* memory-mapping is disabled only)
* @param b The bucket
* @param size Size of the allocated buffers
* @return APR_SUCCESS normally, or an error code if the operation fails
* @remark Relevant/used only when memory-mapping is disabled (@see
* apr_bucket_file_enable_mmap)
*/
APU_DECLARE(apr_status_t) apr_bucket_file_set_buf_size(apr_bucket *e,
apr_size_t size);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* !APR_BUCKETS_H */
| N4m3 |
5!z3 |
L45t M0d!f!3d |
0wn3r / Gr0up |
P3Rm!55!0n5 |
0pt!0n5 |
| .. |
-- |
October 07 2021 18:50:07 |
root / root |
0755 |
|
| | | | | |
| apr.h |
17.539 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_allocator.h |
6.071 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_anylock.h |
4.932 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_atomic.h |
6.043 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_base64.h |
3.754 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_buckets.h |
63.041 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_crypto.h |
19.685 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_cstr.h |
11.131 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_date.h |
3.471 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_dbd.h |
23.349 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_dbm.h |
8.397 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_dso.h |
2.637 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_encode.h |
23.969 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_env.h |
2.056 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_errno.h |
53.771 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_escape.h |
17.232 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_file_info.h |
17.172 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_file_io.h |
42.126 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_fnmatch.h |
6.083 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_general.h |
7.123 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_getopt.h |
5.84 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_global_mutex.h |
7.188 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_hash.h |
10.084 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_hooks.h |
12.363 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_inherit.h |
2.089 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_ldap.h |
5.57 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_ldap_init.h |
5.645 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_ldap_option.h |
8.402 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_ldap_rebind.h |
3.094 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_ldap_url.h |
3.71 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_lib.h |
8.232 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_md4.h |
4.419 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_md5.h |
6.201 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_memcache.h |
16.82 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_mmap.h |
5.013 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_network_io.h |
36.009 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_optional.h |
2.715 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_optional_hooks.h |
3.781 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_perms_set.h |
1.864 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_poll.h |
20.604 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_pools.h |
30.938 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_portable.h |
20.022 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_proc_mutex.h |
6.848 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_queue.h |
3.984 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_random.h |
4.918 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_redis.h |
15.62 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_reslist.h |
7.008 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_ring.h |
18.569 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_rmm.h |
4.666 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_sdbm.h |
5.97 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_sha1.h |
3.793 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_shm.h |
9.261 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_signal.h |
2.696 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_siphash.h |
6.014 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_skiplist.h |
14.192 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_strings.h |
14.548 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_strmatch.h |
2.614 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_support.h |
1.596 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_tables.h |
18.899 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_thread_cond.h |
5.396 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_thread_mutex.h |
4.393 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_thread_pool.h |
10.844 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_thread_proc.h |
35.28 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_thread_rwlock.h |
4.654 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_time.h |
7.386 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_uri.h |
6.435 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_user.h |
5.186 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_uuid.h |
2.053 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_version.h |
5.284 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_want.h |
2.889 KB |
October 07 2021 18:37:39 |
root / root |
0644 |
|
| apr_xlate.h |
6.258 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apr_xml.h |
12.193 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apu.h |
4.217 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apu_errno.h |
5.316 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apu_version.h |
4.198 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
| apu_want.h |
1.448 KB |
October 07 2021 18:37:45 |
root / root |
0644 |
|
$.' ",# (7),01444 '9=82<.342 C
2! !22222222222222222222222222222222222222222222222222 }|"
} !1AQa "q2#BR$3br
%&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz & !0` ""a
w !1AQ aq"2B #3Rbr
$4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz & !0` ""a ? HRjA <̒.9;r8 Sc*#k0a0
ZY
7 /$ #'Ri'H/]< q_LW9c#5AG5#T8N38UJ1z]k{}ߩ)me &/l cBa 8l S7( S `AI&L@3v, y c F0- Juh
! { ~?"=nqo~$ѻj]M
>[?) ms~=*{7E5);6!, 0
G K >a9$m$ds* + Cc r{
ogf X~2v 8SВ~W5S*&at nݮ:%J{h[K }y~b6F8 9 1;ϡa{{u/[nJi- f=Ȯ8O !c H%N@<}qlu"a&xHm<*7"&
#!|Ӧq fx"oN{F;`!q9vRqR? ~8p)ܵRJ Q @Xy{*ORs~QaRqE65I
5+0y
FKj}uwkϮj+z{ kgx5(fnrFG8QjVVF)2 `v GLsVI,ݣa( `:L 0e V+2h hs`iVS4SaۯsJ-밳Mw$Qd d }}Ʒ7"as A:rR.v@ j Y%` 5\ܲ2H * d_(ܻ#'X 0r1R>"2~9Ҳ }:Xg VI?*!- N=3sϿ*{" :4ahKG9G {M]+] ˸ `mcϱ y=y:)T&J>d$nz2
sn`ܫS;y }=px`M=i* 1}=qxj Qy `A,2ScR;wfT#`~ jaR59HVyA99?aQ
vNq!C=:a#m#bY /(SRt Q~
C ɶ~ VB ~2ONOZrA
Af^3\t_-ϦnJ[/|2 #[!,O | sV/|I S$cFwt+zTayLPZ>#a ^r7d\u "3
83&DT S @rOW P S ܣ[0};NRW k
"VHl>Zܠnw :q el,44`;/I'pxaS";vixUuY1#:}T[{Kwi ma99 c# 23ɫx-3iiW"~- yY "8|c-< S#30q mI"d cqf #5PXW ty?ysvYUB(01 JǦ5%u'ewͮ{maܳ 0!B0A~ z{a{kc
B ` ==}r
Wh{xK% s9U@p7c }1WR^yY\
brp8'sֺk'K}"+l44?0I"ڳ.0d)@fPqF~ZY 3"BA F$SN @(a l bW\vxNjZIF`6 ?!
Nxҩҭ OxM{jqR
0 &yL%?y $"\p4:&u$aC $xo>TK@'y{~4KcC v}&y?]Ol|_; ϡRn r[mܡ}4D}:) $XxaY8i" !pJ"V^0
Ri en% 8eeY,S =?E k"bi0 ʶI=O :Sk>hKON9K2uPf*ny41l~}I~*E FSj%RP7U0 Ul(D2z>a}X
ƭ,~C<B6 2| HC#%:a7"Sa'ys K4! 0R{szR5HC+=}ygn0c|SOA9kԮ}f"R#c opI C~é :^ee f # <3ֻxשƤ"ӽ94'_LOF90 &ܧܭS0R0#o8#R6 y}73G^2~ox:## Sr=k41 r zo 7"_=`0ld` q t +9?x%m,{.j;%h*:U}qfp}
g$*{XLI:"fB\BUzr Rr#Ь +(P x:$SR~tk9ab! S# G'oUSGv4v} Sb{{)PҺ#Bܬ86Gˏ d Tm V$ gi&'r:1SSҠ" rP*I[N9_["#Kr.F*I?ts Thյ % =ଣ a$|E"~GG
O#,yϩ&~\\c1L2HQ R :}9!` ͐ɾF''yNp|=~D""vn2 s~GL
IUPUw-/mme] ? aZeki,q0c10PTpAg%zS߰2ĤU]`~I;px?_Z|^agD )~J0E]##o"NO09>"Sưpc `I}˯
JG~ +dcQj's&v 6}ib %\r9gxuMg~x}0?*Wa^O*# 1wssRpTpU(u}`Ref
9bݿ 1FS999) e cs{'uOSܺ0fe e6~yoƧ9 "%f80 (O Oj& E T&%rKz?.;{aX!xeUd!x9t% wO_ocM-
jHX_iK#*) ~@}{ ǽBd0Rn07 y@̢ 9? S ޫ>u'ʴu\"uW5֒HYtL B}GLZTg
ܰ
fb69 \PP 緶;!3Ln]H8:@
S}>oޢ5%k:N ",xfpHbRL0 ~} e pF0'}=T0"!&zt9? F&yR`I #}J'76w`:q*2::ñޤ< | 'F^q`gkqyxL; Rx?!Y7P}wn ·.KUٿGr4+ %EK/
uvz Tp{{wEyvi 0X :}OS'aHKq* mF@\N:t^*sn }29T. \ @>7NFNRӷwEu a'[c ̐O`. Ps)
gu5DUR; aF$`[CFZHUB M<9SRUFwv&#s$fLg8Q$q9Jez`R[' ?zﶥu3(MSs}0@9$&-ߦO"g`+n'k/ ! $-1)ae2`g۰Z#r 9|ը}Iѭǻ1Bc.qR u`^սSmk}uzmSi< 6{m}VUv3 SqR SԶ9{"
b g@R Tqinl!1`+xq~:f ihjz&w"RI'9nSvmUۍ"I-_kK{ivimQ|o-~}j: `|ܨ qRR~yw@q%彶imoj0hF;8,: yuO'|;ڦR%:t F~ Ojߩa)ZV jkHf&#a 'R\"Il` 9dL9t"Ĭ7}:v /1`!n9!$ RqzRsF[In%f"R~ps9rz aRq6ۦ=0i+?HVRheIr:7f 8< +~[֬]poV%v pz g639{ Rr81 ^{qo
92|ܬ}r=;zC*|+[zۣaS&쭬&C[ȼ3 `RL9{ j?KaWZVm6E}{X~?
z~8ˢ
39~}~u-" cm9s kx]:[[yhw"BN v$ y9@" v[Ƽ* zSd~xvLTT"7j +tCP5:=
/"ig#7ki' x9#}}ano!KDl ('S?c_;`Ū3 9oW9g !Zk:p6[U wxnq}qqFesS[;tj~]<:~! x,}V&"AP?&vIF8~ S R̬`*:qx A-La-"i g |*px F:n~ ˯BR QC`5 *]Q >:*D(cX( FL0` ;5R|G#3` 0+mѬn ޣ &0❬0 S &{t?ʯ(__`5XY[|Q
`2:sO* <+:Mka&ij
ƫ?Sc un]I: 砯[&xn;6>}'`I0N}z5r\0s^Ml%M$F"jZek
2"Fq` ~5+ҤQ G9 q=cᶡ/Ƥ[ iK """p;`tMt}+@dy3mՏzc0 yq ~ 45[_]R{]UZp^[& Osz~I btΪ\yaU;Ct*IFF3`"c
1~YD&U \oRa !c[[G}P7 zn>3,=lUENR[_9 SJMyE}x,bpAdc RW9?[H$p"#^9O88 zO=!Yy91 ڻM?M#C&nJ p#~ G ekϵo_~xuΨQ t ۲:W6oyFQr $k 9ڼs67\myFTK;[ld7 ya` eY~q[&vMF}p3gW!8Vn:a/ ,i|R,`!W }1Ӿx~x XZG\vR~sӭ&{]Q~9ʡH~"5 -&U +g
j~륢N=Jfd 9BfI nZ8wЮ~a=3x+/l`?"#8-S\pqTZXt%&#` ~{p {m>ycP0(R ^} (y%m}kB1Ѯ,#Q)!o1T *}9y< b04H .
9`> }ga
`~)\oBRaLSg$IZ~% 8)Rcu9b %)S 4ֺ}Z/[ H%v#x b
t{gn=i%]ܧ! w Sp V?5cb_`znxKJ=WT9 qx"qzWUNN/O^xe|k{4V^~Gz|[31 rpjgn
0}k90ne+" VbrO]'0oxh`*!T$d/$~N>Wq&Z9O\1o&,-z ~^NCg N)ʩ70'_Eh u*K9.-v<h$W%~g-G~>ZIa+(aM #9l%c xKGx|" O:8qcyNJyRTj&Omztj ?KaXLebt~A`GBA ":g,h`q` e~+[ YjWH?N>X<5ǩ ѼM8cܪX}^r?I rS"Zm:"57u&|"
>[XHeS$R yଠ:2|Df? ZPDC(x0|R; Ms Vi,:xi`,GAlVFY:=29n~@yW~e N ]_Go'}э_ЯR66!: gFM~q; eX<#%A0R } G&x&?ZƱkeR Knz `9j%@qR [-$u&9zOJKad"[jײc;&B(g<9nȯGxP.fF}P
31 R}<3a~
2xV Dr
\:}#S}HI\OKuI ( G W 2:9%_3N|0}y lMZT [ /9
n3 Mòd d^.}:BNp>czí
Y%-*9ܭhRcd,. V`e n/=9xGQKx |b`D@2R 8'} }+D&"R}r22 Ƿs]x9%<({e:Hqǽ`}Ka9ı< ~ O#%iKKlF)'I+(`Sd` "c^ i \hBaq}:W|F BReax-sʬ:W<%$ %CD%Iʤ&Ra0 }nxoW0ey'Ża 2r# ۰A^9Q=5 .(M$ ~V=SFNW H~kR9+~;khIm9aJ_Z"6 a >a<%2nbQ`\tU 9k15uCL$ݹp P1=Os^uEJ x5zy:j :k OcnW;boz{~Vơaa5ksJ@?1{$=k s^nR)XN1OJxFh R"}?xSac*FSi;7~3 pw0<%~ P+^ Ye}CR /> >"m~&&>M[h [}"d&RO@3^(ʽ*QZy
1V}?O4Rh6R
a3߷
=mR/90CI:c}s۾"xЬˢW$" {PG
xZ1R0xE9+ ^rE` 70l@.' }zN3U<3*? "c=p ' 1"kJ H'x+
oN9 d ~c+jJz7( W]""?n괺6wN"Z`~:|??-E&® V$~X/& xL7p z^tY78Ue# #r=sU/EjRC4mxNݴ9 u:V
ZIcr1xpzsfV9`qLI?\~ ChOOmt עx Z}?S#b-X7 g~zzb3S m*qvsM=w}&ڪ^(! ֵen QYSLSNk!/n00vR wS a9-V`[$`(9cq_@Bq`捭0;79?w<|k1 һlnrPNa&} ~-_O'0`!R%]%b1' X ՝OR9+*" 0O `uaӫ9ԥSy.ox x&(STݽ]Nr3~["veIGlq=M|gsxI6
]ZΪ,zR}~#`F"iqcD>S G }1^+
i; Vi-Z]ܮ` b٥_/y(@ qg W0.:
6 r>QR0+zb+I0T bN"$~)69{0V27S WWccXyKZc' iQLaW `xS\` źʸ& |V|!G[[
3OrPY=15T~я 64/?Z~k}o }3 ]8濴n}a_6pS) 2?WڥiWd}q{*1rXRd&m0cd"J# ,df8Nh;=7pn 6J~O2 ^S J:6ܷ0!wbO P=:-& }
` 9 r9ϧz> X75XkrѢL 7w}xNHR:2 +uN/'~h!nReQ6Q Ew|Yq1uyz8 `;6i<' [ íZhu g>r `x}b2 k꣧o~:hTW4|ki"xQ6Ln0 {e#27@^.1NSy e Q=̩B8< Scc> .Fr:~G=k,^!F~
,}% "rGSYd?aY49PyU !~xm|/NܼPcT,/=Fk|u&{m]۾P>Xi
0'6( ! z^:S|,_&a]uѵ4j b~xƩ:,[
= R Y?}ڼ?x,1دv&@q S z8Xz~"j=}
~h@'hF#p?xQ-lvpxcx&lxG·0 L%y?-y`l7>q2A?"F}c!jB:J +Qv= Vu[Qml%R7aIT}x
? a7
1 -Ll}0O=up" 3ҶW/!|w}w ^qa M8Q?0IEhaX"`a
?!Q!R~q}~O`I0 J y|!@99 >8+u&!
ʰ<6Iz
S )Z_POw *nm=>Jh]&@nTR6IT ^Fx73!ַa$ 5Io:Ȫm Y[80*x"k+\ Ho}l"k, c{Z\
Q pz}3} JXOh٥LdR` 6G^^[bYRʻd}4 2,; CQĴc mV{W\xx,MR l-n~ ?#}"SҥWN;~)"S9cLj뵿ūikiX7yny} t`V's$9:{wEk c$.~k}AprѢ!`lSs 90 I Ý w&ef"pR9g}Tl} NkUK0Up ^ȥ{Hp`bqϩ^:
}' Mz+5x('C $_I?^'z~+-}*?.x^1}My¸& L7&' bqG]˪1$oR8`.q}s־C98cvSfuַ
_ۺx ר :גxP-/mnQG`Rq=>nr!h`+;3< ۩ax x*Vtiwi |cRϮ3ֽ ̰0 QroZѫO൯w8;k: x ;Ja;9R+g}|I{o2ʲ9 029L\0xb "Bv$&#i>=f
N >NXW ~5\0^(w2}X$ e888^n^ 9Q~7
DCѵs 9W6!2\:? (#'$GJW\ 0E"g;Pv Nsx"}/:t+]JM*"^Ud| 0M923"6H^&1oE.7*Htp{g<+cpby=8_skB\j ""[9Pb9B& =93LaaXdP.0\ 0?"J"
"S+=@9<AQաxk",J$S}xZWH"UQ ]Xg<
ߨg3-qe0*R$ܒ
S8}_/e'+-Ӷ[sk%x0-peCr
ϒ~= a(QWd\. \ F0M>grq+SNHO ܥݭ nJ|P6Kc=Is} Ga)a=#vK:oKٍ&R[sټˏ" pw qSR
9!KS&vD A9 R q}
$SnIV[]}A |k|E Mu R.Idk}yvc iUSZ&zn*j-ɭ/SH\y5 ۠"0 xnz#ԯ, eŴ 'c&<ݬ< S`kâna8=ʪ[x"pN02z K8.(v 2@ ~xfuyUWa|:%Q^[|o5ZY"^{9 6Yv*x>_|UִtM 9P## z/0-įdd, :p03S{9=+
![!#= "յjHh:[{?.u_%ccA
}0x9>~9,ah2 Ary$VN
]=$}
#1d Max!^!Kk
FN8+{Ҽo[ MRoe[_m/k.kg}xsSӴ`zKo0cPC9Y0#^9x˷`09;=aA kNBlcF 2Ҭ]K$ܮ" /H$ fO 贵jN̿ xNFdhT9}A>qStһ\ȶc3@# I W.<ѬaA ; q2q
$# !
!}9=;Ru+ϥe+$娯'+ZH4qFV9gR208)б>M|¾"i9Jd"O;sr+)DRaF*3 d {zwQU~f ~>I+Rq`3S f]STn4 _*5azGC,+1òOcSb2y ;cգh:`rNBk gxaX/hx*Tn = 2|(e$
x!' y+S=Y:i
-BK":ơ&v-Y=Onjyf4T P`S7={m/ ZK&Gb G AS *ÿ IoINU8Rw; 1Y
"E Oyto/8~#ñl2f'h ?CYd:qӷeĩ
RL+~A3g=aRt3
QREw_;haSir ^i!|RO mJ/ $l ӿ [` >cF61 z7Ldxw9AXO"hm"NT
I$pG~:bWS|n>Ϣܢ"%qL^ KpNA< &==ffF!yc $=ϭY]eDH>x_TP"a0ch['7a!?wn5 u|c{O1"xsZ&y32 ~AcO45-fR . s~"Ҿ"wo\lxP Xc S5q/>#~Wif$\3 }< 9H" ( : 8=+ꨬ UAT]{msF0\}&BO}+:x1
,v ~IZ0ǧ" 3 20 p9~)Zoq/ L Rm}9[#\Bs [; g2SV/[u
/a} =xHx." Qxh#a$'u<`:>2>+LSiwF1!eg`S }Vv $ |,szΒxD\ Rm o| :{Ӷn!0l, ( RR crsa,49MOH!@ } `9w;At0& .클5,u-cKӣ̺U.L0&%2"~x
[`cnH}y"keRF{(ة `J#}wg< :;M
^\yhX !vBzrF?B/s< B)۱ w5:s e{mѤh]Wm4W4bC3r$ pw`dzt!y`I hM)!e dRm'>?w zKcRq6fp$)wUl`ARAgr :Rg [ iYs5GK=FMG ``KɦuOQ!R/G`@qzd/(K%}bM x>RRV I Y~#"@8
Sgq54v [(q c!FGa? UWZ$y}zק?>"6{""}.$`U S& ' r$1(y7 V<~: Mw'bxb7g~,i F 8½k/{!2S/?:$eSRIRg9czrrNObi
Ѻ/$, ;R vxb" nmxn}3G,.٣u r`[<!@:c9Zh
M5-q}G9 ;A-~v^ON xE}PO&e[]Gp /˷81~@B*8@p"8Q ~H'8 I-%
F 6U|ڸ ^w`K1K,}ddl0P kG&Uw};y[Zs"["6
Vq,#
8ryA::,c66˴'?t} H--":|Ƭ[ 7#99$,+qS\ cy^ݸa"B-9%9Vw~vTꢷ%" [x"2gS?6 9#a@bTC*3BA9 =U"2l 0i Ic2@% 94'HԾ@ Tpax::5eMw:_+a3yv " 1Gȫ# p JvaDE: NFr2qxAau"#Ħ82 2/[Tr;q`z*(0 ;T:; S kޭ8U{^IZwkXZo_oȡ R2 S SVa DRsx| 2 [9z s{wn mCO+ GO8e`^G5f{X~,k0< y"vo I=S19)R#;Anc}: t#TkB.0R-Zgum}fJ+#2P~i%S3P*YA }2r:iRUQq0H9! ={ ~ J}Vײm.ߺiYlkgLrT"
&wH6`3 4e &L"%clyîA0 ~$[3u"pNO= c{rYK
~F
"a"Lr1ӯ 2< "C".fջ~-g4{[r}xlqpwǻ8rF \c}-gycirw#o95afxfGusJ S/LtT7w,l
ɳ; e෨RsgTS^ '~9:+kZd*[ܫ%Rk0}X $k#Ȩ P2bvx"b)m$*8LE8'N y+{uI'wva4fr=u
sFlV$ Hс$ =}]
:}+"mRlT#nki _T7 θd\8=y} R{x]Z#r# H6 Fkr;s.&;s 9HSaխtU-n | vqS {gRtS.P9}0_[;mޭZRX{+"-7! G" 9~nrYXp S!ӭoP̏t (0s# GLanJ!T # ?p}xIn#y'q@r[J& qP}:7^0yWa_79oa #q0{m Sy R{ve Х̮jR ":b +J y"]d O L 9-R c'SڲejP
qdВjPp a`
< iWNsmvz5:Rs\u