Apache: Bucket Brigades

#define APR_BRIGADE_CHECK_CONSISTENCY ( b )

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.

引数:

b

The 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)

Concatenate brigade b onto the end of brigade a, leaving brigade b empty

引数:

	a	The first brigade
	b	The second brigade

#define APR_BRIGADE_EMPTY ( b ) APR_RING_EMPTY(&(b)->list, apr_bucket, link)

Determine if the bucket brigade is empty

引数:

b

The brigade to check

戻り値:: true or false

#define APR_BRIGADE_FIRST ( b ) APR_RING_FIRST(&(b)->list)

Return the first bucket in a brigade

引数:

b

The brigade to query

戻り値:: The first bucket in the brigade

#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 front of a brigade

引数:

	b	The brigade to add to
	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)

Insert a list of buckets at the end of a brigade

引数:

	b	The brigade to add to
	e	The first bucket in a list of buckets to insert

#define APR_BRIGADE_LAST ( b ) APR_RING_LAST(&(b)->list)

Return the last bucket in a brigade

引数:

b

The brigade to query

戻り値:: The last bucket in the 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)

Prepend brigade b onto the beginning of brigade a, leaving brigade b empty

引数:

	a	The first brigade
	b	The second brigade

#define APR_BRIGADE_SENTINEL ( b ) APR_RING_SENTINEL(&(b)->list, apr_bucket, link)

The magic pointer value that indicates the head of the brigade

意見:

This is used to find the beginning and end of the brigade, eg:

      while (e != APR_BRIGADE_SENTINEL(b)) {
          ...
          e = APR_BUCKET_NEXT(e);
      }

引数:

b

The brigade

戻り値:: The magic pointer value

#define APR_BUCKET_ALLOC_SIZE APR_ALIGN_DEFAULT(2*sizeof(apr_bucket_structs))

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_BUFF_SIZE 8000

default bucket buffer size - 8KB minus room for memory allocator headers

#define APR_BUCKET_CHECK_CONSISTENCY ( e )

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.

引数:

e

The bucket

#define apr_bucket_copy	(	e,
		c		)	(e)->type->copy(e, c)

Copy a bucket.

引数:

	e	The bucket to copy
	c	Returns a pointer to the new bucket

#define apr_bucket_delete ( e )

値:

do {                                    \
        APR_BUCKET_REMOVE(e);                                           \
        apr_bucket_destroy(e);                                          \
    } while (0)

Delete a bucket by removing it from its brigade (if any) and then destroying it.

意見:

This mainly acts as an aid in avoiding code verbosity. It is the preferred exact equivalent to:

      APR_BUCKET_REMOVE(e);
      apr_bucket_destroy(e);

引数:

e

The bucket to delete

#define apr_bucket_destroy ( e )

値:

do {                                    \
        (e)->type->destroy((e)->data);                                  \
        (e)->free(e);                                                   \
    } while (0)

Free the resources used by a bucket. If multiple buckets refer to the same resource it is freed when the last one goes away.

参照:: apr_bucket_delete()

引数:

e

The bucket to destroy

#define APR_BUCKET_INIT ( e ) APR_RING_ELEM_INIT((e), link)

Initialize a new bucket's prev/next pointers

引数:

e

The bucket to initialize

#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)

Insert a list of buckets after a specified bucket

引数:

	a	The bucket to insert after
	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 before a specified bucket

引数:

	a	The bucket to insert before
	b	The buckets to insert

#define APR_BUCKET_IS_EOS ( e ) ((e)->type == &apr_bucket_type_eos)

Determine if a bucket is an EOS bucket

引数:

e

The bucket to inspect

戻り値:: true or false

#define APR_BUCKET_IS_FILE ( e ) ((e)->type == &apr_bucket_type_file)

Determine if a bucket is a FILE bucket

引数:

e

The bucket to inspect

戻り値:: true or false

#define APR_BUCKET_IS_FLUSH ( e ) ((e)->type == &apr_bucket_type_flush)

Determine if a bucket is a FLUSH bucket

引数:

e

The bucket to inspect

戻り値:: true or false

#define APR_BUCKET_IS_HEAP ( e ) ((e)->type == &apr_bucket_type_heap)

Determine if a bucket is a HEAP bucket

引数:

e

The bucket to inspect

戻り値:: true or false

