refactor: move trie back to own static library

trie/CMakeLists.txt

@@ -0,0 +1,8 @@
+include_directories(include)
+
+if(CMAKE_BUILD_TYPE MATCHES "^Test")
+    enable_testing()
+    add_subdirectory(test)
+endif()
+
+add_library(trie STATIC include/trie.h src/trie.c)

trie/include/trie.h

@@ -0,0 +1,119 @@
+#ifndef AD3_TERNARYTRIE
+#define AD3_TERNARYTRIE
+
+#define ALPHABET_SIZE 256
+#define DELIMITER '\0'
+#define MAX(x, y) (((x) > (y)) ? (x) : (y))
+
+// Should not be higher than 254 or stuff will break
+#define TRIE_MAX_SKIP_SIZE 8
+
+/**
+ * The implementation of a Ternary Trie.
+ *
+ * Each node should be represented by a binary tree in order to reduce the
+ * memory usage.
+ */
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+
+static const char charset[] =
+    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+static const size_t charset_len = sizeof(charset) - 1;
+
+// Length of randomly generated keys
+#define RANDOM_KEY_LENGTH_SHORT 4
+#define RANDOM_KEY_LENGTH_LONG 16
+
+/**
+ * Type definition for the struct representing the current Trie.
+ *
+ * You can (and should) redefine this in your c-file with the concrete fields.
+ */
+typedef struct ttrie Trie;
+
+typedef enum entry_type { Redirect, Paste, Unknown } EntryType;
+
+typedef struct entry {
+  EntryType type;
+  char *string;
+} Entry;
+
+Entry *entry_new(EntryType type, const char *string);
+
+/**
+ * Allocate and initialize an empty Trie.
+ *
+ * @return a pointer to an empty Trie struct
+ */
+Trie *trie_init();
+
+/**
+ * Populate trie with entries stored in the given file.
+ *
+ * @param trie
+ * @param file_path path to file containing entries
+ * @return amount of entries added; -1 if an error occured
+ */
+int trie_populate(Trie *trie, const char *file_path);
+
+/**
+ * De-allocate a trie by freeing the memory occupied by this trie.
+ *
+ * @param trie which should be freed
+ */
+void trie_free(Trie *trie);
+
+/**
+ * Search for an entry in the trie.
+ *
+ * @param trie
+ * @param key key representing the entry
+ * @return pointer to entry; NULL if not found
+ */
+Entry *trie_search(Trie *trie, const char *key);
+
+/**
+ * Add a string to this trie.
+ *
+ * @param trie
+ * @param key key to represent entry with
+ * @param entry entry to add
+ * @return true if the trie was changed by this operation, false if it was
+ * already present
+ */
+bool trie_add(Trie *trie, const char *key, Entry *entry);
+
+bool trie_add_no_lock(Trie *trie, const char *key, Entry *entry);
+
+/**
+ * Add an entry by generating a random string as the key.
+ *
+ * @param trie
+ * @param entry entry to add
+ * @param secure whether to generate a longer, more secure random key
+ * @return the generated key
+ */
+char *trie_add_random(Trie *trie, Entry *entry, bool secure);
+
+/**
+ * Remove an entry from this trie given its key.
+ *
+ * @param trie
+ * @param key key representing entry
+ * @return true if the entry was present and has been removed, false if it was
+ * not present
+ */
+bool trie_remove(Trie *trie, const char *key);
+
+/**
+ * Returns the number of entries in this trie.
+ *
+ * @param trie
+ * @return the number of entries in this trie
+ */
+size_t trie_size(Trie *trie);
+
+#endif // AD3_TERNARYTRIE

trie/src/trie.c

