hash.c

Go to the documentation of this file.

/*
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
/** Resizable hash tables
 *
 * The weird "reverse" function is based on an idea from
 * "Split-Ordered Lists - Lock-free Resizable Hash Tables", with
 * modifications so that they're not lock-free. :(
 *
 * However, the split-order idea allows a fast & easy splitting of the
 * hash bucket chain when the hash table is resized.  Without it, we'd
 * have to check & update the pointers for every node in the buck chain,
 * rather than being able to move 1/2 of the entries in the chain with
 * one update.
 *
 * @file src/lib/util/hash.c
 *
 * @copyright 2005,2006 The FreeRADIUS server project
 */
RCSID("$Id: 6ceeaa4f74ea379d554b8766ffd61b568af676d3 $")
 
#include <freeradius-devel/util/hash.h>
 
/*
 *      A reasonable number of buckets to start off with.
 *      Should be a power of two.
 */
#define FR_HASH_NUM_BUCKETS (64)
 
struct fr_hash_entry_s {
        fr_hash_entry_t         *next;
        uint32_t                reversed;
        uint32_t                key;
        void                    *data;
};
 
struct fr_hash_table_s {
        uint32_t                num_elements;   //!< Number of elements in the hash table.
        uint32_t                num_buckets;    //!< Number of buckets (how long the array is) - power of 2 */
        uint32_t                next_grow;
        uint32_t                mask;
 
        fr_free_t               free;           //!< Data free function.
        fr_hash_t               hash;           //!< Hashing function.
        fr_cmp_t                cmp;            //!< Comparison function.
 
        char const              *type;          //!< Talloc type to check elements against.
 
        fr_hash_entry_t         null;
        fr_hash_entry_t         **buckets;      //!< Array of hash buckets.
};
 
#ifdef TESTING
static int grow = 0;
#endif
 
/*
 * perl -e 'foreach $i (0..255) {$r = 0; foreach $j (0 .. 7 ) { if (($i & ( 1<< $j)) != 0) { $r |= (1 << (7 - $j));}} print $r, ", ";if (($i & 7) == 7) {print "\n";}}'
 */
static const uint8_t reversed_byte[256] = {
        0,  128, 64, 192, 32, 160, 96,  224,
        16, 144, 80, 208, 48, 176, 112, 240,
        8,  136, 72, 200, 40, 168, 104, 232,
        24, 152, 88, 216, 56, 184, 120, 248,
        4,  132, 68, 196, 36, 164, 100, 228,
        20, 148, 84, 212, 52, 180, 116, 244,
        12, 140, 76, 204, 44, 172, 108, 236,
        28, 156, 92, 220, 60, 188, 124, 252,
        2,  130, 66, 194, 34, 162, 98,  226,
        18, 146, 82, 210, 50, 178, 114, 242,
        10, 138, 74, 202, 42, 170, 106, 234,
        26, 154, 90, 218, 58, 186, 122, 250,
        6,  134, 70, 198, 38, 166, 102, 230,
        22, 150, 86, 214, 54, 182, 118, 246,
        14, 142, 78, 206, 46, 174, 110, 238,
        30, 158, 94, 222, 62, 190, 126, 254,
        1,  129, 65, 193, 33, 161, 97,  225,
        17, 145, 81, 209, 49, 177, 113, 241,
        9,  137, 73, 201, 41, 169, 105, 233,
        25, 153, 89, 217, 57, 185, 121, 249,
        5,  133, 69, 197, 37, 165, 101, 229,
        21, 149, 85, 213, 53, 181, 117, 245,
        13, 141, 77, 205, 45, 173, 109, 237,
        29, 157, 93, 221, 61, 189, 125, 253,
        3,  131, 67, 195, 35, 163, 99,  227,
        19, 147, 83, 211, 51, 179, 115, 243,
        11, 139, 75, 203, 43, 171, 107, 235,
        27, 155, 91, 219, 59, 187, 123, 251,
        7,  135, 71, 199, 39, 167, 103, 231,
        23, 151, 87, 215, 55, 183, 119, 247,
        15, 143, 79, 207, 47, 175, 111, 239,
        31, 159, 95, 223, 63, 191, 127, 255
};
 
 
/*
 * perl -e 'foreach $i (0..255) {$r = 0;foreach $j (0 .. 7) { $r = $i & (1 << (7 - $j)); last if ($r)} print $i & ~($r), ", ";if (($i & 7) == 7) {print "\n";}}'
 */
