diff --git a/src/util-error.h b/src/util-error.h
index 82a6cfd19e..5e1910f97b 100644
--- a/src/util-error.h
+++ b/src/util-error.h
@@ -16,6 +16,7 @@ typedef enum {
     SC_COUNTER_EXCEEDED,
     SC_INVALID_CHECKSUM,
     SC_SPRINTF_ERROR,
+    SC_INVALID_ARGUMENT,
 } SCError;
 
 const char *SCErrorToString(SCError);
diff --git a/src/util-radix-tree.c b/src/util-radix-tree.c
index 35926eeb0f..4f4dd0dc51 100644
--- a/src/util-radix-tree.c
+++ b/src/util-radix-tree.c
@@ -11,120 +11,105 @@
 #include <arpa/inet.h>
 
 #include "util-radix-tree.h"
+#include "util-debug.h"
+#include "util-error.h"
 #include "util-unittest.h"
 
 /**
- * \brief Creates a new node for the Radix tree
+ * \brief Creates a new Prefix for a key.  Used internally by the API.
  *
- * \retval node The newly created node for the radix tree
- */
-static inline SCRadixNode *SCRadixCreateNode()
-{
-    SCRadixNode *node = NULL;
-
-    if ( (node = malloc(sizeof(SCRadixNode))) == NULL) {
-        printf("Error allocating memory\n");
-        exit(EXIT_FAILURE);
-    }
-    memset(node, 0, sizeof(SCRadixNode));
-
-    return node;
-}
-
-/**
- * \brief Frees a Radix tree node
- *
- * \param node Pointer to a Radix tree node
- */
-static inline void SCRadixReleaseNode(SCRadixNode *node)
-{
-    if (node != NULL) {
-        //SCRadixReleaseKeyPrefix(node->prefix);
-        free(node);
-    }
-
-    return;
-}
-
-/**
- * \brief Creates a new Prefix
- *
- * \param stream Data that has to be wrapped in a SCRadixPrefix instance to be
- *               processed for insertion/lookup by the radix tree
- * \param bitlen The bitlen of the the above stream.  For example if the stream
- *               holds the ipv4 address(in 1 byte), bitlen would be 32
+ * \param key_stream Data that has to be wrapped in a SCRadixPrefix instance to
+ *                   be processed for insertion/lookup/removal of a node by the
+ *                   radix tree
+ * \param key_bitlen The bitlen of the the above stream.  For example if the
+ *                   stream holds the ipv4 address(4 bytes), bitlen would be 32
+ * \param user       Pointer to the user data that has to be associated with
+ *                   this key
  *
  * \retval prefix The newly created prefix instance on success; NULL on failure
  */
