hash.c 3.37 KB
Newer Older
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
/*
 * Copyright (C) 2008 Stig Venaas <venaas@uninett.no>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 */

#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include "list.h"
#include "hash.h"

/* allocates and initialises hash structure; returns NULL if malloc fails */
struct hash *hash_create() {
    struct hash *h = malloc(sizeof(struct hash));
    if (!h)
	return NULL;
    h->hashlist = list_create();
    if (!h->hashlist) {
	free(h);
	return NULL;
    }
    pthread_mutex_init(&h->mutex, NULL);
    return h;
}

/* frees all memory associated with the hash */
void hash_destroy(struct hash *h) {
    struct list_node *ln;
32

33 34 35
    if (!h)
	return;
    for (ln = list_first(h->hashlist); ln; ln = list_next(ln)) {
36 37
	free(((struct hash_entry *)ln->data)->key);
	free(((struct hash_entry *)ln->data)->data);
38 39 40 41 42 43 44
    }
    list_destroy(h->hashlist);
    pthread_mutex_destroy(&h->mutex);
}

/* insert entry in hash; returns 1 if ok, 0 if malloc fails */
int hash_insert(struct hash *h, void *key, uint32_t keylen, void *data) {
45
    struct hash_entry *e;
46 47 48

    if (!h)
	return 0;
49
    e = malloc(sizeof(struct hash_entry));
50 51
    if (!e)
	return 0;
52
    memset(e, 0, sizeof(struct hash_entry));
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
    e->key = malloc(keylen);
    if (!e->key) {
	free(e);
	return 0;
    }
    memcpy(e->key, key, keylen);
    e->keylen = keylen;
    e->data = data;
    pthread_mutex_lock(&h->mutex);
    if (!list_push(h->hashlist, e)) {
	pthread_mutex_unlock(&h->mutex);
	free(e->key);
	free(e);
	return 0;
    }
    pthread_mutex_unlock(&h->mutex);
    return 1;
}

/* reads entry from hash */
void *hash_read(struct hash *h, void *key, uint32_t keylen) {
    struct list_node *ln;
75
    struct hash_entry *e;
76

77 78 79 80
    if (!h)
	return 0;
    pthread_mutex_lock(&h->mutex);
    for (ln = list_first(h->hashlist); ln; ln = list_next(ln)) {
81
	e = (struct hash_entry *)ln->data;
82
	if (e->keylen == keylen && !memcmp(e->key, key, keylen)) {
83 84
	    pthread_mutex_unlock(&h->mutex);
	    return e->data;
85 86 87 88 89
	}
    }
    pthread_mutex_unlock(&h->mutex);
    return NULL;
}
90 91 92 93

/* extracts entry from hash */
void *hash_extract(struct hash *h, void *key, uint32_t keylen) {
    struct list_node *ln;
94
    struct hash_entry *e;
95
    void *data;
96

97 98 99 100
    if (!h)
	return 0;
    pthread_mutex_lock(&h->mutex);
    for (ln = list_first(h->hashlist); ln; ln = list_next(ln)) {
101
	e = (struct hash_entry *)ln->data;
102 103 104
	if (e->keylen == keylen && !memcmp(e->key, key, keylen)) {
	    free(e->key);
	    list_removedata(h->hashlist, e);
105
	    data = e->data;
106 107
	    free(e);
	    pthread_mutex_unlock(&h->mutex);
108
	    return data;
109 110 111 112 113
	}
    }
    pthread_mutex_unlock(&h->mutex);
    return NULL;
}
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134

/* returns first entry */
struct hash_entry *hash_first(struct hash *hash) {
    struct list_node *ln;
    struct hash_entry *e;
    if (!hash || !((ln = list_first(hash->hashlist))))
	return NULL;
    e = (struct hash_entry *)ln->data;
    e->next = ln->next;
    return e;
}

/* returns the next node after the argument */
struct hash_entry *hash_next(struct hash_entry *entry) {
    struct hash_entry *e;
    if (!entry || !entry->next)
	return NULL;
    e = (struct hash_entry *)entry->next->data;
    e->next = (struct list_node *)entry->next->next;
    return e;
}
135 136 137 138

/* Local Variables: */
/* c-file-style: "stroustrup" */
/* End: */