static uint8_t parent_byte[256] = {
        0, 0, 0, 1, 0, 1, 2, 3,
        0, 1, 2, 3, 4, 5, 6, 7,
        0, 1, 2, 3, 4, 5, 6, 7,
        8, 9, 10, 11, 12, 13, 14, 15,
        0, 1, 2, 3, 4, 5, 6, 7,
        8, 9, 10, 11, 12, 13, 14, 15,
        16, 17, 18, 19, 20, 21, 22, 23,
        24, 25, 26, 27, 28, 29, 30, 31,
        0, 1, 2, 3, 4, 5, 6, 7,
        8, 9, 10, 11, 12, 13, 14, 15,
        16, 17, 18, 19, 20, 21, 22, 23,
        24, 25, 26, 27, 28, 29, 30, 31,
        32, 33, 34, 35, 36, 37, 38, 39,
        40, 41, 42, 43, 44, 45, 46, 47,
        48, 49, 50, 51, 52, 53, 54, 55,
        56, 57, 58, 59, 60, 61, 62, 63,
        0, 1, 2, 3, 4, 5, 6, 7,
        8, 9, 10, 11, 12, 13, 14, 15,
        16, 17, 18, 19, 20, 21, 22, 23,
        24, 25, 26, 27, 28, 29, 30, 31,
        32, 33, 34, 35, 36, 37, 38, 39,
        40, 41, 42, 43, 44, 45, 46, 47,
        48, 49, 50, 51, 52, 53, 54, 55,
        56, 57, 58, 59, 60, 61, 62, 63,
        64, 65, 66, 67, 68, 69, 70, 71,
        72, 73, 74, 75, 76, 77, 78, 79,
        80, 81, 82, 83, 84, 85, 86, 87,
        88, 89, 90, 91, 92, 93, 94, 95,
        96, 97, 98, 99, 100, 101, 102, 103,
        104, 105, 106, 107, 108, 109, 110, 111,
        112, 113, 114, 115, 116, 117, 118, 119,
        120, 121, 122, 123, 124, 125, 126, 127
};
 
 
/*
 *      Reverse a key.
 */
static uint32_t reverse(uint32_t key)
{
        /*
         *      Cast to uint32_t is required because the
         *      default type of of the expression is an
         *      int and ubsan correctly complains that
         *      the result of 0xff << 24 won't fit in a
         *      signed 32bit integer.
         */
        return (((uint32_t)reversed_byte[key & 0xff] << 24) |
                ((uint32_t)reversed_byte[(key >> 8) & 0xff] << 16) |
                ((uint32_t)reversed_byte[(key >> 16) & 0xff] << 8) |
                ((uint32_t)reversed_byte[(key >> 24) & 0xff]));
}
 
/*
 *      Take the parent by discarding the highest bit that is set.
 */
static uint32_t parent_of(uint32_t key)
{
        if (key > 0x00ffffff)
                return (key & 0x00ffffff) | (parent_byte[key >> 24] << 24);
 
        if (key > 0x0000ffff)
                return (key & 0x0000ffff) | (parent_byte[key >> 16] << 16);
 
        if (key > 0x000000ff)
                return (key & 0x000000ff) | (parent_byte[key >> 8] << 8);
 
        return parent_byte[key];
}
 
 
static fr_hash_entry_t *list_find(fr_hash_table_t *ht,
                                  fr_hash_entry_t *head, uint32_t reversed, void const *data)
{
        fr_hash_entry_t *cur;
 
        for (cur = head; cur != &ht->null; cur = cur->next) {
                if (cur->reversed == reversed) {
                        if (ht->cmp) {
                                int cmp = ht->cmp(data, cur->data);
                                if (cmp > 0) break;
                                if (cmp < 0) continue;
                        }
                        return cur;
                }
                if (cur->reversed > reversed) break;
        }
 
        return NULL;
}
 
 
/*
 *      Inserts a new entry into the list, in order.
 */
