replace leftover users of hashmap with htab

also fixes a bug where the ErrorFile directive would create a
new hashmap on every added item, effectively allowing only
the use of the last specified errornumber, and producing memory
leaks on each config reload.

12 files changed, 89 insertions, 687 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index c3b8dca..fd8a499 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -32,7 +32,6 @@ tinyproxy_SOURCES = \
 	conf.c conf.h \
 	conns.c conns.h \
 	daemon.c daemon.h \
-	hashmap.c hashmap.h \
 	heap.c heap.h \
 	html-error.c html-error.h \
 	http-message.c http-message.h \
diff --git a/src/anonymous.c b/src/anonymous.c
index f38fd44..91e490c 100644
--- a/src/anonymous.c
+++ b/src/anonymous.c
@@ -23,7 +23,7 @@
 #include "main.h"
 
 #include "anonymous.h"
-#include "hashmap.h"
+#include "hsearch.h"
 #include "heap.h"
 #include "log.h"
 #include "conf.h"
@@ -42,7 +42,7 @@ int anonymous_search (struct config_s *conf, const char *s)
         assert (s != NULL);
         assert (conf->anonymous_map != NULL);
 
-        return hashmap_search (conf->anonymous_map, s);
+        return !!htab_find (conf->anonymous_map, s);
 }
 
 /*
@@ -51,23 +51,21 @@ int anonymous_search (struct config_s *conf, const char *s)
  * Return -1 if there is an error, otherwise a 0 is returned if the insert was
  * successful.
  */
-int anonymous_insert (struct config_s *conf, const char *s)
+int anonymous_insert (struct config_s *conf, char *s)
 {
-        char data = 1;
-
         assert (s != NULL);
 
         if (!conf->anonymous_map) {
-                conf->anonymous_map = hashmap_create (32);
+                conf->anonymous_map = htab_create (32);
                 if (!conf->anonymous_map)
                         return -1;
         }
 
-        if (hashmap_search (conf->anonymous_map, s) > 0) {
-                /* The key was already found, so return a positive number. */
+        if (htab_find (conf->anonymous_map, s)) {
+                /* The key was already found. */
                 return 0;
         }
 
         /* Insert the new key */
-        return hashmap_insert (conf->anonymous_map, s, &data, sizeof (data));
+        return htab_insert (conf->anonymous_map, s, HTV_N(1)) ? 0 : -1;
 }
diff --git a/src/anonymous.h b/src/anonymous.h
index 6fc4518..78ce771 100644
--- a/src/anonymous.h
+++ b/src/anonymous.h
@@ -23,6 +23,6 @@
 
 extern short int is_anonymous_enabled (struct config_s *conf);
 extern int anonymous_search (struct config_s *conf, const char *s);
-extern int anonymous_insert (struct config_s *conf, const char *s);
+extern int anonymous_insert (struct config_s *conf, char *s);
 
 #endif
diff --git a/src/conf.c b/src/conf.c
index f0db500..20d60d6 100644
--- a/src/conf.c
+++ b/src/conf.c
@@ -288,6 +288,9 @@ free_added_headers (vector_t add_headers)
 
 void free_config (struct config_s *conf)
 {
+        char *k;
+        htab_value *v;
+        size_t it;
         safefree (conf->logf_name);
         safefree (conf->stathost);
         safefree (conf->user);
@@ -307,13 +310,25 @@ void free_config (struct config_s *conf)
         safefree (conf->pidpath);
         safefree (conf->bind_address);
         safefree (conf->via_proxy_name);
-        hashmap_delete (conf->errorpages);
+        if (conf->errorpages) {
+                it = 0;
+                while((it = htab_next(conf->errorpages, it, &k, &v))) {
+                        safefree(k);
+                        safefree(v->p);
+                }
+                htab_destroy (conf->errorpages);
+        }
         free_added_headers (conf->add_headers);
         safefree (conf->errorpage_undef);
         safefree (conf->statpage);
         flush_access_list (conf->access_list);
         free_connect_ports_list (conf->connect_ports);
-        hashmap_delete (conf->anonymous_map);
+        if (conf->anonymous_map) {
+                it = 0;
+                while((it = htab_next(conf->anonymous_map, it, &k, &v)))
+                       safefree(k);
+                htab_destroy (conf->anonymous_map);
+        }
 
         memset (conf, 0, sizeof(*conf));
 }
@@ -623,8 +638,14 @@ static HANDLE_FUNC (handle_anonymous)
         if (!arg)
                 return -1;
 
-        anonymous_insert (conf, arg);
-        safefree (arg);
+        if(anonymous_insert (conf, arg) < 0) {
+                log_message (LOG_WARNING,
+                             "anonymous_insert() failed: '%s'",
+                             arg);
+                safefree(arg);
+                return -1;
+        }
+
         return 0;
 }
 
