NetBSD/dist/dhcp/omapip/hash.c

418 lines
9.5 KiB
C

/* hash.c
Routines for manipulating hash tables... */
/*
* Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
* Copyright (c) 1995-2003 by Internet Software Consortium
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Internet Systems Consortium, Inc.
* 950 Charter Street
* Redwood City, CA 94063
* <info@isc.org>
* http://www.isc.org/
*
* This software has been written for Internet Systems Consortium
* by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
* To learn more about Internet Systems Consortium, see
* ``http://www.isc.org/''. To learn more about Vixie Enterprises,
* see ``http://www.vix.com''. To learn more about Nominum, Inc., see
* ``http://www.nominum.com''.
*/
#ifndef lint
static char copyright[] =
"$Id: hash.c,v 1.5 2005/08/11 17:13:30 drochner Exp $ Copyright (c) 2004 Internet Systems Consortium. All rights reserved.\n";
#endif /* not lint */
#include <omapip/omapip_p.h>
#include <ctype.h>
static int do_hash (const unsigned char *, unsigned, unsigned);
static int do_case_hash (const unsigned char *, unsigned, unsigned);
int new_hash_table (tp, count, file, line)
struct hash_table **tp;
int count;
const char *file;
int line;
{
struct hash_table *rval;
if (!tp) {
log_error ("%s(%d): new_hash_table called with null pointer.",
file, line);
#if defined (POINTER_DEBUG)
abort ();
#endif
return 0;
}
if (*tp) {
log_error ("%s(%d): non-null target for new_hash_table.",
file, line);
#if defined (POINTER_DEBUG)
abort ();
#endif
}
rval = dmalloc (sizeof (struct hash_table) -
(DEFAULT_HASH_SIZE * sizeof (struct hash_bucket *)) +
(count * sizeof (struct hash_bucket *)), file, line);
if (!rval)
return 0;
rval -> hash_count = count;
*tp = rval;
return 1;
}
void free_hash_table (tp, file, line)
struct hash_table **tp;
const char *file;
int line;
{
struct hash_table *ptr = *tp;
#if defined (DEBUG_MEMORY_LEAKAGE) || \
defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
int i;
struct hash_bucket *hbc, *hbn = (struct hash_bucket *)0;
for (i = 0; i < ptr -> hash_count; i++) {
for (hbc = ptr -> buckets [i]; hbc; hbc = hbn) {
hbn = hbc -> next;
if (ptr -> dereferencer && hbc -> value)
(*ptr -> dereferencer) (&hbc -> value, MDL);
}
for (hbc = ptr -> buckets [i]; hbc; hbc = hbn) {
hbn = hbc -> next;
free_hash_bucket (hbc, MDL);
}
ptr -> buckets [i] = (struct hash_bucket *)0;
}
#endif
dfree ((VOIDPTR)ptr, MDL);
*tp = (struct hash_table *)0;
}
struct hash_bucket *free_hash_buckets;
#if defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
struct hash_bucket *hash_bucket_hunks;
void relinquish_hash_bucket_hunks ()
{
struct hash_bucket *c, *n, **p;
/* Account for all the hash buckets on the free list. */
p = &free_hash_buckets;
for (c = free_hash_buckets; c; c = c -> next) {
for (n = hash_bucket_hunks; n; n = n -> next) {
if (c > n && c < n + 127) {
*p = c -> next;
n -> len++;
break;
}
}
/* If we didn't delete the hash bucket from the free list,
advance the pointer. */
if (!n)
p = &c -> next;
}
for (c = hash_bucket_hunks; c; c = n) {
n = c -> next;
if (c -> len != 126) {
log_info ("hashbucket %lx hash_buckets %d free %u",
(unsigned long)c, 127, c -> len);
}
dfree (c, MDL);
}
}
#endif
struct hash_bucket *new_hash_bucket (file, line)
const char *file;
int line;
{
struct hash_bucket *rval;
int i = 0;
if (!free_hash_buckets) {
rval = dmalloc (127 * sizeof (struct hash_bucket),
file, line);
if (!rval)
return rval;
# if defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
rval -> next = hash_bucket_hunks;
hash_bucket_hunks = rval;
hash_bucket_hunks -> len = 0;
i++;
rval++;
#endif
for (; i < 127; i++) {
rval -> next = free_hash_buckets;
free_hash_buckets = rval;
rval++;
}
}
rval = free_hash_buckets;
free_hash_buckets = rval -> next;
return rval;
}
void free_hash_bucket (ptr, file, line)
struct hash_bucket *ptr;
const char *file;
int line;
{
#if defined (DEBUG_MALLOC_POOL)
struct hash_bucket *hp;
for (hp = free_hash_buckets; hp; hp = hp -> next) {
if (hp == ptr) {
log_error ("hash bucket freed twice!");
abort ();
}
}
#endif
ptr -> next = free_hash_buckets;
free_hash_buckets = ptr;
}
int new_hash (struct hash_table **rp,
hash_reference referencer,
hash_dereference dereferencer,
int casep, const char *file, int line)
{
if (!new_hash_table (rp, DEFAULT_HASH_SIZE, file, line))
return 0;
memset (&(*rp) -> buckets [0], 0,
DEFAULT_HASH_SIZE * sizeof (struct hash_bucket *));
(*rp) -> referencer = referencer;
(*rp) -> dereferencer = dereferencer;
if (casep) {
(*rp) -> cmp = casecmp;
(*rp) -> do_hash = do_case_hash;
} else {
(*rp) -> cmp = (hash_comparator_t)memcmp;
(*rp) -> do_hash = do_hash;
}
return 1;
}
static int do_case_hash (name, len, size)
const unsigned char *name;
unsigned len;
unsigned size;
{
register int accum = 0;
register const unsigned char *s = (const unsigned char *)name;
int i = len;
register unsigned c;
while (i--) {
/* Make the hash case-insensitive. */
c = *s++;
if (isascii (c) && isupper (c))
c = tolower (c);
/* Add the character in... */
accum = (accum << 1) + c;
/* Add carry back in... */
while (accum > 65535) {
accum = (accum & 65535) + (accum >> 16);
}
}
return accum % size;
}
static int do_hash (name, len, size)
const unsigned char *name;
unsigned len;
unsigned size;
{
register int accum = 0;
register const unsigned char *s = (const unsigned char *)name;
int i = len;
while (i--) {
/* Add the character in... */
accum = (accum << 1) + *s++;
/* Add carry back in... */
while (accum > 65535) {
accum = (accum & 65535) + (accum >> 16);
}
}
return accum % size;
}
void add_hash (table, name, len, pointer, file, line)
struct hash_table *table;
unsigned len;
const unsigned char *name;
hashed_object_t *pointer;
const char *file;
int line;
{
int hashno;
struct hash_bucket *bp;
void *foo;
if (!table)
return;
if (!len)
len = strlen ((const char *)name);
hashno = (*table -> do_hash) (name, len, table -> hash_count);
bp = new_hash_bucket (file, line);
if (!bp) {
log_error ("Can't add %s to hash table.", name);
return;
}
bp -> name = name;
if (table -> referencer) {
foo = &bp -> value;
(*(table -> referencer)) (foo, pointer, file, line);
} else
bp -> value = pointer;
bp -> next = table -> buckets [hashno];
bp -> len = len;
table -> buckets [hashno] = bp;
}
void delete_hash_entry (table, name, len, file, line)
struct hash_table *table;
unsigned len;
const unsigned char *name;
const char *file;
int line;
{
int hashno;
struct hash_bucket *bp, *pbp = (struct hash_bucket *)0;
void *foo;
if (!table)
return;
if (!len)
len = strlen ((const char *)name);
hashno = (*table -> do_hash) (name, len, table -> hash_count);
/* Go through the list looking for an entry that matches;
if we find it, delete it. */
for (bp = table -> buckets [hashno]; bp; bp = bp -> next) {
if ((!bp -> len &&
!strcmp ((const char *)bp -> name, (const char *)name)) ||
(bp -> len == len &&
!(*table -> cmp) (bp -> name, name, len))) {
if (pbp) {
pbp -> next = bp -> next;
} else {
table -> buckets [hashno] = bp -> next;
}
if (bp -> value && table -> dereferencer) {
foo = &bp -> value;
(*(table -> dereferencer)) (foo, file, line);
}
free_hash_bucket (bp, file, line);
break;
}
pbp = bp; /* jwg, 9/6/96 - nice catch! */
}
}
int hash_lookup (vp, table, name, len, file, line)
hashed_object_t **vp;
struct hash_table *table;
const unsigned char *name;
unsigned len;
const char *file;
int line;
{
int hashno;
struct hash_bucket *bp;
if (!table)
return 0;
if (!len)
len = strlen ((const char *)name);
hashno = (*table -> do_hash) (name, len, table -> hash_count);
for (bp = table -> buckets [hashno]; bp; bp = bp -> next) {
if (len == bp -> len
&& !(*table -> cmp) (bp -> name, name, len)) {
if (table -> referencer)
(*table -> referencer) (vp, bp -> value,
file, line);
else
*vp = bp -> value;
return 1;
}
}
return 0;
}
int hash_foreach (struct hash_table *table, hash_foreach_func func)
{
int i;
struct hash_bucket *bp, *next;
int count = 0;
if (!table)
return 0;
for (i = 0; i < table -> hash_count; i++) {
bp = table -> buckets [i];
while (bp) {
next = bp -> next;
(*func) (bp -> name, bp -> len, bp -> value);
bp = next;
count++;
}
}
return count;
}
int casecmp (const void *v1, const void *v2, unsigned long len)
{
unsigned i;
const char *s = v1;
const char *t = v2;
for (i = 0; i < len; i++)
{
int c1, c2;
if (isupper ((unsigned char)s [i]))
c1 = tolower ((unsigned char)s [i]);
else
c1 = s [i];
if (isupper ((unsigned char)t [i]))
c2 = tolower ((unsigned char)t [i]);
else
c2 = t [i];
if (c1 < c2)
return -1;
if (c1 > c2)
return 1;
}
return 0;
}