static bool list_insert(fr_hash_table_t *ht,
                        fr_hash_entry_t **head, fr_hash_entry_t *node)
{
        fr_hash_entry_t **last, *cur;
 
        last = head;
 
        for (cur = *head; cur != &ht->null; cur = cur->next) {
                if (cur->reversed > node->reversed) break;
                last = &(cur->next);
 
                if (cur->reversed == node->reversed) {
                        if (ht->cmp) {
                                int8_t cmp = ht->cmp(node->data, cur->data);
                                if (cmp > 0) break;
                                if (cmp < 0) continue;
                        }
                        return false;
                }
        }
 
        node->next = *last;
        *last = node;
 
        return true;
}
 
 
/*
 *      Delete an entry from the list.
 */
static void list_delete(fr_hash_table_t *ht,
                        fr_hash_entry_t **head, fr_hash_entry_t *node)
{
        fr_hash_entry_t **last, *cur;
 
        last = head;
 
        for (cur = *head; cur != &ht->null; cur = cur->next) {
                if (cur == node) break;
                last = &(cur->next);
        }
 
        *last = node->next;
}
 
static int _fr_hash_table_free(fr_hash_table_t *ht)
{
        uint32_t i;
        fr_hash_entry_t *node, *next;
 
        if (ht->free) {
                for (i = 0; i < ht->num_buckets; i++) {
                        if (ht->buckets[i]) for (node = ht->buckets[i];
                                                 node != &ht->null;
                                                 node = next) {
                                next = node->next;
                                if (!node->data) continue; /* dummy entry */
 
                                ht->free(node->data);
                        }
                }
        }
 
        return 0;
}
 
/*
 *      Create the table.
 *
 *      Memory usage in bytes is (20/3) * number of entries.
 */
fr_hash_table_t *_fr_hash_table_alloc(TALLOC_CTX *ctx,
                                      char const *type,
                                      fr_hash_t hash_func,
                                      fr_cmp_t cmp_func,
                                      fr_free_t free_func)
{
        fr_hash_table_t *ht;
 
        ht = talloc(ctx, fr_hash_table_t);
        if (!ht) return NULL;
        talloc_set_destructor(ht, _fr_hash_table_free);
 
        *ht = (fr_hash_table_t){
                .type = type,
                .free = free_func,
                .hash = hash_func,
                .cmp = cmp_func,
                .num_buckets = FR_HASH_NUM_BUCKETS,
                .mask = FR_HASH_NUM_BUCKETS - 1,
 
                /*
                 *      Have a default load factor of 2.5.  In practice this
                 *      means that the average load will hit 3 before the
                 *      table grows.
                 */
                .next_grow = (FR_HASH_NUM_BUCKETS << 1) + (FR_HASH_NUM_BUCKETS >> 1),
                .buckets = talloc_zero_array(ht, fr_hash_entry_t *, FR_HASH_NUM_BUCKETS)
        };
        if (unlikely(!ht->buckets)) {
                talloc_free(ht);
                return NULL;
        }
 
        ht->null.reversed = ~0;
        ht->null.key = ~0;
        ht->null.next = &ht->null;
        ht->buckets[0] = &ht->null;
 
        return ht;
}
 
 
/*
 *      If the current bucket is uninitialized, initialize it
 *      by recursively copying information from the parent.
 *
 *      We may have a situation where entry E is a parent to 2 other
 *      entries E' and E".  If we split E into E and E', then the
 *      nodes meant for E" end up in E or E', either of which is
 *      wrong.  To solve that problem, we walk down the whole chain,
 *      inserting the elements into the correct place.
 */
static void fr_hash_table_fixup(fr_hash_table_t *ht, uint32_t entry)
{
        uint32_t parent_entry;
        fr_hash_entry_t **last, *cur;
        uint32_t this;
 
        parent_entry = parent_of(entry);
 
        /* parent_entry == entry if and only if entry == 0 */
 
        if (!ht->buckets[parent_entry]) {
                fr_hash_table_fixup(ht, parent_entry);
        }
 
        /*
         *      Keep walking down cur, trying to find entries that
         *      don't belong here any more.  There may be multiple
         *      ones, so we can't have a naive algorithm...
         */
        last = &ht->buckets[parent_entry];
        this = parent_entry;
 
        for (cur = *last; cur != &ht->null; cur = cur->next) {
                uint32_t real_entry;
 
                real_entry = cur->key & ht->mask;
                if (real_entry != this) { /* ht->buckets[real_entry] == NULL */
                        *last = &ht->null;
                        ht->buckets[real_entry] = cur;
                        this = real_entry;
                }
 
                last = &(cur->next);
        }
 
        /*
         *      We may NOT have initialized this bucket, so do it now.
         */
        if (!ht->buckets[entry]) ht->buckets[entry] = &ht->null;
}
 