@@ -814,8 +835,12 @@ static HANDLE_FUNC (handle_errorfile)
         unsigned long int err = get_long_arg (line, &match[2]);
         char *page = get_string_arg (line, &match[4]);
 
-        add_new_errorpage (conf, page, err);
-        safefree (page);
+        if(add_new_errorpage (conf, page, err) < 0) {
+                log_message (LOG_WARNING,
+                             "add_new_errorpage() failed: '%s'",
+                             page);
+                safefree (page);
+        }
         return 0;
 }
 
diff --git a/src/conf.h b/src/conf.h
index 8433381..128d0d2 100644
--- a/src/conf.h
+++ b/src/conf.h
@@ -22,7 +22,7 @@
 #ifndef TINYPROXY_CONF_H
 #define TINYPROXY_CONF_H
 
-#include "hashmap.h"
+#include "hsearch.h"
 #include "vector.h"
 #include "acl.h"
 
@@ -81,7 +81,7 @@ struct config_s {
         /*
          * Error page support.  Map error numbers to file paths.
          */
-        hashmap_t errorpages;
+        struct htab *errorpages;
 
         /*
          * Error page to be displayed if appropriate page cannot be located
@@ -105,7 +105,7 @@ struct config_s {
          * Map of headers which should be let through when the
          * anonymous feature is turned on.
          */
-        hashmap_t anonymous_map;
+        struct htab *anonymous_map;
 
         /*
          * Extra headers to be added to outgoing HTTP requests.
diff --git a/src/conns.c b/src/conns.c
index 505b5c4..c6c267f 100644
--- a/src/conns.c
+++ b/src/conns.c
@@ -122,8 +122,16 @@ void destroy_conn (struct conn_s *connptr)
         if (connptr->request_line)
                 safefree (connptr->request_line);
 
-        if (connptr->error_variables)
-                hashmap_delete (connptr->error_variables);
+        if (connptr->error_variables) {
+                char *k;
+                htab_value *v;
+                size_t it = 0;
+                while((it = htab_next(connptr->error_variables, it, &k, &v))) {
+                        safefree(v->p);
+                        safefree(k);
+                }
+                htab_destroy (connptr->error_variables);
+        }
 
         if (connptr->error_string)
                 safefree (connptr->error_string);
diff --git a/src/conns.h b/src/conns.h
index 393e5d4..dc1670d 100644
--- a/src/conns.h
+++ b/src/conns.h
@@ -22,7 +22,7 @@
 #define TINYPROXY_CONNS_H
 
 #include "main.h"
-#include "hashmap.h"
+#include "hsearch.h"
 
 /*
  * Connection Definition
@@ -45,7 +45,7 @@ struct conn_s {
          * This structure stores key -> value mappings for substitution
          * in the error HTML files.
          */
-        hashmap_t error_variables;
+        struct htab *error_variables;
 
         int error_number;
         char *error_string;
diff --git a/src/hashmap.c b/src/hashmap.c
deleted file mode 100644
index 7793d08..0000000
--- a/src/hashmap.c
+++ /dev/null
@@ -1,516 +0,0 @@
-/* tinyproxy - A fast light-weight HTTP proxy
- * Copyright (C) 2002 Robert James Kaes <rjkaes@users.sourceforge.net>
- *
- * 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-/* A hashmap implementation.  The keys are case-insensitive NULL terminated
- * strings, and the data is arbitrary lumps of data.  Copies of both the
- * key and the data in the hashmap itself, so you must free the original
- * key and data to avoid a memory leak.  The hashmap returns a pointer
- * to the data when a key is searched for, so take care in modifying the
- * data as it's modifying the data stored in the hashmap.  (In other words,
- * don't try to free the data, or realloc the memory. :)
- */
-
-#include "main.h"
-
-#include "hashmap.h"
-#include "heap.h"
-
-/*
- * These structures are the storage for the hashmap.  Entries are stored in
- * struct hashentry_s (the key, data, and length), and all the "buckets" are
- * grouped together in hashmap_s.  The hashmap_s.size member is for
- * internal use.  It stores the number of buckets the hashmap was created
- * with.
- */
-struct hashentry_s {
-        char *key;
-        void *data;
-        size_t len;
-
-        struct hashentry_s *prev, *next;
-};
-
-struct hashbucket_s {
-        struct hashentry_s *head, *tail;
-};
-
-struct hashmap_s {
-        uint32_t seed;
-        unsigned int size;
-        hashmap_iter end_iterator;
-
-        struct hashbucket_s *buckets;
-};
-
-/*
- * A NULL terminated string is passed to this function and a "hash" value
- * is produced within the range of [0 .. size)  (In other words, 0 to one
- * less than size.)
- * The contents of the key are converted to lowercase, so this function
- * is not case-sensitive.
- *
- * This is Dan Bernstein's hash function as described, for example, here:
- * http://www.cse.yorku.ca/~oz/hash.html
- *
- * If any of the arguments are invalid a negative number is returned.
- */
-static int hashfunc (const char *key, unsigned int size, uint32_t seed)
-{
-        uint32_t hash;
-
-        if (key == NULL)
-                return -EINVAL;
-        if (size == 0)
-                return -ERANGE;
-
-        for (hash = seed; *key != '\0'; key++) {
-                hash = ((hash << 5) + hash) ^ tolower (*key);
-        }
-
-        /* Keep the hash within the table limits */
-        return hash % size;
-}
-
-/*
- * Create a hashmap with the requested number of buckets.  If "nbuckets" is
- * not greater than zero a NULL is returned; otherwise, a _token_ to the
- * hashmap is returned.
- *
- * NULLs are also returned if memory could not be allocated for hashmap.
- */
-hashmap_t hashmap_create (unsigned int nbuckets)
-{
-        struct hashmap_s *ptr;
-
-        if (nbuckets == 0)
-                return NULL;
-
-        ptr = (struct hashmap_s *) safecalloc (1, sizeof (struct hashmap_s));
-        if (!ptr)
-                return NULL;
-
-        ptr->seed = (uint32_t)rand();
-        ptr->size = nbuckets;
-        ptr->buckets = (struct hashbucket_s *) safecalloc (nbuckets,
-                                                           sizeof (struct
-                                                                   hashbucket_s));
-        if (!ptr->buckets) {
-                safefree (ptr);
-                return NULL;
-        }
-
-        /* This points to "one" past the end of the hashmap. */
-        ptr->end_iterator = 0;
-
-        return ptr;
-}
-
-/*
- * Follow the chain of hashentries and delete them (including the data and
- * the key.)
- *
- * Returns: 0 if the function completed successfully
- *          negative number is returned if "entry" was NULL
- */
-static int delete_hashbucket (struct hashbucket_s *bucket)
-{
-        struct hashentry_s *nextptr;
-        struct hashentry_s *ptr;
-
-        if (bucket == NULL || bucket->head == NULL)
-                return -EINVAL;
-
-        ptr = bucket->head;
-        while (ptr) {
-                nextptr = ptr->next;
-
-                safefree (ptr->key);
-                safefree (ptr->data);
-                safefree (ptr);
-
-                ptr = nextptr;
-        }
-
-        return 0;
-}
-
-/*
- * Deletes a hashmap.  All the key/data pairs are also deleted.
- *
- * Returns: 0 on success
- *          negative if a NULL "map" was supplied
- */
-int hashmap_delete (hashmap_t map)
-{
-        unsigned int i;
-
-        if (map == NULL)
-                return -EINVAL;
-
-        for (i = 0; i != map->size; i++) {
-                if (map->buckets[i].head != NULL) {
-                        delete_hashbucket (&map->buckets[i]);
-                }
-        }
-
-        safefree (map->buckets);
-        safefree (map);
-
-        return 0;
-}
-
-/*
- * Inserts a NULL terminated string (as the key), plus any arbitrary "data"
- * of "len" bytes.  Both the key and the data are copied, so the original
- * key/data must be freed to avoid a memory leak.
- * The "data" must be non-NULL and "len" must be greater than zero.  You
- * cannot insert NULL data in association with the key.
- *
- * Returns: 0 on success
- *          negative number if there are errors
- */
-int
-hashmap_insert (hashmap_t map, const char *key, const void *data, size_t len)
-{
-        struct hashentry_s *ptr;
-        int hash;
-        char *key_copy;
-        void *data_copy;
-
-        assert (map != NULL);
-        assert (key != NULL);
-        assert (data != NULL);
-        assert (len > 0);
-
-        if (map == NULL || key == NULL)
-                return -EINVAL;
-        if (!data || len < 1)
-                return -ERANGE;
-
-        hash = hashfunc (key, map->size, map->seed);
-        if (hash < 0)
-                return hash;
-
-        /*
-         * First make copies of the key and data in case there is a memory
-         * problem later.
-         */
-        key_copy = safestrdup (key);
-        if (!key_copy)
-                return -ENOMEM;
-
-        data_copy = safemalloc (len);
-        if (!data_copy) {
-                safefree (key_copy);
-                return -ENOMEM;
-        }
-        memcpy (data_copy, data, len);
-
-        ptr = (struct hashentry_s *) safemalloc (sizeof (struct hashentry_s));
-        if (!ptr) {
-                safefree (key_copy);
-                safefree (data_copy);
-                return -ENOMEM;
-        }
-
-        ptr->key = key_copy;
-        ptr->data = data_copy;
-        ptr->len = len;
-
-        /*
-         * Now add the entry to the end of the bucket chain.
-         */
-        ptr->next = NULL;
-        ptr->prev = map->buckets[hash].tail;
-        if (map->buckets[hash].tail)
-                map->buckets[hash].tail->next = ptr;
-
-        map->buckets[hash].tail = ptr;
-        if (!map->buckets[hash].head)
-                map->buckets[hash].head = ptr;
-
-        map->end_iterator++;
-        return 0;
-}
-
-/*
- * Get an iterator to the first entry.
- *
- * Returns: an negative value upon error.
- */
-hashmap_iter hashmap_first (hashmap_t map)
-{
-        assert (map != NULL);
-
-        if (!map)
-                return -EINVAL;
-
-        if (map->end_iterator == 0)
-                return -1;
-        else
-                return 0;
-}
-
-/*
- * Checks to see if the iterator is pointing at the "end" of the entries.
- *
- * Returns: 1 if it is the end
- *          0 otherwise
- */
-int hashmap_is_end (hashmap_t map, hashmap_iter iter)
-{
-        assert (map != NULL);
-        assert (iter >= 0);
-
-        if (!map || iter < 0)
-                return -EINVAL;
-
-        if (iter == map->end_iterator)
-                return 1;
-        else
-                return 0;
-}
-
-/*
- * Return a "pointer" to the first instance of the particular key.  It can
- * be tested against hashmap_is_end() to see if the key was not found.
- *
- * Returns: negative upon an error
- *          an "iterator" pointing at the first key
- *          an "end-iterator" if the key wasn't found
- */
-hashmap_iter hashmap_find (hashmap_t map, const char *key)
-{
-        unsigned int i;
-        hashmap_iter iter = 0;
-        struct hashentry_s *ptr;
-
-        assert (map != NULL);
-        assert (key != NULL);
-
-        if (!map || !key)
-                return -EINVAL;
-
-        /*
-         * Loop through all the keys and look for the first occurrence
-         * of a particular key.
-         */
-        for (i = 0; i != map->size; i++) {
-                ptr = map->buckets[i].head;
-
-                while (ptr) {
-                        if (strcasecmp (ptr->key, key) == 0) {
-                                /* Found it, so return the current count */
-                                return iter;
-                        }
-
-                        iter++;
-                        ptr = ptr->next;
-                }
-        }
-
-        return iter;
-}
-
-/*
- * Retrieve the data associated with a particular iterator.
- *
- * Returns: the length of the data block upon success
- *          negative upon error
- */
-ssize_t
-hashmap_return_entry (hashmap_t map, hashmap_iter iter, char **key, void **data)
-{
-        unsigned int i;
-        struct hashentry_s *ptr;
-        hashmap_iter count = 0;
-
-        assert (map != NULL);
-        assert (iter >= 0);
-        assert (iter != map->end_iterator);
-        assert (key != NULL);
-        assert (data != NULL);
-
-        if (!map || iter < 0 || !key || !data)
-                return -EINVAL;
-
-        for (i = 0; i != map->size; i++) {
-                ptr = map->buckets[i].head;
-                while (ptr) {
-                        if (count == iter) {
-                                /* This is the data so return it */
-                                *key = ptr->key;
-                                *data = ptr->data;
-                                return ptr->len;
-                        }
-
-                        ptr = ptr->next;
-                        count++;
-                }
-        }
-
-        return -EFAULT;
-}
-
-/*
- * Searches for _any_ occurrences of "key" within the hashmap.
- *
- * Returns: negative upon an error
- *          zero if no key is found
- *          count found
- */
-ssize_t hashmap_search (hashmap_t map, const char *key)
-{
-        int hash;
-        struct hashentry_s *ptr;
-        ssize_t count = 0;
-
-        if (map == NULL || key == NULL)
-                return -EINVAL;
-
-        hash = hashfunc (key, map->size, map->seed);
-        if (hash < 0)
-                return hash;
-
-        ptr = map->buckets[hash].head;
-
-        /* All right, there is an entry here, now see if it's the one we want */
-        while (ptr) {
-                if (strcasecmp (ptr->key, key) == 0)
-                        ++count;
-
-                /* This entry didn't contain the key; move to the next one */
-                ptr = ptr->next;
-        }
-
-        return count;
-}
-
-/*
- * Get the first entry (assuming there is more than one) for a particular
- * key.  The data MUST be non-NULL.
- *
- * Returns: negative upon error
- *          zero if no entry is found
- *          length of data for the entry
- */
-ssize_t hashmap_entry_by_key (hashmap_t map, const char *key, void **data)
-{
-        int hash;
-        struct hashentry_s *ptr;
-
-        if (!map || !key || !data)
-                return -EINVAL;
-
-        hash = hashfunc (key, map->size, map->seed);
-        if (hash < 0)
-                return hash;
-
-        ptr = map->buckets[hash].head;
-
-        while (ptr) {
-                if (strcasecmp (ptr->key, key) == 0) {
-                        *data = ptr->data;
-                        return ptr->len;
-                }
-
-                ptr = ptr->next;
-        }
-
-        return 0;
-}
-
-/*
- * Go through the hashmap and remove the particular key.
- * NOTE: This will invalidate any iterators which have been created.
- *
- * Remove: negative upon error
- *         0 if the key was not found
- *         positive count of entries deleted
- */
-ssize_t hashmap_remove (hashmap_t map, const char *key)
-{
-        int hash;
-        struct hashentry_s *ptr, *next;
-        short int deleted = 0;
-
-        if (map == NULL || key == NULL)
-                return -EINVAL;
-
-        hash = hashfunc (key, map->size, map->seed);
-        if (hash < 0)
-                return hash;
-
-        ptr = map->buckets[hash].head;
-        while (ptr) {
-                if (strcasecmp (ptr->key, key) == 0) {
-                        /*
-                         * Found the data, now need to remove everything
-                         * and update the hashmap.
-                         */
-                        next = ptr->next;
-
-                        if (ptr->prev)
-                                ptr->prev->next = ptr->next;
-                        if (ptr->next)
-                                ptr->next->prev = ptr->prev;
-
-                        if (map->buckets[hash].head == ptr)
-                                map->buckets[hash].head = ptr->next;
-                        if (map->buckets[hash].tail == ptr)
-                                map->buckets[hash].tail = ptr->prev;
-
-                        safefree (ptr->key);
-                        safefree (ptr->data);
-                        safefree (ptr);
-
-                        ++deleted;
-                        --map->end_iterator;
-
-                        ptr = next;
-                        continue;
-                }
-
-                /* This entry didn't contain the key; move to the next one */
-                ptr = ptr->next;
-        }
-
-        /* The key was not found, so return 0 */
-        return deleted;
-}
-
-/*
- * Look up the value for a variable.
- */
-char *lookup_variable (hashmap_t map, const char *varname)
-{
-        hashmap_iter result_iter;
-        char *key;
-        char *data;
-
-        result_iter = hashmap_find (map, varname);
-
-        if (hashmap_is_end (map, result_iter))
-                return (NULL);
-
-        if (hashmap_return_entry (map, result_iter,
-                                  &key, (void **) &data) < 0)
-                return (NULL);
-
-        return (data);
-}
diff --git a/src/hashmap.h b/src/hashmap.h
deleted file mode 100644
index 9206737..0000000
--- a/src/hashmap.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/* tinyproxy - A fast light-weight HTTP proxy
- * Copyright (C) 2002 Robert James Kaes <rjkaes@users.sourceforge.net>
- *
- * 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-/* See 'hashmap.c' for detailed information. */
-
-#ifndef _HASHMAP_H
-#define _HASHMAP_H
-
-#include "common.h"
-
-/*
- * We're using a typedef here to "hide" the implementation details of the
- * hash map.  Sure, it's a pointer, but the struct is hidden in the C file.
- * So, just use the hashmap_t like it's a cookie. :)
- */
-typedef struct hashmap_s *hashmap_t;
-typedef int hashmap_iter;
-
-/*
- * hashmap_create() takes one argument, which is the number of buckets to
- * use internally.  hashmap_delete() is self explanatory.
- */
-extern hashmap_t hashmap_create (unsigned int nbuckets);
-extern int hashmap_delete (hashmap_t map);
-
-/*
- * When the you insert a key/data pair into the hashmap it will the key
- * and data are duplicated, so you must free your copy if it was created
- * on the heap.  The key must be a NULL terminated string.  "data" must be
- * non-NULL and length must be greater than zero.
- *
- * Returns: negative on error
- *          0 upon successful insert
- */
-extern int hashmap_insert (hashmap_t map, const char *key,
-                           const void *data, size_t len);
-
-/*
- * Get an iterator to the first entry.
- *
- * Returns: an negative value upon error.
- */
-extern hashmap_iter hashmap_first (hashmap_t map);
-
-/*
- * Checks to see if the iterator is pointing at the "end" of the entries.
- *
- * Returns: 1 if it is the end
- *          0 otherwise
- */
-extern int hashmap_is_end (hashmap_t map, hashmap_iter iter);
-
-/*
- * Return a "pointer" to the first instance of the particular key.  It can
- * be tested against hashmap_is_end() to see if the key was not found.
- *
- * Returns: negative upon an error
- *          an "iterator" pointing at the first key
- *          an "end-iterator" if the key wasn't found
- */
-extern hashmap_iter hashmap_find (hashmap_t map, const char *key);
-
-/*
- * Retrieve the key/data associated with a particular iterator.
- * NOTE: These are pointers to the actual data, so don't mess around with them
- *       too much.
- *
- * Returns: the length of the data block upon success
- *          negative upon error
- */
-extern ssize_t hashmap_return_entry (hashmap_t map, hashmap_iter iter,
-                                     char **key, void **data);
-
-/*
- * Get the first entry (assuming there is more than one) for a particular
- * key.  The data MUST be non-NULL.
- *
- * Returns: negative upon error
- *          zero if no entry is found
- *          length of data for the entry
- */
-extern ssize_t hashmap_entry_by_key (hashmap_t map, const char *key,
-                                     void **data);
-
-/*
- * Searches for _any_ occurrances of "key" within the hashmap and returns the
- * number of matching entries.
- *
- * Returns: negative upon an error
- *          zero if no key is found
- *          count found (positive value)
- */
-extern ssize_t hashmap_search (hashmap_t map, const char *key);
-
-/*
- * Go through the hashmap and remove the particular key.
- * NOTE: This will invalidate any iterators which have been created.
- *
- * Remove: negative upon error
- *         0 if the key was not found
- *         positive count of entries deleted
- */
-extern ssize_t hashmap_remove (hashmap_t map, const char *key);
-
-/*
- * Look up the value for a variable.
- */
-extern char *lookup_variable (hashmap_t map, const char *varname);
-
-#endif /* _HASHMAP_H */
diff --git a/src/html-error.c b/src/html-error.c
index d643aaa..7c71f74 100644
--- a/src/html-error.c
+++ b/src/html-error.c
@@ -40,17 +40,22 @@
 int add_new_errorpage (struct config_s *conf, char *filepath,
                        unsigned int errornum)
 {
-        char errornbuf[ERRORNUM_BUFSIZE];
+        char errornbuf[ERRORNUM_BUFSIZE], *k;
 
-        conf->errorpages = hashmap_create (ERRPAGES_BUCKETCOUNT);
+        if (!conf->errorpages)
+                conf->errorpages = htab_create (ERRPAGES_BUCKETCOUNT);
         if (!conf->errorpages)
                 return (-1);
 
         snprintf (errornbuf, ERRORNUM_BUFSIZE, "%u", errornum);
 
-        if (hashmap_insert (conf->errorpages, errornbuf,
-                            filepath, strlen (filepath) + 1) < 0)
+        k = safestrdup(errornbuf);
+        if (!k) return -1;
+
+        if (!htab_insert (conf->errorpages, k, HTV_P(filepath))) {
+                safefree(k);
                 return (-1);
+        }
 
         return (0);
 }
@@ -60,10 +65,8 @@ int add_new_errorpage (struct config_s *conf, char *filepath,
  */
 static char *get_html_file (unsigned int errornum)
 {
-        hashmap_iter result_iter;
         char errornbuf[ERRORNUM_BUFSIZE];
-        char *key;
-        char *val;
+        htab_value *hv;
 
         assert (errornum >= 100 && errornum < 1000);
 
@@ -72,16 +75,15 @@ static char *get_html_file (unsigned int errornum)
 
         snprintf (errornbuf, ERRORNUM_BUFSIZE, "%u", errornum);
 
-        result_iter = hashmap_find (config->errorpages, errornbuf);
-
-        if (hashmap_is_end (config->errorpages, result_iter))
-                return (config->errorpage_undef);
-
-        if (hashmap_return_entry (config->errorpages, result_iter,
-                                  &key, (void **) &val) < 0)
-                return (config->errorpage_undef);
+        hv = htab_find (config->errorpages, errornbuf);
+        if (!hv) return (config->errorpage_undef);
+        return hv->p;
+}
 
-        return (val);
+static char *lookup_variable (struct htab *map, const char *varname) {
+	htab_value *v;
+	v = htab_find(map, varname);
+	return v ? v->p : 0;
 }
 
 static void varsubst_sendline(struct conn_s *connptr, regex_t *re, char *p) {
@@ -203,14 +205,25 @@ int send_http_error_message (struct conn_s *connptr)
 int
 add_error_variable (struct conn_s *connptr, const char *key, const char *val)
 {
+	char *k, *v;
+
         if (!connptr->error_variables)
                 if (!
                     (connptr->error_variables =
-                     hashmap_create (ERRVAR_BUCKETCOUNT)))
+                     htab_create (ERRVAR_BUCKETCOUNT)))
                         return (-1);
 
-        return hashmap_insert (connptr->error_variables, key, val,
-                               strlen (val) + 1);
+        k = safestrdup(key);
+        v = safestrdup(val);
+
+        if (!v || !k) goto oom;
+
+        if(htab_insert (connptr->error_variables, k, HTV_P(v)))
+                return 1;
+oom:;
+	safefree(k);
+	safefree(v);
+	return -1;
 }
 
 #define ADD_VAR_RET(x, y)				   \
diff --git a/src/main.c b/src/main.c
index 42e8048..8bda2b9 100644
--- a/src/main.c
+++ b/src/main.c
@@ -337,8 +337,8 @@ main (int argc, char **argv)
          * HTTP/1.0 request. Also add the Content-Type header since it
          * goes hand in hand with Content-Length. */
         if (is_anonymous_enabled (config)) {
-                anonymous_insert (config, "Content-Length");
-                anonymous_insert (config, "Content-Type");
+                anonymous_insert (config, safestrdup("Content-Length"));
+                anonymous_insert (config, safestrdup("Content-Type"));
         }
 
         if (daemonized == TRUE) {
diff --git a/src/reqs.c b/src/reqs.c
index 47bb304..b962153 100644
--- a/src/reqs.c
+++ b/src/reqs.c
@@ -32,7 +32,7 @@
 #include "buffer.h"
 #include "conns.h"
 #include "filter.h"
-#include "hashmap.h"
+#include "hsearch.h"
 #include "orderedmap.h"
 #include "heap.h"
 #include "html-error.h"