chore: fix repo compilation after rebase with main

src/main.c

@@ -50,14 +50,14 @@ int main() {
 
   info("Initializing trie");
 
-  Trie *trie = trie_init();
-  int count = trie_populate(trie, "lander.data");
+  Trie *trie;
+  TrieExitCode res = trie_init(&trie, "lander.data");
 
-  if (count < 0) {
+  if (res != Ok) {
     critical(1, "An error occured while populating the trie.");
   }
 
-  info("Trie initialized and populated with %i entries", count);
+  info("Trie initialized and populated with %i entries", trie_size(trie));
 
   http_loop_gctx *gctx = http_loop_gctx_init();
   gctx->trie = trie;

src/trie/trie.c

@@ -0,0 +1,411 @@
+#include <pthread.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "trie.h"
+#include "trie_entry.h"
+#include "trie_node.h"
+
+typedef struct ttrie {
+  TrieNode *root;
+  size_t size;
+  char *file_path;
+  pthread_rwlock_t lock;
+} Trie;
+
+TrieExitCode trie_add_no_lock(Trie *trie, const char *key, Entry *entry);
+
+/**
+ * Allocate and initialize an empty Trie
+ *
+ * @return pointer to the empty Trie
+ */
+TrieExitCode trie_init(Trie **trie_ptr, const char *file_path) {
+  // Allocate & initialize trie
+  Trie *trie = calloc(1, sizeof(Trie));
+  trie->root = tnode_init();
+  pthread_rwlock_init(&trie->lock, NULL);
+
+  if (file_path == NULL) {
+    trie->file_path = NULL;
+    *trie_ptr = trie;
+    return Ok;
+  }
+
+  trie->file_path = strdup(file_path);
+
+  // Populate trie with data from file
+  FILE *fp = fopen(file_path, "r");
+
+  if (fp == NULL) {
+    return FileError;
+  }
+
+  // We read in lines of at most 8192 characters (sounds like enough)
+  char buffer[8192];
+  EntryType type;
+  Entry *entry;
+  char *string;
+  int i, j;
+  TrieExitCode status;
+
+  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);
+    status = trie_add_no_lock(trie, buffer, entry);
+
+    if (status != Ok) {
+      trie_free(trie);
+      return status;
+    }
+  }
+
+  fclose(fp);
+
+  *trie_ptr = trie;
+
+  return Ok;
+}
+
+/**
+ * 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);
+}
+
+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;
+
+    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
+ */
+TrieExitCode trie_search(Trie *trie, Entry **entry_ptr, const char *key) {
+  SearchResult res = trie_search_node(trie, key);
+
+  if (res.child == NULL) {
+    return NotFound;
+  }
+
+  *entry_ptr = res.child->entry;
+
+  return Ok;
+}
+
+/**
+ * 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
+ */
+TrieExitCode 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 Ok;
+    }
+
+    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 AlreadyPresent;
+  }
+
+  (*child_node_ptr)->represents = true;
+  (*child_node_ptr)->entry = entry;
+  trie->size++;
+  return Ok;
+}
+
+TrieExitCode trie_add(Trie *trie, const char *key, Entry *entry) {
+  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 AlreadyPresent;
+    }
+
+    FILE *fp = fopen(trie->file_path, "a");
+
+    if (fp == NULL) {
+      return FileError;
+    }
+
+    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 Ok. Otherwise, the function would've
+  // exited because the string was found in the trie.
+  return trie_add_no_lock(trie, key, entry);
+}
+
+TrieExitCode trie_add_random(Trie *trie, char **key_ptr, Entry *entry,
+                             bool secure) {
+  // 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;
+  }
+
+  TrieExitCode return_value = trie_add(trie, key, entry);
+
+  if (return_value == Ok) {
+    *key_ptr = key;
+  } else {
+    free(key);
+  }
+
+  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; }
+
+int trie_rlock(Trie *trie) { return pthread_rwlock_rdlock(&trie->lock); }
+
+int trie_wlock(Trie *trie) { return pthread_rwlock_wrlock(&trie->lock); }
+
+int trie_unlock(Trie *trie) { return pthread_rwlock_unlock(&trie->lock); }

src/trie/trie_entry.c

@@ -0,0 +1,37 @@
+#include "trie_entry.h"
+#include <stdlib.h>
+
+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;
+}

src/trie/trie_entry.h

@@ -0,0 +1,7 @@
+#include "trie.h"
+
+EntryType entry_type_from_char(char c);
+
+char entry_type_to_char(EntryType et);
+
+Entry *entry_new(EntryType type, const char *string);

src/trie/trie_node.c

@@ -0,0 +1,265 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "trie_node.h"
+
+/**
+ * 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--;
+}

src/trie/trie_node.h

@@ -0,0 +1,53 @@
+#include <stdint.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;
+
+TrieInnerNode *tinode_init(char c);
+
+TrieNode *tnode_init();
+
+void tinode_free_cascade(TrieInnerNode *node);
+
+void tnode_free(TrieNode *node);
+
+TrieNode **tnode_search(TrieNode *node, const char c, bool create);
+
+void tinode_remove(TrieInnerNode *node, const char c);
+
+void tnode_remove(TrieNode *node, const char c);