/*
 *      This should be a power of two.  Changing it to 4 doesn't seem
 *      to make any difference.
 */
#define GROW_FACTOR (2)
 
/*
 *      Grow the hash table.
 */
static void fr_hash_table_grow(fr_hash_table_t *ht)
{
        fr_hash_entry_t **buckets;
        size_t existing = talloc_get_size(ht->buckets);
 
        buckets = talloc_realloc(ht, ht->buckets, fr_hash_entry_t *, GROW_FACTOR * ht->num_buckets);
        if (!buckets) return;
 
        memset(((uint8_t *)buckets) + existing, 0, talloc_get_size(buckets) - existing);
 
        ht->buckets = buckets;
        ht->num_buckets *= GROW_FACTOR;
        ht->next_grow *= GROW_FACTOR;
        ht->mask = ht->num_buckets - 1;
#ifdef TESTING
        grow = 1;
        fprintf(stderr, "GROW TO %d\n", ht->num_buckets);
#endif
}
 
/*
 *      Internal find a node routine.
 */
static inline CC_HINT(always_inline) fr_hash_entry_t *hash_table_find(fr_hash_table_t *ht,
                                                                         uint32_t key, void const *data)
{
        uint32_t entry;
        uint32_t reversed;
 
        entry = key & ht->mask;
        reversed = reverse(key);
 
        if (!ht->buckets[entry]) fr_hash_table_fixup(ht, entry);
 
        return list_find(ht, ht->buckets[entry], reversed, data);
}
 
/** Find data in a hash table
 *
 * @param[in] ht        to find data in.
 * @param[in] data      to find.  Will be passed to the
 *                      hashing function.
 * @return
 *      - The user data we found.
 *      - NULL if we couldn't find any matching data.
 */
void *fr_hash_table_find(fr_hash_table_t *ht, void const *data)
{
        fr_hash_entry_t *node;
 
        node = hash_table_find(ht, ht->hash(data), data);
        if (!node) return NULL;
 
        return UNCONST(void *, node->data);
}
 
/** Hash table lookup with pre-computed key
 *
 * @param[in] ht        to find data in.
 * @param[in] key       the precomputed key.
 * @param[in] data      for list matching.
 * @return
 *      - The user data we found.
 *      - NULL if we couldn't find any matching data.
 */
void *fr_hash_table_find_by_key(fr_hash_table_t *ht, uint32_t key, void const *data)
{
        fr_hash_entry_t *node;
 
        node = hash_table_find(ht, key, data);
        if (!node) return NULL;
 
        return UNCONST(void *, node->data);
}
 
/** Insert data into a hash table
 *
 * @param[in] ht        to insert data into.
 * @param[in] data      to insert.  Will be passed to the
 *                      hashing function.
 * @return
 *      - true if data was inserted.
 *      - false if data already existed and was not inserted.
 */
bool fr_hash_table_insert(fr_hash_table_t *ht, void const *data)
{
        uint32_t                key;
        uint32_t                entry;
        uint32_t                reversed;
        fr_hash_entry_t         *node;
 
#ifndef TALLOC_GET_TYPE_ABORT_NOOP
        if (ht->type) (void)_talloc_get_type_abort(data, ht->type, __location__);
#endif
 
        key = ht->hash(data);
        entry = key & ht->mask;
        reversed = reverse(key);
 
        if (!ht->buckets[entry]) fr_hash_table_fixup(ht, entry);
 
        /*
         *      If we try to do our own memory allocation here, the
         *      speedup is only ~15% or so, which isn't worth it.
         */
        node = talloc_zero(ht, fr_hash_entry_t);
        if (unlikely(!node)) return false;
 
        node->next = &ht->null;
        node->reversed = reversed;
        node->key = key;
        node->data = UNCONST(void *, data);
 
        /* already in the table, can't insert it */
        if (!list_insert(ht, &ht->buckets[entry], node)) {
                talloc_free(node);
                return false;
        }
 
        /*
         *      Check the load factor, and grow the table if
         *      necessary.
         */
        ht->num_elements++;
        if (ht->num_elements >= ht->next_grow) fr_hash_table_grow(ht);
 
        return true;
}
 