#define APR_BUCKET_IS_IMMORTAL ( e ) ((e)->type == &apr_bucket_type_immortal)

Determine if a bucket is a IMMORTAL bucket

引数:

e

The bucket to inspect

戻り値:: true or false

#define APR_BUCKET_IS_METADATA ( e ) ((e)->type->is_metadata)

Determine if a bucket contains metadata. An empty bucket is safe to arbitrarily remove if and only if this is false.

引数:

e

The bucket to inspect

戻り値:: true or false

#define APR_BUCKET_IS_MMAP ( e ) ((e)->type == &apr_bucket_type_mmap)

Determine if a bucket is a MMAP bucket

引数:

e

The bucket to inspect

戻り値:: true or false

#define APR_BUCKET_IS_PIPE ( e ) ((e)->type == &apr_bucket_type_pipe)

Determine if a bucket is a PIPE bucket

引数:

e

The bucket to inspect

戻り値:: true or false

#define APR_BUCKET_IS_POOL ( e ) ((e)->type == &apr_bucket_type_pool)

Determine if a bucket is a POOL bucket

引数:

e

The bucket to inspect

戻り値:: true or false

#define APR_BUCKET_IS_SOCKET ( e ) ((e)->type == &apr_bucket_type_socket)

Determine if a bucket is a SOCKET bucket

引数:

e

The bucket to inspect

戻り値:: true or false

#define APR_BUCKET_IS_TRANSIENT ( e ) ((e)->type == &apr_bucket_type_transient)

Determine if a bucket is a TRANSIENT bucket

引数:

e

The bucket to inspect

戻り値:: true or false

#define APR_BUCKET_NEXT ( e ) APR_RING_NEXT((e), link)

Get the next bucket in the list

引数:

e

The current bucket

戻り値:: The next bucket

#define APR_BUCKET_PREV ( e ) APR_RING_PREV((e), link)

Get the previous bucket in the list

引数:

e

The current bucket

戻り値:: The previous bucket

#define apr_bucket_read	(	e,
		str,
		len,
		block	)	(e)->type->read(e, str, len, block)

read the data from the bucket

引数:

	e	The bucket to read from
	str	The location to store the data in
	len	The amount of data read
	block	Whether the read function blocks

#define APR_BUCKET_REMOVE ( e ) APR_RING_REMOVE((e), link)

Remove a bucket from its bucket brigade

引数:

e

The bucket to remove

#define apr_bucket_setaside	(	e,
		p		)	(e)->type->setaside(e,p)

Setaside data so that stack data is not destroyed on returning from the function

引数:

	e	The bucket to setaside
	p	The pool to setaside into

#define apr_bucket_split	(	e,
		point		)	(e)->type->split(e, point)

Split one bucket in two.

引数:

	e	The bucket to split
	point	The offset to split the bucket at

typedef apr_status_t(*) apr_brigade_flush(apr_bucket_brigade *bb, void *ctx)

Function called when a brigade should be flushed

typedef struct apr_bucket apr_bucket

参照:: apr_bucket

typedef struct apr_bucket_alloc_t apr_bucket_alloc_t

参照:: apr_bucket_alloc_t

typedef struct apr_bucket_brigade apr_bucket_brigade

参照:: apr_bucket_brigade

typedef struct apr_bucket_file apr_bucket_file

参照:: apr_bucket_file

typedef struct apr_bucket_heap apr_bucket_heap

参照:: apr_bucket_heap

typedef struct apr_bucket_mmap apr_bucket_mmap

参照:: apr_bucket_mmap

typedef struct apr_bucket_pool apr_bucket_pool

参照:: apr_bucket_pool

typedef struct apr_bucket_refcount apr_bucket_refcount

参照:: apr_bucket_refcount

typedef union apr_bucket_structs apr_bucket_structs

参照:: apr_bucket_structs

typedef struct apr_bucket_type_t apr_bucket_type_t

参照:: apr_bucket_type_t

enum apr_read_type_e

Determines how a bucket or brigade should be read

列挙型の値:

APR_BLOCK_READ	block until data becomes available
APR_NONBLOCK_READ	return immediately if no data is available

apr_status_t apr_brigade_cleanup ( void * data )

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.

引数:

data

The bucket brigade to clean up

意見:: 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.

