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.

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 \

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) {
+        if (htab_find (conf->anonymous_map, s)) {
-                /* The key was already found, so return a positive number. */
+                /* 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;
 }

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

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);
+        if(anonymous_insert (conf, arg) < 0) {
-        safefree (arg);
+                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);
+        if(add_new_errorpage (conf, page, err) < 0) {
-        safefree (page);
+                log_message (LOG_WARNING,
+                             "add_new_errorpage() failed: '%s'",
+                             page);
+                safefree (page);
+        }
         return 0;
 }
 

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.

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)
+        if (connptr->error_variables) {
-                hashmap_delete (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);

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;

src/hashmap.c

@@ -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);
-}

src/hashmap.h

@@ -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 */

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,
+        k = safestrdup(errornbuf);
-                            filepath, strlen (filepath) + 1) < 0)
+        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;
+        htab_value *hv;
-        char *val;
 
         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);
+        hv = htab_find (config->errorpages, errornbuf);
+        if (!hv) return (config->errorpage_undef);
+        return hv->p;
+}
 
-        if (hashmap_is_end (config->errorpages, result_iter))
+static char *lookup_variable (struct htab *map, const char *varname) {
-                return (config->errorpage_undef);
+	htab_value *v;
-
+	v = htab_find(map, varname);
-        if (hashmap_return_entry (config->errorpages, result_iter,
+	return v ? v->p : 0;
-                                  &key, (void **) &val) < 0)
-                return (config->errorpage_undef);
-
-        return (val);
 }
 
 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,
+        k = safestrdup(key);
-                               strlen (val) + 1);
+        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)				   \

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, safestrdup("Content-Length"));
-                anonymous_insert (config, "Content-Type");
+                anonymous_insert (config, safestrdup("Content-Type"));
         }
 
         if (daemonized == TRUE) {

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"