- Fixed uninitialized memory bug

- Imported updated sock_any and hash code

4 files changed, 309 insertions, 177 deletions

diff --git a/common/hash.c b/common/hash.c
index 9bbe8ac..5f3308c 100644
--- a/common/hash.c
+++ b/common/hash.c
@@ -22,11 +22,11 @@
 #include <stdlib.h>
 #include "hash.h"
 
-#ifdef HASH_TIMESTAMP
+#ifdef HSH_TIMESTAMP
 #include <time.h>
 #endif
 
-#ifdef HASH_COPYKEYS
+#ifdef HSH_COPYKEYS
   #define KEY_DATA(he) (void*)(((unsigned char*)(he)) + sizeof(*(he)))
 #else
   #define KEY_DATA(he)  ((he)->key)
@@ -41,18 +41,18 @@
  * isn't too bad given that pools have a low allocation overhead.
  */
 
-typedef struct hash_entry_t hash_entry_t;
+typedef struct hsh_entry_t hsh_entry_t;
 
-struct hash_entry_t
+struct hsh_entry_t
 {
-  hash_entry_t* next;
+  hsh_entry_t* next;
   unsigned int hash;
-#ifndef HASH_COPYKEYS
+#ifndef HSH_COPYKEYS
   const void* key;
   size_t klen;
 #endif
   const void* val;
-#ifdef HASH_TIMESTAMP
+#ifdef HSH_TIMESTAMP
   time_t stamp;
 #endif
 };
@@ -62,13 +62,13 @@ struct hash_entry_t
  *
  * We keep a pointer to the next hash entry here to allow the current
  * hash entry to be freed or otherwise mangled between calls to
- * hash_next().
+ * hsh_next().
  */
-struct hash_index_t
+struct hsh_index_t
 {
-  hash_t* ht;
-  hash_entry_t* ths;
-  hash_entry_t* next;
+  hsh_t* ht;
+  hsh_entry_t* ths;
+  hsh_entry_t* next;
   unsigned int index;
 };
 
@@ -79,30 +79,30 @@ struct hash_index_t
  * The count of hash entries may be greater depending on the chosen
  * collision rate.
  */
-struct hash_t
+struct hsh_t
 {
-  hash_entry_t** array;
-  hash_index_t iterator;  /* For hash_first(...) */
+  hsh_entry_t** array;
+  hsh_index_t iterator;  /* For hsh_first(...) */
   unsigned int count;
   unsigned int max;
-#ifdef HASH_COPYKEYS
+#ifdef HSH_COPYKEYS
   unsigned int klen;
 #endif
-#ifdef HASH_CALLBACKS
-  hash_table_calls_t calls;
+#ifdef HSH_CALLBACKS
+  hsh_table_calls_t calls;
 #endif
 };
 
 
 #define INITIAL_MAX 15 /* tunable == 2^n - 1 */
 
-#ifdef HASH_CALLBACKS
+#ifdef HSH_CALLBACKS
 
 /* A copy of the memory call table we've been set to */
-static hash_memory_calls_t g_memory_calls_cpy;
+static hsh_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 hsh_memory_calls_t* g_memory_calls = NULL;
 
 static void* int_malloc(size_t len)
 {
@@ -131,7 +131,7 @@ static void int_free(void* ptr)
     free(ptr);
 }
 
-void hash_set_memory_calls(hash_memory_calls_t* hmc)
+void hsh_set_memory_calls(hsh_memory_calls_t* hmc)
 {
   if(hmc == NULL)
   {
@@ -144,7 +144,7 @@ void hash_set_memory_calls(hash_memory_calls_t* hmc)
   }
 }
 
-void hash_set_table_calls(hash_t* ht, hash_table_calls_t* htc)
+void hsh_set_table_calls(hsh_t* ht, hsh_table_calls_t* htc)
 {
   memcpy(&(ht->calls), htc, sizeof(ht->calls));
 }
@@ -161,24 +161,24 @@ void hash_set_table_calls(hash_t* ht, hash_table_calls_t* htc)
  * Hash creation functions.
  */
 
-static hash_entry_t** alloc_array(hash_t* ht, unsigned int max)
+static hsh_entry_t** alloc_array(hsh_t* ht, unsigned int max)
 {
-  return int_malloc(sizeof(*(ht->array)) * (max + 1));
+  return int_calloc(sizeof(*(ht->array)) * (max + 1));
 }
 
