1 /************************************************************************
2 Copyright 1988, 1991 by Carnegie Mellon University
6 Permission to use, copy, modify, and distribute this software and its
7 documentation for any purpose and without fee is hereby granted, provided
8 that the above copyright notice appear in all copies and that both that
9 copyright notice and this permission notice appear in supporting
10 documentation, and that the name of Carnegie Mellon University not be used
11 in advertising or publicity pertaining to distribution of the software
12 without specific, written prior permission.
14 CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
15 SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
16 IN NO EVENT SHALL CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
17 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
18 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
19 ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
22 $FreeBSD: src/libexec/bootpd/hash.c,v 1.5 1999/08/28 00:09:18 peter Exp $
23 $DragonFly: src/libexec/bootpd/hash.c,v 1.2 2003/06/17 04:27:07 dillon Exp $
25 ************************************************************************/
28 * Generalized hash table ADT
30 * Provides multiple, dynamically-allocated, variable-sized hash tables on
31 * various data and keys.
33 * This package attempts to follow some of the coding conventions suggested
34 * by Bob Sidebotham and the AFS Clean Code Committee of the
35 * Information Technology Center at Carnegie Mellon.
39 #include <sys/types.h>
44 /* Yes, memcpy is OK here (no overlapped copies). */
45 #define bcopy(a,b,c) memcpy(b,a,c)
46 #define bzero(p,l) memset(p,0,l)
47 #define bcmp(a,b,c) memcmp(a,b,c)
59 * This can be changed to make internal routines visible to debuggers, etc.
62 #define PRIVATE static
71 PRIVATE void hashi_FreeMembers P((hash_member *, hash_freefp));
78 * Hash table initialization routine.
80 * This routine creates and intializes a hash table of size "tablesize"
81 * entries. Successful calls return a pointer to the hash table (which must
82 * be passed to other hash routines to identify the hash table). Failed
90 register hash_tbl *hashtblptr;
91 register unsigned totalsize;
94 totalsize = sizeof(hash_tbl)
95 + sizeof(hash_member *) * (tablesize - 1);
96 hashtblptr = (hash_tbl *) malloc(totalsize);
98 bzero((char *) hashtblptr, totalsize);
99 hashtblptr->size = tablesize; /* Success! */
100 hashtblptr->bucketnum = 0;
101 hashtblptr->member = (hashtblptr->table)[0];
104 hashtblptr = NULL; /* Disallow zero-length tables */
106 return hashtblptr; /* NULL if failure */
112 * Frees an entire linked list of bucket members (used in the open
113 * hashing scheme). Does nothing if the passed pointer is NULL.
117 hashi_FreeMembers(bucketptr, free_data)
118 hash_member *bucketptr;
119 hash_freefp free_data;
121 hash_member *nextbucket;
123 nextbucket = bucketptr->next;
124 (*free_data) (bucketptr->data);
125 free((char *) bucketptr);
126 bucketptr = nextbucket;
134 * This routine re-initializes the hash table. It frees all the allocated
135 * memory and resets all bucket pointers to NULL.
139 hash_Reset(hashtable, free_data)
141 hash_freefp free_data;
143 hash_member **bucketptr;
146 bucketptr = hashtable->table;
147 for (i = 0; i < hashtable->size; i++) {
148 hashi_FreeMembers(*bucketptr, free_data);
151 hashtable->bucketnum = 0;
152 hashtable->member = (hashtable->table)[0];
158 * Generic hash function to calculate a hash code from the given string.
160 * For each byte of the string, this function left-shifts the value in an
161 * accumulator and then adds the byte into the accumulator. The contents of
162 * the accumulator is returned after the entire string has been processed.
163 * It is assumed that this result will be used as the "hashcode" parameter in
164 * calls to other functions in this package. These functions automatically
165 * adjust the hashcode for the size of each hashtable.
167 * This algorithm probably works best when the hash table size is a prime
170 * Hopefully, this function is better than the previous one which returned
171 * the sum of the squares of all the bytes. I'm still open to other
172 * suggestions for a default hash function. The programmer is more than
173 * welcome to supply his/her own hash function as that is one of the design
174 * features of this package.
178 hash_HashFunction(string, len)
179 unsigned char *string;
180 register unsigned len;
182 register unsigned accum;
185 for (; len > 0; len--) {
187 accum += (unsigned) (*string++ & 0xFF);
195 * Returns TRUE if at least one entry for the given key exists; FALSE
200 hash_Exists(hashtable, hashcode, compare, key)
206 register hash_member *memberptr;
208 memberptr = (hashtable->table)[hashcode % (hashtable->size)];
210 if ((*compare) (key, memberptr->data)) {
211 return TRUE; /* Entry does exist */
213 memberptr = memberptr->next;
215 return FALSE; /* Entry does not exist */
221 * Insert the data item "element" into the hash table using "hashcode"
222 * to determine the bucket number, and "compare" and "key" to determine
225 * If the insertion is successful 0 is returned. If a matching entry
226 * already exists in the given bucket of the hash table, or some other error
227 * occurs, -1 is returned and the insertion is not done.
231 hash_Insert(hashtable, hashcode, compare, key, element)
235 hash_datum *key, *element;
239 hashcode %= hashtable->size;
240 if (hash_Exists(hashtable, hashcode, compare, key)) {
241 return -1; /* At least one entry already exists */
243 temp = (hash_member *) malloc(sizeof(hash_member));
245 return -1; /* malloc failed! */
247 temp->data = element;
248 temp->next = (hashtable->table)[hashcode];
249 (hashtable->table)[hashcode] = temp;
250 return 0; /* Success */
256 * Delete all data elements which match the given key. If at least one
257 * element is found and the deletion is successful, 0 is returned.
258 * If no matching elements can be found in the hash table, -1 is returned.
262 hash_Delete(hashtable, hashcode, compare, key, free_data)
267 hash_freefp free_data;
269 hash_member *memberptr, *tempptr;
270 hash_member *previous = NULL;
274 hashcode %= hashtable->size;
277 * Delete the first member of the list if it matches. Since this moves
278 * the second member into the first position we have to keep doing this
279 * over and over until it no longer matches.
281 memberptr = (hashtable->table)[hashcode];
282 while (memberptr && (*compare) (key, memberptr->data)) {
283 (hashtable->table)[hashcode] = memberptr->next;
285 * Stop hashi_FreeMembers() from deleting the whole list!
287 memberptr->next = NULL;
288 hashi_FreeMembers(memberptr, free_data);
289 memberptr = (hashtable->table)[hashcode];
294 * Now traverse the rest of the list
297 previous = memberptr;
298 memberptr = memberptr->next;
301 if ((*compare) (key, memberptr->data)) {
303 previous->next = memberptr = memberptr->next;
305 * Put the brakes on hashi_FreeMembers(). . . .
307 tempptr->next = NULL;
308 hashi_FreeMembers(tempptr, free_data);
311 previous = memberptr;
312 memberptr = memberptr->next;
321 * Locate and return the data entry associated with the given key.
323 * If the data entry is found, a pointer to it is returned. Otherwise,
328 hash_Lookup(hashtable, hashcode, compare, key)
334 hash_member *memberptr;
336 memberptr = (hashtable->table)[hashcode % (hashtable->size)];
338 if ((*compare) (key, memberptr->data)) {
339 return (memberptr->data);
341 memberptr = memberptr->next;
349 * Return the next available entry in the hashtable for a linear search
353 hash_NextEntry(hashtable)
356 register unsigned bucket;
357 register hash_member *memberptr;
360 * First try to pick up where we left off.
362 memberptr = hashtable->member;
364 hashtable->member = memberptr->next; /* Set up for next call */
365 return memberptr->data; /* Return the data */
368 * We hit the end of a chain, so look through the array of buckets
369 * until we find a new chain (non-empty bucket) or run out of buckets.
371 bucket = hashtable->bucketnum + 1;
372 while ((bucket < hashtable->size) &&
373 !(memberptr = (hashtable->table)[bucket])) {
378 * Check to see if we ran out of buckets.
380 if (bucket >= hashtable->size) {
382 * Reset to top of table for next call.
384 hashtable->bucketnum = 0;
385 hashtable->member = (hashtable->table)[0];
387 * But return end-of-table indication to the caller this time.
392 * Must have found a non-empty bucket.
394 hashtable->bucketnum = bucket;
395 hashtable->member = memberptr->next; /* Set up for next call */
396 return memberptr->data; /* Return the data */
402 * Return the first entry in a hash table for a linear search
406 hash_FirstEntry(hashtable)
409 hashtable->bucketnum = 0;
410 hashtable->member = (hashtable->table)[0];
411 return hash_NextEntry(hashtable);
418 * c-argdecl-indent: 4
419 * c-continued-statement-offset: 4
420 * c-continued-brace-offset: -4