apr_bucket_brigade* apr_brigade_create	(	apr_pool_t *	p,
		apr_bucket_alloc_t *	list
	)

Create a new bucket brigade. The bucket brigade is originally empty.

引数:

	p	The pool to associate with the brigade. Data is not allocated out of the pool, but a cleanup is registered.
	list	The bucket allocator to use

戻り値:: The empty bucket brigade

apr_status_t apr_brigade_destroy ( apr_bucket_brigade * b )

destroy an entire bucket brigade. This includes destroying all of the buckets within the bucket brigade's bucket list.

引数:

b

The bucket brigade to destroy

apr_status_t apr_brigade_flatten	(	apr_bucket_brigade *	bb,
		char *	c,
		apr_size_t *	len
	)

Take a bucket brigade and store the data in a flat char*

引数:

	bb	The bucket brigade to create the char* from
	c	The char* to write into
	len	The maximum length of the char array. On return, it is the actual length of the char array.

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
	)

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.

引数:

	bb	the brigade to insert into
	f	the file to insert
	start	the offset of the start of the segment
	len	the length of the segment of the file to insert
	p	pool from which file buckets are allocated

戻り値:: the last bucket inserted

apr_status_t apr_brigade_length	(	apr_bucket_brigade *	bb,
		int	read_all,
		apr_off_t *	length
	)

Return the total length of the brigade.

引数:

	bb	The brigade to compute the length of
	read_all	Read unknown-length buckets to force a size
	length	Returns the length of the brigade, or -1 if the brigade has buckets of indeterminate length and read_all is 0.

apr_status_t apr_brigade_partition	(	apr_bucket_brigade *	b,
		apr_off_t	point,
		apr_bucket **	after_point
	)

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.

引数:

	b	The brigade to partition
	point	The offset at which to partition the brigade
	after_point	Returns a pointer to the first bucket after the partition

戻り値:: APR_SUCCESS on success, APR_INCOMPLETE if the contents of the brigade were shorter than point, or an error code.

意見:: if APR_INCOMPLETE is returned, after_point will be set to the brigade sentinel.

apr_status_t apr_brigade_pflatten	(	apr_bucket_brigade *	bb,
		char **	c,
		apr_size_t *	len,
		apr_pool_t *	pool
	)

Creates a pool-allocated string representing a flat bucket brigade

引数:

	bb	The bucket brigade to create the char array from
	c	On return, the allocated char array
	len	On return, the length of the char array.
	pool	The pool to allocate the string from.

apr_status_t apr_brigade_putc	(	apr_bucket_brigade *	b,
		apr_brigade_flush	flush,
		void *	ctx,
		const char	c
	)

This function writes a character into a bucket brigade.

引数:

	b	The bucket brigade to add to
	flush	The flush function to use if the brigade is full
	ctx	The structure to pass to the flush function
	c	The character to add

戻り値:: APR_SUCCESS or error code

apr_status_t apr_brigade_puts	(	apr_bucket_brigade *	bb,
		apr_brigade_flush	flush,
		void *	ctx,
		const char *	str
	)

This function writes a string into a bucket brigade.

引数:

	bb	The bucket brigade to add to
	flush	The flush function to use if the brigade is full
	ctx	The structure to pass to the flush function
	str	The string to add

戻り値:: APR_SUCCESS or error code

apr_bucket_brigade* apr_brigade_split	(	apr_bucket_brigade *	b,
		apr_bucket *	e
	)

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.

引数:

	b	The brigade to split
	e	The first element of the new brigade

戻り値:: The new brigade

apr_status_t apr_brigade_split_line	(	apr_bucket_brigade *	bbOut,
		apr_bucket_brigade *	bbIn,
		apr_read_type_e	block,
		apr_off_t	maxbytes
	)

Split a brigade to represent one LF line.

引数:

	bbOut	The bucket brigade that will have the LF line appended to.
	bbIn	The input bucket brigade to search for a LF-line.
	block	The blocking mode to be used to split the line.
	maxbytes	The maximum bytes to read. If this many bytes are seen without a LF, the brigade will contain a partial line.

apr_status_t apr_brigade_to_iovec	(	apr_bucket_brigade *	b,
		struct iovec *	vec,
		int *	nvec
	)

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.