/** Replace old data with new data, OR insert if there is no old
 *
 * @param[out] old      data that was replaced.  If this argument
 *                      is not NULL, then the old data will not
 *                      be freed, even if a free function is
 *                      configured.
 * @param[in] ht        to insert data into.
 * @param[in] data      to replace.  Will be passed to the
 *                      hashing function.
 * @return
 *      - 1 if data was replaced.
 *      - 0 if data was inserted.
 *      - -1 if we failed to replace data
 */
int fr_hash_table_replace(void **old, fr_hash_table_t *ht, void const *data)
{
        fr_hash_entry_t *node;
 
        node = hash_table_find(ht, ht->hash(data), data);
        if (!node) {
                if (old) *old = NULL;
                return fr_hash_table_insert(ht, data) ? 1 : -1;
        }
 
        if (old) {
                *old = node->data;
        } else if (ht->free) {
                ht->free(node->data);
        }
 
        node->data = UNCONST(void *, data);
 
        return 0;
}
 
/** Remove an entry from the hash table, without freeing the data
 *
 * @param[in] ht        to remove data from.
 * @param[in] data      to remove.  Will be passed to the
 *                      hashing function.
 * @return
 *      - The user data we removed.
 *      - NULL if we couldn't find any matching data.
 */
void *fr_hash_table_remove(fr_hash_table_t *ht, void const *data)
{
        uint32_t                key;
        uint32_t                entry;
        uint32_t                reversed;
        void                    *old;
        fr_hash_entry_t         *node;
 
        key = ht->hash(data);
        entry = key & ht->mask;
        reversed = reverse(key);
 
        if (!ht->buckets[entry]) fr_hash_table_fixup(ht, entry);
 
        node = list_find(ht, ht->buckets[entry], reversed, data);
        if (!node) return NULL;
 
        list_delete(ht, &ht->buckets[entry], node);
        ht->num_elements--;
 
        old = node->data;
        talloc_free(node);
 
        return old;
}
 
/** Remove and free data (if a free function was specified)
 *
 * @param[in] ht        to remove data from.
 * @param[in] data      to remove/free.
 * @return
 *      - true if we removed data.
 *      - false if we couldn't find any matching data.
 */
bool fr_hash_table_delete(fr_hash_table_t *ht, void const *data)
{
        void *old;
 
        old = fr_hash_table_remove(ht, data);
        if (!old) return false;
 
        if (ht->free) ht->free(old);
 
        return true;
}
 
/*
 *      Count number of elements
 */
uint32_t fr_hash_table_num_elements(fr_hash_table_t *ht)
{
        return ht->num_elements;
}
 
/** Iterate over entries in a hash table
 *
 * @note If the hash table is modified the iterator should be considered invalidated.
 *
 * @param[in] ht        to iterate over.
 * @param[in] iter      Pointer to an iterator struct, used to maintain
 *                      state between calls.
 * @return
 *      - User data.
 *      - NULL if at the end of the list.
 */
void *fr_hash_table_iter_next(fr_hash_table_t *ht, fr_hash_iter_t *iter)
{
        fr_hash_entry_t *node;
        uint32_t        i;
 
        /*
         *      Return the next element in the bucket
         */
        if (iter->node != &ht->null) {
                node = iter->node;
                iter->node = node->next;
 
                return node->data;
        }
 
        if (iter->bucket == 0) return NULL;
 
        /*
         *      We might have to go through multiple empty
         *      buckets to find one that contains something
         *      we should return
         */
        i = iter->bucket - 1;
        for (;;) {
                if (!ht->buckets[i]) fr_hash_table_fixup(ht, i);
 
                node = ht->buckets[i];
                if (node == &ht->null) {
                        if (i == 0) break;
                        i--;
                        continue;       /* This bucket was empty too... */
                }
 
                iter->node = node->next;                /* Store the next one to examine */
                iter->bucket = i;
                return node->data;
        }
        iter->bucket = i;
 
        return NULL;
}
 
/** Initialise an iterator
 *
 * @note If the hash table is modified the iterator should be considered invalidated.
 *
 * @param[in] ht        to iterate over.
 * @param[out] iter     to initialise.
 * @return
 *      - The first entry in the hash table.
 *      - NULL if the hash table is empty.
 */