@@ -0,0 +1,474 @@
+#include <pthread.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "trie.h"
+#include "trie_node.c"
+
+typedef struct ttrie {
+  TrieNode *root;
+  size_t size;
+  char *file_path;
+  pthread_rwlock_t lock;
+} Trie;
+
+/**
+ * Allocate and initialize an empty Trie
+ *
+ * @return pointer to the empty Trie
+ */
+Trie *trie_init() {
+  Trie *trie = calloc(1, sizeof(Trie));
+  trie->root = tnode_init();
+  pthread_rwlock_init(&trie->lock, NULL);
+
+  return trie;
+}
+
+/**
+ * De-allocate a TernaryTree by freeing its entire underlying structure.
+ *
+ * @param trie trie to free
+ */
+void trie_free(Trie *trie) {
+  tnode_free(trie->root);
+  free(trie);
+}
+
+bool trie_add_no_lock(Trie *trie, const char *key, Entry *entry);
+
+EntryType entry_type_from_char(char c) {
+  switch (c) {
+  case '0':
+    return Redirect;
+  case '1':
+    return Paste;
+  default:
+    return Unknown;
+  }
+}
+
+char entry_type_to_char(EntryType et) {
+  switch (et) {
+  case Redirect:
+    return '0';
+  case Paste:
+    return '1';
+  default:
+    return '\0';
+  }
+}
+
+Entry *entry_new(EntryType type, const char *string) {
+  Entry *entry = malloc(sizeof(Entry));
+  entry->type = type;
+
+  if (string != NULL) {
+    entry->string = strdup(string);
+  } else {
+    entry->string = NULL;
+  }
+
+  return entry;
+}
+
+int trie_populate(Trie *trie, const char *file_path) {
+  trie->file_path = strdup(file_path);
+
+  FILE *fp = fopen(file_path, "r");
+
+  // TODO properly handle this
+  if (fp == NULL) {
+    return -1;
+  }
+
+  // We read in lines of at most 8192 characters (sounds like enough)
+  char buffer[8192];
+  EntryType type;
+  Entry *entry;
+  char *string;
+  int i, j;
+  int entries = 0;
+
+  while (fgets(buffer, 8192, fp)) {
+    i = 0;
+
+    // Move index in buffer until we encounter first space character
+    while (buffer[i] != ' ') {
+      i++;
+    }
+
+    // Split the buffer into two strings, the key and the payload
+    buffer[i] = '\0';
+
+    type = entry_type_from_char(buffer[i + 1]);
+
+    // Skip type character & its surrounding spaces
+    j = i + 3;
+
+    // Now remove the newline character
+    while (buffer[j] != '\n') {
+      j++;
+    }
+
+    buffer[j] = '\0';
+
+    entry = entry_new(type, buffer + i + 3);
+    trie_add_no_lock(trie, buffer, entry);
+
+    entries++;
+  }
+
+  fclose(fp);
+
+  return entries;
+}
+
+typedef struct searchresult {
+  TrieNode *parent;
+  TrieNode *child;
+} SearchResult;
+
+SearchResult trie_search_node(Trie *trie, const char *key) {
+  SearchResult out = {NULL, NULL};
+
+  size_t i = 0;
+  size_t offset;
+  TrieNode **node_ptr = &(trie->root);
+  TrieNode **child_ptr;
+
+  do {
+    child_ptr = tnode_search(*node_ptr, key[i], false);
+
+    // We don't have to check whether *node_ptr is NULL, because if it was
+    // NULL, it wouldn't be in the binary tree.
+    if (child_ptr == NULL) {
+      return out;
+    }
+
+    i++;
+
+    if (memcmp((*child_ptr)->string, key + i, (*child_ptr)->string_len) != 0) {
+      return out;
+    }
+
+    i += (*child_ptr)->string_len;
+
+/*     offset = 0; */
+
+/*     // We iterate over each character on the edge and compare it to the string. */
+/*     while (offset < (*child_ptr)->string_len) { */
+/*       // Our string ends in the middle of an edge, so it's definitely not in */
+/*       // the trie. */
+/*       if (key[i + offset] == DELIMITER) { */
+/*         return out; */
+/*       } */
+
+/*       // We compare each character with the characters in the skipped */
+/*       // substring. If they don't match, we know the string isn't in the */
+/*       // trie. */
+/*       if (key[i + offset] != ((*child_ptr)->string[offset])) { */
+/*         return out; */
+/*       } */
+
+/*       offset++; */
+/*     } */
+
+/*     i += offset; */
+
+    if (key[i] != DELIMITER) {
+      node_ptr = child_ptr;
+    }
+  } while (key[i] != DELIMITER);
+
+  // At this point, we've either arrived at an empty child, or traversed through
+  // the entire string. Therefore, all we have to do is check whether we're at
+  // the end of the string and if node represents a string.
+  if (key[i] == DELIMITER && (*child_ptr)->represents) {
+    out.parent = *node_ptr;
+    out.child = *child_ptr;
+  }
+
+  return out;
+}
+
+/**
+ * Returns whether the given string is present in the trie.
+ *
+ * @param trie trie to look in
+ * @param string string to look up
+ * @return true if the string is present in the trie, false otherwise
+ */
+Entry *trie_search(Trie *trie, const char *key) {
+  pthread_rwlock_rdlock(&trie->lock);
+
+  SearchResult res = trie_search_node(trie, key);
+
+  Entry *return_value = NULL;
+
+  if (res.child != NULL) {
+    return_value = res.child->entry;
+  }
+
+  pthread_rwlock_unlock(&trie->lock);
+
+  return return_value;
+}
+
+/**
+ * Add the given string to the Trie.
+ *
+ * @param trie trie to add string to
+ * @param string string to add
+ * @return true if the string wasn't present in the trie and thus added, false
+ * otherwise
+ */
+bool trie_add_no_lock(Trie *trie, const char *string, Entry *entry) {
+  size_t i = 0;
+  uint8_t offset;
+  TrieNode **node_ptr = &(trie->root);
+  TrieNode **child_node_ptr;
+  TrieNode *child_node;
+
+  do {
+    offset = 0;
+    child_node_ptr = tnode_search(*node_ptr, string[i], true);
+
+    i++;
+
+    // We've reached a NULL child, so we add the remaining part of the string
+    // here
+    if (*child_node_ptr == NULL) {
+      child_node = tnode_init();
+
+      while (offset < TRIE_MAX_SKIP_SIZE &&
+             string[i + offset] != DELIMITER) {
+        offset++;
+      }
+
+      memcpy(child_node->string, string + i, offset);
+
+      child_node->string_len = offset;
+      *child_node_ptr = child_node;
+
+      // If the remaining part of the string is still longer than the maximum
+      // allowed skip length, we continue through the loop. The next iteration
+      // will enter this if statement again, and perform the same loop, until
+      // the string is fully added to the trie.
+      if (string[i + offset] != DELIMITER) {
+        node_ptr = child_node_ptr;
+        i += offset;
+
+        continue;
+      }
+
+      child_node->represents = true;
+      child_node->entry = entry;
+
+      trie->size++;
+      return true;
+    }
+
+    while (offset < (*child_node_ptr)->string_len) {
+      // String no longer aligns with edge, so we have to split
+      if (string[i + offset] != (*child_node_ptr)->string[offset]) {
+        TrieNode *split_node = tnode_init();
+        child_node = *child_node_ptr;
+
+        // New string of the split node is the prefix that we were able
+        // to skip
+        if (offset > 0) {
+          memcpy(split_node->string, child_node->string, offset);
+          split_node->string_len = offset;
+        }
+
+        // split_node replaces child_node as the child of node
+        *child_node_ptr = split_node;
+        TrieNode **new_node_ptr =
+            tnode_search(split_node, child_node->string[offset], true);
+        *new_node_ptr = child_node;
+
+        // child_node has now become a child of split_node, so we update its
+        // string accordingely by removing the skipped prefix + the one
+        // character that's already stored by being a child of split_node
+        /* char *old_string = child_node->string.ptr; */
+        uint8_t new_skip_len = child_node->string_len - (offset + 1);
+
+        if (new_skip_len > 0) {
+          char old_string[TRIE_MAX_SKIP_SIZE];
+          memcpy(old_string, child_node->string + offset + 1, new_skip_len);
+          memcpy(child_node->string, old_string, new_skip_len);
+        }
+
+        child_node->string_len = new_skip_len;
+
+        // The while loop will exit either way after this has happened, as
+        // child_node is now split_node and split_node's len is already set to
+        // offset.
+        break;
+      }
+
+      offset++;
+    }
+
+    node_ptr = child_node_ptr;
+
+    i += offset;
+  } while (string[i] != DELIMITER);
+
+  if ((*child_node_ptr)->represents) {
+    return false;
+  }
+
+  (*child_node_ptr)->represents = true;
+  trie->size++;
+  return true;
+}
+
+bool trie_add_persistent(Trie *trie, const char *key, Entry *entry) {
+  bool return_value = false;
+
+  if (trie->file_path != NULL) {
+    // Easiest way to make sure we don't add duplicate entries
+    // We use an internal function that doesn't require a read lock, as we're
+    // already inside a write lock
+    if (trie_search_node(trie, key).child != NULL) {
+      return false;
+    }
+
+    FILE *fp = fopen(trie->file_path, "a");
+
+    if (fp == NULL) {
+      return false;
+    }
+
+    fputs(key, fp);
+    fputs(" ", fp);
+    fputc(entry_type_to_char(entry->type), fp);
+    fputs(" ", fp);
+    fputs(entry->string, fp);
+    fputs("\n", fp);
+
+    fclose(fp);
+  }
+
+  // This function *should* always return true. Otherwise, the function would've
+  // exited because the string was found in the trie.
+  return trie_add_no_lock(trie, key, entry);
+}
+
+bool trie_add(Trie *trie, const char *key, Entry *entry) {
+  pthread_rwlock_wrlock(&trie->lock);
+
+  bool return_value = trie_add_persistent(trie, key, entry);
+
+  pthread_rwlock_unlock(&trie->lock);
+
+  return return_value;
+}
+
+char *trie_add_random(Trie *trie, Entry *entry, bool secure) {
+  pthread_rwlock_wrlock(&trie->lock);
+
+  // Generate random key
+  bool ok = false;
+  int key_length = secure ? RANDOM_KEY_LENGTH_LONG : RANDOM_KEY_LENGTH_SHORT;
+  char *key = malloc(key_length + 1);
+  key[key_length] = '\0';
+
+  // We naively generate new keys until we find a key that isn't in the trie
+  // yet. With charset_len ** RANDOM_KEY_LENGTH sufficiently large, this isn't a
+  // problem, because the chances of collisions are extremely small.
+  while (!ok) {
+    for (int i = 0; i < key_length; i++) {
+      key[i] = charset[rand() % charset_len];
+    }
+
+    ok = trie_search_node(trie, key).child == NULL;
+  }
+
+  bool res = trie_add_persistent(trie, key, entry);
+  char *return_value;
+
+  if (res) {
+    return_value = key;
+  } else {
+    return_value = NULL;
+    free(key);
+  }
+
+  pthread_rwlock_unlock(&trie->lock);
+
+  return return_value;
+}
+
+/**
+ * Remove the given string from a Trie.
+ *
+ * @param trie trie to remove string from
+ * @param string string to remove
+ * @return true if the string was in the trie and thus removed, false otherwise
+ */
+/* bool trie_remove(Trie *trie, const char *string) { */
+/*   pthread_rwlock_wrlock(&trie->lock); */
+
+/*   bool return_value = false; */
+
+/*   SearchResult res = trie_search_node(trie, string); */
+
+/*   if (res.child == NULL) { */
+/*     goto end; */
+/*   } */
+
+/*   trie->size--; */
+/*   return_value = true; */
+
+/*   if (res.parent != NULL) { */
+/*     // We're removing a full leaf, so we calculate the offset of the
+ * character */
+/*     // to remove from the parent */
+/*     if (res.child->type == 2) { */
+/*       size_t str_len = strlen(string); */
+/*       size_t suffix_len = strlen(res.child->ptr.string); */
+
+/*       tnode_remove(res.parent, string[str_len - suffix_len - 1]); */
+/*     } */
+/*     // In the other case, the character to remove from the parent is the last
+ */
+/*     // character of the string */
+/*     else if (res.child->size == 0) { */
+/*       size_t i = 0; */
+
+/*       while (string[i + 1] != DELIMITER) { */
+/*         i++; */
+/*       } */
+
+/*       tnode_remove(res.parent, string[i]); */
+/*     } else { */
+/*       res.child->type = 0; */
+
+/*       goto end; */
+/*     } */
+
+/*     tnode_free(res.child); */
+/*   } */
+/*   // We're in the root here */
+/*   else { */
+/*     res.child->type = 0; */
+/*   } */
+
+/* end: */
+/*   pthread_rwlock_unlock(&trie->lock); */
+
+/*   return return_value; */
+/* } */
+
+/**
+ * Return the current size of the given trie.
+ *
+ * @param trie trie to return size for
+ * @return size of the trie
+ */
+size_t trie_size(Trie *trie) { return trie->size; }

