- Changed 'method' to 'handler' throughout

- Fixed bug in hash.c with unitialized memory
- Imported new hash table features
- Writes out pid file when requested with -p option

10 files changed, 355 insertions, 172 deletions

diff --git a/ChangeLog b/ChangeLog
index e69de29..de146d8 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -0,0 +1,9 @@
+0.3
+  - Changed 'method' to 'handler' throughout
+  - Fixed bug in hash.c
+  - Imported new hash table features
+  - Writes out pid file when requested with -p option
+
+0.2
+  - Changed protocol to a more secure resilient protocol
+
diff --git a/apache1x/mod_httpauth.c b/apache1x/mod_httpauth.c
index 39cdd8d..43dfa1b 100644
--- a/apache1x/mod_httpauth.c
+++ b/apache1x/mod_httpauth.c
@@ -19,7 +19,7 @@ typedef struct httpauth_context
   const char* socketname;
   int socket;
   int types;
-  const char* method;
+  const char* handler;
   const char* domain;
   pool* child_pool;
 }
@@ -66,10 +66,10 @@ static const char* set_socket(cmd_parms* cmd, void* config, const char* val)
   return NULL;
 }
 
-static const char* set_method(cmd_parms* cmd, void* config, const char* val)
+static const char* set_handler(cmd_parms* cmd, void* config, const char* val)
 {
   httpauth_context_t* conf = (httpauth_context_t*)config;
-  conf->method = val;
+  conf->handler = val;
   return NULL;
 }
 
@@ -108,8 +108,8 @@ static const command_rec httpauth_cmds[] =
 {
   { "HttpAuthSocket", set_socket, NULL, OR_AUTHCFG, TAKE1,
     "The socket that httpauthd is listening on" },
-  { "HttpAuthMethod", set_method, NULL, OR_AUTHCFG, TAKE1,
-    "The method that httpauthd should use to authenticate" },
+  { "HttpAuthHandler", set_handler, NULL, OR_AUTHCFG, TAKE1,
+    "The handler that httpauthd should use to authenticate" },
   { "HttpAuthTypes", set_types, NULL, OR_AUTHCFG, ITERATE,
     "The types of authentiction allowed (Basic, Digest, NTLM ...)" },
   { "HttpAuthDigestDomain", set_domain, NULL, OR_AUTHCFG, RAW_ARGS,
@@ -518,16 +518,16 @@ int connect_httpauth(httpauth_context_t* ctx, request_rec* r)
     goto finally;
   }
 
-  /* Send our method */
-  if(ctx->method)
+  /* Send our handler */
+  if(ctx->handler)
   {
-    t = ap_pstrcat(r->pool, "SET Method ", ctx->method, "\n", NULL);
+    t = ap_pstrcat(r->pool, "SET Handler ", ctx->handler, "\n", NULL);
 
     if(write_data(ctx, r->server, t) == -1)
       goto finally;
 
     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, r,
-      "httpauth: sent method to daemon: %s", t);
+      "httpauth: sent handler to daemon: %s", t);
 
     if(read_response(ctx, r, &code, NULL, NULL) == -1)
       goto finally;
@@ -659,7 +659,7 @@ static int httpauth_authenticate(request_rec* r)
   ctx = (httpauth_context_t*)ap_get_module_config(r->per_dir_config,
                                                   &httpauth_module);
 
-  if(!ctx->socketname || !ctx->method)
+  if(!ctx->socketname || !ctx->handler)
     return DECLINED;
 
   mainreq = r;
diff --git a/common/hash.c b/common/hash.c
index 6471803..9bbe8ac 100644
--- a/common/hash.c
+++ b/common/hash.c
@@ -89,38 +89,90 @@ struct hash_t
   unsigned int klen;
 #endif
 #ifdef HASH_CALLBACKS
-  hash_free_val_t f_free;
-  void* arg;
+  hash_table_calls_t calls;
 #endif
 };
 
 
 #define INITIAL_MAX 15 /* tunable == 2^n - 1 */
 
