Modified: apr/site/trunk/docs/docs/apr/trunk/apr__buckets_8h-source.html URL: http://svn.apache.org/viewvc/apr/site/trunk/docs/docs/apr/trunk/apr__buckets_8h-source.html?rev=794529&r1=794528&r2=794529&view=diff ============================================================================== --- apr/site/trunk/docs/docs/apr/trunk/apr__buckets_8h-source.html (original) +++ apr/site/trunk/docs/docs/apr/trunk/apr__buckets_8h-source.html Thu Jul 16 05:09:35 2009 @@ -680,7 +680,7 @@ 00655 * @param list The bucket allocator to use 00656 * @return The empty bucket brigade 00657 */ -00658 APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p, +00658 APR_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p, 00659 apr_bucket_alloc_t *list); 00660 00661 /** @@ -688,7 +688,7 @@ 00663 * buckets within the bucket brigade's bucket list. 00664 * @param b The bucket brigade to destroy 00665 */ -00666 APU_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b); +00666 APR_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b); 00667 00668 /** 00669 * empty out an entire bucket brigade. This includes destroying all of the @@ -701,7 +701,7 @@ 00676 * you wish to reuse many times by destroying all of the buckets in 00677 * the brigade and putting new buckets into it later. 00678 */ -00679 APU_DECLARE(apr_status_t) apr_brigade_cleanup(void *data); +00679 APR_DECLARE(apr_status_t) apr_brigade_cleanup(void *data); 00680 00681 /** 00682 * Move the buckets from the tail end of the existing brigade @param b into @@ -716,7 +716,7 @@ 00691 * @warning Note that this function allocates a new brigade if @param a is 00692 * NULL so memory consumption should be carefully considered. 00693 */ -00694 APU_DECLARE(apr_bucket_brigade *) apr_brigade_split_ex(apr_bucket_brigade *b, +00694 APR_DECLARE(apr_bucket_brigade *) apr_brigade_split_ex(apr_bucket_brigade *b, 00695 apr_bucket *e, 00696 apr_bucket_brigade *a); 00697 @@ -731,7 +731,7 @@ 00706 * @warning Note that this function always allocates a new brigade 00707 * so memory consumption should be carefully considered. 00708 */ -00709 APU_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b, +00709 APR_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b, 00710 apr_bucket *e); 00711 00712 /** @@ -746,7 +746,7 @@ 00721 * @remark if APR_INCOMPLETE is returned, @a after_point will be set to 00722 * the brigade sentinel. 00723 */ -00724 APU_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b, +00724 APR_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b, 00725 apr_off_t point, 00726 apr_bucket **after_point); 00727 @@ -758,7 +758,7 @@ 00733 * to a bucket read error), or -1 if the brigade has buckets 00734 * of indeterminate length and read_all is 0. 00735 */ -00736 APU_DECLARE(apr_status_t) apr_brigade_length(apr_bucket_brigade *bb, +00736 APR_DECLARE(apr_status_t) apr_brigade_length(apr_bucket_brigade *bb, 00737 int read_all, 00738 apr_off_t *length); 00739 @@ -769,7 +769,7 @@ 00744 * @param len The maximum length of the char array. On return, it is the 00745 * actual length of the char array. 00746 */ -00747 APU_DECLARE(apr_status_t) apr_brigade_flatten(apr_bucket_brigade *bb, +00747 APR_DECLARE(apr_status_t) apr_brigade_flatten(apr_bucket_brigade *bb, 00748 char *c, 00749 apr_size_t *len); 00750 @@ -780,7 +780,7 @@ 00755 * @param len On return, the length of the char array. 00756 * @param pool The pool to allocate the string from. 00757 */ -00758 APU_DECLARE(apr_status_t) apr_brigade_pflatten(apr_bucket_brigade *bb, +00758 APR_DECLARE(apr_status_t) apr_brigade_pflatten(apr_bucket_brigade *bb, 00759 char **c, 00760 apr_size_t *len, 00761 apr_pool_t *pool); @@ -793,7 +793,7 @@ 00768 * @param maxbytes The maximum bytes to read. If this many bytes are seen 00769 * without a LF, the brigade will contain a partial line. 00770 */ -00771 APU_DECLARE(apr_status_t) apr_brigade_split_line(apr_bucket_brigade *bbOut, +00771 APR_DECLARE(apr_status_t) apr_brigade_split_line(apr_bucket_brigade *bbOut, 00772 apr_bucket_brigade *bbIn, 00773 apr_read_type_e block, 00774 apr_off_t maxbytes); @@ -807,7 +807,7 @@ 00782 * @param nvec The number of elements in the iovec. On return, it is the 00783 * number of iovec elements actually filled out. 00784 */ -00785 APU_DECLARE(apr_status_t) apr_brigade_to_iovec(apr_bucket_brigade *b, +00785 APR_DECLARE(apr_status_t) apr_brigade_to_iovec(apr_bucket_brigade *b, 00786 struct iovec *vec, int *nvec); 00787 00788 /** @@ -818,7 +818,7 @@ 00793 * @param va A list of strings to add 00794 * @return APR_SUCCESS or error code. 00795 */ -00796 APU_DECLARE(apr_status_t) apr_brigade_vputstrs(apr_bucket_brigade *b, +00796 APR_DECLARE(apr_status_t) apr_brigade_vputstrs(apr_bucket_brigade *b, 00797 apr_brigade_flush flush, 00798 void *ctx, 00799 va_list va); @@ -846,7 +846,7 @@ 00821 * @param nbyte The number of bytes to write 00822 * @return APR_SUCCESS or error code 00823 */ -00824 APU_DECLARE(apr_status_t) apr_brigade_write(apr_bucket_brigade *b, +00824 APR_DECLARE(apr_status_t) apr_brigade_write(apr_bucket_brigade *b, 00825 apr_brigade_flush flush, void *ctx, 00826 const char *str, apr_size_t nbyte); 00827 @@ -859,7 +859,7 @@ 00834 * @param nvec The number of entries in iovec 00835 * @return APR_SUCCESS or error code 00836 */ -00837 APU_DECLARE(apr_status_t) apr_brigade_writev(apr_bucket_brigade *b, +00837 APR_DECLARE(apr_status_t) apr_brigade_writev(apr_bucket_brigade *b, 00838 apr_brigade_flush flush, 00839 void *ctx, 00840 const struct iovec *vec, @@ -873,7 +873,7 @@ 00848 * @param str The string to add 00849 * @return APR_SUCCESS or error code 00850 */ -00851 APU_DECLARE(apr_status_t) apr_brigade_puts(apr_bucket_brigade *bb, +00851 APR_DECLARE(apr_status_t) apr_brigade_puts(apr_bucket_brigade *bb, 00852 apr_brigade_flush flush, void *ctx, 00853 const char *str); 00854 @@ -885,7 +885,7 @@ 00860 * @param c The character to add 00861 * @return APR_SUCCESS or error code 00862 */ -00863 APU_DECLARE(apr_status_t) apr_brigade_putc(apr_bucket_brigade *b, +00863 APR_DECLARE(apr_status_t) apr_brigade_putc(apr_bucket_brigade *b, 00864 apr_brigade_flush flush, void *ctx, 00865 const char c); 00866 @@ -897,7 +897,7 @@ 00872 * @param ... The strings to add 00873 * @return APR_SUCCESS or error code 00874 */ -00875 APU_DECLARE_NONSTD(apr_status_t) apr_brigade_putstrs(apr_bucket_brigade *b, +00875 APR_DECLARE_NONSTD(apr_status_t) apr_brigade_putstrs(apr_bucket_brigade *b, 00876 apr_brigade_flush flush, 00877 void *ctx, ...); 00878 @@ -911,7 +911,7 @@ 00886 * @param ... The arguments to fill out the format 00887 * @return APR_SUCCESS or error code 00888 */ -00889 APU_DECLARE_NONSTD(apr_status_t) apr_brigade_printf(apr_bucket_brigade *b, +00889 APR_DECLARE_NONSTD(apr_status_t) apr_brigade_printf(apr_bucket_brigade *b, 00890 apr_brigade_flush flush, 00891 void *ctx, 00892 const char *fmt, ...) @@ -927,7 +927,7 @@ 00902 * @param va The arguments to fill out the format 00903 * @return APR_SUCCESS or error code 00904 */ -00905 APU_DECLARE(apr_status_t) apr_brigade_vprintf(apr_bucket_brigade *b, +00905 APR_DECLARE(apr_status_t) apr_brigade_vprintf(apr_bucket_brigade *b, 00906 apr_brigade_flush flush, 00907 void *ctx, 00908 const char *fmt, va_list va); @@ -944,7 +944,7 @@ 00919 * @param p pool from which file buckets are allocated 00920 * @return the last bucket inserted 00921 */ -00922 APU_DECLARE(apr_bucket *) apr_brigade_insert_file(apr_bucket_brigade *bb, +00922 APR_DECLARE(apr_bucket *) apr_brigade_insert_file(apr_bucket_brigade *bb, 00923 apr_file_t *f, 00924 apr_off_t start, 00925 apr_off_t len, @@ -966,7 +966,7 @@ 00941 * footprint growth that would occur if we allocated from the pool. 00942 * @warning The allocator must never be used by more than one thread at a time. 00943 */ -00944 APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create(apr_pool_t *p); +00944 APR_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create(apr_pool_t *p); 00945 00946 /** 00947 * Create a bucket allocator. @@ -976,26 +976,26 @@ 00951 * apr_allocator_t -- no automatic cleanups will happen. 00952 * @warning The allocator must never be used by more than one thread at a time. 00953 */ -00954 APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create_ex(apr_allocator_t *allocator); +00954 APR_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create_ex(apr_allocator_t *allocator); 00955 00956 /** 00957 * Destroy a bucket allocator. 00958 * @param list The allocator to be destroyed 00959 */ -00960 APU_DECLARE_NONSTD(void) apr_bucket_alloc_destroy(apr_bucket_alloc_t *list); +00960 APR_DECLARE_NONSTD(void) apr_bucket_alloc_destroy(apr_bucket_alloc_t *list); 00961 00962 /** 00963 * Allocate memory for use by the buckets. 00964 * @param size The amount to allocate. 00965 * @param list The allocator from which to allocate the memory. 00966 */ -00967 APU_DECLARE_NONSTD(void *) apr_bucket_alloc(apr_size_t size, apr_bucket_alloc_t *list); +00967 APR_DECLARE_NONSTD(void *) apr_bucket_alloc(apr_size_t size, apr_bucket_alloc_t *list); 00968 00969 /** 00970 * Free memory previously allocated with apr_bucket_alloc(). 00971 * @param block The block of memory to be freed. 00972 */ -00973 APU_DECLARE_NONSTD(void) apr_bucket_free(void *block); +00973 APR_DECLARE_NONSTD(void) apr_bucket_free(void *block); 00974 00975 00976 /* ***** Bucket Functions ***** */ @@ -1133,7 +1133,7 @@ 01108 * @param pool The pool defining the desired lifetime of the bucket data 01109 * @return APR_SUCCESS 01110 */ -01111 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_noop(apr_bucket *data, +01111 APR_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_noop(apr_bucket *data, 01112 apr_pool_t *pool); 01113 01114 /** @@ -1143,7 +1143,7 @@ 01118 * @param pool The pool defining the desired lifetime of the bucket data 01119 * @return APR_ENOTIMPL 01120 */ -01121 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_notimpl(apr_bucket *data, +01121 APR_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_notimpl(apr_bucket *data, 01122 apr_pool_t *pool); 01123 01124 /** @@ -1153,7 +1153,7 @@ 01128 * @param point The location to split the bucket 01129 * @return APR_ENOTIMPL 01130 */ -01131 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_split_notimpl(apr_bucket *data, +01131 APR_DECLARE_NONSTD(apr_status_t) apr_bucket_split_notimpl(apr_bucket *data, 01132 apr_size_t point); 01133 01134 /** @@ -1163,7 +1163,7 @@ 01138 * @param c Returns a pointer to the new bucket 01139 * @return APR_ENOTIMPL 01140 */ -01141 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_notimpl(apr_bucket *e, +01141 APR_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_notimpl(apr_bucket *e, 01142 apr_bucket **c); 01143 01144 /** @@ -1175,7 +1175,7 @@ 01150 * points directly to the apr_file_t. 01151 * @param data The bucket data to destroy 01152 */ -01153 APU_DECLARE_NONSTD(void) apr_bucket_destroy_noop(void *data); +01153 APR_DECLARE_NONSTD(void) apr_bucket_destroy_noop(void *data); 01154 01155 /** 01156 * There is no apr_bucket_destroy_notimpl, because destruction is required @@ -1192,54 +1192,54 @@ 01167 * The flush bucket type. This signifies that all data should be flushed to 01168 * the next filter. The flush bucket should be sent with the other buckets. 01169 */ -01170 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_flush; +01170 APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_flush; 01171 /** 01172 * The EOS bucket type. This signifies that there will be no more data, ever. 01173 * All filters MUST send all data to the next filter when they receive a 01174 * bucket of this type 01175 */ -01176 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_eos; +01176 APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_eos; 01177 /** 01178 * The FILE bucket type. This bucket represents a file on disk 01179 */ -01180 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_file; +01180 APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_file; 01181 /** 01182 * The HEAP bucket type. This bucket represents a data allocated from the 01183 * heap. 01184 */ -01185 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_heap; +01185 APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_heap; 01186 #if APR_HAS_MMAP 01187 /** 01188 * The MMAP bucket type. This bucket represents an MMAP'ed file 01189 */ -01190 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_mmap; +01190 APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_mmap; 01191 #endif 01192 /** 01193 * The POOL bucket type. This bucket represents a data that was allocated 01194 * from a pool. IF this bucket is still available when the pool is cleared, 01195 * the data is copied on to the heap. 01196 */ -01197 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pool; +01197 APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pool; 01198 /** 01199 * The PIPE bucket type. This bucket represents a pipe to another program. 01200 */ -01201 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pipe; +01201 APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pipe; 01202 /** 01203 * The IMMORTAL bucket type. This bucket represents a segment of data that 01204 * the creator is willing to take responsibility for. The core will do 01205 * nothing with the data in an immortal bucket 01206 */ -01207 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_immortal; +01207 APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_immortal; 01208 /** 01209 * The TRANSIENT bucket type. This bucket represents a data allocated off 01210 * the stack. When the setaside function is called, this data is copied on 01211 * to the heap 01212 */ -01213 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_transient; +01213 APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_transient; 01214 /** 01215 * The SOCKET bucket type. This bucket represents a socket to another machine 01216 */ -01217 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_socket; +01217 APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_socket; 01218 01219 01220 /* ***** Simple buckets ***** */ @@ -1255,7 +1255,7 @@ 01230 * APR_ENOMEM if allocation failed; 01231 * or APR_SUCCESS 01232 */ -01233 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_split(apr_bucket *b, +01233 APR_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_split(apr_bucket *b, 01234 apr_size_t point); 01235 01236 /** @@ -1268,7 +1268,7 @@ 01243 * @return APR_ENOMEM if allocation failed; 01244 * or APR_SUCCESS 01245 */ -01246 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_copy(apr_bucket *a, +01246 APR_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_copy(apr_bucket *a, 01247 apr_bucket **b); 01248 01249 @@ -1288,7 +1288,7 @@ 01263 * @param length The length of the data in the bucket 01264 * @return The new bucket, or NULL if allocation failed 01265 */ -01266 APU_DECLARE(apr_bucket *) apr_bucket_shared_make(apr_bucket *b, void *data, +01266 APR_DECLARE(apr_bucket *) apr_bucket_shared_make(apr_bucket *b, void *data, 01267 apr_off_t start, 01268 apr_size_t length); 01269 @@ -1300,7 +1300,7 @@ 01275 * zero, indicating that the shared resource itself can 01276 * be destroyed by the caller. 01277 */ -01278 APU_DECLARE(int) apr_bucket_shared_destroy(void *data); +01278 APR_DECLARE(int) apr_bucket_shared_destroy(void *data); 01279 01280 /** 01281 * Split a bucket into two at the given point, and adjust the refcount @@ -1313,7 +1313,7 @@ 01288 * APR_ENOMEM if allocation failed; 01289 * or APR_SUCCESS 01290 */ -01291 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_split(apr_bucket *b, +01291 APR_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_split(apr_bucket *b, 01292 apr_size_t point); 01293 01294 /** @@ -1325,7 +1325,7 @@ 01300 * @return APR_ENOMEM if allocation failed; 01301 or APR_SUCCESS 01302 */ -01303 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_copy(apr_bucket *a, +01303 APR_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_copy(apr_bucket *a, 01304 apr_bucket **b); 01305 01306 @@ -1347,7 +1347,7 @@ 01322 * @param list The freelist from which this bucket should be allocated 01323 * @return The new bucket, or NULL if allocation failed 01324 */ -01325 APU_DECLARE(apr_bucket *) apr_bucket_eos_create(apr_bucket_alloc_t *list); +01325 APR_DECLARE(apr_bucket *) apr_bucket_eos_create(apr_bucket_alloc_t *list); 01326 01327 /** 01328 * Make the bucket passed in an EOS bucket. This indicates that there is no @@ -1356,7 +1356,7 @@ 01331 * @param b The bucket to make into an EOS bucket 01332 * @return The new bucket, or NULL if allocation failed 01333 */ -01334 APU_DECLARE(apr_bucket *) apr_bucket_eos_make(apr_bucket *b); +01334 APR_DECLARE(apr_bucket *) apr_bucket_eos_make(apr_bucket *b); 01335 01336 /** 01337 * Create a flush bucket. This indicates that filters should flush their @@ -1365,7 +1365,7 @@ 01340 * @param list The freelist from which this bucket should be allocated 01341 * @return The new bucket, or NULL if allocation failed 01342 */ -01343 APU_DECLARE(apr_bucket *) apr_bucket_flush_create(apr_bucket_alloc_t *list); +01343 APR_DECLARE(apr_bucket *) apr_bucket_flush_create(apr_bucket_alloc_t *list); 01344 01345 /** 01346 * Make the bucket passed in a FLUSH bucket. This indicates that filters @@ -1374,7 +1374,7 @@ 01349 * @param b The bucket to make into a FLUSH bucket 01350 * @return The new bucket, or NULL if allocation failed 01351 */ -01352 APU_DECLARE(apr_bucket *) apr_bucket_flush_make(apr_bucket *b); +01352 APR_DECLARE(apr_bucket *) apr_bucket_flush_make(apr_bucket *b); 01353 01354 /** 01355 * Create a bucket referring to long-lived data. @@ -1383,7 +1383,7 @@ 01358 * @param list The freelist from which this bucket should be allocated 01359 * @return The new bucket, or NULL if allocation failed 01360 */ -01361 APU_DECLARE(apr_bucket *) apr_bucket_immortal_create(const char *buf, +01361 APR_DECLARE(apr_bucket *) apr_bucket_immortal_create(const char *buf, 01362 apr_size_t nbyte, 01363 apr_bucket_alloc_t *list); 01364 @@ -1394,7 +1394,7 @@ 01369 * @param nbyte The size of the data to insert. 01370 * @return The new bucket, or NULL if allocation failed 01371 */ -01372 APU_DECLARE(apr_bucket *) apr_bucket_immortal_make(apr_bucket *b, +01372 APR_DECLARE(apr_bucket *) apr_bucket_immortal_make(apr_bucket *b, 01373 const char *buf, 01374 apr_size_t nbyte); 01375 @@ -1405,7 +1405,7 @@ 01380 * @param list The freelist from which this bucket should be allocated 01381 * @return The new bucket, or NULL if allocation failed 01382 */ -01383 APU_DECLARE(apr_bucket *) apr_bucket_transient_create(const char *buf, +01383 APR_DECLARE(apr_bucket *) apr_bucket_transient_create(const char *buf, 01384 apr_size_t nbyte, 01385 apr_bucket_alloc_t *list); 01386 @@ -1416,7 +1416,7 @@ 01391 * @param nbyte The size of the data to insert. 01392 * @return The new bucket, or NULL if allocation failed 01393 */ -01394 APU_DECLARE(apr_bucket *) apr_bucket_transient_make(apr_bucket *b, +01394 APR_DECLARE(apr_bucket *) apr_bucket_transient_make(apr_bucket *b, 01395 const char *buf, 01396 apr_size_t nbyte); 01397 @@ -1434,7 +1434,7 @@ 01409 * @param list The freelist from which this bucket should be allocated 01410 * @return The new bucket, or NULL if allocation failed 01411 */ -01412 APU_DECLARE(apr_bucket *) apr_bucket_heap_create(const char *buf, +01412 APR_DECLARE(apr_bucket *) apr_bucket_heap_create(const char *buf, 01413 apr_size_t nbyte, 01414 void (*free_func)(void *data), 01415 apr_bucket_alloc_t *list); @@ -1447,7 +1447,7 @@ 01422 * bucket should make a copy of the data 01423 * @return The new bucket, or NULL if allocation failed 01424 */ -01425 APU_DECLARE(apr_bucket *) apr_bucket_heap_make(apr_bucket *b, const char *buf, +01425 APR_DECLARE(apr_bucket *) apr_bucket_heap_make(apr_bucket *b, const char *buf, 01426 apr_size_t nbyte, 01427 void (*free_func)(void *data)); 01428 @@ -1460,7 +1460,7 @@ 01435 * @param list The freelist from which this bucket should be allocated 01436 * @return The new bucket, or NULL if allocation failed 01437 */ -01438 APU_DECLARE(apr_bucket *) apr_bucket_pool_create(const char *buf, +01438 APR_DECLARE(apr_bucket *) apr_bucket_pool_create(const char *buf, 01439 apr_size_t length, 01440 apr_pool_t *pool, 01441 apr_bucket_alloc_t *list); @@ -1473,7 +1473,7 @@ 01448 * @param pool The pool the memory was allocated from 01449 * @return The new bucket, or NULL if allocation failed 01450 */ -01451 APU_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b, const char *buf, +01451 APR_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b, const char *buf, 01452 apr_size_t length, 01453 apr_pool_t *pool); 01454 @@ -1487,7 +1487,7 @@ 01462 * @param list The freelist from which this bucket should be allocated 01463 * @return The new bucket, or NULL if allocation failed 01464 */ -01465 APU_DECLARE(apr_bucket *) apr_bucket_mmap_create(apr_mmap_t *mm, +01465 APR_DECLARE(apr_bucket *) apr_bucket_mmap_create(apr_mmap_t *mm, 01466 apr_off_t start, 01467 apr_size_t length, 01468 apr_bucket_alloc_t *list); @@ -1501,7 +1501,7 @@ 01476 * @param length The number of bytes referred to by this bucket 01477 * @return The new bucket, or NULL if allocation failed 01478 */ -01479 APU_DECLARE(apr_bucket *) apr_bucket_mmap_make(apr_bucket *b, apr_mmap_t *mm, +01479 APR_DECLARE(apr_bucket *) apr_bucket_mmap_make(apr_bucket *b, apr_mmap_t *mm, 01480 apr_off_t start, 01481 apr_size_t length); 01482 #endif @@ -1512,7 +1512,7 @@ 01487 * @param list The freelist from which this bucket should be allocated 01488 * @return The new bucket, or NULL if allocation failed 01489 */ -01490 APU_DECLARE(apr_bucket *) apr_bucket_socket_create(apr_socket_t *thissock, +01490 APR_DECLARE(apr_bucket *) apr_bucket_socket_create(apr_socket_t *thissock, 01491 apr_bucket_alloc_t *list); 01492 /** 01493 * Make the bucket passed in a bucket refer to a socket @@ -1520,7 +1520,7 @@ 01495 * @param thissock The socket to put in the bucket 01496 * @return The new bucket, or NULL if allocation failed 01497 */ -01498 APU_DECLARE(apr_bucket *) apr_bucket_socket_make(apr_bucket *b, +01498 APR_DECLARE(apr_bucket *) apr_bucket_socket_make(apr_bucket *b, 01499 apr_socket_t *thissock); 01500 01501 /** @@ -1529,7 +1529,7 @@ 01504 * @param list The freelist from which this bucket should be allocated 01505 * @return The new bucket, or NULL if allocation failed 01506 */ -01507 APU_DECLARE(apr_bucket *) apr_bucket_pipe_create(apr_file_t *thispipe, +01507 APR_DECLARE(apr_bucket *) apr_bucket_pipe_create(apr_file_t *thispipe, 01508 apr_bucket_alloc_t *list); 01509 01510 /** @@ -1538,7 +1538,7 @@ 01513 * @param thispipe The pipe to put in the bucket 01514 * @return The new bucket, or NULL if allocation failed 01515 */ -01516 APU_DECLARE(apr_bucket *) apr_bucket_pipe_make(apr_bucket *b, +01516 APR_DECLARE(apr_bucket *) apr_bucket_pipe_make(apr_bucket *b, 01517 apr_file_t *thispipe); 01518 01519 /** @@ -1557,7 +1557,7 @@ 01532 * insert files into brigades, since that function can correctly 01533 * handle large file issues. 01534 */ -01535 APU_DECLARE(apr_bucket *) apr_bucket_file_create(apr_file_t *fd, +01535 APR_DECLARE(apr_bucket *) apr_bucket_file_create(apr_file_t *fd, 01536 apr_off_t offset, 01537 apr_size_t len, 01538 apr_pool_t *p, @@ -1573,7 +1573,7 @@ 01548 * while reading from this file bucket 01549 * @return The new bucket, or NULL if allocation failed 01550 */ -01551 APU_DECLARE(apr_bucket *) apr_bucket_file_make(apr_bucket *b, apr_file_t *fd, +01551 APR_DECLARE(apr_bucket *) apr_bucket_file_make(apr_bucket *b, apr_file_t *fd, 01552 apr_off_t offset, 01553 apr_size_t len, apr_pool_t *p); 01554 @@ -1583,7 +1583,7 @@ 01558 * @param enabled Whether memory-mapping should be enabled 01559 * @return APR_SUCCESS normally, or an error code if the operation fails 01560 */ -01561 APU_DECLARE(apr_status_t) apr_bucket_file_enable_mmap(apr_bucket *b, +01561 APR_DECLARE(apr_status_t) apr_bucket_file_enable_mmap(apr_bucket *b, 01562 int enabled); 01563 01564 /** @} */ @@ -1593,7 +1593,7 @@ 01568 [... 8 lines stripped ...]