trie/src/trie_node.c

@@ -0,0 +1,304 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "trie.h"
+
+/**
+ * Represents a node of the binary tree contained within each non-leaf
+ * TrieNode.
+ */
+typedef struct tinode {
+  struct tinode *left;
+  struct tinode *right;
+  struct tnode *next;
+  char key;
+} TrieInnerNode;
+
+/**
+ * Represents a node inside a Trie. A node can be in one of three states:
+ * - Internal node: a node that's part of a path to a leaf node. This node will
+ *   always have a size greater than one, and an initialized root.
+ * - Leaf: a node solely used to represent a string ending there. Its size is 0,
+ *   its ptr is unitialized and represents is true.
+ * - Full leaf: a leaf node that contains a string. This occurs when a string is
+ *   added whose path is not fully in the tree yet, causing its remaining suffix
+ *   to be stored as a single node. Its size will be zero, represents its true,
+ *   and its string pointer is initialized.
+ */
+typedef struct tnode {
+  Entry *entry;
+
+  TrieInnerNode *tree;
+  uint8_t tree_size;
+
+  // Skips are at most TRIE_MAX_SKIP_SIZE characters, and are stored in the
+  // nodes
+  char string[TRIE_MAX_SKIP_SIZE];
+  uint8_t string_len;
+
+  bool represents;
+} TrieNode;
+
+// Required for recursively freeing tree structure
+void tnode_free(TrieNode *node);
+
+/**
+ * Allocate and initialize a new TrieInnerNode representing a given
+ * character.
+ *
+ * @param c character to represent
+ * @return pointer to newly allocated struct
+ */
+TrieInnerNode *tinode_init(char c) {
+  TrieInnerNode *node = calloc(1, sizeof(TrieInnerNode));
+  node->key = c;
+
+  return node;
+}
+
+/**
+ * Allocate and initialize a new TrieNode.
+ *
+ * @return pointer to newly allocated struct
+ */
+TrieNode *tnode_init() {
+  TrieNode *node = malloc(sizeof(TrieNode));
+
+  node->tree_size = 0;
+  node->string_len = 0;
+  node->represents = false;
+
+  return node;
+}
+
+/**
+ * Free a TrieInnerNode and its underlying tree structure. This should
+ * usually only be called on the root of a binary tree to free the entire
+ * structure.
+ *
+ * @param node node whose tree to free
+ */
+void tinode_free_cascade(TrieInnerNode *node) {
+  if (node->left != NULL) {
+    tinode_free_cascade(node->left);
+  }
+
+  if (node->right != NULL) {
+    tinode_free_cascade(node->right);
+  }
+
+  if (node->next != NULL) {
+    tnode_free(node->next);
+  }
+
+  free(node);
+}
+
+/**
+ * Free a TrieNode and its underlying tree structure.
+ *
+ * @param node node to free
+ */
+void tnode_free(TrieNode *node) {
+  if (node->tree_size > 0) {
+    tinode_free_cascade(node->tree);
+  }
+
+  // TODO properly free entry
+  /* if (node->payload != NULL) { */
+  /*     free(node->payload); */
+  /* } */
+
+  free(node);
+}
+
+/**
+ * This function performs a lookup in the underlying binary tree of the given
+ * TrieNode. If found, the return value is a pointer to the memory
+ * location where the TrieInnerNode representing the given character
+ * stores its `next` field. If not found, the return value is NULL, unless
+ * `create` is true.
+ *
+ * NOTE: a non-NULL return value does not mean that the dereferenced value is
+ * also not NULL. In particular, if `create` is set to true and the function had
+ * to create the new node, the dereferenced value will always be NULL.
+ *
+ * @param node node to perform lookup in. If node is a full leaf, the return
+ * value will always be NULL, regardless of the value of create.
+ * @param create whether to create the TrieInnerNode if it isn't present
+ * yet. If this is set to true, the function will never return NULL unless the
+ * node represents a leaf with a string, because the struct and therefore the
+ * address is created if it doesn't exist yet.
+ */
+TrieNode **tnode_search(TrieNode *node, const char c, bool create) {
+  // It can happen that the node has no initialized root yet
+  if (node->tree_size == 0) {
+    if (create) {
+      node->tree_size++;
+      node->tree = tinode_init(c);
+
+      return &node->tree->next;
+    }
+
+    return NULL;
+  }
+
+  TrieInnerNode *parent = node->tree;
+  TrieInnerNode *child;
+
+  // Iterate through the tree until we either find the character or realize it's
+  // not present in the tree
+  // FIXME don't use while (1)
+  while (1) {
+    if (parent->key == c) {
+      return &parent->next;
+    } else if (c < parent->key) {
+      child = parent->left;
+    } else {
+      child = parent->right;
+    }
+
+    if (child == NULL) {
+      break;
+    }
+
+    parent = child;
+  };
+
+  // child is NULL, meaning the character isn't in the binary tree yet.
+
+  // If create is true, we create the new node so that we can still return a
+  // non-NULL pointer.
+  if (create) {
+    TrieInnerNode *new_node = tinode_init(c);
+
+    if (c < parent->key) {
+      parent->left = new_node;
+    } else {
+      parent->right = new_node;
+    }
+
+    node->tree_size++;
+
+    return &new_node->next;
+  }
+
+  return NULL;
+}
+
+/**
+ * Split a remaining string leaf node in two. This function assumes it receives
+ * a full leaf as its input.
+ *
+ * @param node node to split
+ */
+/* void tnode_split(TrieNode *node) { */
+/*   TrieNode *new_node = tnode_init(); */
+/*   char key = node->ptr.string[0]; */
+
+/*   // There's a chance the remaining string was only 1 character, meaning the
+ * new */
+/*   // node doesn't have to store a string */
+/*   if (node->ptr.string[1] != DELIMITER) { */
+/*     tnode_set_string(new_node, node->ptr.string + 1); */
+/*   } else { */
+/*     new_node->type = 1; */
+/*   } */
+
+/*   new_node->entry = node->entry; */
+
+/*   node->type = 0; */
+/*   node->size = 0; */
+/*   node->entry = NULL; */
+
+/*   free(node->ptr.string); */
+/*   node->ptr.string = NULL; */
+
+/*   // Initialize node's binary tree with the correct character */
+/*   TrieNode **node_ptr = tnode_search(node, key, true); */
+/*   *node_ptr = new_node; */
+/* } */
+
+/*
+ * Remove the given character from a TrieInnerNode's subtree. The
+ * function assumes the character is indeed in the subtree.
+ */
+void tinode_remove(TrieInnerNode *node, const char c) {
+  TrieInnerNode **to_remove_ptr = &node;
+
+  // We use pointers to pointers here so we can later free the removed node
+  // without having to know what its parent is
+  while ((*to_remove_ptr)->key != c) {
+    to_remove_ptr = (c < (*to_remove_ptr)->key) ? &(*to_remove_ptr)->left
+                                                : &(*to_remove_ptr)->right;
+  };
+
+  // If the node isn't a leaf, we have to replace it with another
+  if ((*to_remove_ptr)->left != NULL || (*to_remove_ptr)->right != NULL) {
+    TrieInnerNode *to_replace = *to_remove_ptr;
+
+    // Replace with its only right child
+    if (to_replace->left == NULL) {
+      TrieInnerNode *to_remove = to_replace->right;
+
+      to_replace->key = to_remove->key;
+      to_replace->next = to_remove->next;
+      to_replace->left = to_remove->left;
+      to_replace->right = to_remove->right;
+
+      free(to_remove);
+    }
+    // Replace with its only left child
+    else if (to_replace->right == NULL) {
+      TrieInnerNode *to_remove = to_replace->left;
+
+      to_replace->key = to_remove->key;
+      to_replace->next = to_remove->next;
+      to_replace->left = to_remove->left;
+      to_replace->right = to_remove->right;
+
+      free(to_remove);
+    }
+    // Node has two children, so replace with successor
+    else {
+      TrieInnerNode *to_remove_parent = to_replace;
+      TrieInnerNode *to_remove = to_replace->right;
+
+      while (to_remove->left != NULL) {
+        to_remove_parent = to_remove;
+        to_remove = to_remove->left;
+      }
+
+      to_replace->key = to_remove->key;
+      to_replace->next = to_remove->next;
+
+      if (to_remove_parent != to_replace) {
+        to_remove_parent->left = to_remove->right;
+      } else {
+        to_remove_parent->right = to_remove->right;
+      }
+
+      free(to_remove);
+    }
+  }
+  // We're the leaf, so we free ourselves
+  else {
+    free(*to_remove_ptr);
+    *to_remove_ptr = NULL;
+  }
+}
+
+/**
+ * Remove the given character from a TrieNode, respecting the rules
+ * of a binary search tree. This function assumes the character is in the search
+ * tree.
+ *
+ * @param node node to remove character from
+ * @param c character to remove
+ */
+void tnode_remove(TrieNode *node, const char c) {
+  tinode_remove(node->tree, c);
+
+  node->tree_size--;
+}