+#ifdef HASH_CALLBACKS
+
+/* A copy of the memory call table we've been set to */
+static hash_memory_calls_t g_memory_calls_cpy;
+
+/* Pointer to above. This indicates when we actually are set */
+static hash_memory_calls_t* g_memory_calls = NULL;
+
+static void* int_malloc(size_t len)
+{
+  if(g_memory_calls)
+    return (g_memory_calls->f_alloc)(g_memory_calls->arg, len);
+  else
+    return malloc(len);
+}
+
+static void* int_calloc(size_t len)
+{
+  void* p = int_malloc(len);
+  memset(p, 0, len);
+  return p;
+}
+
+static void int_free(void* ptr)
+{
+  if(g_memory_calls)
+  {
+    /* We allow for gc type memory allocation with a null free */
+    if(g_memory_calls->f_free)
+      (g_memory_calls->f_free)(g_memory_calls->arg, ptr);
+  }
+  else
+    free(ptr);
+}
+
+void hash_set_memory_calls(hash_memory_calls_t* hmc)
+{
+  if(hmc == NULL)
+  {
+    g_memory_calls = NULL;
+  }
+  else
+  {
+    memcpy(&g_memory_calls_cpy, hmc, sizeof(g_memory_calls_cpy));
+    g_memory_calls = &g_memory_calls_cpy;
+  }
+}
+
+void hash_set_table_calls(hash_t* ht, hash_table_calls_t* htc)
+{
+  memcpy(&(ht->calls), htc, sizeof(ht->calls));
+}
+
+#else
+
+#define int_malloc malloc
+#define int_free free
+
+#endif
+
+
 /*
  * Hash creation functions.
  */
 
 static hash_entry_t** alloc_array(hash_t* ht, unsigned int max)
 {
-  return malloc(sizeof(*(ht->array)) * (max + 1));
+  return int_malloc(sizeof(*(ht->array)) * (max + 1));
 }
 
-#ifdef HASH_CALLBACKS
-  #ifdef HASH_COPYKEYS
-hash_t* hash_create(size_t klen, hash_free_val_t f_free, void* arg)
-  #else
-hash_t* hash_create(hash_free_val_t f_free, void* arg)
-  #endif
-#else
-  #ifdef HASH_COPYKEYS
+#ifdef HASH_COPYKEYS
 hash_t* hash_create(size_t klen)
-  #else
+#else
 hash_t* hash_create()
-  #endif
 #endif
 {
-  hash_t* ht = malloc(sizeof(hash_t));
+  hash_t* ht = int_malloc(sizeof(hash_t));
   if(ht)
   {
     ht->count = 0;
@@ -129,13 +181,9 @@ hash_t* hash_create()
 #ifdef HASH_COPYKEYS
     ht->klen = klen;
 #endif
-#ifdef HASH_CALLBACKS
-    ht->f_free = f_free;
-    ht->arg = arg;
-#endif
     if(!ht->array)
     {
-      free(ht);
+      int_free(ht);
       return NULL;
     }
   }
@@ -149,16 +197,16 @@ void hash_free(hash_t* ht)
   for(hi = hash_first(ht); hi; hi = hash_next(hi))
   {
 #ifdef HASH_CALLBACKS
-    if(hi->ths->val && ht->f_free)
-      ht->f_free(ht->arg, (void*)hi->ths->val);
+    if(hi->ths->val && ht->calls.f_freeval)
+      (ht->calls.f_freeval)(ht->calls.arg, (void*)hi->ths->val);
 #endif
-    free(hi->ths);
+    int_free(hi->ths);
   }
 
   if(ht->array)
-    free(ht->array);
+    int_free(ht->array);
 
-  free(ht);
+  int_free(ht);
 }
 
 /*
@@ -335,9 +383,9 @@ static hash_entry_t** find_entry(hash_t* ht, const void* key, size_t klen, const
 
   /* add a new entry for non-NULL val */
 #ifdef HASH_COPYKEYS
-  he = malloc(sizeof(*he) + klen);
+  he = int_malloc(sizeof(*he) + klen);
 #else
