link_audit/common/hash.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <synch.h>
#include <memory.h>
#include "hash.h"

static int    hash_string(const char *, long);

hash *
make_hash(size_t size)
{
    hash    *ptr;

    ptr = malloc(sizeof (*ptr));
    ptr->size = size;
    ptr->table = malloc((size_t)(sizeof (hash_entry *) * size));
    (void) memset((char *)ptr->table, 0, sizeof (hash_entry *) * size);
    ptr->start = NULL;
    ptr->hash_type = String_Key;
    return (ptr);
}

hash *
make_ihash(size_t size)
{
    hash    *ptr;

    ptr = malloc(sizeof (*ptr));
    ptr->size = size;
    ptr->table = malloc(sizeof (hash_entry *) * size);
    (void) memset((char *)ptr->table, 0, sizeof (hash_entry *) * size);
    ptr->start = NULL;
    ptr->hash_type = Integer_Key;
    return (ptr);
}

char **
get_hash(hash *tbl, char *key)
{
    long        bucket;
    hash_entry  *tmp, *new;

    if (tbl->hash_type == String_Key) {
        tmp = tbl->table[bucket = hash_string(key, tbl->size)];
    } else {
        tmp = tbl->table[bucket = labs((long)key) % tbl->size];
    }

    if (tbl->hash_type == String_Key) {
        while (tmp != NULL) {
            if (strcmp(tmp->key, key) == 0) {
                return (&tmp->data);
            }
            tmp = tmp->next_entry;
        }
    } else {
        while (tmp != NULL) {
            if (tmp->key == key) {
                return (&tmp->data);
            }
            tmp = tmp->next_entry;
        }
    }

    /*
     * not found....
     * insert new entry into bucket...
     */
    new = malloc(sizeof (*new));
    new->key = ((tbl->hash_type == String_Key)?strdup(key):key);

    /*
     * hook into chain from tbl...
     */
    new->right_entry = NULL;
    new->left_entry = tbl->start;
    tbl->start = new;

    /*
     * hook into bucket chain
     */
    new->next_entry = tbl->table[bucket];
    tbl->table[bucket] = new;
    new->data = NULL;       /* so we know that it is new */
    return (&new->data);
}

char **
find_hash(hash *tbl, const char *key)
{
    hash_entry  *tmp;

    if (tbl->hash_type == String_Key) {
        tmp = tbl->table[hash_string(key, tbl->size)];
        for (; tmp != NULL; tmp = tmp->next_entry) {
            if (strcmp(tmp->key, key) == 0) {
                return (&tmp->data);
            }
        }
    } else {
        tmp = tbl->table[labs((long)key) % tbl->size];
        for (; tmp != NULL; tmp = tmp->next_entry) {
            if (tmp->key == key) {
                return (&tmp->data);
            }
        }
    }
    return (NULL);
}

char *
del_hash(hash *tbl, const char *key)
{
    ulong_t bucket;
    hash_entry * tmp, * prev = NULL;

    if (tbl->hash_type == String_Key) {
        bucket = hash_string(key, tbl->size);
    } else {
        bucket = labs((long)key) % tbl->size;
    }

    if ((tmp = tbl->table[bucket]) == NULL) {
        return (NULL);
    } else {
        if (tbl->hash_type == String_Key) {
            while (tmp != NULL) {
                if (strcmp(tmp->key, key) == 0) {
                    break;  /* found item to delete ! */
                }
                prev = tmp;
                tmp  = tmp->next_entry;
            }
        } else {
            while (tmp != NULL) {
                if (tmp->key == key) {
                    break;
                }
                prev = tmp;
                tmp  = tmp->next_entry;
            }
        }
        if (tmp == NULL) {
            return (NULL); /* not found */
        }
    }

    /*
     * tmp now points to entry marked for deletion, prev to
     * item preceding in bucket chain or NULL if tmp is first.
     * remove from bucket chain first....
     */
    if (tbl->hash_type == String_Key) {
        free(tmp->key);
    }
    if (prev != NULL) {
        prev->next_entry = tmp->next_entry;
    } else {
        tbl->table[bucket] = tmp->next_entry;
    }

    /*
     * now remove from tbl chain....
     */
    if (tmp->right_entry != NULL) { /* not first in chain.... */
        tmp->right_entry->left_entry = (tmp->left_entry ?
            tmp->left_entry->right_entry: NULL);
    } else {
        tbl->start = (tmp->left_entry ?tmp->left_entry->right_entry:
            NULL);
    }
    return (tmp->data);
}

size_t
operate_hash(hash *tbl, void (*ptr)(), const char *usr_arg)
{
    hash_entry  *tmp = tbl->start;
    size_t      c = 0;

    while (tmp) {
        (*ptr)(tmp->data, usr_arg, tmp->key);
        tmp = tmp->left_entry;
        c++;
    }
    return (c);
}

size_t
operate_hash_addr(hash *tbl, void (*ptr)(), const char *usr_arg)
{
    hash_entry  *tmp = tbl->start;
    size_t      c = 0;

    while (tmp) {
        (*ptr)(&(tmp->data), usr_arg, tmp->key);
        tmp = tmp->left_entry;
        c++;
    }
    return (c);
}

void
destroy_hash(hash *tbl, int (*ptr)(), const char *usr_arg)
{
    hash_entry * tmp = tbl->start, * prev;

    while (tmp) {
        if (ptr) {
            (void) (*ptr)(tmp->data, usr_arg, tmp->key);
        }

        if (tbl->hash_type == String_Key) {
            free(tmp->key);
        }
        prev = tmp;
        tmp = tmp->left_entry;
        free((char *)prev);
    }
    free((char *)tbl->table);
    free(tbl);
}

static int
hash_string(const char *s, long modulo)
{
    unsigned int    result = 0;
    int     i = 1;

    while (*s != NULL) {
        result += (*s++ << i++);
    }

    /* LINTED */
    return ((int)(result % modulo));
}