引数:

	b	The bucket brigade to create the iovec from
	vec	The iovec to create
	nvec	The number of elements in the iovec. On return, it is the number of iovec elements actually filled out.

apr_status_t apr_brigade_vprintf	(	apr_bucket_brigade *	b,
		apr_brigade_flush	flush,
		void *	ctx,
		const char *	fmt,
		va_list	va
	)

Evaluate a printf and put the resulting string at the end of the bucket brigade.

引数:

	b	The brigade to write to
	flush	The flush function to use if the brigade is full
	ctx	The structure to pass to the flush function
	fmt	The format of the string to write
	va	The arguments to fill out the format

戻り値:: APR_SUCCESS or error code

apr_status_t apr_brigade_vputstrs	(	apr_bucket_brigade *	b,
		apr_brigade_flush	flush,
		void *	ctx,
		va_list	va
	)

This function writes a list of strings into a bucket brigade.

引数:

	b	The bucket brigade to add to
	flush	The flush function to use if the brigade is full
	ctx	The structure to pass to the flush function
	va	A list of strings to add

戻り値:: APR_SUCCESS or error code.

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 a string into a bucket brigade.

引数:

	b	The bucket brigade to add to
	flush	The flush function to use if the brigade is full
	ctx	The structure to pass to the flush function
	str	The string to add
	nbyte	The number of bytes to write

戻り値:: APR_SUCCESS or error code

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 multiple strings into a bucket brigade.

引数:

	b	The bucket brigade to add to
	flush	The flush function to use if the brigade is full
	ctx	The structure to pass to the flush function
	vec	The strings to add (address plus length for each)
	nvec	The number of entries in iovec

戻り値:: APR_SUCCESS or error code

apr_bucket* apr_bucket_eos_create ( apr_bucket_alloc_t * list )

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.

引数:

list

The freelist from which this bucket should be allocated

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_eos_make ( apr_bucket * b )

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.

引数:

b

The bucket to make into an EOS bucket

戻り値:: The new bucket, or NULL if allocation failed

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
	)

Create a bucket referring to a file.

引数:

	fd	The file to put in the bucket
	offset	The offset where the data of interest begins in the file
	len	The amount of data in the file we are interested in
	p	The pool into which any needed structures should be created while reading from this file bucket
	list	The freelist from which this bucket should be allocated

戻り値:: The new bucket, or NULL if allocation failed

apr_status_t apr_bucket_file_enable_mmap	(	apr_bucket *	b,
		int	enabled
	)

Enable or disable memory-mapping for a FILE bucket (default is enabled)

引数:

	b	The bucket
	enabled	Whether memory-mapping should be enabled

戻り値:: APR_SUCCESS normally, or an error code if the operation fails

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
	)

Make the bucket passed in a bucket refer to a file

引数:

	b	The bucket to make into a FILE bucket
	fd	The file to put in the bucket
	offset	The offset where the data of interest begins in the file
	len	The amount of data in the file we are interested in
	p	The pool into which any needed structures should be created while reading from this file bucket

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_flush_create ( apr_bucket_alloc_t * list )

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.

引数:

list

The freelist from which this bucket should be allocated

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_flush_make ( apr_bucket * b )

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.

引数:

b

The bucket to make into a FLUSH bucket

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_heap_create	(	const char *	buf,
		apr_size_t	nbyte,
		void()(void data)	free_func,
		apr_bucket_alloc_t *	list
	)

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.

引数:

	buf	The buffer to insert into the bucket
	nbyte	The size of the buffer to insert.
	free_func	Function to use to free the data; NULL indicates that the bucket should make a copy of the data
	list	The freelist from which this bucket should be allocated

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_heap_make	(	apr_bucket *	b,
		const char *	buf,
		apr_size_t	nbyte,
		void()(void data)	free_func
	)

Make the bucket passed in a bucket refer to heap data

引数:

	b	The bucket to make into a HEAP bucket
	buf	The buffer to insert into the bucket
	nbyte	The size of the buffer to insert.
	free_func	Function to use to free the data; NULL indicates that the bucket should make a copy of the data

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_immortal_create	(	const char *	buf,
		apr_size_t	nbyte,
		apr_bucket_alloc_t *	list
	)

Create a bucket referring to long-lived data.