-SCRadixPrefix *SCRadixCreatePrefix(uint8_t *stream, uint16_t bitlen)
+static SCRadixPrefix *SCRadixCreatePrefix(uint8_t *key_stream,
+                                          uint16_t key_bitlen, void *user)
 {
     SCRadixPrefix *prefix = NULL;
 
-    if ((bitlen % 8 != 0) || bitlen == 0) {
-        printf("Error: SCRadixCreatePrefix: Invalid bitlen: %d", bitlen);
+    if ((key_bitlen % 8 != 0) || key_bitlen == 0) {
+        SCLogError(SC_INVALID_ARGUMENT, "Invalid argument bitlen - %d", key_bitlen);
         return NULL;
     }
 
-    if (stream == NULL) {
-        printf("Error: SCRadixCreatePrefix: Argument \"stream\" NULL");
+    if (key_stream == NULL) {
+        SCLogError(SC_INVALID_ARGUMENT, "Argument \"stream\" NULL");
         return NULL;
     }
 
     if ( (prefix = malloc(sizeof(SCRadixPrefix))) == NULL) {
-        printf("Error allocating memory\n");
+        SCLogError(SC_ERR_MEM_ALLOC, "Error allocating memory");
         exit(EXIT_FAILURE);
     }
     memset(prefix, 0, sizeof(SCRadixPrefix));
 
-    if ( (prefix->stream = malloc(bitlen / 8)) == NULL) {
-        printf("Error allocating memory\n");
+    if ( (prefix->stream = malloc(key_bitlen / 8)) == NULL) {
+        SCLogError(SC_ERR_MEM_ALLOC, "Error allocating memory");
         exit(EXIT_FAILURE);
     }
-    memset(prefix->stream, 0, bitlen / 8);
+    memset(prefix->stream, 0, key_bitlen / 8);
 
-    memcpy(prefix->stream, stream, bitlen / 8);
-    prefix->bitlen = bitlen;
+    memcpy(prefix->stream, key_stream, key_bitlen / 8);
+    prefix->bitlen = key_bitlen;
+    prefix->user = user;
 
     return prefix;
 }
 
 /**
- * \brief Creates a new Prefix for an IPV4 address
- *
- * \param stream IPV4 address that has to be wrapped in a SCRadixPrefix instance
- *               to be processed for insertion/lookup by the radix tree
+ * \brief Frees a SCRadixPrefix instance
  *
- * \retval prefix The newly created prefix instance on success; NULL on failure
+ * \param prefix Pointer to a prefix instance
+ * \param tree   Pointer to the Radix tree to which this prefix belongs
  */
-SCRadixPrefix *SCRadixCreateIPV4Prefix(uint8_t *stream)
+static void SCRadixReleasePrefix(SCRadixPrefix *prefix, SCRadixTree *tree)
 {
-    return SCRadixCreatePrefix(stream, 32);
+    if (prefix != NULL) {
+        if (tree->Free != NULL)
+            tree->Free(prefix->user);
+        if (prefix->stream != NULL)
+            free(prefix->stream);
+        free(prefix);
+    }
+
+    return;
 }
 
 /**
- * \brief Creates a new Prefix for an IPV6 address
- *
- * \param stream IPV6 address that has to be wrapped in a SCRadixPrefix instance
- *               to be processed for insertion/lookup by the radix tree
+ * \brief Creates a new node for the Radix tree
  *
- * \retval prefix The newly created prefix instance on success; NULL on failure
+ * \retval node The newly created node for the radix tree
  */
-SCRadixPrefix *SCRadixCreateIPV6Prefix(uint8_t *stream)
+static inline SCRadixNode *SCRadixCreateNode()
 {
-    return SCRadixCreatePrefix(stream, 128);
+    SCRadixNode *node = NULL;
+
+    if ( (node = malloc(sizeof(SCRadixNode))) == NULL) {
+        SCLogError(SC_ERR_MEM_ALLOC, "Error allocating memory");
+        exit(EXIT_FAILURE);
+    }
+    memset(node, 0, sizeof(SCRadixNode));
+
+    return node;
 }
 
 /**
- * \brief Frees a SCRadixPrefix instance
+ * \brief Frees a Radix tree node
  *
- * \param prefix Pointer to a prefix instance
+ * \param node Pointer to a Radix tree node
+ * \param tree Pointer to the Radix tree to which this node belongs
  */
-void SCRadixReleasePrefix(SCRadixPrefix *prefix)
+static inline void SCRadixReleaseNode(SCRadixNode *node, SCRadixTree *tree)
 {
-    if (prefix != NULL) {
-        if (prefix->stream != NULL)
-            free(prefix->stream);
-        free(prefix);
+    if (node != NULL) {
+        SCRadixReleasePrefix(node->prefix, tree);
+        free(node);
     }
 
     return;
@@ -133,32 +118,39 @@ void SCRadixReleasePrefix(SCRadixPrefix *prefix)
 /**
  * \brief Creates a new Radix tree
  *
+ * \param Free Function pointer supplied by the user to be used by the Radix
+ *             cleanup API to free the user suppplied data
+ *
  * \retval tree The newly created radix tree on success
  */
-SCRadixTree *SCRadixCreateRadixTree()
+SCRadixTree *SCRadixCreateRadixTree(void (*Free)(void*))
 {
     SCRadixTree *tree = NULL;
 
     if ( (tree = malloc(sizeof(SCRadixTree))) == NULL) {
-        printf("Error allocating memory\n");
+        SCLogError(SC_ERR_MEM_ALLOC, "Error allocating memory");
         exit(EXIT_FAILURE);
     }
     memset(tree, 0, sizeof(SCRadixTree));
 
+    tree->Free = Free;
+
     return tree;
 }
 
 /**
- * \brief Internal helper function used by SCRadixReleaseRadixTree to free a subtree
+ * \brief Internal helper function used by SCRadixReleaseRadixTree to free a
+ *        subtree
  *
  * \param node Pointer to the root of the subtree that has to be freed
+ * \param tree Pointer to the Radix tree to which this subtree belongs
  */
-static void SCRadixReleaseRadixSubtree(SCRadixNode *node)
+static void SCRadixReleaseRadixSubtree(SCRadixNode *node, SCRadixTree *tree)
 {
     if (node != NULL) {
-        SCRadixReleaseRadixSubtree(node->left);
-        SCRadixReleaseRadixSubtree(node->right);
-        SCRadixReleaseNode(node);
+        SCRadixReleaseRadixSubtree(node->left, tree);
+        SCRadixReleaseRadixSubtree(node->right, tree);
+        SCRadixReleaseNode(node, tree);
     }
 
     return;
@@ -171,7 +163,7 @@ static void SCRadixReleaseRadixSubtree(SCRadixNode *node)
  */
 void SCRadixReleaseRadixTree(SCRadixTree *tree)
 {
-    SCRadixReleaseRadixSubtree(tree->head);
+    SCRadixReleaseRadixSubtree(tree->head, tree);
 
     tree->head = NULL;
 
@@ -179,14 +171,20 @@ void SCRadixReleaseRadixTree(SCRadixTree *tree)
 }
 
 /**
- * \brief Adds a prefix to the Radix tree
+ * \brief Adds a key to the Radix tree.  Used internally by the API.
  *
- * \param tree   Pointer to the Radix tree
- * \param prefix The prefix that has to be added to the Radix tree
+ * \param key_stream Data that has to added to the Radix tree
+ * \param key_bitlen The bitlen of the the above stream.  For example if the
+ *                   stream is the string "abcd", the bitlen would be 32.  If
+ *                   the stream is an IPV6 address bitlen would be 128
+ * \param tree       Pointer to the Radix tree
+ * \param user       Pointer to the user data that has to be associated with
+ *                   this key
  *
  * \retval node Pointer to the newly created node
  */
-SCRadixNode *SCRadixAddKey(SCRadixPrefix *prefix, SCRadixTree *tree)
+static SCRadixNode *SCRadixAddKey(uint8_t *key_stream, uint16_t key_bitlen,
+                                  SCRadixTree *tree, void *user)
 {
     SCRadixNode *node = NULL;
     SCRadixNode *new_node = NULL;
@@ -194,6 +192,8 @@ SCRadixNode *SCRadixAddKey(SCRadixPrefix *prefix, SCRadixTree *tree)
     SCRadixNode *inter_node = NULL;
     SCRadixNode *bottom_node = NULL;
 
+    SCRadixPrefix *prefix = NULL;
+
     uint8_t *stream = NULL;
     uint8_t bitlen = 0;
 
@@ -204,6 +204,14 @@ SCRadixNode *SCRadixAddKey(SCRadixPrefix *prefix, SCRadixTree *tree)
     int j = 0;
     int temp = 0;
 
+    if ( (prefix = SCRadixCreatePrefix(key_stream, key_bitlen, user)) == NULL)
+        return NULL;
+
+    if (tree == NULL) {
+        SCLogError(SC_INVALID_ARGUMENT, "Argument \"tree\" NULL");
+        return NULL;
+    }
+
     if (tree->head == NULL) {
         node = SCRadixCreateNode();
         node->prefix = prefix;
@@ -258,8 +266,8 @@ SCRadixNode *SCRadixAddKey(SCRadixPrefix *prefix, SCRadixTree *tree)
         }
 
         /* find out the position where the first bit differs.  This method is
-         * larger and faster, but with larger caches these days we don't have
-         * to worry about cache misses */
+         * faster, but at the cost of being larger.  But with larger caches
+         * these days we don't have to worry about cache misses */
         temp = temp * 2;
         if (temp >= 256)
             j = 0;
@@ -296,7 +304,7 @@ SCRadixNode *SCRadixAddKey(SCRadixPrefix *prefix, SCRadixTree *tree)
         if (node->prefix)
             return node;
 
-        node->prefix = SCRadixCreatePrefix(prefix->stream, prefix->bitlen);
+        node->prefix = SCRadixCreatePrefix(prefix->stream, prefix->bitlen, NULL);
         return node;
     }
 
@@ -353,23 +361,91 @@ SCRadixNode *SCRadixAddKey(SCRadixPrefix *prefix, SCRadixTree *tree)
     return new_node;
 }
 
+/**
+ * \brief Adds a new generic key to the Radix tree
+ *
+ * \param key_stream Data that has to be added to the Radix tree
+ * \param key_bitlen The bitlen of the the above stream.  For example if the
+ *                   stream is the string "abcd", the bitlen would be 32
+ * \param tree       Pointer to the Radix tree
+ * \param user       Pointer to the user data that has to be associated with the
+ *                   key
+ *
+ * \retval node Pointer to the newly created node
+ */
+SCRadixNode *SCRadixAddKeyGeneric(uint8_t *key_stream, uint16_t key_bitlen,
+                                  SCRadixTree *tree, void *user)
+{
+    SCRadixNode *node = SCRadixAddKey(key_stream, key_bitlen, tree, user);
+
+    return node;
+}
+
+/**
+ * \brief Adds a new IPV4 address to the Radix tree
+ *
+ * \param key_stream Data that has to be added to the Radix tree.  In this case
+ *                   a pointer to an IPV4 address
+ * \param tree       Pointer to the Radix tree
+ * \param user       Pointer to the user data that has to be associated with the
+ *                   key
+ *
+ * \retval node Pointer to the newly created node
+ */
+SCRadixNode *SCRadixAddKeyIPV4(uint8_t *key_stream, SCRadixTree *tree,
+                               void *user)
+{
+    SCRadixNode *node = SCRadixAddKey(key_stream, 32, tree, user);
+
+    return node;
+}
+
+/**
+ * \brief Adds a new IPV6 address to the Radix tree
+ *
+ * \param key_stream Data that has to be added to the Radix tree.  In this case
+ *                   the pointer to an IPV6 address
+ * \param tree       Pointer to the Radix tree
+ * \param user       Pointer to the user data that has to be associated with the
+ *                   key
+ *
+ * \retval node Pointer to the newly created node
+ */
+SCRadixNode *SCRadixAddKeyIPV6(uint8_t *key_stream, SCRadixTree *tree,
+                               void *user)
+{
+    SCRadixNode *node = SCRadixAddKey(key_stream, 128, tree, user);
+
+    return node;
+}
+
 /**
  * \brief Removes a key from the Radix tree
  *
- * \param prefix Pointer to the key instance that has to be removed
- * \param tree   Pointer to the Radix tree from which the key has to be removed
+ * \param key_stream Data that has to be removed from the Radix tree
+ * \param key_bitlen The bitlen of the the above stream.  For example if the
+ *                   stream holds an IPV4 address(4 bytes), bitlen would be 32
+ * \param tree       Pointer to the Radix tree from which the key has to be
+ *                   removed
  */
-void SCRadixRemoveKey(SCRadixPrefix *prefix, SCRadixTree *tree)
+static void SCRadixRemoveKey(uint8_t *key_stream, uint16_t key_bitlen,
+                             SCRadixTree *tree)
 {
     SCRadixNode *node = tree->head;
     SCRadixNode *parent = NULL;
     SCRadixNode *temp = NULL;
+
+    SCRadixPrefix *prefix = NULL;
+
     int mask = 0;
     int i = 0;
 
     if (node == NULL)
         return;
 
+    if ( (prefix = SCRadixCreatePrefix(key_stream, key_bitlen, NULL)) == NULL)
+        return;
+
     while (node->bit < prefix->bitlen) {
         if (SC_RADIX_BITTEST(prefix->stream[node->bit >> 3],
                              (0x80 >> (node->bit % 8))) ) {
@@ -394,6 +470,8 @@ void SCRadixRemoveKey(SCRadixPrefix *prefix, SCRadixTree *tree)
             ;
         else
             return;
+    } else {
+        return;
     }
 
     if (tree->head == node) {
@@ -421,8 +499,8 @@ void SCRadixRemoveKey(SCRadixPrefix *prefix, SCRadixTree *tree)
                 parent->left->parent = parent->parent;
             }
         }
-        SCRadixReleaseNode(parent);
-        SCRadixReleaseNode(node);
+        SCRadixReleaseNode(parent, tree);
+        SCRadixReleaseNode(node, tree);
     } else {
         temp = tree->head;
         if (parent->left == node) {
@@ -432,28 +510,73 @@ void SCRadixRemoveKey(SCRadixPrefix *prefix, SCRadixTree *tree)
             tree->head->left->parent = NULL;
             tree->head = tree->head->left;
         }
-        SCRadixReleaseNode(temp);
-        SCRadixReleaseNode(node);
+        SCRadixReleaseNode(temp, tree);
+        SCRadixReleaseNode(node, tree);
     }
     return;
 }
 
+/**
+ * \brief Removes a key from the Radix tree
+ *
+ * \param key_stream Data that has to be removed from the Radix tree
+ * \param key_bitlen The bitlen of the the above stream.
+ * \param tree       Pointer to the Radix tree from which the key has to be
+ *                   removed
+ */
+void SCRadixRemoveKeyGeneric(uint8_t *key_stream, uint16_t key_bitlen,
+                             SCRadixTree *tree)
+{
+    return SCRadixRemoveKey(key_stream, key_bitlen, tree);
+}
+
+/**
+ * \brief Removes an IPV4 address key from the Radix tree
+ *
+ * \param key_stream Data that has to be removed from the Radix tree.  In this
+ *                   case an IPV4 address
+ * \param tree       Pointer to the Radix tree from which the key has to be
+ *                   removed
+ */
+void SCRadixRemoveKeyIPV4(uint8_t *key_stream, SCRadixTree *tree)
+{
+    return SCRadixRemoveKey(key_stream, 32, tree);
+}
+
+/**
+ * \brief Removes an IPV6 address key from the Radix tree
+ *
+ * \param key_stream Data that has to be removed from the Radix tree.  In this
+ *                   case an IPV6 address
+ * \param tree       Pointer to the Radix tree from which the key has to be
+ *                   removed
+ */
+void SCRadixRemoveKeyIPV6(uint8_t *key_stream, SCRadixTree *tree)
+{
+    return SCRadixRemoveKey(key_stream, 128, tree);
+}
+
 /**
  * \brief Checks if a key is present in the tree
  *
- * \param prefix Pointer to a SCRadixPrefix instance that holds the key to be
- *               checked
- * \param tree   Pointer to the Radix tree instance
+ * \param key_stream Data that has to be found in the Radix tree
+ * \param key_bitlen The bitlen of the above stream.
+ * \param tree       Pointer to the Radix tree
  */
-SCRadixNode *SCRadixFindKey(SCRadixPrefix *prefix, SCRadixTree *tree)
+static SCRadixNode *SCRadixFindKey(uint8_t *key_stream, uint16_t key_bitlen,
+                                   SCRadixTree *tree)
 {
     SCRadixNode *node = tree->head;
+    SCRadixPrefix *prefix = NULL;
     int mask = 0;
     int i = 0;
 
     if (tree->head == NULL)
         return NULL;
 
+    if ( (prefix = SCRadixCreatePrefix(key_stream, key_bitlen, NULL)) == NULL)
+        return NULL;
+
     while (node->bit < prefix->bitlen) {
         if (SC_RADIX_BITTEST(prefix->stream[node->bit >> 3],
                              (0x80 >> (node->bit % 8))) ) {
@@ -481,6 +604,43 @@ SCRadixNode *SCRadixFindKey(SCRadixPrefix *prefix, SCRadixTree *tree)
     return NULL;
 }
 
+/**
+ * \brief Checks if a key is present in the tree
+ *
+ * \param key_stream Data that has to be found in the Radix tree
+ * \param key_bitlen The bitlen of the the above stream.
+ * \param tree       Pointer to the Radix tree instance
+ */
+SCRadixNode *SCRadixFindKeyGeneric(uint8_t *key_stream, uint16_t key_bitlen,
+                                   SCRadixTree *tree)
+{
+    return SCRadixFindKey(key_stream, key_bitlen, tree);
+}
+
+/**
+ * \brief Checks if an IPV4 address is present in the tree
+ *
+ * \param key_stream Data that has to be found in the Radix tree.  In this case
+ *                   an IPV4 address
+ * \param tree       Pointer to the Radix tree instance
+ */
+SCRadixNode *SCRadixFindKeyIPV4(uint8_t *key_stream, SCRadixTree *tree)
+{
+    return SCRadixFindKey(key_stream, 32, tree);
+}
+
+/**
+ * \brief Checks if an IPV6 address is present in the tree
+ *
+ * \param key_stream Data that has to be found in the Radix tree.  In this case
+ *                   an IPV6 address
+ * \param tree       Pointer to the Radix tree instance
+ */
+SCRadixNode *SCRadixFindKeyIPV6(uint8_t *key_stream, SCRadixTree *tree)
+{
+    return SCRadixFindKey(key_stream, 128, tree);
+}
+
 /**
  * \brief Prints the node information from a Radix tree
  *
@@ -564,16 +724,14 @@ void SCRadixPrintTree(SCRadixTree *tree)
 int SCRadixTestInsertion01(void)
 {
     SCRadixTree *tree = NULL;
-    SCRadixPrefix *prefix = NULL;
     SCRadixNode *node[2];
 
     int result = 1;
 
-    tree = SCRadixCreateRadixTree();
-    prefix = SCRadixCreatePrefix((uint8_t *)"abaa", 32);
-    node[0] = SCRadixAddKey(prefix, tree);
-    prefix = SCRadixCreatePrefix((uint8_t *)"abab", 32);
-    node[1] = SCRadixAddKey(prefix, tree);
+    tree = SCRadixCreateRadixTree(NULL);
+
+    node[0] = SCRadixAddKeyGeneric((uint8_t *)"abaa", 32, tree, NULL);
+    node[1] = SCRadixAddKeyGeneric((uint8_t *)"abab", 32, tree, NULL);
 
     result &= (tree->head->bit == 30);
     result &= (tree->head->right == node[0]);
@@ -587,106 +745,125 @@ int SCRadixTestInsertion01(void)
 int SCRadixTestInsertion02(void)
 {
     SCRadixTree *tree = NULL;
-    SCRadixPrefix *prefix = NULL;
-
     int result = 1;
 
-    tree = SCRadixCreateRadixTree();
-    prefix = SCRadixCreatePrefix((uint8_t *)"aaaaaa", 48);
-    SCRadixAddKey(prefix, tree);
-    prefix = SCRadixCreatePrefix((uint8_t *)"aaaaab", 48);
-    SCRadixAddKey(prefix, tree);
-    prefix = SCRadixCreatePrefix((uint8_t *)"aaaaaba", 56);
-    SCRadixAddKey(prefix, tree);
-    prefix = SCRadixCreatePrefix((uint8_t *)"abab", 32);
-    SCRadixAddKey(prefix, tree);
+    tree = SCRadixCreateRadixTree(NULL);
 
+    SCRadixAddKeyGeneric((uint8_t *)"aaaaaa", 48, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"aaaaab", 48, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"aaaaaba", 56, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"abab", 32, tree, NULL);
     SCRadixReleaseRadixTree(tree);
 
-    /* If we don't have a segfault till here we have succeeded */
+    /* If we don't have a segfault till here we have succeeded :) */
     return result;
 }
 
 int SCRadixTestIPV4Insertion03(void)
 {
     SCRadixTree *tree = NULL;
-    SCRadixPrefix *prefix[10];
-    SCRadixPrefix *temp_prefix = NULL;
-
     struct sockaddr_in servaddr;
-
     int result = 1;
 
+    tree = SCRadixCreateRadixTree(NULL);
+
     /* add the keys */
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "192.168.1.1", &servaddr.sin_addr) <= 0)
         return 0;
-    tree = SCRadixCreateRadixTree();
-    prefix[0] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[0], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "192.168.1.2", &servaddr.sin_addr) <= 0)
         return 0;
-    prefix[1] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[1], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "192.167.1.3", &servaddr.sin_addr) <= 0)
         return 0;
