429 lines
11 KiB
C
429 lines
11 KiB
C
#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;
|
|
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_len(Trie *trie, const char *key, size_t key_len) {
|
|
SearchResult out = {NULL, NULL};
|
|
|
|
size_t i = 0;
|
|
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 (i < key_len) {
|
|
node_ptr = child_ptr;
|
|
}
|
|
} while (i < key_len);
|
|
|
|
// 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 (i == key_len && (*child_ptr)->represents) {
|
|
out.parent = *node_ptr;
|
|
out.child = *child_ptr;
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
SearchResult trie_search_node(Trie *trie, const char *key) {
|
|
return trie_search_node_len(trie, key, strlen(key));
|
|
}
|
|
|
|
/**
|
|
* 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_len(Trie *trie, Entry **entry_ptr, const char *key,
|
|
size_t key_len) {
|
|
SearchResult res = trie_search_node_len(trie, key, key_len);
|
|
|
|
if (res.child == NULL) {
|
|
return NotFound;
|
|
}
|
|
|
|
*entry_ptr = res.child->entry;
|
|
|
|
return Ok;
|
|
}
|
|
|
|
TrieExitCode trie_search(Trie *trie, Entry **entry_ptr, const char *key) {
|
|
return trie_search_len(trie, entry_ptr, key, strlen(key));
|
|
}
|
|
|
|
/**
|
|
* 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_len_no_lock(Trie *trie, const char *key, size_t key_len,
|
|
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, key[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 && i + offset < key_len) {
|
|
offset++;
|
|
}
|
|
|
|
memcpy(child_node->string, key + 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 (i + offset < key_len) {
|
|
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 (key[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 (i < key_len);
|
|
|
|
if ((*child_node_ptr)->represents) {
|
|
return AlreadyPresent;
|
|
}
|
|
|
|
(*child_node_ptr)->represents = true;
|
|
(*child_node_ptr)->entry = entry;
|
|
trie->size++;
|
|
return Ok;
|
|
}
|
|
|
|
TrieExitCode trie_add_no_lock(Trie *trie, const char *key, Entry *entry) {
|
|
return trie_add_len_no_lock(trie, key, strlen(key), entry);
|
|
}
|
|
|
|
TrieExitCode trie_add_len(Trie *trie, const char *key, size_t key_len,
|
|
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_len(trie, key, key_len).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_len_no_lock(trie, key, key_len, entry);
|
|
}
|
|
|
|
TrieExitCode trie_add(Trie *trie, const char *key, Entry *entry) {
|
|
return trie_add_len(trie, key, strlen(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); }
|