引数:

	buf	The data to insert into the bucket
	nbyte	The size of the data to insert.
	list	The freelist from which this bucket should be allocated

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_immortal_make	(	apr_bucket *	b,
		const char *	buf,
		apr_size_t	nbyte
	)

Make the bucket passed in a bucket refer to long-lived data

引数:

	b	The bucket to make into a IMMORTAL bucket
	buf	The data to insert into the bucket
	nbyte	The size of the data to insert.

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_mmap_create	(	apr_mmap_t *	mm,
		apr_off_t	start,
		apr_size_t	length,
		apr_bucket_alloc_t *	list
	)

Create a bucket referring to mmap()ed memory.

引数:

	mm	The mmap to insert into the bucket
	start	The offset of the first byte in the mmap that this bucket refers to
	length	The number of bytes referred to by this bucket
	list	The freelist from which this bucket should be allocated

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_mmap_make	(	apr_bucket *	b,
		apr_mmap_t *	mm,
		apr_off_t	start,
		apr_size_t	length
	)

Make the bucket passed in a bucket refer to an MMAP'ed file

引数:

	b	The bucket to make into a MMAP bucket
	mm	The mmap to insert into the bucket
	start	The offset of the first byte in the mmap that this bucket refers to
	length	The number of bytes referred to by this bucket

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_pipe_create	(	apr_file_t *	thispipe,
		apr_bucket_alloc_t *	list
	)

Create a bucket referring to a pipe.

引数:

	thispipe	The pipe to put in the bucket
	list	The freelist from which this bucket should be allocated

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_pipe_make	(	apr_bucket *	b,
		apr_file_t *	thispipe
	)

Make the bucket passed in a bucket refer to a pipe

引数:

	b	The bucket to make into a PIPE bucket
	thispipe	The pipe to put in the bucket

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_pool_create	(	const char *	buf,
		apr_size_t	length,
		apr_pool_t *	pool,
		apr_bucket_alloc_t *	list
	)

Create a bucket referring to memory allocated from a pool.

引数:

	buf	The buffer to insert into the bucket
	length	The number of bytes referred to by this bucket
	pool	The pool the memory was allocated from
	list	The freelist from which this bucket should be allocated

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_pool_make	(	apr_bucket *	b,
		const char *	buf,
		apr_size_t	length,
		apr_pool_t *	pool
	)

Make the bucket passed in a bucket refer to pool data

引数:

	b	The bucket to make into a pool bucket
	buf	The buffer to insert into the bucket
	length	The number of bytes referred to by this bucket
	pool	The pool the memory was allocated from

戻り値:: The new bucket, or NULL if allocation failed

int apr_bucket_shared_destroy ( void * data )

Decrement the refcount of the data in the bucket. This function should only be called by type-specific bucket destruction functions.

引数:

data

The private data pointer from the bucket to be destroyed

戻り値:: TRUE or FALSE; TRUE if the reference count is now zero, indicating that the shared resource itself can be destroyed by the caller.

apr_bucket* apr_bucket_shared_make	(	apr_bucket *	b,
		void *	data,
		apr_off_t	start,
		apr_size_t	length
	)

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.

引数:

	b	The bucket to initialize
	data	A pointer to the private data structure with the reference count at the start
	start	The start of the data in the bucket relative to the private base pointer
	length	The length of the data in the bucket

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_socket_create	(	apr_socket_t *	thissock,
		apr_bucket_alloc_t *	list
	)

Create a bucket referring to a socket.

引数:

	thissock	The socket to put in the bucket
	list	The freelist from which this bucket should be allocated

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_socket_make	(	apr_bucket *	b,
		apr_socket_t *	thissock
	)

Make the bucket passed in a bucket refer to a socket

引数:

	b	The bucket to make into a SOCKET bucket
	thissock	The socket to put in the bucket

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_transient_create	(	const char *	buf,
		apr_size_t	nbyte,
		apr_bucket_alloc_t *	list
	)

Create a bucket referring to data on the stack.

引数:

	buf	The data to insert into the bucket
	nbyte	The size of the data to insert.
	list	The freelist from which this bucket should be allocated

戻り値:: The new bucket, or NULL if allocation failed

apr_bucket* apr_bucket_transient_make	(	apr_bucket *	b,
		const char *	buf,
		apr_size_t	nbyte
	)

Make the bucket passed in a bucket refer to stack data