void *fr_hash_table_iter_init(fr_hash_table_t *ht, fr_hash_iter_t *iter)
{
        iter->bucket = ht->num_buckets;
        iter->node = &ht->null;
 
        return fr_hash_table_iter_next(ht, iter);
}
 
/** Copy all entries out of a hash table into an array
 *
 * @param[in] ctx       to allocate array in.
 * @param[in] out       array of hash table entries.
 * @param[in] ht        to flatter.
 * @return
 *      - 0 on success.
 *      - -1 on failure.
 */
int fr_hash_table_flatten(TALLOC_CTX *ctx, void **out[], fr_hash_table_t *ht)
{
        uint64_t        num = fr_hash_table_num_elements(ht), i;
        fr_hash_iter_t  iter;
        void            *item, **list;
 
        if (unlikely(!(list = talloc_array(ctx, void *, num)))) return -1;
 
        for (item = fr_hash_table_iter_init(ht, &iter), i = 0;
             item;
             item = fr_hash_table_iter_next(ht, &iter), i++) list[i] = item;
 
        *out = list;
 
        return 0;
}
 
/** Ensure all buckets are filled
 *
 * This must be called if the table will be read by multiple threads without
 * synchronisation.  Synchronisation is still required for updates.
 *
 * @param[in] ht        to fill.
 */
void fr_hash_table_fill(fr_hash_table_t *ht)
{
        int i;
 
        for (i = ht->num_buckets - 1; i >= 0; i--) if (!ht->buckets[i]) fr_hash_table_fixup(ht, i);
}
 
#ifdef TESTING
/*
 *      Show what the hash table is doing.
 */
int fr_hash_table_info(fr_hash_table_t *ht)
{
        int i, a, collisions, uninitialized;
        int array[256];
 
        if (!ht) return 0;
 
        uninitialized = collisions = 0;
        memset(array, 0, sizeof(array));
 
        for (i = 0; i < ht->num_buckets; i++) {
                uint32_t key;
                int load;
                fr_hash_entry_t *node, *next;
 
                /*
                 *      If we haven't inserted or looked up an entry
                 *      in a bucket, it's uninitialized.
                 */
                if (!ht->buckets[i]) {
                        uninitialized++;
                        continue;
                }
 
                load = 0;
                key = ~0;
                for (node = ht->buckets[i]; node != &ht->null; node = next) {
                        if (node->reversed == key) {
                                collisions++;
                        } else {
                                key = node->reversed;
                        }
                        next = node->next;
                        load++;
                }
 
                if (load > 255) load = 255;
                array[load]++;
        }
 
        printf("HASH TABLE %p\tbuckets: %d\t(%d uninitialized)\n", ht,
                ht->num_buckets, uninitialized);
        printf("\tnum entries %d\thash collisions %d\n",
                ht->num_elements, collisions);
 
        a = 0;
        for (i = 1; i < 256; i++) {
                if (!array[i]) continue;
                printf("%d\t%d\n", i, array[i]);
 
                /*
                 *      Since the entries are ordered, the lookup cost
                 *      for any one element in a chain is (on average)
                 *      the cost of walking half of the chain.
                 */
                if (i > 1) {
                        a += array[i] * i;
                }
        }
        a /= 2;
        a += array[1];
 
        printf("\texpected lookup cost = %d/%d or %f\n\n",
               ht->num_elements, a,
               (float) ht->num_elements / (float) a);
 
        return 0;
}
#endif
 
 
#define FNV_MAGIC_INIT (0x811c9dc5)
#define FNV_MAGIC_PRIME (0x01000193)
 
/*
 *      A fast hash function.  For details, see:
 *
 *      http://www.isthe.com/chongo/tech/comp/fnv/
 *
 *      Which also includes public domain source.  We've re-written
 *      it here for our purposes.
 */
uint32_t fr_hash(void const *data, size_t size)
{
        uint8_t const *p = data;
        uint8_t const *q = p + size;
        uint32_t      hash = FNV_MAGIC_INIT;
 
        /*
         *      FNV-1 hash each octet in the buffer
         */
        while (p != q) {
                /*
                 *      XOR the 8-bit quantity into the bottom of
                 *      the hash.
                 */
                hash ^= (uint32_t) (*p++);
 
                /*
                 *      Multiple by 32-bit magic FNV prime, mod 2^32
                 */
                hash *= FNV_MAGIC_PRIME;
#if 0
                /*
                 *      Potential optimization.
                 */
                hash += (hash<<1) + (hash<<4) + (hash<<7) + (hash<<8) + (hash<<24);
#endif
    }
 
    return hash;
}
 