-    prefix[2] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[2], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "192.167.1.4", &servaddr.sin_addr) <= 0)
         return 0;
-    prefix[3] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[3], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
-    /* Try to add the prefix that already exists in the tree */
-    SCRadixAddKey(prefix[2], tree);
+    /* add a key that already exists in the tree */
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
+    /* test for the existance of a key */
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.168.1.6", &servaddr.sin_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) == NULL);
+
+    /* test for the existance of a key */
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.167.1.4", &servaddr.sin_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) != NULL);
+
+    /* continue adding keys */
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "220.168.1.2", &servaddr.sin_addr) <= 0)
         return 0;
-    prefix[4] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[4], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
+    bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "192.168.1.5", &servaddr.sin_addr) <= 0)
         return 0;
-    prefix[5] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[5], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
+    bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "192.168.1.18", &servaddr.sin_addr) <= 0)
         return 0;
-    prefix[6] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[6], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
     /* test the existence of keys */
-    result &= (SCRadixFindKey(prefix[0], tree) != NULL);
-
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "192.168.1.3", &servaddr.sin_addr) <= 0)
         return 0;
-    temp_prefix = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    result &= (SCRadixFindKey(temp_prefix, tree) == NULL);
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) == NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "127.234.2.62", &servaddr.sin_addr) <= 0)
         return 0;