-  he = malloc(sizeof(*he));
+  he = int_malloc(sizeof(*he));
 #endif
 
   if(he)
@@ -395,8 +443,8 @@ int hash_set(hash_t* ht, const void* key, size_t klen, void* val)
   if(hep && *hep)
   {
 #ifdef HASH_CALLBACKS
-    if((*hep)->val && (*hep)->val != val && ht->f_free)
-      ht->f_free(ht->arg, (void*)((*hep)->val));
+    if((*hep)->val && (*hep)->val != val && ht->calls.f_freeval)
+      (ht->calls.f_freeval)(ht->calls.arg, (void*)((*hep)->val));
 #endif
 
     /* replace entry */
@@ -467,8 +515,8 @@ int hash_purge(hash_t* ht, time_t stamp)
 #endif
 
 #ifdef HASH_CALLBACKS
-      if(val && ht->f_free)
-        (ht->f_free)(ht->arg, val);
+      if(val && ht->calls.f_freeval)
+        (ht->calls.f_freeval)(ht->calls.arg, val);
 #endif
 
       r++;
@@ -523,8 +571,8 @@ int hash_bump(hash_t* ht)
 #endif
 
 #ifdef HASH_CALLBACKS
-    if(val && ht->f_free)
-      (ht->f_free)(ht->arg, (void*)val);
+    if(val && ht->calls.f_freeval)
+      (ht->calls.f_freeval)(ht->calls.arg, (void*)val);
 #endif
 
     return 1;
diff --git a/common/hash.h b/common/hash.h
index 2b22b64..174c209 100644
--- a/common/hash.h
+++ b/common/hash.h
@@ -21,30 +21,43 @@
 #ifndef __HASH_H__
 #define __HASH_H__
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
+ * OPTIONAL FEATURES
+ *
  * Features to define. You need to build both this file and
- * the corresponding hash.c file with whatever options you set here
+ * the corresponding hash.c file with whatever options you set here.
+ * These affect the method signatures, so see the sections below
+ * for the actual options
  */
 
 /* Keep timestamps for the entries */
-#define HASH_TIMESTAMP  1
+#define HASH_TIMESTAMP
 
 /* Keep key values internally */
-#define HASH_COPYKEYS   1
+#define HASH_COPYKEYS
 
 /* Hash callback functionality */
-#define HASH_CALLBACKS  1
+#define HASH_CALLBACKS
 
+/*
+ * ARGUMENT DOCUMENTATION
+ *
+ * ht: The hashtable
+ * key: Pointer to the key value
+ * klen: The length of the key
+ * val: Pointer to the value
+ * hi: A hashtable iterator
+ * stamp: A unix timestamp
+ */
 
-#ifdef __cplusplus
-extern "C" {
-#endif
 
-/**
- * When passing a key to hash_set or hash_get, this value can be passed to
- * indicate a string-valued key, and have hash compute the length automatically.
+/* ----------------------------------------------------------------------------------
+ * TYPES
  */
-#define HASH_KEY_STRING     (-1)
 
 /* Abstract type for hash tables. */
 typedef struct hash_t hash_t;
@@ -52,146 +65,216 @@ typedef struct hash_t hash_t;
 /* Abstract type for scanning hash tables.  */
 typedef struct hash_index_t hash_index_t;
 
-/* A callback during remove operations */
-#ifdef HASH_CALLBACKS
-  typedef void (*hash_free_val_t)(void* arg, void* val);
-#endif
 
-/* Create a hash table */
-#ifdef HASH_CALLBACKS
-  #ifdef HASH_COPYKEYS
-    hash_t* hash_create(size_t klen, hash_free_val_t f_free, void* arg);
-  #else
-    hash_t* hash_create(hash_free_val_t f_free, void* arg);
-  #endif
-#else
-  #ifdef HASH_COPYKEYS
-    hash_t* hash_create(size_t klen);
-  #else
-    hash_t* hash_create();
-  #endif
-#endif /* HASH_CALLBACKS */
+/* ----------------------------------------------------------------------------------
+ * COPY KEYS MODE
+ *
+ * Use these functions when you want specific length keys, with those
+ * keys stored in the hashtable itself.
+ */
+
+#ifdef HASH_COPYKEYS
 
+/*
+ * hash_create : Create a hash table
+ * - returns an allocated hashtable
+ */
+hash_t* hash_create(size_t klen);
 
-/* To release all resources for a hash table */
+/*
+ * hash_free : Free a hash table
+ */
 void hash_free(hash_t* ht);
 
+/*
+ * hash_count: Number of values in hash table
+ * - returns the number of entries in hash table
+ */
+unsigned int hash_count(hash_t* ht);
 
-/**
- * Associate a value with a key in a hash table.
- *
- * ht The hash table
- * key Pointer to the key
- * klen Length of the key. Can be HASH_KEY_STRING to use the string length.
- * val Value to associate with the key
- *
- * val must not be null
+/*
+ * hash_get: Retrieves a value from the hash table
+ * - returns the value of the entry
  */
-#ifdef HASH_COPYKEYS
-  int hash_set(hash_t* ht, const void* key, void* val);
-#else
-  int hash_set(hash_t* ht, const void* key, size_t klen, void* val);
-#endif
+void* hash_get(hash_t* ht, const void* key);
 
+/*
+ * hash_set: Set a value in the hash table
+ * - returns 1 if the entry was added properly
+ */
+int hash_set(hash_t* ht, const void* key, void* val);
 
-/**
- * Remove a value and key form the hash table
- *
- * ht The hash table
- * key Pointer to the key
- * klen Length of the key. Can be HASH_KEY_STRING to use the string length
+/*
+ * hash_rem: Remove a value from the hash table
+ * - returns the value of the removed entry
  */
-#ifdef HASH_COPYKEYS
-  void* hash_rem(hash_t* ht, const void* key);
-#else
-  void* hash_rem(hash_t* ht, const void* key, size_t klen);
-#endif
+void* hash_rem(hash_t* ht, const void* key);
 
+/*
+ * hash_first: Start enumerating through the hash table
+ * - returns a hash iterator
+ */
+hash_index_t* hash_first(hash_t* ht);
 
-/**
- * Look up the value associated with a key in a hash table.
- *
- * ht The hash table
- * key Pointer to the key
- * klen Length of the key. Can be APR_HASH_KEY_STRING to use the string length.
+/*
+ * hash_next: Enumerate through hash table
+ * - returns the hash iterator or null when no more entries
+ */
+hash_index_t* hash_next(hash_index_t* hi);
+
+/*
+ * hash_this: While enumerating get current value
+ * - returns the value that the iterator currently points to
+ */
+void* hash_this(hash_index_t* hi, const void** key);
+
+
+
+/* ----------------------------------------------------------------------------------
+ * VARIABLE KEYS MODE
  *
- * Returns NULL if the key is not present.
+ * Use these functions if you want to use variable length keys or for some
+ * other reason don't want the keys stored in the hash table.
  */
-#ifdef HASH_COPYKEYS
-  void* hash_get(hash_t* ht, const void* key);
+
 #else
-  void* hash_get(hash_t* ht, const void* key, size_t klen);
-#endif
 
+/*
+ * hash_create : Create a hash table
+ * - returns an allocated hashtable
+ */
+hash_t* hash_create();
 
-/**
- * Start iterating over the entries in a hash table.
- *
- * ht The hash table
- *
- * There is no restriction on adding or deleting hash entries during
- * an iteration (although the results may be unpredictable unless all you do
- * is delete the current entry). Only one iteration can be in progress at once.
+/*
+ * hash_free : Free a hash table
  */
-hash_index_t* hash_first(hash_t* ht);
+void hash_free(hash_t* ht);
 
+/*
+ * hash_count: Number of values in hash table
+ * - returns the number of entries in hash table
+ */
+unsigned int hash_count(hash_t* ht);
 
-/**
- * Continue iterating over the entries in a hash table.
- *
- * hi The iteration state
- *
- * Returns a pointer to the updated iteration state.
- * NULL if there are no more entries.
+/*
+ * hash_get: Retrieves a value from the hash table
+ * - returns the value of the entry
+ */
+void* hash_get(hash_t* ht, const void* key, size_t klen);
+
+/*
+ * hash_set: Set a value in the hash table
+ * - returns 1 if the entry was added properly
+ */
+int hash_set(hash_t* ht, const void* key, size_t klen, void* val);
+
+/*
+ * hash_rem: Remove a value from the hash table
+ * - returns the value of the removed entry
+ */
+void* hash_rem(hash_t* ht, const void* key, size_t klen);
+
+/*
+ * hash_first: Start enumerating through the hash table
+ * - returns a hash iterator
+ */
+hash_index_t* hash_first(hash_t* ht);
+
+/*
+ * hash_next: Enumerate through hash table
+ * - returns the hash iterator or null when no more entries
  */
 hash_index_t* hash_next(hash_index_t* hi);
 
+/*
+ * hash_this: While enumerating get current value
+ * - returns the value that the iterator currently points to
+ */
+void* hash_this(hash_index_t* hi, const void** key, size_t* klen);
 
-/**
- * Get the current entry's details from the iteration state.
- *
- * hi The iteration state
- * key Return pointer for the pointer to the key.
- * klen Return pointer for the key length.
- * val Return pointer for the associated value.
- *
- * The return pointers should point to a variable that will be set to the
- * corresponding data, or they may be NULL if the data isn't interesting.
+/*
+ * This can be passed as 'klen' in any of the above functions to indicate
+ * a string-valued key, and have hash compute the length automatically.
  */
-#ifdef HASH_COPYKEYS
-  void* hash_this(hash_index_t* hi, const void** key);
-#else
-  void* hash_this(hash_index_t* hi, const void** key, size_t* klen);
+#define HASH_KEY_STRING     (-1)
+
 #endif
 
 
-/**
- * Purge entries before a certain timestamp
+
+/* ----------------------------------------------------------------------------------
+ * TIMESTAMP FUNCTIONALITY
+ *
+ * Use these functions to include functionality which tracks the time
+ * each key was added or changed. This is useful for caches. Use these
+ * functions in addition to one of the above 'key' modes.
  */
+
 #ifdef HASH_TIMESTAMP
 
+/*
+ * hash_purge: Purge entries before a certain timestamp
+ * - returns the number of entries purged
+ */
 int hash_purge(hash_t* ht, time_t stamp);
 
+/*
+ * hash_touch: Touch an entry to make it's timestamp current
+ */
 #ifdef HASH_COPYKEYS
   void hash_touch(hash_t* ht, const void* key);
 #else
   void hash_touch(hash_t* ht, const void* key, size_t* klen);
 #endif
 
-/* Bumps the oldest out */
+/*
+ * hash_bump: Bumps the oldest entry out
+ */
 int hash_bump(hash_t* ht);
 
 #endif
 
 
-/**
- * Get the number of key/value pairs in the hash table.
- *
- * ht The hash table
+
+/* ----------------------------------------------------------------------------------
+ * CALLBACK FUNCTIONALITY
  *
- * The number of key/value pairs in the hash table.
+ * Use these functions to replace certain calls (malloc, free etc...) as
+ * well as to get callbacks when an item is discarded.
  */
-unsigned int hash_count(hash_t* ht);
+
+#ifdef HASH_CALLBACKS
+
+typedef void* (*hash_falloc)(void* arg, size_t len);
+typedef void (*hash_ffree)(void* arg, void* ptr);
+
+typedef struct hash_memory_calls
+{
+  hash_falloc f_alloc;
+  hash_ffree f_free;
+  void* arg;
+}
+hash_memory_calls_t;
+
+/* Set the global memory calls */
+void hash_set_memory_calls(hash_memory_calls_t* hmc);
+
+
+typedef void (*hash_ffreeval)(void* arg, void* val);
+
+typedef struct hash_table_calls
+{
+  hash_ffreeval f_freeval;
+  void* arg;
+}
+hash_table_calls_t;
+
+/* Set the per table free value call */
+void hash_set_table_calls(hash_t* ht, hash_table_calls_t* htc);
+
+#endif
+
+
 
 
 #ifdef __cplusplus
diff --git a/configure.in b/configure.in
index 5ba49a1..ecd2c47 100644
--- a/configure.in
+++ b/configure.in
@@ -36,8 +36,8 @@ dnl  Nate Nielsen <nielsen@memberwebs.com>
 dnl 
 
 dnl Process this file with autoconf to produce a configure script.
-AC_INIT(httpauth, 0.2, nielsen@memberwebs.com)
-AM_INIT_AUTOMAKE(httpauth, 0.2)
+AC_INIT(httpauth, 0.3, nielsen@memberwebs.com)
+AM_INIT_AUTOMAKE(httpauth, 0.3)
 
 LDFLAGS="$LDFLAGS -L/usr/local/lib"
 CFLAGS="$CFLAGS -I/usr/local/include -g -O0"
diff --git a/daemon/httpauthd.c b/daemon/httpauthd.c
index 00cb261..03a331a 100644
--- a/daemon/httpauthd.c
+++ b/daemon/httpauthd.c
@@ -122,6 +122,7 @@ pthread_mutexattr_t g_mutexattr;
  */
 
 static int usage();
+static void writepid(const char* pid);
 static void* httpauth_thread(void* arg);
 static int httpauth_processor(int ifd, int ofd);
 static int httpauth_respond(int ofd, int scode, int ccode, const char* msg);
@@ -137,6 +138,7 @@ static void on_quit(int signal);
 int main(int argc, char* argv[])
 {
   const char* conf = DEFAULT_CONFIG;
+  const char* pidfile = NULL;
   httpauth_thread_t* threads = NULL;
   httpauth_loaded_t* h;
   int daemonize = 1;
@@ -154,7 +156,7 @@ int main(int argc, char* argv[])
     errx(1, "threading problem. can't create mutex");
 
   /* Parse the arguments nicely */
-	while((ch = getopt(argc, argv, "d:f:X")) != -1)
+	while((ch = getopt(argc, argv, "d:f:p:X")) != -1)
 	{
 		switch(ch)
 		{
@@ -176,6 +178,11 @@ int main(int argc, char* argv[])
       conf = optarg;
       break;
 
+    /* Write out a pid file */
+    case 'p':
+      pidfile = optarg;
+      break;
+
     /* Process console input instead */
 		case 'X':
       g_console = 1;
@@ -282,9 +289,12 @@ int main(int argc, char* argv[])
         exit(1);
       }
 
+      ha_messagex(LOG_DEBUG, "running as a daemon");
       g_daemonized = 1;
     }
 
+    writepid(pidfile);
+
     /* Handle some signals */
     signal(SIGPIPE, SIG_IGN);
     signal(SIGHUP, SIG_IGN);
@@ -413,10 +423,28 @@ static void on_quit(int signal)
 
 static int usage()
 {
-  fprintf(stderr, "usage: httpauthd [-d level] [-X] [-f conffile]\n");
+  fprintf(stderr, "usage: httpauthd [-d level] [-X] [-p pidfile] [-f conffile]\n");
   return 2;
 }
 
+static void writepid(const char* pidfile)
+{
+  FILE* f = fopen(pidfile, "w");
+  if(f == NULL)
+  {
+    warnx("couldn't open pid file: %s", pidfile);
+  }
+  else
+  {
+    fprintf(f, "%d\n", (int)getpid());
+
+    if(ferror(f))
+      warnx("couldn't write to pid file: %s", pidfile);
+
+    fclose(f);
+  }
+}
+
 static void* httpauth_thread(void* arg)
 {
   httpauth_thread_t* thread = (httpauth_thread_t*)arg;
@@ -868,8 +896,8 @@ static int httpauth_auth(int ofd, ha_request_t* req, ha_response_t* resp)
 
   if(!req->context)
   {
-    ha_messagex(LOG_ERR, "no auth method set");
-    return httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "No Auth Method Set");
+    ha_messagex(LOG_ERR, "no auth handler set");
+    return httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "No Auth Handler Set");
   }
 
   /* Clear out our response */
@@ -930,11 +958,11 @@ static int httpauth_set(int ofd, ha_request_t* req)
     req->digest_domain = value ? value : "";
   }
 
-  else if(strcasecmp(name, "Method") == 0)
+  else if(strcasecmp(name, "Handler") == 0)
   {
     if(!value || !*value)
     {
-      ha_messagex(LOG_ERR, "no auth method specified in SET request.");
+      ha_messagex(LOG_ERR, "no auth handler specified in SET request.");
       return HA_BADREQ;
     }
 
@@ -952,7 +980,7 @@ static int httpauth_set(int ofd, ha_request_t* req)
     if(value != NULL)
     {
       ha_messagex(LOG_ERR, "unknown authentication type: %s", req->args[0]);
-      return httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "Unknown Auth Method");
+      return httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "Unknown Auth Handler");
     }
   }
 