/*
 *      Continue hashing data.
 */
uint32_t fr_hash_update(void const *data, size_t size, uint32_t hash)
{
        uint8_t const *p = data;
        uint8_t const *q;
 
        if (size == 0) return hash;     /* Avoid ubsan issues with access NULL pointer */
 
        q = p + size;
        while (p < q) {
                hash *= FNV_MAGIC_PRIME;
                hash ^= (uint32_t) (*p++);
        }
 
        return hash;
}
 
/*
 *      Hash a C string, so we loop over it once.
 */
uint32_t fr_hash_string(char const *p)
{
        uint32_t      hash = FNV_MAGIC_INIT;
 
        while (*p) {
                hash *= FNV_MAGIC_PRIME;
                hash ^= (uint32_t) (*p++);
        }
 
        return hash;
}
 
/** Hash a C string, converting all chars to lowercase
 *
 */
uint32_t fr_hash_case_string(char const *p)
{
        uint32_t      hash = FNV_MAGIC_INIT;
 
        while (*p) {
                hash *= FNV_MAGIC_PRIME;
                hash ^= (uint32_t) (tolower((uint8_t) *p++));
        }
 
        return hash;
}
 
/** Check hash table is sane
 *
 */
void fr_hash_table_verify(fr_hash_table_t *ht)
{
        fr_hash_iter_t  iter;
        void            *ptr;
 
        (void)talloc_get_type_abort(ht, fr_hash_table_t);
        (void)talloc_get_type_abort(ht->buckets, fr_hash_entry_t *);
 
        fr_assert(talloc_array_length(ht->buckets) == ht->num_buckets);
 
        /*
         *      Check talloc headers on all data
         */
        if (ht->type) {
                for (ptr = fr_hash_table_iter_init(ht, &iter);
                     ptr;
                     ptr = fr_hash_table_iter_next(ht, &iter)) {
                        (void)_talloc_get_type_abort(ptr, ht->type, __location__);
                }
        }
}
 
#ifdef TESTING
/*
 *  cc -g -DTESTING -I ../include hash.c -o hash
 *
 *  ./hash
 */
static uint32_t hash_int(void const *data)
{
        return fr_hash((int *) data, sizeof(int));
}
 
#define MAX 1024*1024
int main(int argc, char **argv)
{
        int i, *p, *q, k;
        fr_hash_table_t *ht;
        int *array;
 
        ht = fr_hash_table_alloc(NULL, hash_int, NULL, NULL);
        if (!ht) {
                fprintf(stderr, "Hash create failed\n");
                fr_exit(1);
        }
 
        array = talloc_zero_array(NULL, int, MAX);
        if (!array) fr_exit(1);
 
        for (i = 0; i < MAX; i++) {
                p = array + i;
                *p = i;
 
                if (!fr_hash_table_insert(ht, p)) {
                        fprintf(stderr, "Failed insert %08x\n", i);
                        fr_exit(1);
                }
#ifdef TEST_INSERT
                q = fr_hash_table_find(ht, p);
                if (q != p) {
                        fprintf(stderr, "Bad data %d\n", i);
                        fr_exit(1);
                }
#endif
        }
 
        fr_hash_table_info(ht);
 
        /*
         *      Build this to see how lookups result in shortening
         *      of the hash chains.
         */
        if (1) {
                for (i = 0; i < MAX ; i++) {
                        q = fr_hash_table_find(ht, &i);
                        if (!q || *q != i) {
                                fprintf(stderr, "Failed finding %d\n", i);
                                fr_exit(1);
                        }
 
#if 0
                        if (!fr_hash_table_delete(ht, &i)) {
                                fprintf(stderr, "Failed deleting %d\n", i);
                                fr_exit(1);
                        }
                        q = fr_hash_table_find(ht, &i);
                        if (q) {
                                fprintf(stderr, "Failed to delete %08x\n", i);
                                fr_exit(1);
                        }
#endif
                }
 
                fr_hash_table_info(ht);
        }
 
        fr_hash_table_free(ht);
        talloc_free(array);
 
        return EXIT_SUCCESS;
}
#endif