-    temp_prefix = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    result &= (SCRadixFindKey(temp_prefix, tree) == NULL);
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) == NULL);
+
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.168.1.1", &servaddr.sin_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) != NULL);
 
-    result &= (SCRadixFindKey(prefix[2], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[3], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[4], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[5], tree) != NULL);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.168.1.5", &servaddr.sin_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) != NULL);
 
     bzero(&servaddr, sizeof(servaddr));
-    if (inet_pton(AF_INET, "192.168.1.6", &servaddr.sin_addr) <= 0)
+    if (inet_pton(AF_INET, "192.168.1.2", &servaddr.sin_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) != NULL);
+
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.167.1.3", &servaddr.sin_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) != NULL);
+
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.167.1.4", &servaddr.sin_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) != NULL);
+
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "220.168.1.2", &servaddr.sin_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) != NULL);
+
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.168.1.18", &servaddr.sin_addr) <= 0)
         return 0;
-    temp_prefix = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    result &= (SCRadixFindKey(temp_prefix, tree) == NULL);
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) != NULL);
 
     SCRadixReleaseRadixTree(tree);
 
@@ -696,442 +873,562 @@ int SCRadixTestIPV4Insertion03(void)
 int SCRadixTestIPV4Removal04(void)
 {
     SCRadixTree *tree = NULL;
-    SCRadixPrefix *prefix[10];
-
     struct sockaddr_in servaddr;
-
     int result = 1;
 
+    tree = SCRadixCreateRadixTree(NULL);
+
     /* add the keys */
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "192.168.1.1", &servaddr.sin_addr) <= 0)
         return 0;