引数:

	b	The bucket to make into a TRANSIENT bucket
	buf	The data to insert into the bucket
	nbyte	The size of the data to insert.

戻り値:: The new bucket, or NULL if allocation failed

APU_DECLARE_NONSTD ( void * )

Allocate memory for use by the buckets.

引数:

	size	The amount to allocate.
	list	The allocator from which to allocate the memory.

APU_DECLARE_NONSTD ( void )

Destroy a bucket allocator.

引数:

list

The allocator to be destroyed

APU_DECLARE_NONSTD ( apr_bucket_alloc_t * )

Create a bucket allocator.

引数:

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.

意見:: 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.

警告:: The allocator must never be used by more than one thread at a time.

APU_DECLARE_NONSTD ( apr_status_t )

This function writes an unspecified number of strings into a bucket brigade.

引数:

	b	The bucket brigade to add to
	flush	The flush function to use if the brigade is full
	ctx	The structure to pass to the flush function
	...	The strings to add

戻り値:: APR_SUCCESS or error code

const apr_bucket_type_t apr_bucket_type_eos

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

const apr_bucket_type_t apr_bucket_type_file

The FILE bucket type. This bucket represents a file on disk

const apr_bucket_type_t apr_bucket_type_flush

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.

const apr_bucket_type_t apr_bucket_type_heap

The HEAP bucket type. This bucket represents a data allocated from the heap.

const apr_bucket_type_t apr_bucket_type_immortal

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

const apr_bucket_type_t apr_bucket_type_mmap

The MMAP bucket type. This bucket represents an MMAP'ed file

const apr_bucket_type_t apr_bucket_type_pipe

The PIPE bucket type. This bucket represents a pipe to another program.

const apr_bucket_type_t apr_bucket_type_pool

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.

const apr_bucket_type_t apr_bucket_type_socket

The SOCKET bucket type. This bucket represents a socket to another machine

const apr_bucket_type_t apr_bucket_type_transient

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

Bucket Brigades

データ構造

マクロ定義

型定義

列挙型

関数

変数

マクロ定義

型定義

列挙型

関数

変数


