mirror of
https://github.com/moparisthebest/curl
synced 2024-12-21 23:58:49 -05:00
286 lines
6.7 KiB
C
286 lines
6.7 KiB
C
/*****************************************************************************
|
|
* _ _ ____ _
|
|
* Project ___| | | | _ \| |
|
|
* / __| | | | |_) | |
|
|
* | (__| |_| | _ <| |___
|
|
* \___|\___/|_| \_\_____|
|
|
*
|
|
* Copyright (C) 1998 - 2002, Daniel Stenberg, <daniel@haxx.se>, et al.
|
|
*
|
|
* In order to be useful for every potential user, curl and libcurl are
|
|
* dual-licensed under the MPL and the MIT/X-derivate licenses.
|
|
*
|
|
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
|
|
* copies of the Software, and permit persons to whom the Software is
|
|
* furnished to do so, under the terms of the MPL or the MIT/X-derivate
|
|
* licenses. You may pick one of these licenses.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
* $Id$
|
|
*****************************************************************************/
|
|
|
|
#include "setup.h"
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include "hash.h"
|
|
#include "llist.h"
|
|
|
|
#ifdef MALLOCDEBUG
|
|
/* this must be the last include file */
|
|
#include "memdebug.h"
|
|
#endif
|
|
|
|
|
|
static unsigned long
|
|
curl_hash_str(const char *key, unsigned int key_length)
|
|
{
|
|
register unsigned long h = 0;
|
|
register unsigned long g;
|
|
register char *p = (char *) key;
|
|
register char *end = (char *) key + key_length;
|
|
|
|
while (p < end) {
|
|
h = (h << 4) + *p++;
|
|
if ((g = (h & 0xF0000000))) {
|
|
h = h ^ (g >> 24);
|
|
h = h ^ g;
|
|
}
|
|
}
|
|
|
|
return h;
|
|
}
|
|
|
|
static unsigned long
|
|
curl_hash_num(unsigned long key)
|
|
{
|
|
key += ~(key << 15);
|
|
key ^= (key >> 10);
|
|
key += (key << 3);
|
|
key ^= (key >> 6);
|
|
key += (key << 11);
|
|
key ^= (key >> 16);
|
|
|
|
return key;
|
|
}
|
|
|
|
static void
|
|
hash_element_dtor(void *u, void *ele)
|
|
{
|
|
curl_hash_element *e = (curl_hash_element *) ele;
|
|
curl_hash *h = (curl_hash *) u;
|
|
|
|
if (e->key.type == CURL_HASH_KEY_IS_STRING) {
|
|
free(e->key.value.str.val);
|
|
}
|
|
h->dtor(e->ptr);
|
|
|
|
free(e);
|
|
e = NULL;
|
|
}
|
|
|
|
void
|
|
curl_hash_init(curl_hash *h, int slots, curl_hash_dtor dtor)
|
|
{
|
|
int i;
|
|
|
|
h->dtor = dtor;
|
|
h->size = 0;
|
|
h->slots = slots;
|
|
|
|
h->table = (curl_llist **) malloc(slots * sizeof(curl_llist *));
|
|
for (i = 0; i < h->slots; ++i) {
|
|
h->table[i] = curl_llist_alloc((curl_llist_dtor) hash_element_dtor);
|
|
}
|
|
}
|
|
|
|
curl_hash *
|
|
curl_hash_alloc(int slots, curl_hash_dtor dtor)
|
|
{
|
|
curl_hash *h;
|
|
|
|
h = (curl_hash *)malloc(sizeof(curl_hash));
|
|
if(NULL == h)
|
|
return NULL;
|
|
|
|
curl_hash_init(h, slots, dtor);
|
|
|
|
return h;
|
|
}
|
|
|
|
#define FIND_SLOT(__h, __s_key, __s_key_len, __n_key) \
|
|
((__s_key ? curl_hash_str(__s_key, __s_key_len) : curl_hash_num(__n_key)) % (__h)->slots)
|
|
|
|
#define KEY_CREATE(__k, __s_key, __s_key_len, __n_key, __dup) \
|
|
if (__s_key) { \
|
|
if (__dup) { \
|
|
(__k)->value.str.val = (char *) malloc(__s_key_len); \
|
|
memcpy((__k)->value.str.val, __s_key, __s_key_len); \
|
|
} else { \
|
|
(__k)->value.str.val = __s_key; \
|
|
} \
|
|
(__k)->value.str.len = __s_key_len; \
|
|
(__k)->type = CURL_HASH_KEY_IS_STRING; \
|
|
} else { \
|
|
(__k)->value.num = __n_key; \
|
|
(__k)->type = CURL_HASH_KEY_IS_NUM; \
|
|
}
|
|
|
|
#define MIN(a, b) (a > b ? b : a)
|
|
|
|
static int
|
|
curl_hash_key_compare(curl_hash_key *key1, curl_hash_key *key2)
|
|
{
|
|
if (key1->type == CURL_HASH_KEY_IS_NUM) {
|
|
if (key2->type == CURL_HASH_KEY_IS_STRING)
|
|
return 0;
|
|
|
|
if (key1->value.num == key2->value.num)
|
|
return 1;
|
|
} else {
|
|
if (key2->type == CURL_HASH_KEY_IS_NUM)
|
|
return 0;
|
|
|
|
if (memcmp(key1->value.str.val, key2->value.str.val,
|
|
MIN(key1->value.str.len, key2->value.str.len)) == 0)
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
curl_hash_add_or_update(curl_hash *h, char *str_key, unsigned int str_key_len,
|
|
unsigned long num_key, const void *p)
|
|
{
|
|
curl_hash_element *e;
|
|
curl_hash_key tmp;
|
|
curl_llist *l;
|
|
curl_llist_element *le;
|
|
int slot;
|
|
|
|
slot = FIND_SLOT(h, str_key, str_key_len, num_key);
|
|
l = h->table[slot];
|
|
KEY_CREATE(&tmp, str_key, str_key_len, num_key, 0);
|
|
for (le = CURL_LLIST_HEAD(l); le != NULL; le = CURL_LLIST_NEXT(le)) {
|
|
if (curl_hash_key_compare(&tmp, &((curl_hash_element *) CURL_LLIST_VALP(le))->key)) {
|
|
curl_hash_element *to_update = CURL_LLIST_VALP(le);
|
|
h->dtor(to_update->ptr);
|
|
to_update->ptr = (void *) p;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
e = (curl_hash_element *) malloc(sizeof(curl_hash_element));
|
|
KEY_CREATE(&e->key, str_key, str_key_len, num_key, 1);
|
|
e->ptr = (void *) p;
|
|
|
|
if (curl_llist_insert_next(l, CURL_LLIST_TAIL(l), e)) {
|
|
++h->size;
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int
|
|
curl_hash_extended_delete(curl_hash *h, char *str_key, unsigned int str_key_len,
|
|
unsigned long num_key)
|
|
{
|
|
curl_llist *l;
|
|
curl_llist_element *le;
|
|
curl_hash_key tmp;
|
|
int slot;
|
|
|
|
slot = FIND_SLOT(h, str_key, str_key_len, num_key);
|
|
l = h->table[slot];
|
|
|
|
KEY_CREATE(&tmp, str_key, str_key_len, num_key, 0);
|
|
for (le = CURL_LLIST_HEAD(l); le != NULL; le = CURL_LLIST_NEXT(le)) {
|
|
if (curl_hash_key_compare(&tmp, &((curl_hash_element *) CURL_LLIST_VALP(le))->key)) {
|
|
curl_llist_remove(l, le, (void *) h);
|
|
--h->size;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
curl_hash_extended_find(curl_hash *h, char *str_key, unsigned int str_key_len,
|
|
unsigned long num_key, void **p)
|
|
{
|
|
curl_llist *l;
|
|
curl_llist_element *le;
|
|
curl_hash_key tmp;
|
|
int slot;
|
|
|
|
slot = FIND_SLOT(h, str_key, str_key_len, num_key);
|
|
l = h->table[slot];
|
|
|
|
KEY_CREATE(&tmp, str_key, str_key_len, num_key, 0);
|
|
for (le = CURL_LLIST_HEAD(l); le != NULL; le = CURL_LLIST_NEXT(le)) {
|
|
if (curl_hash_key_compare(&tmp, &((curl_hash_element *) CURL_LLIST_VALP(le))->key)) {
|
|
*p = ((curl_hash_element *) CURL_LLIST_VALP(le))->ptr;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
curl_hash_apply(curl_hash *h, void *user, void (*cb)(void *, curl_hash_element *))
|
|
{
|
|
curl_llist_element *le;
|
|
int i;
|
|
|
|
for (i = 0; i < h->slots; ++i) {
|
|
for (le = CURL_LLIST_HEAD(h->table[i]); le != NULL; le = CURL_LLIST_NEXT(le)) {
|
|
cb(user, (curl_hash_element *) CURL_LLIST_VALP(le));
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
curl_hash_clean(curl_hash *h)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < h->slots; ++i) {
|
|
curl_llist_destroy(h->table[i], (void *) h);
|
|
}
|
|
|
|
free(h->table);
|
|
h->table = NULL;
|
|
}
|
|
|
|
size_t
|
|
curl_hash_count(curl_hash *h)
|
|
{
|
|
return h->size;
|
|
}
|
|
|
|
void
|
|
curl_hash_destroy(curl_hash *h)
|
|
{
|
|
if (!h) {
|
|
return;
|
|
}
|
|
|
|
curl_hash_clean(h);
|
|
free(h);
|
|
h = NULL;
|
|
}
|
|
|
|
/*
|
|
* local variables:
|
|
* eval: (load-file "../curl-mode.el")
|
|
* end:
|
|
* vim600: fdm=marker
|
|
* vim: et sw=2 ts=2 sts=2 tw=78
|
|
*/
|