-    tree = SCRadixCreateRadixTree();
-    prefix[0] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[0], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "192.168.1.2", &servaddr.sin_addr) <= 0)
         return 0;
-    prefix[1] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[1], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "192.167.1.3", &servaddr.sin_addr) <= 0)
         return 0;
-    prefix[2] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[2], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "192.167.1.4", &servaddr.sin_addr) <= 0)
         return 0;
-    prefix[3] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[3], tree);
-
-    /* Try to add the prefix that already exists in the tree */
-    SCRadixAddKey(prefix[2], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "220.168.1.2", &servaddr.sin_addr) <= 0)
         return 0;
-    prefix[4] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[4], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
+    bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "192.168.1.5", &servaddr.sin_addr) <= 0)
         return 0;
-    prefix[5] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[5], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
+    bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET, "192.168.1.18", &servaddr.sin_addr) <= 0)
         return 0;
-    prefix[6] = SCRadixCreateIPV4Prefix((uint8_t *)&servaddr.sin_addr);
-    SCRadixAddKey(prefix[6], tree);
+    SCRadixAddKeyIPV4((uint8_t *)&servaddr.sin_addr, tree, NULL);
 
-    /* test the existence of keys */
-    SCRadixRemoveKey(prefix[0], tree);
-    SCRadixRemoveKey(prefix[2], tree);
-    SCRadixRemoveKey(prefix[5], tree);
-    SCRadixRemoveKey(prefix[3], tree);
-
-    result &= (SCRadixFindKey(prefix[3], tree) == NULL);
-    result &= (SCRadixFindKey(prefix[6], tree) != NULL);
+    /* remove the keys from the tree */
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.168.1.1", &servaddr.sin_addr) <= 0)
+        return 0;
+    SCRadixRemoveKeyIPV4((uint8_t *)&servaddr.sin_addr, tree);
 
-    SCRadixRemoveKey(prefix[1], tree);
-    SCRadixRemoveKey(prefix[4], tree);
-    SCRadixRemoveKey(prefix[6], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.167.1.3", &servaddr.sin_addr) <= 0)
+        return 0;
+    SCRadixRemoveKeyIPV4((uint8_t *)&servaddr.sin_addr, tree);
 
-    result &= (SCRadixFindKey(prefix[5], tree) == NULL);
-    result &= (tree->head == NULL);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.167.1.4", &servaddr.sin_addr) <= 0)
+        return 0;
+    SCRadixRemoveKeyIPV4((uint8_t *)&servaddr.sin_addr, tree);
 
-    SCRadixReleaseRadixTree(tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.168.1.18", &servaddr.sin_addr) <= 0)
+        return 0;
+    SCRadixRemoveKeyIPV4((uint8_t *)&servaddr.sin_addr, tree);
 
-    return result;
-}
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.167.1.1", &servaddr.sin_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) == NULL);
 
-int SCRadixTestCharacterInsertion05(void)
-{
-    SCRadixTree *tree = NULL;
-    SCRadixPrefix *prefix[10];
-    SCRadixPrefix *temp_prefix = NULL;
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.168.1.2", &servaddr.sin_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) != NULL);
 
-    int result = 1;
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.167.1.3", &servaddr.sin_addr) <= 0)
+        return 0;
+    SCRadixRemoveKeyIPV4((uint8_t *)&servaddr.sin_addr, tree);
 
-    tree = SCRadixCreateRadixTree();
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "220.168.1.2", &servaddr.sin_addr) <= 0)
+        return 0;
+    SCRadixRemoveKeyIPV4((uint8_t *)&servaddr.sin_addr, tree);
 
-    /* Let us have our team here ;-) */
-    prefix[0] = SCRadixCreatePrefix((uint8_t *)"Victor", 48);
-    SCRadixAddKey(prefix[0], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.168.1.5", &servaddr.sin_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) != NULL);
 
-    prefix[1] = SCRadixCreatePrefix((uint8_t *)"Matt", 32);
-    SCRadixAddKey(prefix[1], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.168.1.2", &servaddr.sin_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV4((uint8_t *)&servaddr.sin_addr, tree) != NULL);
 
-    prefix[2] = SCRadixCreatePrefix((uint8_t *)"Josh", 56);
-    SCRadixAddKey(prefix[2], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.168.1.2", &servaddr.sin_addr) <= 0)
+        return 0;
+    SCRadixRemoveKeyIPV4((uint8_t *)&servaddr.sin_addr, tree);
 
-    prefix[3] = SCRadixCreatePrefix((uint8_t *)"Margaret", 64);
-    SCRadixAddKey(prefix[3], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET, "192.168.1.5", &servaddr.sin_addr) <= 0)
+        return 0;
+    SCRadixRemoveKeyIPV4((uint8_t *)&servaddr.sin_addr, tree);
 
-    prefix[4] = SCRadixCreatePrefix((uint8_t *)"Pablo", 40);
-    SCRadixAddKey(prefix[4], tree);
+    result &= (tree->head == NULL);
 
-    prefix[5] = SCRadixCreatePrefix((uint8_t *)"Brian", 40);
-    SCRadixAddKey(prefix[5], tree);
+    SCRadixReleaseRadixTree(tree);
 
-    prefix[6] = SCRadixCreatePrefix((uint8_t *)"Jasonish", 64);
-    SCRadixAddKey(prefix[6], tree);
+    return result;
+}
 
-    prefix[7] = SCRadixCreatePrefix((uint8_t *)"Jasonmc", 56);
-    SCRadixAddKey(prefix[7], tree);
+int SCRadixTestCharacterInsertion05(void)
+{
+    SCRadixTree *tree = NULL;
+    int result = 1;
 
-    prefix[8] = SCRadixCreatePrefix((uint8_t *)"Nathan", 48);
-    SCRadixAddKey(prefix[8], tree);
+    tree = SCRadixCreateRadixTree(NULL);
 
-    prefix[9] = SCRadixCreatePrefix((uint8_t *)"Anoop", 40);
-    SCRadixAddKey(prefix[9], tree);
+    /* Let us have our team here ;-) */
+    SCRadixAddKeyGeneric((uint8_t *)"Victor", 48, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Matt", 32, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Josh", 32, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Margaret", 64, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Pablo", 40, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Brian", 40, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Jasonish", 64, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Jasonmc", 56, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Nathan", 48, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Anoop", 40, tree, NULL);
+
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Victor", 48, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Matt", 32, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Josh", 32, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Margaret", 64, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Pablo", 40, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Brian", 40, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Jasonish", 64, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Jasonmc", 56, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Nathan", 48, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Anoop", 40, tree) != NULL);
+
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"bamboo", 48, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"bool", 32, tree) == NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"meerkat", 56, tree) == NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Victor", 48, tree) == NULL);
 
