1 /* hash.h 2 3 Definitions for hashing... */ 4 5 /* 6 * Copyright (c) 2004-2017 by Internet Systems Consortium, Inc. ("ISC") 7 * Copyright (c) 1995-2003 by Internet Software Consortium 8 * 9 * This Source Code Form is subject to the terms of the Mozilla Public 10 * License, v. 2.0. If a copy of the MPL was not distributed with this 11 * file, You can obtain one at http://mozilla.org/MPL/2.0/. 12 * 13 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES 14 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 15 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR 16 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 17 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 18 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 19 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 20 * 21 * Internet Systems Consortium, Inc. 22 * 950 Charter Street 23 * Redwood City, CA 94063 24 * <info@isc.org> 25 * https://www.isc.org/ 26 * 27 */ 28 29 #ifndef OMAPI_HASH_H 30 #define OMAPI_HASH_H 31 32 #if !defined (DEFAULT_HASH_SIZE) 33 # define DEFAULT_HASH_SIZE 9973 34 #endif 35 36 #if !defined (KEY_HASH_SIZE) 37 # define KEY_HASH_SIZE 1009 38 #endif 39 40 /* The purpose of the hashed_object_t struct is to not match anything else. */ 41 typedef struct { 42 int foo; 43 } hashed_object_t; 44 45 typedef isc_result_t (*hash_foreach_func)(const void *, unsigned, void *); 46 typedef int (*hash_reference) (hashed_object_t **, hashed_object_t *, 47 const char *, int); 48 typedef int (*hash_dereference) (hashed_object_t **, const char *, int); 49 50 struct hash_bucket { 51 struct hash_bucket *next; 52 const unsigned char *name; 53 unsigned len; 54 hashed_object_t *value; 55 }; 56 57 typedef int (*hash_comparator_t)(const void *, const void *, size_t); 58 59 struct hash_table { 60 unsigned hash_count; 61 hash_reference referencer; 62 hash_dereference dereferencer; 63 hash_comparator_t cmp; 64 unsigned (*do_hash)(const void *, unsigned, unsigned); 65 66 /* This must remain the last entry in this table. */ 67 struct hash_bucket *buckets [1]; 68 }; 69 70 struct named_hash { 71 struct named_hash *next; 72 const char *name; 73 struct hash_table *hash; 74 }; 75 76 #define HASH_FUNCTIONS_DECL(name, bufarg, type, hashtype) \ 77 void name##_hash_add (hashtype *, bufarg, unsigned, type *, \ 78 const char *, int); \ 79 void name##_hash_delete (hashtype *, bufarg, unsigned, \ 80 const char *, int); \ 81 int name##_hash_lookup (type **, hashtype *, bufarg, unsigned, \ 82 const char *, int); \ 83 unsigned char * name##_hash_report(hashtype *); \ 84 int name##_hash_foreach (hashtype *, hash_foreach_func); \ 85 int name##_new_hash (hashtype **, unsigned, const char *, int); \ 86 void name##_free_hash_table (hashtype **, const char *, int); 87 88 89 #define HASH_FUNCTIONS(name, bufarg, type, hashtype, ref, deref, hasher) \ 90 void name##_hash_add (hashtype *table, \ 91 bufarg buf, unsigned len, type *ptr, \ 92 const char *file, int line) \ 93 { \ 94 add_hash ((struct hash_table *)table, buf, \ 95 len, (hashed_object_t *)ptr, file, line); \ 96 } \ 97 \ 98 void name##_hash_delete (hashtype *table, bufarg buf, unsigned len, \ 99 const char *file, int line) \ 100 { \ 101 delete_hash_entry ((struct hash_table *)table, buf, len, \ 102 file, line); \ 103 } \ 104 \ 105 int name##_hash_lookup (type **ptr, hashtype *table, \ 106 bufarg buf, unsigned len, const char *file, int line) \ 107 { \ 108 return hash_lookup ((hashed_object_t **)ptr, \ 109 (struct hash_table *)table, \ 110 buf, len, file, line); \ 111 } \ 112 \ 113 unsigned char * name##_hash_report(hashtype *table) \ 114 { \ 115 return hash_report((struct hash_table *)table); \ 116 } \ 117 \ 118 int name##_hash_foreach (hashtype *table, hash_foreach_func func) \ 119 { \ 120 return hash_foreach ((struct hash_table *)table, \ 121 func); \ 122 } \ 123 \ 124 int name##_new_hash (hashtype **tp, unsigned c, const char *file, int line) \ 125 { \ 126 return new_hash ((struct hash_table **)tp, \ 127 (hash_reference)ref, (hash_dereference)deref, c, \ 128 hasher, file, line); \ 129 } \ 130 \ 131 void name##_free_hash_table (hashtype **table, const char *file, int line) \ 132 { \ 133 free_hash_table ((struct hash_table **)table, file, line); \ 134 } 135 136 void relinquish_hash_bucket_hunks (void); 137 int new_hash_table (struct hash_table **, unsigned, const char *, int); 138 void free_hash_table (struct hash_table **, const char *, int); 139 struct hash_bucket *new_hash_bucket (const char *, int); 140 void free_hash_bucket (struct hash_bucket *, const char *, int); 141 int new_hash(struct hash_table **, 142 hash_reference, hash_dereference, unsigned, 143 unsigned (*do_hash)(const void *, unsigned, unsigned), 144 const char *, int); 145 unsigned do_string_hash(const void *, unsigned, unsigned); 146 unsigned do_case_hash(const void *, unsigned, unsigned); 147 unsigned do_id_hash(const void *, unsigned, unsigned); 148 unsigned do_number_hash(const void *, unsigned, unsigned); 149 unsigned do_ip4_hash(const void *, unsigned, unsigned); 150 unsigned char *hash_report(struct hash_table *); 151 void add_hash (struct hash_table *, 152 const void *, unsigned, hashed_object_t *, 153 const char *, int); 154 void delete_hash_entry (struct hash_table *, const void *, 155 unsigned, const char *, int); 156 int hash_lookup (hashed_object_t **, struct hash_table *, 157 const void *, unsigned, const char *, int); 158 int hash_foreach (struct hash_table *, hash_foreach_func); 159 int casecmp (const void *s, const void *t, size_t len); 160 161 #endif /* OMAPI_HASH_H */ 162