@@ -1126,7 +1154,7 @@ static ha_context_t* config_addhandler(ha_buffer_t* buf, const char* alias,
     for(;;)
     {
       if(strcasecmp(alias, l->ctx.name) == 0)
-        errx(1, "duplicate method section for '%s'", alias);
+        errx(1, "duplicate handler section for '%s'", alias);
 
       if(!(l->next))
         break;
@@ -1137,7 +1165,7 @@ static ha_context_t* config_addhandler(ha_buffer_t* buf, const char* alias,
     l->next = loaded;
   }
 
-  ha_messagex(LOG_DEBUG, "configuration: method: %s (%s)", alias, handler->type);
+  ha_messagex(LOG_DEBUG, "configuration: handler: %s (%s)", alias, handler->type);
   return &(loaded->ctx);
 }
 
@@ -1202,7 +1230,7 @@ static int config_parse(const char* file, ha_buffer_t* buf)
       name = ha_bufparseline(buf, 1);
 
       if(!name || name[strlen(name) - 1] != ']')
-        errx(1, "method section invalid (line %d)", line);
+        errx(1, "handler section invalid (line %d)", line);
 
 
       /* remove the bracket */
@@ -1223,7 +1251,7 @@ static int config_parse(const char* file, ha_buffer_t* buf)
 
         /* Validate the alias name */
         if(!*t || strspn(t, VALID_ALIAS_CHARS) != strlen(t))
-          errx(1, "invalid name for method: %s", t);
+          errx(1, "invalid name for handler: %s", t);
       }
 
       /* Rid of whitespace */