-    result &= (SCRadixFindKey(prefix[0], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[1], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[2], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[3], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[4], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[5], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[6], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[7], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[8], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[9], tree) != NULL);
+    SCRadixReleaseRadixTree(tree);
 
-    temp_prefix = SCRadixCreatePrefix((uint8_t *)"bamboo", 48);
-    result &= (SCRadixFindKey(temp_prefix, tree) == NULL);
+    return 1;
+}
 
-    temp_prefix = SCRadixCreatePrefix((uint8_t *)"bool", 32);
-    result &= (SCRadixFindKey(temp_prefix, tree) == NULL);
+int SCRadixTestCharacterRemoval06(void)
+{
+    SCRadixTree *tree = NULL;
+    int result = 1;
 
-    temp_prefix = SCRadixCreatePrefix((uint8_t *)"meerkat", 56);
-    result &= (SCRadixFindKey(temp_prefix, tree) == NULL);
+    tree = SCRadixCreateRadixTree(NULL);
 
-    temp_prefix = SCRadixCreatePrefix((uint8_t *)"Victor", 48);
-    result &= (SCRadixFindKey(temp_prefix, tree) == NULL);
+    /* Let us have our team here ;-) */
+    SCRadixAddKeyGeneric((uint8_t *)"Victor", 48, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Matt", 32, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Josh", 32, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Margaret", 64, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Pablo", 40, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Brian", 40, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Jasonish", 64, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Jasonmc", 56, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Nathan", 48, tree, NULL);
+    SCRadixAddKeyGeneric((uint8_t *)"Anoop", 40, tree, NULL);
+
+    SCRadixRemoveKeyGeneric((uint8_t *)"Nathan", 48, tree);
+    SCRadixRemoveKeyGeneric((uint8_t *)"Brian", 40, tree);
+    SCRadixRemoveKeyGeneric((uint8_t *)"Margaret", 64, tree);
+
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Victor", 48, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Matt", 32, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Josh", 32, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Margaret", 64, tree) == NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Brian", 40, tree) == NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Nathan", 48, tree) == NULL);
+
+    SCRadixRemoveKeyGeneric((uint8_t *)"Victor", 48, tree);
+    SCRadixRemoveKeyGeneric((uint8_t *)"Josh", 32, tree);
+    SCRadixRemoveKeyGeneric((uint8_t *)"Jasonmc", 56, tree);
+    SCRadixRemoveKeyGeneric((uint8_t *)"Matt", 32, tree);
+
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Pablo", 40, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Jasonish", 64, tree) != NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Anoop", 40, tree) != NULL);
+
+    SCRadixRemoveKeyGeneric((uint8_t *)"Pablo", 40, tree);
+    SCRadixRemoveKeyGeneric((uint8_t *)"Jasonish", 64, tree);
+    SCRadixRemoveKeyGeneric((uint8_t *)"Anoop", 40, tree);
+
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Pablo", 40, tree) == NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Jasonish", 64, tree) == NULL);
+    result &= (SCRadixFindKeyGeneric((uint8_t *)"Anoop", 40, tree) == NULL);
 
+    result &= (tree->head == NULL);
 
     SCRadixReleaseRadixTree(tree);
 
     return 1;
 }
 
-int SCRadixTestCharacterRemoval06(void)
+int SCRadixTestIPV6Insertion07(void)
 {
     SCRadixTree *tree = NULL;
-    SCRadixPrefix *prefix[10];
-
+    struct sockaddr_in6 servaddr;
     int result = 1;
 
-    tree = SCRadixCreateRadixTree();
+    tree = SCRadixCreateRadixTree(NULL);
 
-    /* Let us have our team here ;-) */
-    prefix[0] = SCRadixCreatePrefix((uint8_t *)"Victor", 48);
-    SCRadixAddKey(prefix[0], tree);
+    /* add the keys */
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "2003:0BF1:5346:BDEA:7422:8713:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
-    prefix[1] = SCRadixCreatePrefix((uint8_t *)"Matt", 32);
-    SCRadixAddKey(prefix[1], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "BD15:9791:5346:6223:AADB:8713:9882:2432",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
-    prefix[2] = SCRadixCreatePrefix((uint8_t *)"Josh", 56);
-    SCRadixAddKey(prefix[2], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "1111:A21B:6221:BDEA:BBBA::DBAA:9861",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
-    prefix[3] = SCRadixCreatePrefix((uint8_t *)"Margaret", 64);
-    SCRadixAddKey(prefix[3], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "4444:0BF7:5346:BDEA:7422:8713:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
-    prefix[4] = SCRadixCreatePrefix((uint8_t *)"Pablo", 40);
-    SCRadixAddKey(prefix[4], tree);
+    /* Try to add the prefix that already exists in the tree */
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
-    prefix[5] = SCRadixCreatePrefix((uint8_t *)"Brian", 40);
-    SCRadixAddKey(prefix[5], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "5555:0BF1:ABCD:ADEA:7922:ABCD:9124:2375",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
-    prefix[6] = SCRadixCreatePrefix((uint8_t *)"Jasonish", 64);
-    SCRadixAddKey(prefix[6], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "DBCA:ABCD:ABCD:DBCA:1245:2342:1111:2212",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
-    prefix[7] = SCRadixCreatePrefix((uint8_t *)"Jasonmc", 56);
-    SCRadixAddKey(prefix[7], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "2003:0BF1:5346:1251:7422:1112:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
-    prefix[8] = SCRadixCreatePrefix((uint8_t *)"Nathan", 48);
-    SCRadixAddKey(prefix[8], tree);
+    /* test the existence of keys */
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "2003:0BF1:5346:BDEA:7422:8713:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
-    prefix[9] = SCRadixCreatePrefix((uint8_t *)"Anoop", 40);
-    SCRadixAddKey(prefix[9], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "BD15:9791:5346:6223:AADB:8713:9882:2432",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
-    SCRadixRemoveKey(prefix[8], tree);
-    SCRadixRemoveKey(prefix[5], tree);
-    SCRadixRemoveKey(prefix[3], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "1111:A21B:6221:BDEA:BBBA::DBAA:9861",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
-    result &= (SCRadixFindKey(prefix[0], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[1], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[2], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[3], tree) == NULL);
-    result &= (SCRadixFindKey(prefix[5], tree) == NULL);
-    result &= (SCRadixFindKey(prefix[8], tree) == NULL);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "4444:0BF7:5346:BDEA:7422:8713:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
-    SCRadixRemoveKey(prefix[0], tree);
-    SCRadixRemoveKey(prefix[2], tree);
-    SCRadixRemoveKey(prefix[7], tree);
-    SCRadixRemoveKey(prefix[1], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "DBCA:ABC2:ABCD:DBCA:1245:2342:1111:2212",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) == NULL);
 
-    result &= (SCRadixFindKey(prefix[4], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[6], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[9], tree) != NULL);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "2003:0BF5:5346:1251:7422:1112:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) == NULL);
 
-    SCRadixRemoveKey(prefix[4], tree);
-    SCRadixRemoveKey(prefix[6], tree);
-    SCRadixRemoveKey(prefix[9], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "5555:0BF1:ABCD:ADEA:7922:ABCD:9124:2375",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
-    result &= (SCRadixFindKey(prefix[4], tree) == NULL);
-    result &= (SCRadixFindKey(prefix[6], tree) == NULL);
-    result &= (SCRadixFindKey(prefix[9], tree) == NULL);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "DBCA:ABCD:ABCD:DBCA:1245:2342:1111:2212",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
-    result &= (tree->head == NULL);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "2003:0BF1:5346:1251:7422:1112:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
     SCRadixReleaseRadixTree(tree);
 
-    return 1;
+    return result;
 }
 
-int SCRadixTestIPV6Insertion07(void)
+int SCRadixTestIPV6Removal08(void)
 {
     SCRadixTree *tree = NULL;
-    SCRadixPrefix *prefix[10];
-    SCRadixPrefix *temp_prefix = NULL;
-
     struct sockaddr_in6 servaddr;
-
     int result = 1;
 
+    tree = SCRadixCreateRadixTree(NULL);
+
     /* add the keys */
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "2003:0BF1:5346:BDEA:7422:8713:9124:2315",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    tree = SCRadixCreateRadixTree();
-    prefix[0] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[0], tree);
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "BD15:9791:5346:6223:AADB:8713:9882:2432",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    prefix[1] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[1], tree);
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "1111:A21B:6221:BDEA:BBBA::DBAA:9861",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    prefix[2] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[2], tree);
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "4444:0BF7:5346:BDEA:7422:8713:9124:2315",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    prefix[3] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[3], tree);
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
     /* Try to add the prefix that already exists in the tree */
-    SCRadixAddKey(prefix[2], tree);
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "5555:0BF1:ABCD:ADEA:7922:ABCD:9124:2375",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    prefix[4] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[4], tree);
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
+    bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "DBCA:ABCD:ABCD:DBCA:1245:2342:1111:2212",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    prefix[5] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[5], tree);
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
+    bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "2003:0BF1:5346:1251:7422:1112:9124:2315",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    prefix[6] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[6], tree);
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
     /* test the existence of keys */
-    result &= (SCRadixFindKey(prefix[0], tree) != NULL);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "2003:0BF1:5346:BDEA:7422:8713:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "8888:0BF1:5346:BDEA:6422:8713:9124:2315",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    temp_prefix = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    result &= (SCRadixFindKey(temp_prefix, tree) == NULL);
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) == NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "2006:0BF1:5346:BDEA:7422:8713:9124:2315",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    temp_prefix = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    result &= (SCRadixFindKey(temp_prefix, tree) == NULL);
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) == NULL);
 
