includes/omapip/hash.h

   1 /* hash.h
   2
   3    Definitions for hashing... */
   4
   5 /*
   6  * Copyright (C) 2004-2022 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  *   PO Box 360
  23  *   Newmarket, NH 03857 USA
  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 */