summaryrefslogtreecommitdiff
path: root/lib/rsp_hash.c
diff options
context:
space:
mode:
authorLinus Nordberg <linus@nordu.net>2010-11-11 10:30:35 +0100
committerLinus Nordberg <linus@nordu.net>2010-11-11 10:30:35 +0100
commit83e82dba47aced4a93f9e431b4d8bca94c2f8517 (patch)
tree7ff1779ea924d557b6ded9bd21c0cc8a65f062dd /lib/rsp_hash.c
parentf9b25cad24ec4e3e89e818457beb29cbe08eed0c (diff)
Bringing up TLS connections working.
NOTE: Clean up of resources not yet sane. Expect resource leakages. NOTE: Most failure cases are not handled properly. With the wind at your back and the sun shining, it might work.
Diffstat (limited to 'lib/rsp_hash.c')
-rw-r--r--lib/rsp_hash.c136
1 files changed, 136 insertions, 0 deletions
diff --git a/lib/rsp_hash.c b/lib/rsp_hash.c
new file mode 100644
index 0000000..cc37e7f
--- /dev/null
+++ b/lib/rsp_hash.c
@@ -0,0 +1,136 @@
+/*
+ * 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 "rsp_list.h"
+#include "rsp_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;
+
+ if (!h)
+ return;
+ for (ln = list_first(h->hashlist); ln; ln = list_next(ln)) {
+ free(((struct hash_entry *)ln->data)->key);
+ free(((struct hash_entry *)ln->data)->data);
+ }
+ 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) {
+ struct hash_entry *e;
+
+ if (!h)
+ return 0;
+ e = malloc(sizeof(struct hash_entry));
+ if (!e)
+ return 0;
+ memset(e, 0, sizeof(struct hash_entry));
+ 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;
+ struct hash_entry *e;
+
+ if (!h)
+ return 0;
+ pthread_mutex_lock(&h->mutex);
+ for (ln = list_first(h->hashlist); ln; ln = list_next(ln)) {
+ e = (struct hash_entry *)ln->data;
+ if (e->keylen == keylen && !memcmp(e->key, key, keylen)) {
+ pthread_mutex_unlock(&h->mutex);
+ return e->data;
+ }
+ }
+ pthread_mutex_unlock(&h->mutex);
+ return NULL;
+}
+
+/* extracts entry from hash */
+void *hash_extract(struct hash *h, void *key, uint32_t keylen) {
+ struct list_node *ln;
+ struct hash_entry *e;
+
+ if (!h)
+ return 0;
+ pthread_mutex_lock(&h->mutex);
+ for (ln = list_first(h->hashlist); ln; ln = list_next(ln)) {
+ e = (struct hash_entry *)ln->data;
+ if (e->keylen == keylen && !memcmp(e->key, key, keylen)) {
+ free(e->key);
+ list_removedata(h->hashlist, e);
+ free(e);
+ pthread_mutex_unlock(&h->mutex);
+ return e->data;
+ }
+ }
+ pthread_mutex_unlock(&h->mutex);
+ return NULL;
+}
+
+/* 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;
+}
+
+/* Local Variables: */
+/* c-file-style: "stroustrup" */
+/* End: */