|
GME
13
|
00001 /* Licensed to the Apache Software Foundation (ASF) under one or more 00002 * contributor license agreements. See the NOTICE file distributed with 00003 * this work for additional information regarding copyright ownership. 00004 * The ASF licenses this file to You under the Apache License, Version 2.0 00005 * (the "License"); you may not use this file except in compliance with 00006 * the License. You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an "AS IS" BASIS, 00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00021 #ifndef APR_BUCKETS_H 00022 #define APR_BUCKETS_H 00023 00024 #if defined(APR_BUCKET_DEBUG) && !defined(APR_RING_DEBUG) 00025 #define APR_RING_DEBUG 00026 #endif 00027 00028 #include "apu.h" 00029 #include "apr_network_io.h" 00030 #include "apr_file_io.h" 00031 #include "apr_general.h" 00032 #include "apr_mmap.h" 00033 #include "apr_errno.h" 00034 #include "apr_ring.h" 00035 #include "apr.h" 00036 #if APR_HAVE_SYS_UIO_H 00037 #include <sys/uio.h> /* for struct iovec */ 00038 #endif 00039 #if APR_HAVE_STDARG_H 00040 #include <stdarg.h> 00041 #endif 00042 00043 #ifdef __cplusplus 00044 extern "C" { 00045 #endif 00046 00054 #define APR_BUCKET_BUFF_SIZE 8000 00055 00057 typedef enum { 00058 APR_BLOCK_READ, 00059 APR_NONBLOCK_READ 00060 } apr_read_type_e; 00061 00114 /* 00115 * Forward declaration of the main types. 00116 */ 00117 00119 typedef struct apr_bucket_brigade apr_bucket_brigade; 00121 typedef struct apr_bucket apr_bucket; 00123 typedef struct apr_bucket_alloc_t apr_bucket_alloc_t; 00124 00126 typedef struct apr_bucket_type_t apr_bucket_type_t; 00127 00131 struct apr_bucket_type_t { 00135 const char *name; 00140 int num_func; 00151 enum { 00153 APR_BUCKET_DATA = 0, 00155 APR_BUCKET_METADATA = 1 00156 } is_metadata; 00164 void (*destroy)(void *data); 00165 00176 apr_status_t (*read)(apr_bucket *b, const char **str, apr_size_t *len, 00177 apr_read_type_e block); 00178 00192 apr_status_t (*setaside)(apr_bucket *e, apr_pool_t *pool); 00193 00203 apr_status_t (*split)(apr_bucket *e, apr_size_t point); 00204 00211 apr_status_t (*copy)(apr_bucket *e, apr_bucket **c); 00212 00213 }; 00214 00224 struct apr_bucket { 00226 APR_RING_ENTRY(apr_bucket) link; 00228 const apr_bucket_type_t *type; 00234 apr_size_t length; 00242 apr_off_t start; 00244 void *data; 00252 void (*free)(void *e); 00254 apr_bucket_alloc_t *list; 00255 }; 00256 00258 struct apr_bucket_brigade { 00264 apr_pool_t *p; 00266 /* 00267 * The apr_bucket_list structure doesn't actually need a name tag 00268 * because it has no existence independent of struct apr_bucket_brigade; 00269 * the ring macros are designed so that you can leave the name tag 00270 * argument empty in this situation but apparently the Windows compiler 00271 * doesn't like that. 00272 */ 00273 APR_RING_HEAD(apr_bucket_list, apr_bucket) list; 00275 apr_bucket_alloc_t *bucket_alloc; 00276 }; 00277 00278 00282 typedef apr_status_t (*apr_brigade_flush)(apr_bucket_brigade *bb, void *ctx); 00283 00284 /* 00285 * define APR_BUCKET_DEBUG if you want your brigades to be checked for 00286 * validity at every possible instant. this will slow your code down 00287 * substantially but is a very useful debugging tool. 00288 */ 00289 #ifdef APR_BUCKET_DEBUG 00290 00291 #define APR_BRIGADE_CHECK_CONSISTENCY(b) \ 00292 APR_RING_CHECK_CONSISTENCY(&(b)->list, apr_bucket, link) 00293 00294 #define APR_BUCKET_CHECK_CONSISTENCY(e) \ 00295 APR_RING_CHECK_ELEM_CONSISTENCY((e), apr_bucket, link) 00296 00297 #else 00298 00304 #define APR_BRIGADE_CHECK_CONSISTENCY(b) 00305 00311 #define APR_BUCKET_CHECK_CONSISTENCY(e) 00312 #endif 00313 00314 00331 #define APR_BRIGADE_SENTINEL(b) APR_RING_SENTINEL(&(b)->list, apr_bucket, link) 00332 00338 #define APR_BRIGADE_EMPTY(b) APR_RING_EMPTY(&(b)->list, apr_bucket, link) 00339 00345 #define APR_BRIGADE_FIRST(b) APR_RING_FIRST(&(b)->list) 00346 00351 #define APR_BRIGADE_LAST(b) APR_RING_LAST(&(b)->list) 00352 00358 #define APR_BRIGADE_INSERT_HEAD(b, e) do { \ 00359 apr_bucket *ap__b = (e); \ 00360 APR_RING_INSERT_HEAD(&(b)->list, ap__b, apr_bucket, link); \ 00361 APR_BRIGADE_CHECK_CONSISTENCY((b)); \ 00362 } while (0) 00363 00369 #define APR_BRIGADE_INSERT_TAIL(b, e) do { \ 00370 apr_bucket *ap__b = (e); \ 00371 APR_RING_INSERT_TAIL(&(b)->list, ap__b, apr_bucket, link); \ 00372 APR_BRIGADE_CHECK_CONSISTENCY((b)); \ 00373 } while (0) 00374 00380 #define APR_BRIGADE_CONCAT(a, b) do { \ 00381 APR_RING_CONCAT(&(a)->list, &(b)->list, apr_bucket, link); \ 00382 APR_BRIGADE_CHECK_CONSISTENCY((a)); \ 00383 } while (0) 00384 00390 #define APR_BRIGADE_PREPEND(a, b) do { \ 00391 APR_RING_PREPEND(&(a)->list, &(b)->list, apr_bucket, link); \ 00392 APR_BRIGADE_CHECK_CONSISTENCY((a)); \ 00393 } while (0) 00394 00400 #define APR_BUCKET_INSERT_BEFORE(a, b) do { \ 00401 apr_bucket *ap__a = (a), *ap__b = (b); \ 00402 APR_RING_INSERT_BEFORE(ap__a, ap__b, link); \ 00403 APR_BUCKET_CHECK_CONSISTENCY(ap__a); \ 00404 } while (0) 00405 00411 #define APR_BUCKET_INSERT_AFTER(a, b) do { \ 00412 apr_bucket *ap__a = (a), *ap__b = (b); \ 00413 APR_RING_INSERT_AFTER(ap__a, ap__b, link); \ 00414 APR_BUCKET_CHECK_CONSISTENCY(ap__a); \ 00415 } while (0) 00416 00422 #define APR_BUCKET_NEXT(e) APR_RING_NEXT((e), link) 00423 00428 #define APR_BUCKET_PREV(e) APR_RING_PREV((e), link) 00429 00434 #define APR_BUCKET_REMOVE(e) APR_RING_REMOVE((e), link) 00435 00440 #define APR_BUCKET_INIT(e) APR_RING_ELEM_INIT((e), link) 00441 00448 #define APR_BUCKET_IS_METADATA(e) ((e)->type->is_metadata) 00449 00455 #define APR_BUCKET_IS_FLUSH(e) ((e)->type == &apr_bucket_type_flush) 00456 00461 #define APR_BUCKET_IS_EOS(e) ((e)->type == &apr_bucket_type_eos) 00462 00467 #define APR_BUCKET_IS_FILE(e) ((e)->type == &apr_bucket_type_file) 00468 00473 #define APR_BUCKET_IS_PIPE(e) ((e)->type == &apr_bucket_type_pipe) 00474 00479 #define APR_BUCKET_IS_SOCKET(e) ((e)->type == &apr_bucket_type_socket) 00480 00485 #define APR_BUCKET_IS_HEAP(e) ((e)->type == &apr_bucket_type_heap) 00486 00491 #define APR_BUCKET_IS_TRANSIENT(e) ((e)->type == &apr_bucket_type_transient) 00492 00497 #define APR_BUCKET_IS_IMMORTAL(e) ((e)->type == &apr_bucket_type_immortal) 00498 #if APR_HAS_MMAP 00499 00504 #define APR_BUCKET_IS_MMAP(e) ((e)->type == &apr_bucket_type_mmap) 00505 #endif 00506 00511 #define APR_BUCKET_IS_POOL(e) ((e)->type == &apr_bucket_type_pool) 00512 00513 /* 00514 * General-purpose reference counting for the various bucket types. 00515 * 00516 * Any bucket type that keeps track of the resources it uses (i.e. 00517 * most of them except for IMMORTAL, TRANSIENT, and EOS) needs to 00518 * attach a reference count to the resource so that it can be freed 00519 * when the last bucket that uses it goes away. Resource-sharing may 00520 * occur because of bucket splits or buckets that refer to globally 00521 * cached data. */ 00522 00524 typedef struct apr_bucket_refcount apr_bucket_refcount; 00531 struct apr_bucket_refcount { 00533 int refcount; 00534 }; 00535 00536 /* ***** Reference-counted bucket types ***** */ 00537 00539 typedef struct apr_bucket_heap apr_bucket_heap; 00543 struct apr_bucket_heap { 00545 apr_bucket_refcount refcount; 00549 char *base; 00551 apr_size_t alloc_len; 00553 void (*free_func)(void *data); 00554 }; 00555 00557 typedef struct apr_bucket_pool apr_bucket_pool; 00561 struct apr_bucket_pool { 00573 apr_bucket_heap heap; 00579 const char *base; 00586 apr_pool_t *pool; 00590 apr_bucket_alloc_t *list; 00591 }; 00592 00593 #if APR_HAS_MMAP 00594 00595 typedef struct apr_bucket_mmap apr_bucket_mmap; 00599 struct apr_bucket_mmap { 00601 apr_bucket_refcount refcount; 00603 apr_mmap_t *mmap; 00604 }; 00605 #endif 00606 00608 typedef struct apr_bucket_file apr_bucket_file; 00612 struct apr_bucket_file { 00614 apr_bucket_refcount refcount; 00616 apr_file_t *fd; 00619 apr_pool_t *readpool; 00620 #if APR_HAS_MMAP 00621 00623 int can_mmap; 00624 #endif /* APR_HAS_MMAP */ 00625 }; 00626 00628 typedef union apr_bucket_structs apr_bucket_structs; 00633 union apr_bucket_structs { 00634 apr_bucket b; 00635 apr_bucket_heap heap; 00636 apr_bucket_pool pool; 00637 #if APR_HAS_MMAP 00638 apr_bucket_mmap mmap; 00639 #endif 00640 apr_bucket_file file; 00641 }; 00642 00648 #define APR_BUCKET_ALLOC_SIZE APR_ALIGN_DEFAULT(2*sizeof(apr_bucket_structs)) 00649 00650 /* ***** Bucket Brigade Functions ***** */ 00658 APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p, 00659 apr_bucket_alloc_t *list); 00660 00666 APU_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b); 00667 00679 APU_DECLARE(apr_status_t) apr_brigade_cleanup(void *data); 00680 00696 APU_DECLARE(apr_bucket_brigade *) apr_brigade_split_ex(apr_bucket_brigade *b, 00697 apr_bucket *e, 00698 apr_bucket_brigade *a); 00699 00711 APU_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b, 00712 apr_bucket *e); 00713 00726 APU_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b, 00727 apr_off_t point, 00728 apr_bucket **after_point); 00729 00738 APU_DECLARE(apr_status_t) apr_brigade_length(apr_bucket_brigade *bb, 00739 int read_all, 00740 apr_off_t *length); 00741 00749 APU_DECLARE(apr_status_t) apr_brigade_flatten(apr_bucket_brigade *bb, 00750 char *c, 00751 apr_size_t *len); 00752 00760 APU_DECLARE(apr_status_t) apr_brigade_pflatten(apr_bucket_brigade *bb, 00761 char **c, 00762 apr_size_t *len, 00763 apr_pool_t *pool); 00764 00773 APU_DECLARE(apr_status_t) apr_brigade_split_line(apr_bucket_brigade *bbOut, 00774 apr_bucket_brigade *bbIn, 00775 apr_read_type_e block, 00776 apr_off_t maxbytes); 00777 00787 APU_DECLARE(apr_status_t) apr_brigade_to_iovec(apr_bucket_brigade *b, 00788 struct iovec *vec, int *nvec); 00789 00798 APU_DECLARE(apr_status_t) apr_brigade_vputstrs(apr_bucket_brigade *b, 00799 apr_brigade_flush flush, 00800 void *ctx, 00801 va_list va); 00802 00826 APU_DECLARE(apr_status_t) apr_brigade_write(apr_bucket_brigade *b, 00827 apr_brigade_flush flush, void *ctx, 00828 const char *str, apr_size_t nbyte); 00829 00839 APU_DECLARE(apr_status_t) apr_brigade_writev(apr_bucket_brigade *b, 00840 apr_brigade_flush flush, 00841 void *ctx, 00842 const struct iovec *vec, 00843 apr_size_t nvec); 00844 00853 APU_DECLARE(apr_status_t) apr_brigade_puts(apr_bucket_brigade *bb, 00854 apr_brigade_flush flush, void *ctx, 00855 const char *str); 00856 00865 APU_DECLARE(apr_status_t) apr_brigade_putc(apr_bucket_brigade *b, 00866 apr_brigade_flush flush, void *ctx, 00867 const char c); 00868 00877 APU_DECLARE_NONSTD(apr_status_t) apr_brigade_putstrs(apr_bucket_brigade *b, 00878 apr_brigade_flush flush, 00879 void *ctx, ...); 00880 00891 APU_DECLARE_NONSTD(apr_status_t) apr_brigade_printf(apr_bucket_brigade *b, 00892 apr_brigade_flush flush, 00893 void *ctx, 00894 const char *fmt, ...) 00895 __attribute__((format(printf,4,5))); 00896 00907 APU_DECLARE(apr_status_t) apr_brigade_vprintf(apr_bucket_brigade *b, 00908 apr_brigade_flush flush, 00909 void *ctx, 00910 const char *fmt, va_list va); 00911 00924 APU_DECLARE(apr_bucket *) apr_brigade_insert_file(apr_bucket_brigade *bb, 00925 apr_file_t *f, 00926 apr_off_t start, 00927 apr_off_t len, 00928 apr_pool_t *p); 00929 00930 00931 00932 /* ***** Bucket freelist functions ***** */ 00946 APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create(apr_pool_t *p); 00947 00956 APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create_ex(apr_allocator_t *allocator); 00957 00962 APU_DECLARE_NONSTD(void) apr_bucket_alloc_destroy(apr_bucket_alloc_t *list); 00963 00969 APU_DECLARE_NONSTD(void *) apr_bucket_alloc(apr_size_t size, apr_bucket_alloc_t *list); 00970 00975 APU_DECLARE_NONSTD(void) apr_bucket_free(void *block); 00976 00977 00978 /* ***** Bucket Functions ***** */ 00985 #define apr_bucket_destroy(e) do { \ 00986 (e)->type->destroy((e)->data); \ 00987 (e)->free(e); \ 00988 } while (0) 00989 01001 #define apr_bucket_delete(e) do { \ 01002 APR_BUCKET_REMOVE(e); \ 01003 apr_bucket_destroy(e); \ 01004 } while (0) 01005 01073 #define apr_bucket_read(e,str,len,block) (e)->type->read(e, str, len, block) 01074 01081 #define apr_bucket_setaside(e,p) (e)->type->setaside(e,p) 01082 01093 #define apr_bucket_split(e,point) (e)->type->split(e, point) 01094 01100 #define apr_bucket_copy(e,c) (e)->type->copy(e, c) 01101 01102 /* Bucket type handling */ 01103 01113 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_noop(apr_bucket *data, 01114 apr_pool_t *pool); 01115 01123 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_notimpl(apr_bucket *data, 01124 apr_pool_t *pool); 01125 01133 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_split_notimpl(apr_bucket *data, 01134 apr_size_t point); 01135 01143 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_notimpl(apr_bucket *e, 01144 apr_bucket **c); 01145 01155 APU_DECLARE_NONSTD(void) apr_bucket_destroy_noop(void *data); 01156 01163 /* There is no apr_bucket_read_notimpl, because it is a required function 01164 */ 01165 01166 01167 /* All of the bucket types implemented by the core */ 01172 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_flush; 01178 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_eos; 01182 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_file; 01187 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_heap; 01188 #if APR_HAS_MMAP 01189 01192 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_mmap; 01193 #endif 01194 01199 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pool; 01203 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pipe; 01209 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_immortal; 01215 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_transient; 01219 APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_socket; 01220 01221 01222 /* ***** Simple buckets ***** */ 01223 01235 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_split(apr_bucket *b, 01236 apr_size_t point); 01237 01248 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_copy(apr_bucket *a, 01249 apr_bucket **b); 01250 01251 01252 /* ***** Shared, reference-counted buckets ***** */ 01253 01268 APU_DECLARE(apr_bucket *) apr_bucket_shared_make(apr_bucket *b, void *data, 01269 apr_off_t start, 01270 apr_size_t length); 01271 01280 APU_DECLARE(int) apr_bucket_shared_destroy(void *data); 01281 01293 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_split(apr_bucket *b, 01294 apr_size_t point); 01295 01305 APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_copy(apr_bucket *a, 01306 apr_bucket **b); 01307 01308 01309 /* ***** Functions to Create Buckets of varying types ***** */ 01310 /* 01311 * Each bucket type foo has two initialization functions: 01312 * apr_bucket_foo_make which sets up some already-allocated memory as a 01313 * bucket of type foo; and apr_bucket_foo_create which allocates memory 01314 * for the bucket, calls apr_bucket_make_foo, and initializes the 01315 * bucket's list pointers. The apr_bucket_foo_make functions are used 01316 * inside the bucket code to change the type of buckets in place; 01317 * other code should call apr_bucket_foo_create. All the initialization 01318 * functions change nothing if they fail. 01319 */ 01320 01327 APU_DECLARE(apr_bucket *) apr_bucket_eos_create(apr_bucket_alloc_t *list); 01328 01336 APU_DECLARE(apr_bucket *) apr_bucket_eos_make(apr_bucket *b); 01337 01345 APU_DECLARE(apr_bucket *) apr_bucket_flush_create(apr_bucket_alloc_t *list); 01346 01354 APU_DECLARE(apr_bucket *) apr_bucket_flush_make(apr_bucket *b); 01355 01363 APU_DECLARE(apr_bucket *) apr_bucket_immortal_create(const char *buf, 01364 apr_size_t nbyte, 01365 apr_bucket_alloc_t *list); 01366 01374 APU_DECLARE(apr_bucket *) apr_bucket_immortal_make(apr_bucket *b, 01375 const char *buf, 01376 apr_size_t nbyte); 01377 01385 APU_DECLARE(apr_bucket *) apr_bucket_transient_create(const char *buf, 01386 apr_size_t nbyte, 01387 apr_bucket_alloc_t *list); 01388 01396 APU_DECLARE(apr_bucket *) apr_bucket_transient_make(apr_bucket *b, 01397 const char *buf, 01398 apr_size_t nbyte); 01399 01414 APU_DECLARE(apr_bucket *) apr_bucket_heap_create(const char *buf, 01415 apr_size_t nbyte, 01416 void (*free_func)(void *data), 01417 apr_bucket_alloc_t *list); 01427 APU_DECLARE(apr_bucket *) apr_bucket_heap_make(apr_bucket *b, const char *buf, 01428 apr_size_t nbyte, 01429 void (*free_func)(void *data)); 01430 01440 APU_DECLARE(apr_bucket *) apr_bucket_pool_create(const char *buf, 01441 apr_size_t length, 01442 apr_pool_t *pool, 01443 apr_bucket_alloc_t *list); 01444 01453 APU_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b, const char *buf, 01454 apr_size_t length, 01455 apr_pool_t *pool); 01456 01457 #if APR_HAS_MMAP 01458 01467 APU_DECLARE(apr_bucket *) apr_bucket_mmap_create(apr_mmap_t *mm, 01468 apr_off_t start, 01469 apr_size_t length, 01470 apr_bucket_alloc_t *list); 01471 01481 APU_DECLARE(apr_bucket *) apr_bucket_mmap_make(apr_bucket *b, apr_mmap_t *mm, 01482 apr_off_t start, 01483 apr_size_t length); 01484 #endif 01485 01492 APU_DECLARE(apr_bucket *) apr_bucket_socket_create(apr_socket_t *thissock, 01493 apr_bucket_alloc_t *list); 01500 APU_DECLARE(apr_bucket *) apr_bucket_socket_make(apr_bucket *b, 01501 apr_socket_t *thissock); 01502 01509 APU_DECLARE(apr_bucket *) apr_bucket_pipe_create(apr_file_t *thispipe, 01510 apr_bucket_alloc_t *list); 01511 01518 APU_DECLARE(apr_bucket *) apr_bucket_pipe_make(apr_bucket *b, 01519 apr_file_t *thispipe); 01520 01537 APU_DECLARE(apr_bucket *) apr_bucket_file_create(apr_file_t *fd, 01538 apr_off_t offset, 01539 apr_size_t len, 01540 apr_pool_t *p, 01541 apr_bucket_alloc_t *list); 01542 01553 APU_DECLARE(apr_bucket *) apr_bucket_file_make(apr_bucket *b, apr_file_t *fd, 01554 apr_off_t offset, 01555 apr_size_t len, apr_pool_t *p); 01556 01563 APU_DECLARE(apr_status_t) apr_bucket_file_enable_mmap(apr_bucket *b, 01564 int enabled); 01565 01567 #ifdef __cplusplus 01568 } 01569 #endif 01570 01571 #endif /* !APR_BUCKETS_H */
1.7.6.1