@@ -1241,7 +1269,7 @@ static int config_parse(const char* file, ha_buffer_t* buf)
       }
 
       if(handler == NULL)
-        errx(1, "unknown method type '%s' (line %d)", name, line);
+        errx(1, "unknown handler type '%s' (line %d)", name, line);
 
       /* If we had a last handler then add it to handlers */
       ctx = config_addhandler(buf, t ? t : name, handler, &defaults);
@@ -1404,7 +1432,7 @@ static int config_parse(const char* file, ha_buffer_t* buf)
   }
 
   if(!g_handlers)
-    ha_messagex(LOG_WARNING, "configuration: no methods found in configuration file");
+    ha_messagex(LOG_WARNING, "configuration: no handlers found in configuration file");
 
   return 0;
 }
diff --git a/daemon/ldap.c b/daemon/ldap.c
index a996305..37ef27a 100644
--- a/daemon/ldap.c
+++ b/daemon/ldap.c
@@ -1310,6 +1310,7 @@ int ldap_inithand(ha_context_t* context)
   else
   {
     ldap_context_t* ctx = (ldap_context_t*)(context->ctx_data);
+    hash_table_calls_t htc;
 
     ASSERT(ctx);
 
@@ -1337,12 +1338,16 @@ int ldap_inithand(ha_context_t* context)
     }
 
     /* The cache for digest records and basic */