-    result &= (SCRadixFindKey(prefix[0], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[1], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[2], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[3], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[4], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[5], tree) != NULL);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "2003:0BF1:5346:BDEA:7422:8713:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
     bzero(&servaddr, sizeof(servaddr));
-    if (inet_pton(AF_INET6, "2003:0BF1:5346:BDEA:7422:8713:DDDD:2315",
+    if (inet_pton(AF_INET6, "BD15:9791:5346:6223:AADB:8713:9882:2432",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    temp_prefix = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    result &= (SCRadixFindKey(temp_prefix, tree) == NULL);
+    SCRadixAddKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree, NULL);
 
-    SCRadixReleaseRadixTree(tree);
+    /* test for existance */
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "1111:A21B:6221:BDEA:BBBA::DBAA:9861",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
-    return result;
-}
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "4444:0BF7:5346:BDEA:7422:8713:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
-int SCRadixTestIPV6Removal08(void)
-{
-    SCRadixTree *tree = NULL;
-    SCRadixPrefix *prefix[10];
-    SCRadixPrefix *temp_prefix = NULL;
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "5555:0BF1:ABCD:ADEA:7922:ABCD:9124:2375",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
-    struct sockaddr_in6 servaddr;
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "DBCA:ABCD:ABCD:DBCA:1245:2342:1111:2212",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
-    int result = 1;
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "2003:0BF1:5346:1251:7422:1112:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
-    /* add the keys */
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "2003:0BF1:5346:BDEA:7422:8713:DDDD:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) == NULL);
+
+    /* remove keys */
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "2003:0BF1:5346:BDEA:7422:8713:9124:2315",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    tree = SCRadixCreateRadixTree();
-    prefix[0] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[0], tree);
+    SCRadixRemoveKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "BD15:9791:5346:6223:AADB:8713:9882:2432",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    prefix[1] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[1], tree);
+    SCRadixRemoveKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree);
+
+    /* test for existance */
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "2003:0BF1:5346:BDEA:7422:8713:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) == NULL);
+
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "BD15:9791:5346:6223:AADB:8713:9882:2432",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) == NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "1111:A21B:6221:BDEA:BBBA::DBAA:9861",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    prefix[2] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[2], tree);
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "4444:0BF7:5346:BDEA:7422:8713:9124:2315",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    prefix[3] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[3], tree);
-
-    /* Try to add the prefix that already exists in the tree */
-    SCRadixAddKey(prefix[2], tree);
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
     bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "5555:0BF1:ABCD:ADEA:7922:ABCD:9124:2375",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    prefix[4] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[4], tree);
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
+    bzero(&servaddr, sizeof(servaddr));
     if (inet_pton(AF_INET6, "DBCA:ABCD:ABCD:DBCA:1245:2342:1111:2212",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    prefix[5] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[5], tree);
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) != NULL);
 