trie/test/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_compile_options(-Wno-incompatible-pointer-types)
+
+add_executable(test_trie test_trie.c ../src/trie.c)
+add_test(NAME test_trie COMMAND test_trie)
+add_executable(test_trie_fuzzy test_trie_fuzzy.c ../src/trie.c)
+add_test(NAME test_trie_fuzzy COMMAND test_trie_fuzzy)

trie/test/fuzzy.h

@@ -0,0 +1,202 @@
+#ifndef AD3_FUZZYTEST
+#define AD3_FUZZYTEST
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef struct fuzzyconfig {
+    int seed;
+    int word_length;
+    int word_count;
+} FuzzyConfig;
+
+void random_clean_string(char* s, int len) {
+    char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789,?";
+    int charset_len = strlen(charset);
+
+    // len - 1 ensures that we can still set the null byte for the final byte
+    int actual_len = rand() % (len - 1);
+    int key;
+    int i;
+
+    for (i = 0; i < actual_len; i++) {
+        key = rand() % charset_len;
+        s[i] = charset[key];
+    }
+
+    s[i] = '\0';
+}
+
+void random_string(char* s, int len) {
+    int val = rand();
+
+    // String can't be an empty string as they aren't supported
+    s[0] = (char)(val % 255 + 1);
+
+    for (int i = 1; i < len - 1; i++) {
+        val = rand();
+        s[i] = (char)(val % 256);
+    }
+
+    // Just in case no null characters were created
+    s[len - 1] = '\0';
+}
+
+void random_string_matrix(char** s, int count, int len) {
+    for (int i = 0; i < count; i++) {
+        random_string(s[i], len);
+    }
+}
+
+char** init_string_matrix(int count, int len) {
+    char** matrix = malloc(count * sizeof(char*));
+
+    for (int i = 0; i < count; i++) {
+        matrix[i] = calloc(len, sizeof(char));
+    }
+
+    return matrix;
+}
+
+/**
+ * Test a given trie implementation using randomly generated strings generated
+ * using a given seed.
+ *
+ * @param seed seed to use for generating random strings
+ * @param count how many strings to test with
+ * @param len maximum length of each string
+ * @param init_func function to creat a new trie of the wanted type
+ * @param free_func function to free the given trie
+ * @param add_func function to add a string to the given trie
+ * @param remove_func function to remove a string from the given trie
+ * @param size_func function to get the size of the given trie
+ * @return exit code describing failures, if any
+ */
+int fuzzy_test_trie_seed(FuzzyConfig conf, void* (*init_func) (), void (*free_func) (void*), bool (*add_func) (void*, char*, void*), bool (*remove_func) (void*, char*), size_t (*size_func) (void*)) {
+    srand(conf.seed);
+
+    char** matrix = init_string_matrix(conf.word_count, conf.word_length);
+    random_string_matrix(matrix, conf.word_count, conf.word_length);
+    bool* contains = calloc(conf.word_count, sizeof(bool));
+
+    // It's possible that the string matrix contains duplicate strings
+    bool** contains_dedupped = calloc(conf.word_count, sizeof(bool*));
+
+    for (int i = 0; i < conf.word_count; i++) {
+        if (contains_dedupped[i] == NULL) {
+            contains_dedupped[i] = contains + i;
+
+            for (int j = i + 1; j < conf.word_count; j++) {
+                if (strcmp(matrix[i], matrix[j]) == 0) {
+                    contains_dedupped[j] = contains + i;
+                }
+            }
+        }
+    }
+    
+    // We keep track of the size as well so that we can check whether this is
+    // also correct
+    size_t size = 0;
+
+    void* ct = init_func();
+
+    bool changed;
+
+    // 0: success
+    // 1: invalid add
+    // 2: invalid remove
+    // 3: bad size after adds
+    // 4: bad size after removes
+    int exit_code = 0;
+
+    // Add all strings to trie, checking for duplicates
+    for (int i = 0; i < conf.word_count; i++) {
+      changed = add_func(ct, matrix[i], NULL);
+
+      // if changed is false, *contains_dedupped[i] should be true, as changed
+      // can only be false if the string is already contained in the trie. if
+      // changed is true, *contains_dedupped[i] should be false, as the string
+      // cannot be in the trie yet.
+      if (changed == *contains_dedupped[i]) {
+        exit_code = 1;
+        goto END;
+      }
+
+      if (!*contains_dedupped[i]) {
+        *contains_dedupped[i] = true;
+        size++;
+      }
+    }
+
+    // Ensure size is correct
+    if (size_func(ct) != size) {
+      printf("%i %i\n", size_func(ct), size);
+      exit_code = 3;
+      goto END;
+    }
+
+    // Remove all strings again, again taking duplicates into consideration
+    /* for (int i = 0; i < conf.word_count; i++) { */
+    /*   changed = remove_func(ct, matrix[i]); */
+
+    /*   // The string shouldn't be in the trie, yet another add operation */
+    /*   // says it added it as well */
+    /*   if (changed != *contains_dedupped[i]) { */
+    /*     exit_code = 2; */
+    /*     goto END; */
+    /*   } */
+
+    /*   if (*contains_dedupped[i]) { */
+    /*     *contains_dedupped[i] = false; */
+    /*     size--; */
+    /*   } */
+    /* } */
+
+    // Finally, check that the trie is completely empty
+    /* if (size_func(ct) != 0) { */
+    /*   exit_code = 4; */
+    /* } */
+
+END:
+    free_func(ct);
+
+    // Even testing functions should properly free memory
+    free(contains);
+    free(contains_dedupped);
+
+    for (int i = 0; i < conf.word_count; i++) {
+        free(matrix[i]);
+    }
+
+    free(matrix);
+
+    return exit_code;
+}
+
+/**
+ * Same as fuzzy_test_trie_seed, except that the seed is randomly generated.
+ *
+ * @param count how many strings to test with
+ * @param len maximum length of each string
+ * @param init_func function to creat a new trie of the wanted type
+ * @param free_func function to free the given trie
+ * @param add_func function to add a string to the given trie
+ * @param remove_func function to remove a string from the given trie
+ * @param size_func function to get the size of the given trie
+ * @return the generated seed if the test wasn't successful, -1 otherwise.
+ */
+/* int fuzzy_test_trie(int count, int len, void* (*init_func) (), void (*free_func) (void*), bool (*add_func) (void*, char*), bool (*remove_func) (void*, char*), int (*size_func) (void*)) { */
+/*     int seed = rand(); */
+/*     bool succeeded = fuzzy_test_trie_seed(seed, count, len, init_func, free_func, add_func, remove_func, size_func); */
+
+/*     if (!succeeded) { */
+/*         return seed; */
+/*     } */
+
+/*     return -1; */
+/* } */
+
+
+#endif