-#ifdef HASH_COPYKEYS
-hash_t* hash_create(size_t klen)
+#ifdef HSH_COPYKEYS
+hsh_t* hsh_create(size_t klen)
 #else
-hash_t* hash_create()
+hsh_t* hsh_create()
 #endif
 {
-  hash_t* ht = int_malloc(sizeof(hash_t));
+  hsh_t* ht = int_malloc(sizeof(hsh_t));
   if(ht)
   {
     ht->count = 0;
     ht->max = INITIAL_MAX;
     ht->array = alloc_array(ht, ht->max);
-#ifdef HASH_COPYKEYS
+#ifdef HSH_COPYKEYS
     ht->klen = klen;
 #endif
     if(!ht->array)
@@ -190,13 +190,13 @@ hash_t* hash_create()
   return ht;
 }
 
-void hash_free(hash_t* ht)
+void hsh_free(hsh_t* ht)
 {
-  hash_index_t* hi;
+  hsh_index_t* hi;
 
-  for(hi = hash_first(ht); hi; hi = hash_next(hi))
+  for(hi = hsh_first(ht); hi; hi = hsh_next(hi))
   {
-#ifdef HASH_CALLBACKS
+#ifdef HSH_CALLBACKS
     if(hi->ths->val && ht->calls.f_freeval)
       (ht->calls.f_freeval)(ht->calls.arg, (void*)hi->ths->val);
 #endif
@@ -213,7 +213,7 @@ void hash_free(hash_t* ht)
  * Hash iteration functions.
  */
 
-hash_index_t* hash_next(hash_index_t* hi)
+hsh_index_t* hsh_next(hsh_index_t* hi)
 {
   hi->ths = hi->next;
   while(!hi->ths)
@@ -227,27 +227,27 @@ hash_index_t* hash_next(hash_index_t* hi)
   return hi;
 }
 
-hash_index_t* hash_first(hash_t* ht)
+hsh_index_t* hsh_first(hsh_t* ht)
 {
-  hash_index_t* hi = &ht->iterator;
+  hsh_index_t* hi = &ht->iterator;
 
   hi->ht = ht;
   hi->index = 0;
   hi->ths = NULL;
   hi->next = NULL;
-  return hash_next(hi);
+  return hsh_next(hi);
 }
 
-#ifdef HASH_COPYKEYS
-void* hash_this(hash_index_t* hi, const void** key)
+#ifdef HSH_COPYKEYS
+void* hsh_this(hsh_index_t* hi, const void** key)
 #else
-void* hash_this(hash_index_t* hi, const void** key, size_t* klen)
+void* hsh_this(hsh_index_t* hi, const void** key, size_t* klen)
 #endif
 {
   if(key)
     *key = KEY_DATA(hi->ths);
 
-#ifndef HASH_COPYKEYS
+#ifndef HSH_COPYKEYS
   if(klen)
     *klen = hi->ths->klen;
 #endif
@@ -260,10 +260,10 @@ void* hash_this(hash_index_t* hi, const void** key, size_t* klen)
  * Expanding a hash table
  */
 
-static int expand_array(hash_t* ht)
+static int expand_array(hsh_t* ht)
 {
-  hash_index_t* hi;
-  hash_entry_t** new_array;
+  hsh_index_t* hi;
+  hsh_entry_t** new_array;
   unsigned int new_max;
 
   new_max = ht->max * 2 + 1;
@@ -272,7 +272,7 @@ static int expand_array(hash_t* ht)
   if(!new_array)
     return 0;
 
-  for(hi = hash_first(ht); hi; hi = hash_next(hi))
+  for(hi = hsh_first(ht); hi; hi = hsh_next(hi))
   {
     unsigned int i = hi->ths->hash & new_max;
     hi->ths->next = new_array[i];
@@ -296,19 +296,19 @@ static int expand_array(hash_t* ht)
  * that hash entries can be removed.
  */
 
-#ifdef HASH_COPYKEYS
-static hash_entry_t** find_entry(hash_t* ht, const void* key, const void* val)
+#ifdef HSH_COPYKEYS
+static hsh_entry_t** find_entry(hsh_t* ht, const void* key, const void* val)
 #else
-static hash_entry_t** find_entry(hash_t* ht, const void* key, size_t klen, const void* val)
+static hsh_entry_t** find_entry(hsh_t* ht, const void* key, size_t klen, const void* val)
 #endif
 {
-  hash_entry_t** hep;
-  hash_entry_t* he;
+  hsh_entry_t** hep;
+  hsh_entry_t* he;
   const unsigned char* p;
   unsigned int hash;
   size_t i;
 
-#ifdef HASH_COPYKEYS
+#ifdef HSH_COPYKEYS
   size_t klen = ht->klen;
 #endif
 
@@ -351,8 +351,8 @@ static hash_entry_t** find_entry(hash_t* ht, const void* key, size_t klen, const
    */
   hash = 0;
 
-#ifndef HASH_COPYKEYS
-  if(klen == HASH_KEY_STRING)
+#ifndef HSH_COPYKEYS
+  if(klen == HSH_KEY_STRING)
   {
     for(p = key; *p; p++)
       hash = hash * 33 + *p;
@@ -371,7 +371,7 @@ static hash_entry_t** find_entry(hash_t* ht, const void* key, size_t klen, const
       he; hep = &he->next, he = *hep)
   {
    if(he->hash == hash &&
-#ifndef HASH_COPYKEYS
+#ifndef HSH_COPYKEYS
       he->klen == klen &&
 #endif
       memcmp(KEY_DATA(he), key, klen) == 0)
@@ -382,7 +382,7 @@ static hash_entry_t** find_entry(hash_t* ht, const void* key, size_t klen, const
     return hep;
 
   /* add a new entry for non-NULL val */
-#ifdef HASH_COPYKEYS
+#ifdef HSH_COPYKEYS
   he = int_malloc(sizeof(*he) + klen);
 #else
   he = int_malloc(sizeof(*he));
@@ -390,7 +390,7 @@ static hash_entry_t** find_entry(hash_t* ht, const void* key, size_t klen, const
 
   if(he)
   {
-#ifdef HASH_COPYKEYS
+#ifdef HSH_COPYKEYS
     /* Key data points past end of entry */
     memcpy(KEY_DATA(he), key, klen);
 #else
@@ -403,7 +403,7 @@ static hash_entry_t** find_entry(hash_t* ht, const void* key, size_t klen, const
     he->hash = hash;
     he->val  = val;
 
-#ifdef HASH_TIMESTAMP
+#ifdef HSH_TIMESTAMP
     he->stamp = 0;
 #endif
 
@@ -414,14 +414,14 @@ static hash_entry_t** find_entry(hash_t* ht, const void* key, size_t klen, const
   return hep;
 }
 
-#ifdef HASH_COPYKEYS
-void* hash_get(hash_t* ht, const void *key)
+#ifdef HSH_COPYKEYS
+void* hsh_get(hsh_t* ht, const void *key)
 {
-    hash_entry_t** he = find_entry(ht, key, NULL);
+    hsh_entry_t** he = find_entry(ht, key, NULL);
 #else
-void* hash_get(hash_t* ht, const void *key, size_t klen)
+void* hsh_get(hsh_t* ht, const void *key, size_t klen)
 {
-    hash_entry_t** he = find_entry(ht, key, klen, NULL);
+    hsh_entry_t** he = find_entry(ht, key, klen, NULL);
 #endif
 
     if(he && *he)
@@ -430,19 +430,19 @@ void* hash_get(hash_t* ht, const void *key, size_t klen)
       return NULL;
 }
 
-#ifdef HASH_COPYKEYS
-int hash_set(hash_t* ht, const void* key, void* val)
+#ifdef HSH_COPYKEYS
+int hsh_set(hsh_t* ht, const void* key, void* val)
 {
-  hash_entry_t** hep = find_entry(ht, key, val);
+  hsh_entry_t** hep = find_entry(ht, key, val);
 #else
-int hash_set(hash_t* ht, const void* key, size_t klen, void* val)
+int hsh_set(hsh_t* ht, const void* key, size_t klen, void* val)
 {
-  hash_entry_t** hep = find_entry(ht, key, klen, val);
+  hsh_entry_t** hep = find_entry(ht, key, klen, val);
 #endif
 
   if(hep && *hep)
   {
-#ifdef HASH_CALLBACKS
+#ifdef HSH_CALLBACKS
     if((*hep)->val && (*hep)->val != val && ht->calls.f_freeval)
       (ht->calls.f_freeval)(ht->calls.arg, (void*)((*hep)->val));
 #endif
@@ -450,7 +450,7 @@ int hash_set(hash_t* ht, const void* key, size_t klen, void* val)
     /* replace entry */
     (*hep)->val = val;
 
-#ifdef HASH_TIMESTAMP
+#ifdef HSH_TIMESTAMP
     /* Update or set the timestamp */
     (*hep)->stamp = time(NULL);
 #endif
@@ -468,20 +468,20 @@ int hash_set(hash_t* ht, const void* key, size_t klen, void* val)
   return 0;
 }
 
-#ifdef HASH_COPYKEYS
-void* hash_rem(hash_t* ht, const void* key)
+#ifdef HSH_COPYKEYS
+void* hsh_rem(hsh_t* ht, const void* key)
 {
-  hash_entry_t** hep = find_entry(ht, key, NULL);
+  hsh_entry_t** hep = find_entry(ht, key, NULL);
 #else
-void* hash_rem(hash_t* ht, const void* key, size_t klen)
+void* hsh_rem(hsh_t* ht, const void* key, size_t klen)
 {
-  hash_entry_t** hep = find_entry(ht, key, klen, NULL);
+  hsh_entry_t** hep = find_entry(ht, key, klen, NULL);
 #endif
   void* val = NULL;
 
   if(hep && *hep)
   {
-    hash_entry_t* old = *hep;
+    hsh_entry_t* old = *hep;
     *hep = (*hep)->next;
     --ht->count;
     val = (void*)old->val;
@@ -491,30 +491,30 @@ void* hash_rem(hash_t* ht, const void* key, size_t klen)
   return val;
 }
 
-unsigned int hash_count(hash_t* ht)
+unsigned int hsh_count(hsh_t* ht)
 {
   return ht->count;
 }
 
-#ifdef HASH_TIMESTAMP
-int hash_purge(hash_t* ht, time_t stamp)
+#ifdef HSH_TIMESTAMP
+int hsh_purge(hsh_t* ht, time_t stamp)
 {
-  hash_index_t* hi;
+  hsh_index_t* hi;
   int r = 0;
   void* val;
 
-  for(hi = hash_first(ht); hi; hi = hash_next(hi))
+  for(hi = hsh_first(ht); hi; hi = hsh_next(hi))
   {
     if(hi->ths->stamp < stamp)
     {
       /* No need to check for errors as we're deleting */
-#ifdef HASH_COPYKEYS
-      val = hash_rem(ht, KEY_DATA(hi->ths));
+#ifdef HSH_COPYKEYS
+      val = hsh_rem(ht, KEY_DATA(hi->ths));
 #else
-      val = hash_rem(ht, hi->ths->key, hi->ths->klen);
+      val = hsh_rem(ht, hi->ths->key, hi->ths->klen);
 #endif
 
-#ifdef HASH_CALLBACKS
+#ifdef HSH_CALLBACKS
       if(val && ht->calls.f_freeval)
         (ht->calls.f_freeval)(ht->calls.arg, val);
 #endif
@@ -526,37 +526,37 @@ int hash_purge(hash_t* ht, time_t stamp)
   return r;
 }
 
-#ifdef HASH_COPYKEYS
-void hash_touch(hash_t* ht, const void* key)
+#ifdef HSH_COPYKEYS
+void hsh_touch(hsh_t* ht, const void* key)
 {
-  hash_entry_t** hep = find_entry(ht, key, NULL);
+  hsh_entry_t** hep = find_entry(ht, key, NULL);
 #else
-void hash_touch(hash_t* ht, const void* key, size_t* klen)
+void hsh_touch(hsh_t* ht, const void* key, size_t* klen)
 {
-  hash_entry_t** hep = find_entry(ht, key, klen, NULL);
+  hsh_entry_t** hep = find_entry(ht, key, klen, NULL);
 #endif
 
   if(hep && *hep)
     ((*hep)->stamp) = time(NULL);
 }
 
-int hash_bump(hash_t* ht)
+int hsh_bump(hsh_t* ht)
 {
-  hash_index_t* hi;
+  hsh_index_t* hi;
   void* key = NULL;
   void* val = NULL;
   time_t least = 0;
-#ifndef HASH_COPYKEYS
+#ifndef HSH_COPYKEYS
   size_t klen = 0;
 #endif
 
-  for(hi = hash_first(ht); hi; hi = hash_next(hi))
+  for(hi = hsh_first(ht); hi; hi = hsh_next(hi))
   {
     if(least == 0 || hi->ths->stamp < least)
     {
       least = hi->ths->stamp;
       key = KEY_DATA(hi->ths);
-#ifndef HASH_COPYKEYS
+#ifndef HSH_COPYKEYS
       klen = hi->this->klen;
 #endif
     }
@@ -564,13 +564,13 @@ int hash_bump(hash_t* ht)
 
   if(key)
   {
-#ifdef HASH_COPYKEYS
-    val = hash_rem(ht, key);
+#ifdef HSH_COPYKEYS
+    val = hsh_rem(ht, key);
 #else
-    val = hash_rem(ht, key, klen);
+    val = hsh_rem(ht, key, klen);
 #endif
 
-#ifdef HASH_CALLBACKS
+#ifdef HSH_CALLBACKS
     if(val && ht->calls.f_freeval)
       (ht->calls.f_freeval)(ht->calls.arg, (void*)val);
 #endif
@@ -581,4 +581,4 @@ int hash_bump(hash_t* ht)
   return 0;
 }
 
-#endif /* HASH_TIMESTAMP */
+#endif /* HSH_TIMESTAMP */
diff --git a/common/hash.h b/common/hash.h
index 174c209..fef2803 100644
--- a/common/hash.h
+++ b/common/hash.h
@@ -18,8 +18,8 @@
  * limitations under the License.
  */
 
-#ifndef __HASH_H__
-#define __HASH_H__
+#ifndef __HSH_H__
+#define __HSH_H__
 
 #ifdef __cplusplus
 extern "C" {
@@ -35,13 +35,13 @@ extern "C" {
  */
 
 /* Keep timestamps for the entries */
-#define HASH_TIMESTAMP
+#define HSH_TIMESTAMP
 
 /* Keep key values internally */
-#define HASH_COPYKEYS
+#define HSH_COPYKEYS
 
 /* Hash callback functionality */
-#define HASH_CALLBACKS
+#define HSH_CALLBACKS
 
 /*
  * ARGUMENT DOCUMENTATION
@@ -60,10 +60,10 @@ extern "C" {
  */
 
 /* Abstract type for hash tables. */
-typedef struct hash_t hash_t;
+typedef struct hsh_t hsh_t;
 
 /* Abstract type for scanning hash tables.  */
-typedef struct hash_index_t hash_index_t;
+typedef struct hsh_index_t hsh_index_t;
 
 
 /* ----------------------------------------------------------------------------------
@@ -73,60 +73,60 @@ typedef struct hash_index_t hash_index_t;
  * keys stored in the hashtable itself.
  */
 
-#ifdef HASH_COPYKEYS
+#ifdef HSH_COPYKEYS
 
 /*
- * hash_create : Create a hash table
+ * hsh_create : Create a hash table
  * - returns an allocated hashtable
  */
-hash_t* hash_create(size_t klen);
+hsh_t* hsh_create(size_t klen);
 
 /*
- * hash_free : Free a hash table
+ * hsh_free : Free a hash table
  */
-void hash_free(hash_t* ht);
+void hsh_free(hsh_t* ht);
 
 /*
- * hash_count: Number of values in hash table
+ * hsh_count: Number of values in hash table
  * - returns the number of entries in hash table
  */
-unsigned int hash_count(hash_t* ht);
+unsigned int hsh_count(hsh_t* ht);
 
 /*
- * hash_get: Retrieves a value from the hash table
+ * hsh_get: Retrieves a value from the hash table
  * - returns the value of the entry
  */
-void* hash_get(hash_t* ht, const void* key);
+void* hsh_get(hsh_t* ht, const void* key);
 
 /*
- * hash_set: Set a value in the hash table
+ * hsh_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);
+int hsh_set(hsh_t* ht, const void* key, void* val);
 
 /*
- * hash_rem: Remove a value from the hash table
+ * hsh_rem: Remove a value from the hash table
  * - returns the value of the removed entry
  */
-void* hash_rem(hash_t* ht, const void* key);
+void* hsh_rem(hsh_t* ht, const void* key);
 
 /*
- * hash_first: Start enumerating through the hash table
+ * hsh_first: Start enumerating through the hash table
  * - returns a hash iterator
  */
-hash_index_t* hash_first(hash_t* ht);
+hsh_index_t* hsh_first(hsh_t* ht);
 
 /*
- * hash_next: Enumerate through hash table
+ * hsh_next: Enumerate through hash table
  * - returns the hash iterator or null when no more entries
  */
-hash_index_t* hash_next(hash_index_t* hi);
+hsh_index_t* hsh_next(hsh_index_t* hi);
 
 /*
- * hash_this: While enumerating get current value
+ * hsh_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);
+void* hsh_this(hsh_index_t* hi, const void** key);
 
 
 
@@ -140,63 +140,63 @@ void* hash_this(hash_index_t* hi, const void** key);
 #else
 
 /*
- * hash_create : Create a hash table
+ * hsh_create : Create a hash table
  * - returns an allocated hashtable
  */
-hash_t* hash_create();
+hsh_t* hsh_create();
 
 /*
- * hash_free : Free a hash table
+ * hsh_free : Free a hash table
  */
-void hash_free(hash_t* ht);
+void hsh_free(hsh_t* ht);
 
 /*
- * hash_count: Number of values in hash table
+ * hsh_count: Number of values in hash table
  * - returns the number of entries in hash table
  */
-unsigned int hash_count(hash_t* ht);
+unsigned int hsh_count(hsh_t* ht);
 
 /*
- * hash_get: Retrieves a value from the hash table
+ * hsh_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);
+void* hsh_get(hsh_t* ht, const void* key, size_t klen);
 
 /*
- * hash_set: Set a value in the hash table
+ * hsh_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);
+int hsh_set(hsh_t* ht, const void* key, size_t klen, void* val);
 
 /*
- * hash_rem: Remove a value from the hash table
+ * hsh_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);
+void* hsh_rem(hsh_t* ht, const void* key, size_t klen);
 
 /*
- * hash_first: Start enumerating through the hash table
+ * hsh_first: Start enumerating through the hash table
  * - returns a hash iterator
  */
-hash_index_t* hash_first(hash_t* ht);
+hsh_index_t* hsh_first(hsh_t* ht);
 
 /*
- * hash_next: Enumerate through hash table
+ * hsh_next: Enumerate through hash table
  * - returns the hash iterator or null when no more entries
  */
-hash_index_t* hash_next(hash_index_t* hi);
+hsh_index_t* hsh_next(hsh_index_t* hi);
 
 /*
- * hash_this: While enumerating get current value
+ * hsh_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);
+void* hsh_this(hsh_index_t* hi, const void** key, size_t* klen);
 
 /*
  * 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.
  */
-#define HASH_KEY_STRING     (-1)
+#define HSH_KEY_STRING     (-1)
 
 #endif
 
@@ -210,27 +210,27 @@ void* hash_this(hash_index_t* hi, const void** key, size_t* klen);
  * functions in addition to one of the above 'key' modes.
  */
 
-#ifdef HASH_TIMESTAMP
+#ifdef HSH_TIMESTAMP
 
 /*
- * hash_purge: Purge entries before a certain timestamp
+ * hsh_purge: Purge entries before a certain timestamp
  * - returns the number of entries purged
  */
-int hash_purge(hash_t* ht, time_t stamp);
+int hsh_purge(hsh_t* ht, time_t stamp);
 
 /*
- * hash_touch: Touch an entry to make it's timestamp current
+ * hsh_touch: Touch an entry to make it's timestamp current
  */
-#ifdef HASH_COPYKEYS
-  void hash_touch(hash_t* ht, const void* key);
+#ifdef HSH_COPYKEYS
+  void hsh_touch(hsh_t* ht, const void* key);
 #else
-  void hash_touch(hash_t* ht, const void* key, size_t* klen);
+  void hsh_touch(hsh_t* ht, const void* key, size_t* klen);
 #endif
 
 /*
- * hash_bump: Bumps the oldest entry out
+ * hsh_bump: Bumps the oldest entry out
  */
-int hash_bump(hash_t* ht);
+int hsh_bump(hsh_t* ht);
 
 #endif
 
@@ -243,34 +243,34 @@ int hash_bump(hash_t* ht);
  * well as to get callbacks when an item is discarded.
  */
 
-#ifdef HASH_CALLBACKS
+#ifdef HSH_CALLBACKS
 
-typedef void* (*hash_falloc)(void* arg, size_t len);
-typedef void (*hash_ffree)(void* arg, void* ptr);
+typedef void* (*hsh_falloc)(void* arg, size_t len);
+typedef void (*hsh_ffree)(void* arg, void* ptr);
 
-typedef struct hash_memory_calls
+typedef struct hsh_memory_calls
 {
-  hash_falloc f_alloc;
-  hash_ffree f_free;
+  hsh_falloc f_alloc;
+  hsh_ffree f_free;
   void* arg;
 }
-hash_memory_calls_t;
+hsh_memory_calls_t;
 
 /* Set the global memory calls */
-void hash_set_memory_calls(hash_memory_calls_t* hmc);
+void hsh_set_memory_calls(hsh_memory_calls_t* hmc);
 
 
-typedef void (*hash_ffreeval)(void* arg, void* val);
+typedef void (*hsh_ffreeval)(void* arg, void* val);
 
-typedef struct hash_table_calls
+typedef struct hsh_table_calls
 {
-  hash_ffreeval f_freeval;
+  hsh_ffreeval f_freeval;
   void* arg;
 }
-hash_table_calls_t;
+hsh_table_calls_t;
 
 /* Set the per table free value call */
-void hash_set_table_calls(hash_t* ht, hash_table_calls_t* htc);
+void hsh_set_table_calls(hsh_t* ht, hsh_table_calls_t* htc);
 
 #endif
 
@@ -281,4 +281,4 @@ void hash_set_table_calls(hash_t* ht, hash_table_calls_t* htc);
 }
 #endif
 
-#endif  /* __HASH_H__ */
+#endif  /* __HSH_H__ */
diff --git a/common/sock_any.c b/common/sock_any.c
index acac8ee..0018318 100644
--- a/common/sock_any.c
+++ b/common/sock_any.c
@@ -1,3 +1,40 @@
+/*
+ * Copyright (c) 2004, Nate Nielsen
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions of source code must retain the above
+ *       copyright notice, this list of conditions and the
+ *       following disclaimer.
+ *     * Redistributions in binary form must reproduce the
+ *       above copyright notice, this list of conditions and
+ *       the following disclaimer in the documentation and/or
+ *       other materials provided with the distribution.
+ *     * The names of contributors to this software may not be
+ *       used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ *
+ * CONTRIBUTORS
+ *  Nate Nielsen <nielsen@memberwebs.com>
+ *
+ */
 
 #include <stdlib.h>
 #include <errno.h>
@@ -10,12 +47,15 @@
 
 #include <arpa/inet.h>
 
-int sock_any_pton(const char* addr, struct sockaddr_any* any, int defport)
+#define LOCALHOST_ADDR  0x7F000001
+
+int sock_any_pton(const char* addr, struct sockaddr_any* any, int opts)
 {
   size_t l;
-  char buf[256];   /* TODO: Use a constant */
+  char buf[256];
   char* t;
   char* t2;
+  int defport = (opts & 0xFFFF);
 
   memset(any, 0, sizeof(*any));
 
@@ -32,13 +72,35 @@ int sock_any_pton(const char* addr, struct sockaddr_any* any, int defport)
     if(l < PORT_MIN || l > PORT_MAX || addr[l] != 0)
       break;
 
-    port = strtol(t, &t2, 10);
+    port = strtol(addr, &t2, 10);
     if(*t2 || port <= 0 || port >= 65536)
       break;
 
-    any->s.in.sin_family = AF_INET;
-    any->s.in.sin_port = htons((unsigned short)(port <= 0 ? defport : port));
-    any->s.in.sin_addr.s_addr = 0;
+    any->s.in.sin_port = htons(port);
+
+    /* Fill in the type based on defaults */
+#ifdef HAVE_INET6
+    if(opts & SANY_OPT_DEFINET6)
+        any->s.in.sin_family = AF_INET6;
+    else
+#endif
+        any->s.in.sin_family = AF_INET;
+
+    /* Fill in the address based on defaults */
+    if(opts & SANY_OPT_DEFLOCAL)
+    {
+#ifdef HAVE_INET6
+        if(opts & SANY_OPT_DEFINET6)
+            memcpy(&(any->s.in.sin6_addr), &in6addr_loopback, sizeof(struct in6_addr));
+        else
+#endif
+            any->s.in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+    }
+
+    /*
+     * Note the 'any' option is the default since we zero out
+     * the entire structure above.
+     */
 
     any->namelen = sizeof(any->s.in);
     return AF_INET;
@@ -237,9 +299,10 @@ int sock_any_pton(const char* addr, struct sockaddr_any* any, int defport)
   return -1;
 }
 
-int sock_any_ntop(struct sockaddr_any* any, char* addr, size_t addrlen)
+int sock_any_ntop(struct sockaddr_any* any, char* addr, size_t addrlen, int opts)
 {
   int len = 0;
+  int port = 0;
 
   switch(any->s.a.sa_family)
   {
@@ -257,12 +320,14 @@ int sock_any_ntop(struct sockaddr_any* any, char* addr, size_t addrlen)
   case AF_INET:
     if(inet_ntop(any->s.a.sa_family, &(any->s.in.sin_addr), addr, addrlen) == NULL)
       return -1;
+    port = ntohs(any->s.in.sin_port);
     break;
 
 #ifdef HAVE_INET6
   case AF_INET6:
     if(inet_ntop(any->s.a.sa_family, &(any->s.in6.sin6_addr), addr, addrlen) == NULL)
       return -1;
+    port = ntohs(any->s.in6.sin6_port);
     break;
 #endif
 
@@ -271,5 +336,17 @@ int sock_any_ntop(struct sockaddr_any* any, char* addr, size_t addrlen)
     return -1;
   }
 
+  if(!(opts & SANY_OPT_NOPORT) && port != 0)
+  {
+    strncat(addr, ":", addrlen);
+    addr[addrlen - 1] = 0;
+
+    len = strlen(addr);
+    addr += len;
+    addrlen -= len;
+
+    snprintf(addr, addrlen, "%d", port);
+  }
+
   return 0;
 }
diff --git a/common/sock_any.h b/common/sock_any.h
index 693bd2a..0b492b4 100644
--- a/common/sock_any.h
+++ b/common/sock_any.h
@@ -1,3 +1,40 @@
+/*
+ * Copyright (c) 2004, Nate Nielsen
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions of source code must retain the above
+ *       copyright notice, this list of conditions and the
+ *       following disclaimer.
+ *     * Redistributions in binary form must reproduce the
+ *       above copyright notice, this list of conditions and
+ *       the following disclaimer in the documentation and/or
+ *       other materials provided with the distribution.
+ *     * The names of contributors to this software may not be
+ *       used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ *
+ * CONTRIBUTORS
+ *  Nate Nielsen <nielsen@memberwebs.com>
+ *
+ */
 
 #ifndef __SOCK_ANY_H__
 #define __SOCK_ANY_H__
@@ -27,7 +64,25 @@ struct sockaddr_any
 #define SANY_LEN(any)   ((any).namelen)
 #define SANY_TYPE(any)  ((any).s.a.sa_family)
 
-int sock_any_pton(const char* addr, struct sockaddr_any* any, int defport);
-int sock_any_ntop(struct sockaddr_any* any, char* addr, size_t addrlen);
+int sock_any_pton(const char* addr, struct sockaddr_any* any, int opts);
+
+/* The default port to fill in when no IP/IPv6 port specified */
+#define SANY_OPT_DEFPORT(p)     (int)((p) & 0xFFFF)
+
+/* When only port specified default to IPANY */
+#define SANY_OPT_DEFANY         0x00000000
+
+/* When only port specified default to LOCALHOST */
+#define SANY_OPT_DEFLOCAL       0x00100000
+
+/* When only port specified default to IPv6 */
+#ifdef HAVE_INET6
+#define SANY_OPT_DEFINET6       0x00200000
+#endif
+
+int sock_any_ntop(struct sockaddr_any* any, char* addr, size_t addrlen, int opts);
+
+/* Don't print the port */
+#define SANY_OPT_NOPORT         0x01000000
 
 #endif /* __SOCK_ANY_H__ */