-    if (inet_pton(AF_INET6, "2003:0BF1:5346:1251:7422:1112:9124:2315",
+    /* remove keys */
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "1111:A21B:6221:BDEA:BBBA::DBAA:9861",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    prefix[6] = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    SCRadixAddKey(prefix[6], tree);
+    SCRadixRemoveKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree);
 
-    /* test the existence of keys */
-    result &= (SCRadixFindKey(prefix[0], tree) != NULL);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "4444:0BF7:5346:BDEA:7422:8713:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    SCRadixRemoveKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree);
 
     bzero(&servaddr, sizeof(servaddr));
-    if (inet_pton(AF_INET6, "8888:0BF1:5346:BDEA:6422:8713:9124:2315",
+    if (inet_pton(AF_INET6, "5555:0BF1:ABCD:ADEA:7922:ABCD:9124:2375",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    temp_prefix = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    result &= (SCRadixFindKey(temp_prefix, tree) == NULL);
+    SCRadixRemoveKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree);
 
     bzero(&servaddr, sizeof(servaddr));
-    if (inet_pton(AF_INET6, "2006:0BF1:5346:BDEA:7422:8713:9124:2315",
+    if (inet_pton(AF_INET6, "DBCA:ABCD:ABCD:DBCA:1245:2342:1111:2212",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    temp_prefix = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    result &= (SCRadixFindKey(temp_prefix, tree) == NULL);
+    SCRadixRemoveKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree);
 
-    result &= (SCRadixFindKey(prefix[0], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[1], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[2], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[3], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[4], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[5], tree) != NULL);
+    /* test for existance */
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "2003:0BF1:5346:BDEA:7422:8713:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) == NULL);
 
     bzero(&servaddr, sizeof(servaddr));
-    if (inet_pton(AF_INET6, "2003:0BF1:5346:BDEA:7422:8713:DDDD:2315",
+    if (inet_pton(AF_INET6, "BD15:9791:5346:6223:AADB:8713:9882:2432",
                   &servaddr.sin6_addr) <= 0)
         return 0;
-    temp_prefix = SCRadixCreateIPV6Prefix((uint8_t *)&servaddr.sin6_addr);
-    result &= (SCRadixFindKey(temp_prefix, tree) == NULL);
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) == NULL);
 
-    SCRadixRemoveKey(prefix[0], tree);
-    SCRadixRemoveKey(prefix[1], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "1111:A21B:6221:BDEA:BBBA::DBAA:9861",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) == NULL);
 
-    result &= (SCRadixFindKey(prefix[0], tree) == NULL);
-    result &= (SCRadixFindKey(prefix[1], tree) == NULL);
-    result &= (SCRadixFindKey(prefix[2], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[3], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[4], tree) != NULL);
-    result &= (SCRadixFindKey(prefix[5], tree) != NULL);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "4444:0BF7:5346:BDEA:7422:8713:9124:2315",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) == NULL);
 
-    SCRadixRemoveKey(prefix[2], tree);
-    SCRadixRemoveKey(prefix[3], tree);
-    SCRadixRemoveKey(prefix[4], tree);
-    SCRadixRemoveKey(prefix[5], tree);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "5555:0BF1:ABCD:ADEA:7922:ABCD:9124:2375",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) == NULL);
 
-    result &= (SCRadixFindKey(prefix[0], tree) == NULL);
-    result &= (SCRadixFindKey(prefix[1], tree) == NULL);
-    result &= (SCRadixFindKey(prefix[2], tree) == NULL);
-    result &= (SCRadixFindKey(prefix[3], tree) == NULL);
-    result &= (SCRadixFindKey(prefix[4], tree) == NULL);
-    result &= (SCRadixFindKey(prefix[5], tree) == NULL);
+    bzero(&servaddr, sizeof(servaddr));
+    if (inet_pton(AF_INET6, "DBCA:ABCD:ABCD:DBCA:1245:2342:1111:2212",
+                  &servaddr.sin6_addr) <= 0)
+        return 0;
+    result &= (SCRadixFindKeyIPV6((uint8_t *)&servaddr.sin6_addr, tree) == NULL);
 
     SCRadixReleaseRadixTree(tree);
 
     return result;
 }
 
-
 #endif
 
 void SCRadixRegisterTests(void)
diff --git a/src/util-radix-tree.h b/src/util-radix-tree.h
index beeb58bfb9..43af1e05c4 100644
--- a/src/util-radix-tree.h
+++ b/src/util-radix-tree.h
@@ -16,6 +16,9 @@ typedef struct SCRadixPrefix_ {
 
     /* the key that has been stored in the tree */
     uint8_t *stream;
+
+    /* any user data that has to be associated with this key */
+    void *user;
 } SCRadixPrefix;
 
 /**
@@ -26,7 +29,7 @@ typedef struct SCRadixNode_ {
      * to determine the path to be taken during a lookup*/
     uint16_t bit;
 
-    /* Holds the prefix that the path to this node holds */
+    /* holds the prefix that the path to this node holds */
     SCRadixPrefix *prefix;
 
     /* the left and the right children of a node */
@@ -34,9 +37,6 @@ typedef struct SCRadixNode_ {
 
     /* the parent node for this tree */
     struct SCRadixNode_ *parent;
-
-    /* any user data that has to be associated with this node */
-    void *user;
 } SCRadixNode;
 
 /**
@@ -45,21 +45,27 @@ typedef struct SCRadixNode_ {
 typedef struct SCRadixTree_ {
     /* the root node in the radix tree */
     SCRadixNode *head;
+
+    /* function pointer that is supplied by the user to free the user data
+     * held by the user field of SCRadixNode */
+    void (*Free)(void *);
 } SCRadixTree;
 
 
-SCRadixTree *SCRadixCreateRadixTree();
+SCRadixTree *SCRadixCreateRadixTree(void (*Free)(void*));
 void SCRadixReleaseRadixTree(SCRadixTree *);
 
-SCRadixPrefix *SCRadixCreatePrefix(uint8_t *, uint16_t);
-SCRadixPrefix *SCRadixCreateIPV4Prefix(uint8_t *);
-SCRadixPrefix *SCRadixCreateIPV6Preix(uint8_t *);
-void SCRadixReleasePrefix(SCRadixPrefix *prefix);
+SCRadixNode *SCRadixAddKeyGeneric(uint8_t *, uint16_t, SCRadixTree *, void *);
+SCRadixNode *SCRadixAddKeyIPV4(uint8_t *, SCRadixTree *, void *);
+SCRadixNode *SCRadixAddKeyIPV6(uint8_t *, SCRadixTree *, void *);
 
-SCRadixNode *SCRadixAddKey(SCRadixPrefix *, SCRadixTree *);
-void SCRadixRemoveKey(SCRadixPrefix *, SCRadixTree *);
+void SCRadixRemoveKeyGeneric(uint8_t *, uint16_t, SCRadixTree *);
+void SCRadixRemoveKeyIPV4(uint8_t *, SCRadixTree *);
+void SCRadixRemoveKeyIPV6(uint8_t *, SCRadixTree *);
 
-SCRadixNode *SCRadixFindKey(SCRadixPrefix *, SCRadixTree *);
+SCRadixNode *SCRadixFindKeyGeneric(uint8_t *, uint16_t, SCRadixTree *);
+SCRadixNode *SCRadixFindKeyIPV4(uint8_t *, SCRadixTree *);
+SCRadixNode *SCRadixFindKeyIPV6(uint8_t *, SCRadixTree *);
 
 void SCRadixPrintTree(SCRadixTree *);
 
@@ -67,4 +73,3 @@ void SCRadixRegisterTests(void);
 
 
 #endif /* __UTIL_RADIX_TREE_H__ */
-