trie/test/test_trie.c

@@ -0,0 +1,149 @@
+#include "test.h"
+#include "trie.h"
+#include "fuzzy.h"
+
+#define TEST_SIZE(ct, size) \
+    TEST_CHECK(trie_size(ct) == size); \
+    TEST_MSG("Size: %zu", trie_size(ct))
+                                \
+void test_init() {
+    Trie* ct = trie_init();
+    TEST_CHECK(ct != NULL);
+    TEST_SIZE(ct, 0);
+    trie_free(ct);
+}
+
+void test_add_one() {
+    Trie* ct = trie_init();
+    TEST_CHECK(ct != NULL);
+
+    Entry *entry = entry_new(Redirect, "");
+    const char* string = "this is a test";
+
+    TEST_CHECK(trie_add(ct, string, entry));
+    TEST_CHECK(trie_search(ct, string) == entry);
+    TEST_SIZE(ct, 1);
+    trie_free(ct);
+}
+
+void test_search_not_present() {
+    Trie* ct = trie_init();
+    TEST_CHECK(ct != NULL);
+
+    TEST_CHECK(trie_add(ct, "this string exists", NULL));
+    TEST_CHECK(trie_search(ct, "this string does not exist") == NULL);
+    trie_free(ct);
+}
+
+void test_add_more() {
+    Trie* ct = trie_init();
+    TEST_CHECK(ct != NULL);
+
+    const char* one = "one";
+    const char* two = "two";
+    const char* twenty = "twenty";
+    const char* twentytwo = "twentytwo";
+    Entry *entry = entry_new(Redirect, "");
+
+    TEST_CHECK(trie_add(ct, one, entry));
+    TEST_CHECK(trie_add(ct, two, entry));
+    TEST_CHECK(trie_add(ct, twenty, entry));
+    TEST_CHECK(trie_add(ct, twentytwo, entry));
+
+    TEST_SIZE(ct, 4);
+
+    TEST_CHECK(trie_search(ct, one) == entry);
+    TEST_CHECK(trie_search(ct, two) == entry);
+    TEST_CHECK(trie_search(ct, twenty) == entry);
+    TEST_CHECK(trie_search(ct, twentytwo) == entry);
+
+    TEST_CHECK(!trie_add(ct, one, NULL));
+    TEST_CHECK(!trie_add(ct, two, NULL));
+    TEST_CHECK(!trie_add(ct, twenty, NULL));
+    TEST_CHECK(!trie_add(ct, twentytwo, NULL));
+
+    trie_free(ct);
+}
+
+/* void test_remove_one() { */
+/*     Trie* ct = trie_init(); */
+/*     TEST_CHECK(ct != NULL); */
+
+/*     const char* string = "this is a test"; */
+/*     TEST_CHECK(trie_add(ct, string, NULL)); */
+/*     TEST_SIZE(ct, 1); */
+
+/*     TEST_CHECK(trie_remove(ct, string)); */
+/*     TEST_SIZE(ct, 0); */
+
+/*     trie_free(ct); */
+/* } */
+
+/* void test_remove_more() { */
+/*     Trie* ct = trie_init(); */
+/*     TEST_CHECK(ct != NULL); */
+
+/*     const char* one = "one"; */
+/*     const char* two = "two"; */
+/*     const char* twenty = "twenty"; */
+/*     const char* twentytwo = "twentytwo"; */
+/*     TEST_CHECK(trie_add(ct, one, NULL)); */
+/*     TEST_CHECK(trie_add(ct, two, NULL)); */
+/*     TEST_CHECK(trie_add(ct, twenty, NULL)); */
+/*     TEST_CHECK(trie_add(ct, twentytwo, NULL)); */
+
+/*     TEST_SIZE(ct, 4); */
+
+/*     TEST_CHECK(trie_remove(ct, one)); */
+/*     TEST_CHECK(trie_remove(ct, two)); */
+/*     TEST_CHECK(trie_remove(ct, twenty)); */
+/*     TEST_CHECK(trie_remove(ct, twentytwo)); */
+
+/*     TEST_SIZE(ct, 0); */
+
+/*     trie_free(ct); */
+/* } */
+
+/* void test_remove_not_present() { */
+/*     Trie* ct = trie_init(); */
+/*     TEST_CHECK(ct != NULL); */
+
+/*     TEST_CHECK(trie_add(ct, "this string exists", NULL)); */
+/*     TEST_CHECK(!trie_remove(ct, "this string does not exist")); */
+
+/*     trie_free(ct); */
+/* } */
+
+// Test seeds that are known to fail so we don't get regressions
+void test_fuzzy_set() {
+  FuzzyConfig configs[] = {
+    { 403318210, 5, 500},
+    { 588218406, 16, 460},
+    { 297512224, 21, 500},
+    { 403318210, 5, 500}
+  };
+
+  int count = sizeof(configs) / sizeof(FuzzyConfig);
+  int res;
+
+  for (int i = 0; i < count; i++) {
+res = fuzzy_test_trie_seed(configs[i], trie_init,
+                                     trie_free, trie_add_no_lock,
+                                     NULL, trie_size);
+    TEST_CHECK_(res == 0,
+                "Failed config, seed = %i, len = %i, count = %i, code=%i", configs[i].seed, configs[i].word_length, configs[i].word_count, res);
+    }
+}
+
+TEST_LIST = {
+        {"trie init",test_init },
+        { "trie add one",test_add_one },
+        { "trie add more",test_add_more },
+        { "trie search not present",test_search_not_present},
+
+        /* { "trie remove one",test_remove_one }, */
+        /* { "trie remove more",test_remove_more }, */
+        /* { "trie remove not present",test_remove_not_present}, */
+        { "trie fuzzy set", test_fuzzy_set },
+        { NULL, NULL}
+};

trie/test/test_trie_fuzzy.c

@@ -0,0 +1,36 @@
+#include "test.h"
+#include "trie.h"
+#include "fuzzy.h"
+
+void test_fuzzy() {
+    // Randomize seed
+    srand(time(NULL));
+
+    FuzzyConfig config;
+    int counter = 0;
+    int res;
+
+    for (int len = 1; len < 25; len += 5) {
+      for (int count = 10; count <= 500; count += 10) {
+        for (int i = 0; i < 50; i++) {
+          counter++;
+
+          config.seed = rand();
+          config.word_length = len;
+          config.word_count = count;
+
+res = fuzzy_test_trie_seed(config, trie_init,
+                                     trie_free, trie_add_no_lock,
+                                     NULL, trie_size);
+    TEST_CHECK_(res == 0,
+                "Failed config, seed = %i, len = %i, count = %i, code = %i", config.seed, config.word_length, config.word_count, res);
+        }
+      }
+    }
+    TEST_MSG("fuzzy tests done = %i", counter);
+}
+
+TEST_LIST = {
+  { "customtrie fuzzy", test_fuzzy },
+  { NULL, NULL}
+};