diff options
Diffstat (limited to 'rubbos/app/httpd-2.0.64/srclib/apr/tables/apr_tables.c')
| -rw-r--r-- | rubbos/app/httpd-2.0.64/srclib/apr/tables/apr_tables.c | 1207 |
1 files changed, 0 insertions, 1207 deletions
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/tables/apr_tables.c b/rubbos/app/httpd-2.0.64/srclib/apr/tables/apr_tables.c deleted file mode 100644 index 3f1f2edd..00000000 --- a/rubbos/app/httpd-2.0.64/srclib/apr/tables/apr_tables.c +++ /dev/null @@ -1,1207 +0,0 @@ -#include <stdio.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. - */ - -/* - * Resource allocation code... the code here is responsible for making - * sure that nothing leaks. - * - * rst --- 4/95 --- 6/95 - */ - -#include "apr_private.h" - -#include "apr_general.h" -#include "apr_pools.h" -#include "apr_tables.h" -#include "apr_strings.h" -#include "apr_lib.h" -#if APR_HAVE_STDLIB_H -#include <stdlib.h> -#endif -#if APR_HAVE_STRING_H -#include <string.h> -#endif -#if APR_HAVE_STRINGS_H -#include <strings.h> -#endif - -/***************************************************************** - * This file contains array and apr_table_t functions only. - */ - -/***************************************************************** - * - * The 'array' functions... - */ - -static void make_array_core(apr_array_header_t *res, apr_pool_t *p, - int nelts, int elt_size, int clear) -{ - /* - * Assure sanity if someone asks for - * array of zero elts. - */ - if (nelts < 1) { - nelts = 1; - } - - if (clear) { - res->elts = apr_pcalloc(p, nelts * elt_size); - } - else { - res->elts = apr_palloc(p, nelts * elt_size); - } - - res->pool = p; - res->elt_size = elt_size; - res->nelts = 0; /* No active elements yet... */ - res->nalloc = nelts; /* ...but this many allocated */ -} - -APR_DECLARE(int) apr_is_empty_array(const apr_array_header_t *a) -{ - return ((a == NULL) || (a->nelts == 0)); -} - -APR_DECLARE(apr_array_header_t *) apr_array_make(apr_pool_t *p, - int nelts, int elt_size) -{ - apr_array_header_t *res; - - res = (apr_array_header_t *) apr_palloc(p, sizeof(apr_array_header_t)); - make_array_core(res, p, nelts, elt_size, 1); - return res; -} - -APR_DECLARE(void *) apr_array_pop(apr_array_header_t *arr) -{ - if (apr_is_empty_array(arr)) { - return NULL; - } - - return arr->elts + (arr->elt_size * (--arr->nelts)); -} - -APR_DECLARE(void *) apr_array_push(apr_array_header_t *arr) -{ - if (arr->nelts == arr->nalloc) { - int new_size = (arr->nalloc <= 0) ? 1 : arr->nalloc * 2; - char *new_data; - - new_data = apr_palloc(arr->pool, arr->elt_size * new_size); - - memcpy(new_data, arr->elts, arr->nalloc * arr->elt_size); - memset(new_data + arr->nalloc * arr->elt_size, 0, - arr->elt_size * (new_size - arr->nalloc)); - arr->elts = new_data; - arr->nalloc = new_size; - } - - ++arr->nelts; - return arr->elts + (arr->elt_size * (arr->nelts - 1)); -} - -static void *apr_array_push_noclear(apr_array_header_t *arr) -{ - if (arr->nelts == arr->nalloc) { - int new_size = (arr->nalloc <= 0) ? 1 : arr->nalloc * 2; - char *new_data; - - new_data = apr_palloc(arr->pool, arr->elt_size * new_size); - - memcpy(new_data, arr->elts, arr->nalloc * arr->elt_size); - arr->elts = new_data; - arr->nalloc = new_size; - } - - ++arr->nelts; - return arr->elts + (arr->elt_size * (arr->nelts - 1)); -} - -APR_DECLARE(void) apr_array_cat(apr_array_header_t *dst, - const apr_array_header_t *src) -{ - int elt_size = dst->elt_size; - - if (dst->nelts + src->nelts > dst->nalloc) { - int new_size = (dst->nalloc <= 0) ? 1 : dst->nalloc * 2; - char *new_data; - - while (dst->nelts + src->nelts > new_size) { - new_size *= 2; - } - - new_data = apr_pcalloc(dst->pool, elt_size * new_size); - memcpy(new_data, dst->elts, dst->nalloc * elt_size); - - dst->elts = new_data; - dst->nalloc = new_size; - } - - memcpy(dst->elts + dst->nelts * elt_size, src->elts, - elt_size * src->nelts); - dst->nelts += src->nelts; -} - -APR_DECLARE(apr_array_header_t *) apr_array_copy(apr_pool_t *p, - const apr_array_header_t *arr) -{ - apr_array_header_t *res = - (apr_array_header_t *) apr_palloc(p, sizeof(apr_array_header_t)); - make_array_core(res, p, arr->nalloc, arr->elt_size, 0); - - memcpy(res->elts, arr->elts, arr->elt_size * arr->nelts); - res->nelts = arr->nelts; - memset(res->elts + res->elt_size * res->nelts, 0, - res->elt_size * (res->nalloc - res->nelts)); - return res; -} - -/* This cute function copies the array header *only*, but arranges - * for the data section to be copied on the first push or arraycat. - * It's useful when the elements of the array being copied are - * read only, but new stuff *might* get added on the end; we have the - * overhead of the full copy only where it is really needed. - */ - -static APR_INLINE void copy_array_hdr_core(apr_array_header_t *res, - const apr_array_header_t *arr) -{ - res->elts = arr->elts; - res->elt_size = arr->elt_size; - res->nelts = arr->nelts; - res->nalloc = arr->nelts; /* Force overflow on push */ -} - -APR_DECLARE(apr_array_header_t *) - apr_array_copy_hdr(apr_pool_t *p, - const apr_array_header_t *arr) -{ - apr_array_header_t *res; - - res = (apr_array_header_t *) apr_palloc(p, sizeof(apr_array_header_t)); - res->pool = p; - copy_array_hdr_core(res, arr); - return res; -} - -/* The above is used here to avoid consing multiple new array bodies... */ - -APR_DECLARE(apr_array_header_t *) - apr_array_append(apr_pool_t *p, - const apr_array_header_t *first, - const apr_array_header_t *second) -{ - apr_array_header_t *res = apr_array_copy_hdr(p, first); - - apr_array_cat(res, second); - return res; -} - -/* apr_array_pstrcat generates a new string from the apr_pool_t containing - * the concatenated sequence of substrings referenced as elements within - * the array. The string will be empty if all substrings are empty or null, - * or if there are no elements in the array. - * If sep is non-NUL, it will be inserted between elements as a separator. - */ -APR_DECLARE(char *) apr_array_pstrcat(apr_pool_t *p, - const apr_array_header_t *arr, - const char sep) -{ - char *cp, *res, **strpp; - apr_size_t len; - int i; - - if (arr->nelts <= 0 || arr->elts == NULL) { /* Empty table? */ - return (char *) apr_pcalloc(p, 1); - } - - /* Pass one --- find length of required string */ - - len = 0; - for (i = 0, strpp = (char **) arr->elts; ; ++strpp) { - if (strpp && *strpp != NULL) { - len += strlen(*strpp); - } - if (++i >= arr->nelts) { - break; - } - if (sep) { - ++len; - } - } - - /* Allocate the required string */ - - res = (char *) apr_palloc(p, len + 1); - cp = res; - - /* Pass two --- copy the argument strings into the result space */ - - for (i = 0, strpp = (char **) arr->elts; ; ++strpp) { - if (strpp && *strpp != NULL) { - len = strlen(*strpp); - memcpy(cp, *strpp, len); - cp += len; - } - if (++i >= arr->nelts) { - break; - } - if (sep) { - *cp++ = sep; - } - } - - *cp = '\0'; - - /* Return the result string */ - - return res; -} - - -/***************************************************************** - * - * The "table" functions. - */ - -#if APR_CHARSET_EBCDIC -#define CASE_MASK 0xbfbfbfbf -#else -#define CASE_MASK 0xdfdfdfdf -#endif - -#define TABLE_HASH_SIZE 32 -#define TABLE_INDEX_MASK 0x1f -#define TABLE_HASH(key) (TABLE_INDEX_MASK & *(unsigned char *)(key)) -#define TABLE_INDEX_IS_INITIALIZED(t, i) ((t)->index_initialized & (1 << (i))) -#define TABLE_SET_INDEX_INITIALIZED(t, i) ((t)->index_initialized |= (1 << (i))) - -/* Compute the "checksum" for a key, consisting of the first - * 4 bytes, normalized for case-insensitivity and packed into - * an int...this checksum allows us to do a single integer - * comparison as a fast check to determine whether we can - * skip a strcasecmp - */ -#define COMPUTE_KEY_CHECKSUM(key, checksum) \ -{ \ - const char *k = (key); \ - apr_uint32_t c = (apr_uint32_t)*k; \ - (checksum) = c; \ - (checksum) <<= 8; \ - if (c) { \ - c = (apr_uint32_t)*++k; \ - checksum |= c; \ - } \ - (checksum) <<= 8; \ - if (c) { \ - c = (apr_uint32_t)*++k; \ - checksum |= c; \ - } \ - (checksum) <<= 8; \ - if (c) { \ - c = (apr_uint32_t)*++k; \ - checksum |= c; \ - } \ - checksum &= CASE_MASK; \ -} - -/** The opaque string-content table type */ -struct apr_table_t { - /* This has to be first to promote backwards compatibility with - * older modules which cast a apr_table_t * to an apr_array_header_t *... - * they should use the apr_table_elts() function for most of the - * cases they do this for. - */ - /** The underlying array for the table */ - apr_array_header_t a; -#ifdef MAKE_TABLE_PROFILE - /** Who created the array. */ - void *creator; -#endif - /* An index to speed up table lookups. The way this works is: - * - Take the requested key and compute its checksum - * - Hash the checksum into the index: - * - index_first[TABLE_HASH(checksum)] is the offset within - * the table of the first entry with that key checksum - * - index_last[TABLE_HASH(checksum)] is the offset within - * the table of the first entry with that key checksum - * - If (and only if) there is no entry in the table whose - * checksum hashes to index element i, then the i'th bit - * of index_initialized will be zero. (Check this before - * trying to use index_first[i] or index_last[i]!) - */ - apr_uint32_t index_initialized; - int index_first[TABLE_HASH_SIZE]; - int index_last[TABLE_HASH_SIZE]; -}; - -/* - * NOTICE: if you tweak this you should look at is_empty_table() - * and table_elts() in alloc.h - */ -#ifdef MAKE_TABLE_PROFILE -static apr_table_entry_t *table_push(apr_table_t *t) -{ - if (t->a.nelts == t->a.nalloc) { - return NULL; - } - return (apr_table_entry_t *) apr_array_push_noclear(&t->a); -} -#else /* MAKE_TABLE_PROFILE */ -#define table_push(t) ((apr_table_entry_t *) apr_array_push_noclear(&(t)->a)) -#endif /* MAKE_TABLE_PROFILE */ - -APR_DECLARE(const apr_array_header_t *) apr_table_elts(const apr_table_t *t) -{ - return (const apr_array_header_t *)t; -} - -APR_DECLARE(int) apr_is_empty_table(const apr_table_t *t) -{ - return ((t == NULL) || (t->a.nelts == 0)); -} - -APR_DECLARE(apr_table_t *) apr_table_make(apr_pool_t *p, int nelts) -{ - apr_table_t *t = apr_palloc(p, sizeof(apr_table_t)); - - make_array_core(&t->a, p, nelts, sizeof(apr_table_entry_t), 0); -#ifdef MAKE_TABLE_PROFILE - t->creator = __builtin_return_address(0); -#endif - t->index_initialized = 0; - return t; -} - -APR_DECLARE(apr_table_t *) apr_table_copy(apr_pool_t *p, const apr_table_t *t) -{ - apr_table_t *new = apr_palloc(p, sizeof(apr_table_t)); - -#ifdef POOL_DEBUG - /* we don't copy keys and values, so it's necessary that t->a.pool - * have a life span at least as long as p - */ - if (!apr_pool_is_ancestor(t->a.pool, p)) { - fprintf(stderr, "copy_table: t's pool is not an ancestor of p\n"); - abort(); - } -#endif - make_array_core(&new->a, p, t->a.nalloc, sizeof(apr_table_entry_t), 0); - memcpy(new->a.elts, t->a.elts, t->a.nelts * sizeof(apr_table_entry_t)); - new->a.nelts = t->a.nelts; - memcpy(new->index_first, t->index_first, sizeof(int) * TABLE_HASH_SIZE); - memcpy(new->index_last, t->index_last, sizeof(int) * TABLE_HASH_SIZE); - new->index_initialized = t->index_initialized; - return new; -} - -static void table_reindex(apr_table_t *t) -{ - int i; - int hash; - apr_table_entry_t *next_elt = (apr_table_entry_t *) t->a.elts; - - t->index_initialized = 0; - for (i = 0; i < t->a.nelts; i++, next_elt++) { - hash = TABLE_HASH(next_elt->key); - t->index_last[hash] = i; - if (!TABLE_INDEX_IS_INITIALIZED(t, hash)) { - t->index_first[hash] = i; - TABLE_SET_INDEX_INITIALIZED(t, hash); - } - } -} - -APR_DECLARE(void) apr_table_clear(apr_table_t *t) -{ - t->a.nelts = 0; - t->index_initialized = 0; -} - -APR_DECLARE(const char *) apr_table_get(const apr_table_t *t, const char *key) -{ - apr_table_entry_t *next_elt; - apr_table_entry_t *end_elt; - apr_uint32_t checksum; - int hash; - - if (key == NULL) { - return NULL; - } - - hash = TABLE_HASH(key); - if (!TABLE_INDEX_IS_INITIALIZED(t, hash)) { - return NULL; - } - COMPUTE_KEY_CHECKSUM(key, checksum); - next_elt = ((apr_table_entry_t *) t->a.elts) + t->index_first[hash];; - end_elt = ((apr_table_entry_t *) t->a.elts) + t->index_last[hash]; - - for (; next_elt <= end_elt; next_elt++) { - if ((checksum == next_elt->key_checksum) && - !strcasecmp(next_elt->key, key)) { - return next_elt->val; - } - } - - return NULL; -} - -APR_DECLARE(void) apr_table_set(apr_table_t *t, const char *key, - const char *val) -{ - apr_table_entry_t *next_elt; - apr_table_entry_t *end_elt; - apr_table_entry_t *table_end; - apr_uint32_t checksum; - int hash; - - COMPUTE_KEY_CHECKSUM(key, checksum); - hash = TABLE_HASH(key); - if (!TABLE_INDEX_IS_INITIALIZED(t, hash)) { - t->index_first[hash] = t->a.nelts; - TABLE_SET_INDEX_INITIALIZED(t, hash); - goto add_new_elt; - } - next_elt = ((apr_table_entry_t *) t->a.elts) + t->index_first[hash];; - end_elt = ((apr_table_entry_t *) t->a.elts) + t->index_last[hash]; - table_end =((apr_table_entry_t *) t->a.elts) + t->a.nelts; - - for (; next_elt <= end_elt; next_elt++) { - if ((checksum == next_elt->key_checksum) && - !strcasecmp(next_elt->key, key)) { - - /* Found an existing entry with the same key, so overwrite it */ - - int must_reindex = 0; - apr_table_entry_t *dst_elt = NULL; - - next_elt->val = apr_pstrdup(t->a.pool, val); - - /* Remove any other instances of this key */ - for (next_elt++; next_elt <= end_elt; next_elt++) { - if ((checksum == next_elt->key_checksum) && - !strcasecmp(next_elt->key, key)) { - t->a.nelts--; - if (!dst_elt) { - dst_elt = next_elt; - } - } - else if (dst_elt) { - *dst_elt++ = *next_elt; - must_reindex = 1; - } - } - - /* If we've removed anything, shift over the remainder - * of the table (note that the previous loop didn't - * run to the end of the table, just to the last match - * for the index) - */ - if (dst_elt) { - for (; next_elt < table_end; next_elt++) { - *dst_elt++ = *next_elt; - } - must_reindex = 1; - } - if (must_reindex) { - table_reindex(t); - } - return; - } - } - -add_new_elt: - t->index_last[hash] = t->a.nelts; - next_elt = (apr_table_entry_t *) table_push(t); - next_elt->key = apr_pstrdup(t->a.pool, key); - next_elt->val = apr_pstrdup(t->a.pool, val); - next_elt->key_checksum = checksum; -} - -APR_DECLARE(void) apr_table_setn(apr_table_t *t, const char *key, - const char *val) -{ - apr_table_entry_t *next_elt; - apr_table_entry_t *end_elt; - apr_table_entry_t *table_end; - apr_uint32_t checksum; - int hash; - - COMPUTE_KEY_CHECKSUM(key, checksum); - hash = TABLE_HASH(key); - if (!TABLE_INDEX_IS_INITIALIZED(t, hash)) { - t->index_first[hash] = t->a.nelts; - TABLE_SET_INDEX_INITIALIZED(t, hash); - goto add_new_elt; - } - next_elt = ((apr_table_entry_t *) t->a.elts) + t->index_first[hash];; - end_elt = ((apr_table_entry_t *) t->a.elts) + t->index_last[hash]; - table_end =((apr_table_entry_t *) t->a.elts) + t->a.nelts; - - for (; next_elt <= end_elt; next_elt++) { - if ((checksum == next_elt->key_checksum) && - !strcasecmp(next_elt->key, key)) { - - /* Found an existing entry with the same key, so overwrite it */ - - int must_reindex = 0; - apr_table_entry_t *dst_elt = NULL; - - next_elt->val = (char *)val; - - /* Remove any other instances of this key */ - for (next_elt++; next_elt <= end_elt; next_elt++) { - if ((checksum == next_elt->key_checksum) && - !strcasecmp(next_elt->key, key)) { - t->a.nelts--; - if (!dst_elt) { - dst_elt = next_elt; - } - } - else if (dst_elt) { - *dst_elt++ = *next_elt; - must_reindex = 1; - } - } - - /* If we've removed anything, shift over the remainder - * of the table (note that the previous loop didn't - * run to the end of the table, just to the last match - * for the index) - */ - if (dst_elt) { - for (; next_elt < table_end; next_elt++) { - *dst_elt++ = *next_elt; - } - must_reindex = 1; - } - if (must_reindex) { - table_reindex(t); - } - return; - } - } - -add_new_elt: - t->index_last[hash] = t->a.nelts; - next_elt = (apr_table_entry_t *) table_push(t); - next_elt->key = (char *)key; - next_elt->val = (char *)val; - next_elt->key_checksum = checksum; -} - -APR_DECLARE(void) apr_table_unset(apr_table_t *t, const char *key) -{ - apr_table_entry_t *next_elt; - apr_table_entry_t *end_elt; - apr_table_entry_t *dst_elt; - apr_uint32_t checksum; - int hash; - int must_reindex; - - hash = TABLE_HASH(key); - if (!TABLE_INDEX_IS_INITIALIZED(t, hash)) { - return; - } - COMPUTE_KEY_CHECKSUM(key, checksum); - next_elt = ((apr_table_entry_t *) t->a.elts) + t->index_first[hash]; - end_elt = ((apr_table_entry_t *) t->a.elts) + t->index_last[hash]; - must_reindex = 0; - for (; next_elt <= end_elt; next_elt++) { - if ((checksum == next_elt->key_checksum) && - !strcasecmp(next_elt->key, key)) { - - /* Found a match: remove this entry, plus any additional - * matches for the same key that might follow - */ - apr_table_entry_t *table_end = ((apr_table_entry_t *) t->a.elts) + - t->a.nelts; - t->a.nelts--; - dst_elt = next_elt; - for (next_elt++; next_elt <= end_elt; next_elt++) { - if ((checksum == next_elt->key_checksum) && - !strcasecmp(next_elt->key, key)) { - t->a.nelts--; - } - else { - *dst_elt++ = *next_elt; - } - } - - /* Shift over the remainder of the table (note that - * the previous loop didn't run to the end of the table, - * just to the last match for the index) - */ - for (; next_elt < table_end; next_elt++) { - *dst_elt++ = *next_elt; - } - must_reindex = 1; - break; - } - } - if (must_reindex) { - table_reindex(t); - } -} - -APR_DECLARE(void) apr_table_merge(apr_table_t *t, const char *key, - const char *val) -{ - apr_table_entry_t *next_elt; - apr_table_entry_t *end_elt; - apr_uint32_t checksum; - int hash; - - COMPUTE_KEY_CHECKSUM(key, checksum); - hash = TABLE_HASH(key); - if (!TABLE_INDEX_IS_INITIALIZED(t, hash)) { - t->index_first[hash] = t->a.nelts; - TABLE_SET_INDEX_INITIALIZED(t, hash); - goto add_new_elt; - } - next_elt = ((apr_table_entry_t *) t->a.elts) + t->index_first[hash]; - end_elt = ((apr_table_entry_t *) t->a.elts) + t->index_last[hash]; - - for (; next_elt <= end_elt; next_elt++) { - if ((checksum == next_elt->key_checksum) && - !strcasecmp(next_elt->key, key)) { - - /* Found an existing entry with the same key, so merge with it */ - next_elt->val = apr_pstrcat(t->a.pool, next_elt->val, ", ", - val, NULL); - return; - } - } - -add_new_elt: - t->index_last[hash] = t->a.nelts; - next_elt = (apr_table_entry_t *) table_push(t); - next_elt->key = apr_pstrdup(t->a.pool, key); - next_elt->val = apr_pstrdup(t->a.pool, val); - next_elt->key_checksum = checksum; -} - -APR_DECLARE(void) apr_table_mergen(apr_table_t *t, const char *key, - const char *val) -{ - apr_table_entry_t *next_elt; - apr_table_entry_t *end_elt; - apr_uint32_t checksum; - int hash; - -#ifdef POOL_DEBUG - { - if (!apr_pool_is_ancestor(apr_pool_find(key), t->a.pool)) { - fprintf(stderr, "table_set: key not in ancestor pool of t\n"); - abort(); - } - if (!apr_pool_is_ancestor(apr_pool_find(val), t->a.pool)) { - fprintf(stderr, "table_set: val not in ancestor pool of t\n"); - abort(); - } - } -#endif - - COMPUTE_KEY_CHECKSUM(key, checksum); - hash = TABLE_HASH(key); - if (!TABLE_INDEX_IS_INITIALIZED(t, hash)) { - t->index_first[hash] = t->a.nelts; - TABLE_SET_INDEX_INITIALIZED(t, hash); - goto add_new_elt; - } - next_elt = ((apr_table_entry_t *) t->a.elts) + t->index_first[hash];; - end_elt = ((apr_table_entry_t *) t->a.elts) + t->index_last[hash]; - - for (; next_elt <= end_elt; next_elt++) { - if ((checksum == next_elt->key_checksum) && - !strcasecmp(next_elt->key, key)) { - - /* Found an existing entry with the same key, so merge with it */ - next_elt->val = apr_pstrcat(t->a.pool, next_elt->val, ", ", - val, NULL); - return; - } - } - -add_new_elt: - t->index_last[hash] = t->a.nelts; - next_elt = (apr_table_entry_t *) table_push(t); - next_elt->key = (char *)key; - next_elt->val = (char *)val; - next_elt->key_checksum = checksum; -} - -APR_DECLARE(void) apr_table_add(apr_table_t *t, const char *key, - const char *val) -{ - apr_table_entry_t *elts; - apr_uint32_t checksum; - int hash; - - hash = TABLE_HASH(key); - t->index_last[hash] = t->a.nelts; - if (!TABLE_INDEX_IS_INITIALIZED(t, hash)) { - t->index_first[hash] = t->a.nelts; - TABLE_SET_INDEX_INITIALIZED(t, hash); - } - COMPUTE_KEY_CHECKSUM(key, checksum); - elts = (apr_table_entry_t *) table_push(t); - elts->key = apr_pstrdup(t->a.pool, key); - elts->val = apr_pstrdup(t->a.pool, val); - elts->key_checksum = checksum; -} - -APR_DECLARE(void) apr_table_addn(apr_table_t *t, const char *key, - const char *val) -{ - apr_table_entry_t *elts; - apr_uint32_t checksum; - int hash; - -#ifdef POOL_DEBUG - { - if (!apr_pool_is_ancestor(apr_pool_find(key), t->a.pool)) { - fprintf(stderr, "table_set: key not in ancestor pool of t\n"); - abort(); - } - if (!apr_pool_is_ancestor(apr_pool_find(val), t->a.pool)) { - fprintf(stderr, "table_set: val not in ancestor pool of t\n"); - abort(); - } - } -#endif - - hash = TABLE_HASH(key); - t->index_last[hash] = t->a.nelts; - if (!TABLE_INDEX_IS_INITIALIZED(t, hash)) { - t->index_first[hash] = t->a.nelts; - TABLE_SET_INDEX_INITIALIZED(t, hash); - } - COMPUTE_KEY_CHECKSUM(key, checksum); - elts = (apr_table_entry_t *) table_push(t); - elts->key = (char *)key; - elts->val = (char *)val; - elts->key_checksum = checksum; -} - -APR_DECLARE(apr_table_t *) apr_table_overlay(apr_pool_t *p, - const apr_table_t *overlay, - const apr_table_t *base) -{ - apr_table_t *res; - -#ifdef POOL_DEBUG - /* we don't copy keys and values, so it's necessary that - * overlay->a.pool and base->a.pool have a life span at least - * as long as p - */ - if (!apr_pool_is_ancestor(overlay->a.pool, p)) { - fprintf(stderr, - "overlay_tables: overlay's pool is not an ancestor of p\n"); - abort(); - } - if (!apr_pool_is_ancestor(base->a.pool, p)) { - fprintf(stderr, - "overlay_tables: base's pool is not an ancestor of p\n"); - abort(); - } -#endif - - res = apr_palloc(p, sizeof(apr_table_t)); - /* behave like append_arrays */ - res->a.pool = p; - copy_array_hdr_core(&res->a, &overlay->a); - apr_array_cat(&res->a, &base->a); - table_reindex(res); - return res; -} - -/* And now for something completely abstract ... - - * For each key value given as a vararg: - * run the function pointed to as - * int comp(void *r, char *key, char *value); - * on each valid key-value pair in the apr_table_t t that matches the vararg key, - * or once for every valid key-value pair if the vararg list is empty, - * until the function returns false (0) or we finish the table. - * - * Note that we restart the traversal for each vararg, which means that - * duplicate varargs will result in multiple executions of the function - * for each matching key. Note also that if the vararg list is empty, - * only one traversal will be made and will cut short if comp returns 0. - * - * Note that the table_get and table_merge functions assume that each key in - * the apr_table_t is unique (i.e., no multiple entries with the same key). This - * function does not make that assumption, since it (unfortunately) isn't - * true for some of Apache's tables. - * - * Note that rec is simply passed-on to the comp function, so that the - * caller can pass additional info for the task. - * - * ADDENDUM for apr_table_vdo(): - * - * The caching api will allow a user to walk the header values: - * - * apr_status_t apr_cache_el_header_walk(apr_cache_el *el, - * int (*comp)(void *, const char *, const char *), void *rec, ...); - * - * So it can be ..., however from there I use a callback that use a va_list: - * - * apr_status_t (*cache_el_header_walk)(apr_cache_el *el, - * int (*comp)(void *, const char *, const char *), void *rec, va_list); - * - * To pass those ...'s on down to the actual module that will handle walking - * their headers, in the file case this is actually just an apr_table - and - * rather than reimplementing apr_table_do (which IMHO would be bad) I just - * called it with the va_list. For mod_shmem_cache I don't need it since I - * can't use apr_table's, but mod_file_cache should (though a good hash would - * be better, but that's a different issue :). - * - * So to make mod_file_cache easier to maintain, it's a good thing - */ -APR_DECLARE_NONSTD(int) apr_table_do(apr_table_do_callback_fn_t *comp, - void *rec, const apr_table_t *t, ...) -{ - int rv; - - va_list vp; - va_start(vp, t); - rv = apr_table_vdo(comp, rec, t, vp); - va_end(vp); - - return rv; -} - -/* XXX: do the semantics of this routine make any sense? Right now, - * if the caller passed in a non-empty va_list of keys to search for, - * the "early termination" facility only terminates on *that* key; other - * keys will continue to process. Note that this only has any effect - * at all if there are multiple entries in the table with the same key, - * otherwise the called function can never effectively early-terminate - * this function, as the zero return value is effectively ignored. - * - * Note also that this behavior is at odds with the behavior seen if an - * empty va_list is passed in -- in that case, a zero return value terminates - * the entire apr_table_vdo (which is what I think should happen in - * both cases). - * - * If nobody objects soon, I'm going to change the order of the nested - * loops in this function so that any zero return value from the (*comp) - * function will cause a full termination of apr_table_vdo. I'm hesitant - * at the moment because these (funky) semantics have been around for a - * very long time, and although Apache doesn't seem to use them at all, - * some third-party vendor might. I can only think of one possible reason - * the existing semantics would make any sense, and it's very Apache-centric, - * which is this: if (*comp) is looking for matches of a particular - * substring in request headers (let's say it's looking for a particular - * cookie name in the Set-Cookie headers), then maybe it wants to be - * able to stop searching early as soon as it finds that one and move - * on to the next key. That's only an optimization of course, but changing - * the behavior of this function would mean that any code that tried - * to do that would stop working right. - * - * Sigh. --JCW, 06/28/02 - */ -APR_DECLARE(int) apr_table_vdo(apr_table_do_callback_fn_t *comp, - void *rec, const apr_table_t *t, va_list vp) -{ - char *argp; - apr_table_entry_t *elts = (apr_table_entry_t *) t->a.elts; - int vdorv = 1; - - argp = va_arg(vp, char *); - do { - int rv = 1, i; - if (argp) { - /* Scan for entries that match the next key */ - int hash = TABLE_HASH(argp); - if (TABLE_INDEX_IS_INITIALIZED(t, hash)) { - apr_uint32_t checksum; - COMPUTE_KEY_CHECKSUM(argp, checksum); - for (i = t->index_first[hash]; - rv && (i <= t->index_last[hash]); ++i) { - if (elts[i].key && (checksum == elts[i].key_checksum) && - !strcasecmp(elts[i].key, argp)) { - rv = (*comp) (rec, elts[i].key, elts[i].val); - } - } - } - } - else { - /* Scan the entire table */ - for (i = 0; rv && (i < t->a.nelts); ++i) { - if (elts[i].key) { - rv = (*comp) (rec, elts[i].key, elts[i].val); - } - } - } - if (rv == 0) { - vdorv = 0; - } - } while (argp && ((argp = va_arg(vp, char *)) != NULL)); - - return vdorv; -} - -static apr_table_entry_t **table_mergesort(apr_pool_t *pool, - apr_table_entry_t **values, int n) -{ - /* Bottom-up mergesort, based on design in Sedgewick's "Algorithms - * in C," chapter 8 - */ - apr_table_entry_t **values_tmp = - (apr_table_entry_t **)apr_palloc(pool, n * sizeof(apr_table_entry_t*)); - int i; - int blocksize; - - /* First pass: sort pairs of elements (blocksize=1) */ - for (i = 0; i + 1 < n; i += 2) { - if (strcasecmp(values[i]->key, values[i + 1]->key) > 0) { - apr_table_entry_t *swap = values[i]; - values[i] = values[i + 1]; - values[i + 1] = swap; - } - } - - /* Merge successively larger blocks */ - blocksize = 2; - while (blocksize < n) { - apr_table_entry_t **dst = values_tmp; - int next_start; - apr_table_entry_t **swap; - - /* Merge consecutive pairs blocks of the next blocksize. - * Within a block, elements are in sorted order due to - * the previous iteration. - */ - for (next_start = 0; next_start + blocksize < n; - next_start += (blocksize + blocksize)) { - - int block1_start = next_start; - int block2_start = block1_start + blocksize; - int block1_end = block2_start; - int block2_end = block2_start + blocksize; - if (block2_end > n) { - /* The last block may be smaller than blocksize */ - block2_end = n; - } - for (;;) { - - /* Merge the next two blocks: - * Pick the smaller of the next element from - * block 1 and the next element from block 2. - * Once either of the blocks is emptied, copy - * over all the remaining elements from the - * other block - */ - if (block1_start == block1_end) { - for (; block2_start < block2_end; block2_start++) { - *dst++ = values[block2_start]; - } - break; - } - else if (block2_start == block2_end) { - for (; block1_start < block1_end; block1_start++) { - *dst++ = values[block1_start]; - } - break; - } - if (strcasecmp(values[block1_start]->key, - values[block2_start]->key) > 0) { - *dst++ = values[block2_start++]; - } - else { - *dst++ = values[block1_start++]; - } - } - } - - /* If n is not a multiple of 2*blocksize, some elements - * will be left over at the end of the array. - */ - for (i = dst - values_tmp; i < n; i++) { - values_tmp[i] = values[i]; - } - - /* The output array of this pass becomes the input - * array of the next pass, and vice versa - */ - swap = values_tmp; - values_tmp = values; - values = swap; - - blocksize += blocksize; - } - - return values; -} - -APR_DECLARE(void) apr_table_compress(apr_table_t *t, unsigned flags) -{ - apr_table_entry_t **sort_array; - apr_table_entry_t **sort_next; - apr_table_entry_t **sort_end; - apr_table_entry_t *table_next; - apr_table_entry_t **last; - int i; - int dups_found; - - if (t->a.nelts <= 1) { - return; - } - - /* Copy pointers to all the table elements into an - * array and sort to allow for easy detection of - * duplicate keys - */ - sort_array = (apr_table_entry_t **) - apr_palloc(t->a.pool, t->a.nelts * sizeof(apr_table_entry_t*)); - sort_next = sort_array; - table_next = (apr_table_entry_t *)t->a.elts; - i = t->a.nelts; - do { - *sort_next++ = table_next++; - } while (--i); - - /* Note: the merge is done with mergesort instead of quicksort - * because mergesort is a stable sort and runs in n*log(n) - * time regardless of its inputs (quicksort is quadratic in - * the worst case) - */ - sort_array = table_mergesort(t->a.pool, sort_array, t->a.nelts); - - /* Process any duplicate keys */ - dups_found = 0; - sort_next = sort_array; - sort_end = sort_array + t->a.nelts; - last = sort_next++; - while (sort_next < sort_end) { - if (((*sort_next)->key_checksum == (*last)->key_checksum) && - !strcasecmp((*sort_next)->key, (*last)->key)) { - apr_table_entry_t **dup_last = sort_next + 1; - dups_found = 1; - while ((dup_last < sort_end) && - ((*dup_last)->key_checksum == (*last)->key_checksum) && - !strcasecmp((*dup_last)->key, (*last)->key)) { - dup_last++; - } - dup_last--; /* Elements from last through dup_last, inclusive, - * all have the same key - */ - if (flags == APR_OVERLAP_TABLES_MERGE) { - apr_size_t len = 0; - apr_table_entry_t **next = last; - char *new_val; - char *val_dst; - do { - len += strlen((*next)->val); - len += 2; /* for ", " or trailing null */ - } while (++next <= dup_last); - new_val = (char *)apr_palloc(t->a.pool, len); - val_dst = new_val; - next = last; - for (;;) { - strcpy(val_dst, (*next)->val); - val_dst += strlen((*next)->val); - next++; - if (next > dup_last) { - *val_dst = 0; - break; - } - else { - *val_dst++ = ','; - *val_dst++ = ' '; - } - } - (*last)->val = new_val; - } - else { /* overwrite */ - (*last)->val = (*dup_last)->val; - } - do { - (*sort_next)->key = NULL; - } while (++sort_next <= dup_last); - } - else { - last = sort_next++; - } - } - - /* Shift elements to the left to fill holes left by removing duplicates */ - if (dups_found) { - apr_table_entry_t *src = (apr_table_entry_t *)t->a.elts; - apr_table_entry_t *dst = (apr_table_entry_t *)t->a.elts; - apr_table_entry_t *last_elt = src + t->a.nelts; - do { - if (src->key) { - *dst++ = *src; - } - } while (++src < last_elt); - t->a.nelts -= (last_elt - dst); - } - - table_reindex(t); -} - -static void apr_table_cat(apr_table_t *t, const apr_table_t *s) -{ - const int n = t->a.nelts; - register int idx; - - apr_array_cat(&t->a,&s->a); - - if (n == 0) { - memcpy(t->index_first,s->index_first,sizeof(int) * TABLE_HASH_SIZE); - memcpy(t->index_last, s->index_last, sizeof(int) * TABLE_HASH_SIZE); - t->index_initialized = s->index_initialized; - return; - } - - for (idx = 0; idx < TABLE_HASH_SIZE; ++idx) { - if (TABLE_INDEX_IS_INITIALIZED(s, idx)) { - t->index_last[idx] = s->index_last[idx] + n; - if (!TABLE_INDEX_IS_INITIALIZED(t, idx)) { - t->index_first[idx] = s->index_first[idx] + n; - } - } - } - - t->index_initialized |= s->index_initialized; -} - -APR_DECLARE(void) apr_table_overlap(apr_table_t *a, const apr_table_t *b, - unsigned flags) -{ - const int m = a->a.nelts; - const int n = b->a.nelts; - apr_pool_t *p = b->a.pool; - - if (m + n == 0) { - return; - } - - /* copy (extend) a using b's pool */ - if (a->a.pool != p) { - make_array_core(&a->a, p, m+n, sizeof(apr_table_entry_t), 0); - } - - apr_table_cat(a, b); - - apr_table_compress(a, flags); -} |