-    if(!(ctx->cache = hash_create(MD5_LEN, free_hash_object, NULL)))
+    if(!(ctx->cache = hash_create(MD5_LEN)))
     {
       ha_messagex(LOG_CRIT, "out of memory");
       return HA_CRITERROR;
     }
 
+    htc.f_freeval = free_hash_object;
+    htc.arg = NULL;
+    hash_set_table_calls(ctx->cache, &htc);
+
     ASSERT(!ctx->pool);
     ASSERT(ctx->ldap_max > 0);
 
diff --git a/daemon/ntlm.c b/daemon/ntlm.c
index 85bee1d..37de9e8 100644
--- a/daemon/ntlm.c
+++ b/daemon/ntlm.c
@@ -581,6 +581,7 @@ int ntlm_init(ha_context_t* context)
   if(context)
   {
     ntlm_context_t* ctx = (ntlm_context_t*)(context->ctx_data);
+    hash_table_calls_t htc;
 
     ASSERT(ctx);
 
@@ -604,13 +605,17 @@ int ntlm_init(ha_context_t* context)
     ASSERT(!ctx->established);
 
     /* Initialize our tables */
-    if(!(ctx->pending = hash_create(NTLM_HASH_KEY_LEN, free_hash_object, NULL)) ||
-       !(ctx->established = hash_create(NTLM_HASH_KEY_LEN, NULL, NULL)))
+    if(!(ctx->pending = hash_create(NTLM_HASH_KEY_LEN)) ||
+       !(ctx->established = hash_create(NTLM_HASH_KEY_LEN)))
     {
       ha_messagex(LOG_CRIT, "out of memory");
       return HA_CRITERROR;
     }
 
+    htc.f_freeval = free_hash_object;
+    htc.arg = NULL;
+    hash_set_table_calls(ctx->pending, &htc);
+
     ha_messagex(LOG_INFO, "ntlm: initialized handler");
   }
 