データ構造
struct	apr_bucket_type_t
struct	apr_bucket
struct	apr_bucket_brigade
struct	apr_bucket_refcount
struct	apr_bucket_heap
struct	apr_bucket_pool
struct	apr_bucket_mmap
struct	apr_bucket_file
union	apr_bucket_structs
マクロ定義
#define	APR_BUCKET_BUFF_SIZE 8000
#define	APR_BRIGADE_CHECK_CONSISTENCY(b)
#define	APR_BUCKET_CHECK_CONSISTENCY(e)
#define	APR_BRIGADE_SENTINEL(b) APR_RING_SENTINEL(&(b)->list, apr_bucket, link)
#define	APR_BRIGADE_EMPTY(b) APR_RING_EMPTY(&(b)->list, apr_bucket, link)
#define	APR_BRIGADE_FIRST(b) APR_RING_FIRST(&(b)->list)
#define	APR_BRIGADE_LAST(b) APR_RING_LAST(&(b)->list)
#define	APR_BRIGADE_INSERT_HEAD(b, e)
#define	APR_BRIGADE_INSERT_TAIL(b, e)
#define	APR_BRIGADE_CONCAT(a, b)
#define	APR_BRIGADE_PREPEND(a, b)
#define	APR_BUCKET_INSERT_BEFORE(a, b)
#define	APR_BUCKET_INSERT_AFTER(a, b)
#define	APR_BUCKET_NEXT(e) APR_RING_NEXT((e), link)
#define	APR_BUCKET_PREV(e) APR_RING_PREV((e), link)
#define	APR_BUCKET_REMOVE(e) APR_RING_REMOVE((e), link)
#define	APR_BUCKET_INIT(e) APR_RING_ELEM_INIT((e), link)
#define	APR_BUCKET_IS_METADATA(e) ((e)->type->is_metadata)
#define	APR_BUCKET_IS_FLUSH(e) ((e)->type == &apr_bucket_type_flush)
#define	APR_BUCKET_IS_EOS(e) ((e)->type == &apr_bucket_type_eos)
#define	APR_BUCKET_IS_FILE(e) ((e)->type == &apr_bucket_type_file)
#define	APR_BUCKET_IS_PIPE(e) ((e)->type == &apr_bucket_type_pipe)
#define	APR_BUCKET_IS_SOCKET(e) ((e)->type == &apr_bucket_type_socket)
#define	APR_BUCKET_IS_HEAP(e) ((e)->type == &apr_bucket_type_heap)
#define	APR_BUCKET_IS_TRANSIENT(e) ((e)->type == &apr_bucket_type_transient)
#define	APR_BUCKET_IS_IMMORTAL(e) ((e)->type == &apr_bucket_type_immortal)
#define	APR_BUCKET_IS_MMAP(e) ((e)->type == &apr_bucket_type_mmap)
#define	APR_BUCKET_IS_POOL(e) ((e)->type == &apr_bucket_type_pool)
#define	APR_BUCKET_ALLOC_SIZE APR_ALIGN_DEFAULT(2*sizeof(apr_bucket_structs))
#define	apr_bucket_destroy(e)
#define	apr_bucket_delete(e)
#define	apr_bucket_read(e, str, len, block) (e)->type->read(e, str, len, block)
#define	apr_bucket_setaside(e, p) (e)->type->setaside(e,p)
#define	apr_bucket_split(e, point) (e)->type->split(e, point)
#define	apr_bucket_copy(e, c) (e)->type->copy(e, c)
型定義
typedef apr_bucket_brigade	apr_bucket_brigade
typedef apr_bucket	apr_bucket
typedef apr_bucket_alloc_t	apr_bucket_alloc_t
typedef apr_bucket_type_t	apr_bucket_type_t
typedef apr_status_t(*)	apr_brigade_flush (apr_bucket_brigade bb, void ctx)
typedef apr_bucket_refcount	apr_bucket_refcount
typedef apr_bucket_heap	apr_bucket_heap
typedef apr_bucket_pool	apr_bucket_pool
typedef apr_bucket_mmap	apr_bucket_mmap
typedef apr_bucket_file	apr_bucket_file
typedef apr_bucket_structs	apr_bucket_structs
列挙型
enum	apr_read_type_e { APR_BLOCK_READ, APR_NONBLOCK_READ }
関数
apr_bucket_brigade *	apr_brigade_create (apr_pool_t p, apr_bucket_alloc_t list)
apr_status_t	apr_brigade_destroy (apr_bucket_brigade *b)
apr_status_t	apr_brigade_cleanup (void *data)
apr_bucket_brigade *	apr_brigade_split (apr_bucket_brigade b, apr_bucket e)
apr_status_t	apr_brigade_partition (apr_bucket_brigade b, apr_off_t point, apr_bucket *after_point)
apr_status_t	apr_brigade_length (apr_bucket_brigade bb, int read_all, apr_off_t length)
apr_status_t	apr_brigade_flatten (apr_bucket_brigade bb, char c, apr_size_t *len)
apr_status_t	apr_brigade_pflatten (apr_bucket_brigade bb, char c, apr_size_t len, apr_pool_t *pool)
apr_status_t	apr_brigade_split_line (apr_bucket_brigade bbOut, apr_bucket_brigade bbIn, apr_read_type_e block, apr_off_t maxbytes)
apr_status_t	apr_brigade_to_iovec (apr_bucket_brigade b, struct iovec vec, int *nvec)
apr_status_t	apr_brigade_vputstrs (apr_bucket_brigade b, apr_brigade_flush flush, void ctx, va_list va)
apr_status_t	apr_brigade_write (apr_bucket_brigade b, apr_brigade_flush flush, void ctx, const char *str, apr_size_t nbyte)
apr_status_t	apr_brigade_writev (apr_bucket_brigade b, apr_brigade_flush flush, void ctx, const struct iovec *vec, apr_size_t nvec)
apr_status_t	apr_brigade_puts (apr_bucket_brigade bb, apr_brigade_flush flush, void ctx, const char *str)
apr_status_t	apr_brigade_putc (apr_bucket_brigade b, apr_brigade_flush flush, void ctx, const char c)
	APU_DECLARE_NONSTD (apr_status_t) apr_brigade_putstrs(apr_bucket_brigade *b
apr_brigade_flush void apr_brigade_flush void const char	__attribute__ ((format(printf, 4, 5)))
apr_status_t	apr_brigade_vprintf (apr_bucket_brigade b, apr_brigade_flush flush, void ctx, const char *fmt, va_list va)
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)
	APU_DECLARE_NONSTD (apr_bucket_alloc_t ) apr_bucket_alloc_create(apr_pool_t p)
	APU_DECLARE_NONSTD (void) apr_bucket_alloc_destroy(apr_bucket_alloc_t *list)
	APU_DECLARE_NONSTD (void *) apr_bucket_alloc(apr_size_t size
apr_bucket *	apr_bucket_shared_make (apr_bucket b, void data, apr_off_t start, apr_size_t length)
int	apr_bucket_shared_destroy (void *data)
apr_bucket *	apr_bucket_eos_create (apr_bucket_alloc_t *list)
apr_bucket *	apr_bucket_eos_make (apr_bucket *b)
apr_bucket *	apr_bucket_flush_create (apr_bucket_alloc_t *list)
apr_bucket *	apr_bucket_flush_make (apr_bucket *b)
apr_bucket *	apr_bucket_immortal_create (const char buf, apr_size_t nbyte, apr_bucket_alloc_t list)
apr_bucket *	apr_bucket_immortal_make (apr_bucket b, const char buf, apr_size_t nbyte)
apr_bucket *	apr_bucket_transient_create (const char buf, apr_size_t nbyte, apr_bucket_alloc_t list)
apr_bucket *	apr_bucket_transient_make (apr_bucket b, const char buf, apr_size_t nbyte)
apr_bucket *	apr_bucket_heap_create (const char buf, apr_size_t nbyte, void(free_func)(void data), apr_bucket_alloc_t list)
apr_bucket *	apr_bucket_heap_make (apr_bucket b, const char buf, apr_size_t nbyte, void(free_func)(void data))
apr_bucket *	apr_bucket_pool_create (const char buf, apr_size_t length, apr_pool_t pool, apr_bucket_alloc_t *list)
apr_bucket *	apr_bucket_pool_make (apr_bucket b, const char buf, apr_size_t length, apr_pool_t *pool)
apr_bucket *	apr_bucket_mmap_create (apr_mmap_t mm, apr_off_t start, apr_size_t length, apr_bucket_alloc_t list)
apr_bucket *	apr_bucket_mmap_make (apr_bucket b, apr_mmap_t mm, apr_off_t start, apr_size_t length)
apr_bucket *	apr_bucket_socket_create (apr_socket_t thissock, apr_bucket_alloc_t list)
apr_bucket *	apr_bucket_socket_make (apr_bucket b, apr_socket_t thissock)
apr_bucket *	apr_bucket_pipe_create (apr_file_t thispipe, apr_bucket_alloc_t list)
apr_bucket *	apr_bucket_pipe_make (apr_bucket b, apr_file_t thispipe)
apr_bucket *	apr_bucket_file_create (apr_file_t fd, apr_off_t offset, apr_size_t len, apr_pool_t p, apr_bucket_alloc_t *list)
apr_bucket *	apr_bucket_file_make (apr_bucket b, apr_file_t fd, apr_off_t offset, apr_size_t len, apr_pool_t *p)
apr_status_t	apr_bucket_file_enable_mmap (apr_bucket *b, int enabled)
変数
apr_brigade_flush	flush
apr_brigade_flush void *	ctx
apr_brigade_flush void apr_brigade_flush	flush
apr_brigade_flush void apr_brigade_flush void *	ctx
apr_brigade_flush void apr_brigade_flush void const char *	fmt
apr_bucket_alloc_t *	list
apr_pool_t *	pool
apr_pool_t *	pool
apr_size_t	point
apr_bucket **	c
const apr_bucket_type_t	apr_bucket_type_flush
const apr_bucket_type_t	apr_bucket_type_eos
const apr_bucket_type_t	apr_bucket_type_file
const apr_bucket_type_t	apr_bucket_type_heap
const apr_bucket_type_t	apr_bucket_type_mmap
const apr_bucket_type_t	apr_bucket_type_pool
const apr_bucket_type_t	apr_bucket_type_pipe
const apr_bucket_type_t	apr_bucket_type_immortal
const apr_bucket_type_t	apr_bucket_type_transient
const apr_bucket_type_t	apr_bucket_type_socket
apr_size_t	point
apr_bucket **	b
apr_size_t	point
apr_bucket **	b