diff --git a/daemon/simple.c b/daemon/simple.c
index 8059051..52d565d 100644
--- a/daemon/simple.c
+++ b/daemon/simple.c
@@ -611,6 +611,7 @@ int simple_init(ha_context_t* context)
   else
   {
     simple_context_t* ctx = (simple_context_t*)(context->ctx_data);
+    hash_table_calls_t htc;
     int fd;
 
     ASSERT(ctx);
@@ -644,12 +645,16 @@ int simple_init(ha_context_t* context)
     ASSERT(!ctx->cache);
 
     /* The cache for digest records and basic */
-    if(!(ctx->cache = hash_create(MD5_LEN, free_hash_object, NULL)))
+    if(!(ctx->cache = hash_create(MD5_LEN)))
     {
       ha_messagex(LOG_CRIT, "out of memory");
       return HA_CRITERROR;
     }
 
+    htc.f_freeval = free_hash_object;
+    htc.arg = NULL;
+    hash_set_table_calls(ctx->cache, &htc);
+
     ha_messagex(LOG_INFO, "simple: initialized handler");
   }
 
diff --git a/sample/httpauthd.conf b/sample/httpauthd.conf
index c536dcd..f9481d2 100644
--- a/sample/httpauthd.conf
+++ b/sample/httpauthd.conf
@@ -3,13 +3,13 @@
 # and blank lines
 MaxThreads: 18
 CacheTimeout: 300
-AuthTypes: Digest
-# AuthTypes: Basic Digest
-Socket: 0.0.0.0:8030
+# AuthTypes: Digest
+AuthTypes: Basic Digest
+Socket: 0.0.0.0
 
-DigestIgnoreNC: True
+# DigestIgnoreNC: True
 
-[Simple:Test]
+[Simple:UDB]
 Realm: blah
 PasswordFile: /data/projects/httpauth/sample/passwd.file
 
@@ -17,7 +17,7 @@ PasswordFile: /data/projects/httpauth/sample/passwd.file
 Realm: blah
 LDAPServers: authdev.ws.local
 LDAPDoBind: False
-# LDAPDNMap: cn=%u,ou=test,dc=fam
+LDAPDNMap: cn=%u,ou=test,dc=fam
 # DigestDomains: http://test.ws.local/
 LDAPUser: cn=root,dc=fam
 LDAPPassword: ldaptest@@password