initial codebase

17 files changed, 3860 insertions, 1 deletions

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..bcdd123
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,21 @@
+# part of Hydrilla
+#
+# Copyright (C) 2021 Wojtek Kosior
+# Redistribution terms are gathered in the `copyright' file.
+
+CC=gcc
+CFLAGS=-Wall -Werror -pedantic -std=c99 -D_USE_INLINE -O0 -g
+#CFLAGS=-Wall -Werror -std=c89 -O0 -g
+
+EXECNAME=hydrilla
+
+$(EXECNAME): string_buf.o hashtable.o serve.o scriptbase_build.o \
+	     scriptbase_query.o scriptbase_json_query.o main.o
+	gcc $(filter %.o,$^) -lmicrohttpd -lcjson -o $@
+
+clean:
+	rm -f $(EXECNAME) *.o
+
+.PHONY: clean
+
+*.o $(EXECNAME): Makefile
diff --git a/README.txt b/README.txt
index fce5901..5821b8e 100644
--- a/README.txt
+++ b/README.txt
@@ -1 +1,7 @@
-This is where Hydrilla will be developed.
+This is the repository of Hydrilla, a repository software to work with browser
+extension Hachette.
+
+See [1] and [2] for details.
+
+[1] https://hachettebugs.koszko.org/projects/hydrilla
+[2] https://hachettebugs.koszko.org/projects/hachette
diff --git a/copyright b/copyright
new file mode 100644
index 0000000..6ba447d
--- /dev/null
+++ b/copyright
@@ -0,0 +1,60 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: Hydrilla
+Source: https://git.koszko.org/hydrilla/
+
+Files: *
+Copyright: 2021 Wojtek Kosior <koszko@koszko.org>
+License: AGPL-3+ or Alicense-1.0
+
+Files: serve.c
+Copyright: 2021 Wojtek Kosior <koszko@koszko.org>
+   2008-2010, 2012 Christian Grothoff
+License: AGPL-3+ or Alicense-1.0, and public-domain
+
+Files: Makefile README.txt copyright
+Copyright: 2021 Wojtek Kosior <koszko@koszko.org>
+License: CC0
+
+Files: licenses/*
+Copyright: 2001, 2002, 2011-2013 Creative Commons
+License: CC-BY-4.0
+
+Files: licenses/agpl-3.0.txt
+Copyright: 2007 Free Software Foundation, Inc. <https://fsf.org/>
+License: no-changing
+ Everyone is permitted to copy and distribute verbatim copies of
+ this license document, but changing it is not allowed.
+
+Files: licenses/alicense.txt
+Copyright: 1988-1990 Regents of the University of California
+   2021 Wojtek Kosior <koszko@koszko.org>
+License: CC0 and public-domain
+
+License: Alicense-1.0
+ You can use and redistribute this program with or without
+ modification under then terms of "A" license version 1.0. You
+ should have received a copy of "A" license along with this
+ program. If not, you can get it from
+ `https://koszko.org/alicense.txt'.
+ Also see `https://koszko.org/en/articles/my-new-license.html'
+ for more explanation.
+
+License: AGPL-3+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as
+ published by the Free Software Foundation, either version 3 of the
+ License, or (at your option) any later version.
+ .
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+ .
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+License: CC0
+ See `licenses/cc0.txt'
+
+License: CC-BY-4.0
+ See `licenses/cc-by-4.0.txt'
diff --git a/hashtable.c b/hashtable.c
new file mode 100644
index 0000000..a397879
--- /dev/null
+++ b/hashtable.c
@@ -0,0 +1,565 @@
+/**
+ * C hashtable implementation
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+/*
+ * GENERAL INFO
+ *
+ * You might want to read the beginning of hashtable.h first.
+ *
+ * In some places "rehashing" and in other ones "resizing" seemed to
+ * be the right word to use. They mean more or less the same.
+ *
+ * Functions starting with ht_ are part of the API. Internal functions
+ * are declared static. I also made some of them inline (either
+ * because they were extremely short or only called from 1 place).
+ *
+ * Hashtable size is always a power of 2.
+ *
+ * When the hashtable is ¾ full, a new, 2x bigger table is allocated
+ * and whenever one of 4 basic operations (adding, removing, setting,
+ * getting) occurs, 4 slots are being rehashed from old table into 8
+ * slots in new table. Similarly, when hashtable is ¼ full, a new,
+ * 2x smaller table is allocated and each of subsequent operations
+ * rehashes 8 entries from old table into 4 in new table.
+ * This mechanism has been made lazier: getting and removing don't
+ * trigger growing of ht even if it's 3/4 full. Similarly, getting,
+ * setting and adding don't trigger shrinking.
+ * Once resizing is triggered, however, any of the operations will
+ * contribute to rehashing. Even if, for example, the operation is
+ * ADD and the table is being shrinked.
+ * This means, that if we have a hashtable of size n which is ¾ full
+ * and growing is triggered, then each subsequent call to
+ * ht_{add,rem,get,set}() rehashes some entries and, depending on
+ * how frequently and how successfully each of these 4 funcs was
+ * called, at the end of resizing we get a size 2n hashtable which is
+ * between ¼ and ½ full. Similarly, if shrinking of a ¼ full
+ * hashtable of size n is triggered, then after some operations we
+ * get a size ½n hashtable, that is somewhere between ¼ and ¾ full.
+ * One can see now, that we always keep the hashtable between ¼ and ¾
+ * full (with the exception of a minimal size one, that can be empty).
+ */
+
+#include "hashtable.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#ifdef _USE_INLINE
+#define INLINE inline
+#else
+#define INLINE
+#endif
+
+/*
+ * We won't shrink hashtable below this size. Newly created one will
+ * be this big.
+ */
+#define MIN_SIZE 4
+
+/* Special value of ht->rehashing_position. */
+#define NOT_REHASHING ((ssize_t) -1)
+
+/*
+ * Those are possible return values of do_resizing_related_stuff()
+ * and rehash_some_entries() (which only returns the first 2).
+ */
+#define REHASHING_IN_PROGRESS     0
+#define REHASHING_NOT_IN_PROGRESS 1
+#define REHASHING_NO_MEM          2
+
+/* Struct used to store a pair. */
+struct ht_node
+{
+  const void *key;
+  const void *val;
+  struct ht_node *next;
+};
+
+enum op
+  {
+    GET,
+    GET_THREADSAFE,
+    ADD,
+    SET,
+    REM,
+  };
+
+int ht_init(hashtable_t *ht,
+	    size_t (*hash)(const void *key),
+	    int (*cmp)(const void *key1, const void *key2))
+{
+  if (!(ht->tab = calloc(MIN_SIZE, sizeof(struct ht_node**))))
+    return HT_NO_MEM;
+
+  ht->tab_size = MIN_SIZE;
+  ht->rehashing_position = NOT_REHASHING;
+  ht->entries = 0;
+  ht->hashfunc = hash;
+  ht->cmpfunc = cmp;
+
+  return HT_OK;
+}
+
+/* First come some utilities :) */
+
+static INLINE size_t min(size_t n1, size_t n2)
+{
+  return n1 < n2 ? n1 : n2;
+}
+
+static INLINE size_t hash2(size_t n)
+{
+  /* I found this "hash improver" on the internet. */
+  n ^= (n >> 20) ^ (n >> 12);
+  return n ^ (n >> 7) ^ (n >> 4);
+}
+
+/* Below are 2 list-handling utility functions. */
+static INLINE struct ht_node *join_lists(struct ht_node *l1,
+					 struct ht_node *l2)
+{
+  if (!l1) return l2;
+  if (!l2) return l1;
+
+  struct ht_node *l1_last;
+
+  for (l1_last = l1; l1_last->next; l1_last = l1_last->next);
+
+  /* Append l2 to the end of l1. */
+  l1_last->next = l2;
+
+  /* For convenience return the first element of the resulting list. */
+  return l1;
+}
+
+
+static INLINE void push(struct ht_node *node, struct ht_node **list)
+{
+  node->next = *list;
+  *list = node;
+}
+
+/*
+ * The following 2 rehash_* functions are helpers of rehash_some_entries().
+ * This func rehashes 1 chain of entries in tab[] into 2 chains in newtab[].
+ */
+static INLINE void rehash_position_growing(hashtable_t *ht)
+{
+  /* There are 2 possible new positions of an entry in a 2x bigger ht. */
+  struct ht_node *list0 = NULL, *list1 = NULL;
+
+  size_t old_position = ht->rehashing_position,
+    new_position0 = old_position,
+    new_position1 = old_position | ht->tab_size;
+
+  struct ht_node *pair = ht->tab[old_position], *next_pair;
+
+  while (pair)
+    {
+      next_pair = pair->next;
+
+      size_t new_position = hash2(ht->hashfunc(pair->key))
+	& (ht->new_size - 1);
+
+      push(pair, new_position == new_position1 ? &list1 : &list0);
+
+      pair = next_pair;
+    }
+
+  ht->newtab[new_position0] = list0;
+  ht->newtab[new_position1] = list1;
+
+  ht->rehashing_position++;
+}
+
+/* This func rehashes 2 chains of entries in tab[] into 1 chain in newtab[]. */
+static INLINE void rehash_2positions_shrinking(hashtable_t *ht)
+{
+  size_t new_position = ht->rehashing_position,
+    old_position0 = new_position,
+    old_position1 = new_position | ht->new_size;
+
+  ht->newtab[new_position] = join_lists(ht->tab[old_position0],
+					ht->tab[old_position1]);
+
+  ht->rehashing_position++;
+}
+
+/*
+ * Rehashes 4(8) positions from tab to newtab. If those were the last
+ * enetries to rehash, the function takes care of everything
+ * (like deallocating old tab) and returns REHASHING_NOT_IN_PROGRESS.
+ * Otherwise, returns REHASHING_IN_PROGRESS.
+ * Caller must make sure rehashing was started b4 calling this func.
+ */
+static int rehash_some_entries(hashtable_t *ht)
+{
+  int rehashes_left = 4;
+
+  if (ht->new_size > ht->tab_size)                    /* growing ht */
+    {
+      while(rehashes_left--) rehash_position_growing(ht);
+      if (ht->rehashing_position != ht->tab_size)
+	return REHASHING_IN_PROGRESS;
+    }
+  else                                                /* shrinking ht */
+    {
+      while(rehashes_left--) rehash_2positions_shrinking(ht);
+      if (ht->rehashing_position != ht->new_size)
+	return REHASHING_IN_PROGRESS;
+    }
+
+  /* rehashing finishes */
+  ht->rehashing_position = NOT_REHASHING;
+  ht->tab_size = ht->new_size;
+  free(ht->tab);
+  ht->tab = ht->newtab;
+
+  return REHASHING_NOT_IN_PROGRESS;
+}
+
+static INLINE bool resizing_taking_place(hashtable_t *ht)
+{
+  return !(ht->rehashing_position == NOT_REHASHING);
+}
+
+void ht_finish_resizing(hashtable_t *ht)
+{
+  if (resizing_taking_place(ht))
+    while (rehash_some_entries(ht) == REHASHING_IN_PROGRESS);
+}
+
+static INLINE bool needs_growing(hashtable_t *ht)
+{
+  return ht->entries >= 3 * ht->tab_size / 4;
+}
+
+static INLINE bool needs_shrinking(hashtable_t *ht)
+{
+  return ht->tab_size > MIN_SIZE
+    && ht->entries <= ht->tab_size / 4;
+}
+/*
+ * Each of hashtable operations (add, set, rem, get) should also
+ * attempt to do part of resizing. This way resizing operation
+ * which is O(n) is distributed among many hashtable accesses
+ * each of them still being O(1). Without this the the amortized
+ * complexity of ht accesses would still be O(1), but a single access
+ * would sometimes be O(n).
+ * Other function that adds, sets, gets or removes sth from ht uses
+ * this one to do this "part of resizing" mentioned above.
+ * This func returns REHASHING_NO_MEM on failed malloc (won't happen
+ * for GET or REM operation) and REHASHING_[NOT_]IN_PROGRESS otherwise.
+ */
+static INLINE int
+do_resizing_related_stuff(hashtable_t *ht, const void *key, enum op op)
+{
+  bool resizing = resizing_taking_place(ht);
+
+  if (!resizing)
+    {
+      size_t new_size;
+
+      switch (op)
+	{
+	case GET:
+	  goto dont_start_resizing;
+	case ADD:
+	case SET:
+	  if (needs_growing(ht))
+	    new_size = ht->tab_size * 2;
+	  else
+	    goto dont_start_resizing;
+	  break;
+	default: /* case REM */
+	  if (needs_shrinking(ht))
+	    new_size = ht->tab_size / 2;
+	  else
+	    goto dont_start_resizing;
+	}
+
+      struct ht_node **newtab;
+      if (!(newtab = malloc(new_size * sizeof(struct ht_node*))))
+	return op == REM ? REHASHING_NOT_IN_PROGRESS : REHASHING_NO_MEM;
+
+      ht->newtab = newtab;
+      ht->new_size = new_size;
+      ht->rehashing_position = 0;
+
+      resizing = true;
+    }
+
+ dont_start_resizing:
+
+  return resizing ?
+    rehash_some_entries(ht) : REHASHING_NOT_IN_PROGRESS;
+}
+
+/*
+ * This is a chaining hashtable, so each element in the array (table)
+ * is actually a list of entries. All operations (adding, removing,
+ * etc.) need to find the right list of entries (here called "bucket")
+ * for a given key first, so it makes sense to do it in a separate
+ * function. The bucket may be in tab or newtab if resizing is taking
+ * place. Being informed by the caller if resizing is in progress,
+ * this func does not need to check for it by itself.
+ */
+static INLINE struct ht_node **find_bucket(hashtable_t *ht, const void *key,
+					   bool resizing_in_progress)
+{
+  size_t hash = hash2(ht->hashfunc(key)),
+    destination_tab_size, position;
+
+  struct ht_node **destination_tab;
+
+  if (resizing_in_progress)
+    /*
+     * Here we must check whether our key's bucket is still
+     * in ht->tab or already rehashed to ht->newtab.
+     */
+    {
+      size_t smaller_tab_size = min(ht->tab_size, ht->new_size),
+	smaller_tab_position = hash & (smaller_tab_size - 1);
+
+      if (smaller_tab_position < ht->rehashing_position)
+	{
+	  destination_tab = ht->newtab;
+	  destination_tab_size = ht->new_size;
+	}
+      else
+	{
+	  destination_tab = ht->tab;
+	  destination_tab_size = ht->tab_size;
+	}
+    }
+  else
+    /* In this case we know, we're working on ht->tab and not newtab. */
+    {
+      destination_tab = ht->tab;
+      destination_tab_size = ht->tab_size;
+    }
+
+  position = hash & (destination_tab_size - 1);
+  return &destination_tab[position];
+}
+
+/*
+ * Operations of adding, removing, etc. all work on list of entries
+ * (bucket) to wchich key hashes and they have some common logic, so
+ * it made sense to make a single function, that does the right
+ * operation based on an enum passed to it.
+ */
+static INLINE int
+perform_operation_on_bucket(hashtable_t *ht, struct ht_node **bucket,
+			    const void *key, const void *val,
+			    void **keyptr, void **valptr,
+			    enum op op)
+{
+  struct ht_node **pairptr, *pair;
+
+  for (pairptr = bucket, pair = *pairptr;
+       pair;
+       pairptr = &pair->next, pair = pair->next)
+
+    if (!ht->cmpfunc(key, pair->key))
+      {
+	if (op == ADD)
+	  return HT_KEY_PRESENT;
+
+	if (keyptr) *keyptr = (void*) pair->key;
+	if (valptr) *valptr = (void*) pair->val;
+
+	switch (op)
+	  {
+	  case GET:
+	  case GET_THREADSAFE:
+	    {
+	      return HT_OK;
+	    }
+	  case SET:
+	    {
+	      pair->key = key;
+	      pair->val = val;
+	      return HT_OK;
+	    }
+	  default: /* case REM */
+	    {
+	      *pairptr = pair->next;
+	      free(pair);
+	      ht->entries--;
+	      return HT_OK;
+	    }
+	  }
+      }
+
+  if (op == GET || op == GET_THREADSAFE || op == REM)
+    return HT_KEY_ABSENT;
+
+  /* op == ADD || op == SET */
+
+  struct ht_node *new_pair = malloc(sizeof(struct ht_node));
+  if (!new_pair)
+    return HT_NO_MEM;
+
+  *new_pair = (struct ht_node) {.key = key, .val = val};
+  push(new_pair, bucket);
+  ht->entries++;
+
+  return HT_OK;
+}
+
+/* Generic function for performing of adding, removing, setting and getting. */
+static int perform_operation(hashtable_t *ht, const void *key, const void *val,
+			     void **keyptr, void **valptr, enum op op)
+{
+  bool resizing_in_progress;
+
+  if (op == GET_THREADSAFE) {
+    resizing_in_progress = resizing_taking_place(ht);
+    goto skip_resizing;
+  }
+
+  switch (do_resizing_related_stuff(ht, key, op))
+    {
+    case REHASHING_IN_PROGRESS:
+      resizing_in_progress = true;
+      break;
+    case REHASHING_NOT_IN_PROGRESS:
+      resizing_in_progress = false;
+      break;
+    default: /* case REHASHING_NO_MEM */
+      return HT_NO_MEM;
+    }
+
+  struct ht_node **bucket;
+
+ skip_resizing:
+  bucket = find_bucket(ht, key, resizing_in_progress);
+
+  return perform_operation_on_bucket(ht, bucket, key, val,
+				     keyptr, valptr, op);
+}
+
+/* The 5 functions below are the main part of the API. */
+int ht_get(hashtable_t *ht, const void *key,
+	   void **storedkey, void **val)
+{
+  return perform_operation(ht, key, NULL, storedkey, val, GET);
+}
+
+int ht_get_threadsafe(hashtable_t *ht, const void *key,
+		      void **storedkey, void **val)
+{
+  return perform_operation(ht, key, NULL, storedkey, val,
+			   GET_THREADSAFE);
+}
+
+int ht_add(hashtable_t *ht, const void *key, const void *val)
+{
+  return perform_operation(ht, key, val, NULL, NULL, ADD);
+}
+
+int ht_set(hashtable_t *ht, const void *key, const void *val,
+	   void **oldkey, void **oldval)
+{
+  return perform_operation(ht, key, val, oldkey, oldval, SET);
+}
+
+int ht_rem(hashtable_t *ht, const void *key,
+	   void **storedkey, void **val)
+{
+  return perform_operation(ht, key, NULL, storedkey, val, REM);
+}
+
+/*
+ * As mentioned in hashtable.h, this func does not deallocate keys
+ * nor vals. One could use ht_map_destroy() if that is needed.
+ */
+void ht_destroy(hashtable_t *ht)
+{
+  ssize_t position;
+
+  if (!ht->entries)
+    goto free_tab;
+
+  ht_finish_resizing(ht);
+
+  struct ht_node **tab = ht->tab;
+
+  for (position = ht->tab_size - 1; position >= 0; position--)
+    {
+      struct ht_node *pair = tab[position], *nextpair;
+
+      while (pair)
+	{
+	  nextpair = pair->next;
+	  free(pair);
+	  pair = nextpair;
+	}
+    }
+
+ free_tab:
+  free(ht->tab);
+}
+
+void ht_map(hashtable_t *ht, void *arg,
+	    void (*mapfunc)(const void *key, void *val, void *arg))
+{
+  ssize_t position;
+
+  if (!ht->entries)
+    return;
+
+  ht_finish_resizing(ht);
+
+  struct ht_node **tab = ht->tab, *pair;
+
+  for (position = ht->tab_size - 1; position >= 0; position--)
+    {
+      for (pair = tab[position]; pair; pair = pair->next)
+	mapfunc(pair->key, (void*) pair->val, arg);
+    }
+}
+
+void ht_map_destroy(hashtable_t *ht, void *arg,
+		    void (*mapfunc)(void *key, void *val, void *arg))
+{
+  /*
+   * If mapfunc() deallocates keys, the following 2 lines make
+   * assumption on ht_destroy(), that it doesn't call ht->hashfunc()
+   * or ht->cmpfunc() on keys.
+   */
+  ht_map(ht, arg, (void (*)(const void*, void*, void*)) mapfunc);
+  ht_destroy(ht);
+}
+
+/*
+ * These 2 functions are for easy making of hashtable with strings as
+ * keys. Note that this hash is *not* secure against DoS attacks.
+ */
+size_t ht_string_hash(const char *key)
+{
+  size_t i = 0, hash = (size_t) 0xa1bad2dead3beef4;
+
+  do
+    {
+      char shift = ((unsigned char) key[i]) % sizeof(size_t);
+      hash += ((hash >> shift) | (hash << (sizeof(size_t) - shift)))
+	^ key[i];
+    }
+  while (key[i++]);
+
+  return hash;
+}
+
+int ht_string_init(hashtable_t *ht)
+{
+  return ht_init(ht, (size_t (*)(const void*)) &ht_string_hash,
+		 (int (*)(const void*, const void*)) &strcmp);
+}
diff --git a/hashtable.h b/hashtable.h
new file mode 100644
index 0000000..19a3897
--- /dev/null
+++ b/hashtable.h
@@ -0,0 +1,143 @@
+/**
+ * C hashtable implementation
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+/*
+ * https://git.koszko.org/C-hashtable
+ * Note that this version is likely to be more up-to-date than the one linked.
+ *
+ * This is a separate chaining hashtable for general use. It's not
+ * universal: it uses malloc() and free(), so it requires a standard
+ * library to function and it's for single-threaded use only. It does,
+ * however, have one advantage: it rehashes automatically, both when
+ * it grows in size and when it shrinks, while retaining O(1) access
+ * time. A normal hashtable with rehashing would have amortized O(1)
+ * access time, but there would be single access with O(n) time
+ * complexity for each rehashing. In this hashtable, rehashing is done
+ * in parts. For example, a ht_add(), aside from adding an entry,
+ * might also rehash 4 other entries from old table to the new one and
+ * leave the rest unrehashed.
+ * Of course, it is assumed that a good hash function is provided
+ * by the programmer. If not, accesses may still degenerate to O(n).
+ * Hence, this hashtable is not secure against DoS attacks.
+ */
+
+#ifndef HASHTABLE_H
+#define HASHTABLE_H
+
+#include <sys/types.h> /* for ssize_t */
+
+/* These are possible return values of some ht_ functions (see below). */
+#define HT_OK           0
+#define HT_NO_MEM      -1
+#define HT_KEY_PRESENT -2
+#define HT_KEY_ABSENT  -3
+
+typedef struct
+{
+  /* All members are considered implementation details, except for "entries",
+   * which can be read, but should not be modified by external code.
+   */
+  size_t entries;
+
+  /*
+   * tab[] is where entries (chains of entries) are stored.
+   * When rehashing, newtab[] is also used.
+   */
+  struct ht_node **tab, **newtab;
+
+  /* sizes of tab[] and newtab[], obviously */
+  size_t tab_size, new_size;
+
+  size_t (*hashfunc)(const void* key);
+  int (*cmpfunc)(const void* key1, const void *key2);
+
+  /*
+   * When no rehashing is taking place, rehashing_position is -1 (#define'd as
+   * NOT_REHASHING in hashtable.c). At any other time, rehashing_position is the
+   * lowest not yet rehashed position in the smaller table.
+   */
+  ssize_t rehashing_position;
+} hashtable_t;
+
+/*
+ * All int functions return 0 (#define'd as HT_OK) on success and in
+ * case of failure they return error codes, as described below.
+ */
+
+/* May fail with HT_NO_MEM. */
+int ht_init(hashtable_t *ht,
+	    size_t (*hash)(const void* key),
+	    int (*cmp)(const void* key1, const void *key2));
+
+/* May fail with HT_NO_MEM and HT_KEY_PRESENT. */
+int ht_add(hashtable_t *ht, const void *key, const void *val);
+
+/*
+ * May fail with HT_NO_MEM. If key was not yet present in hashtable, *oldkey and
+ * *oldval are not modified. Otherwise, just-replaced pair is stored in them.
+ */
+int ht_set(hashtable_t *ht, const void *key, const void *val,
+	   void **oldkey, void **oldval);
+
+/*
+ * If present, the looked for pair is stored in *storedkey and *val. Otherwise,
+ * they're not modified and HT_KEY_ABSENT is returned. storedkey and/or val can
+ * be NULL.
+ */
+int ht_get(hashtable_t *ht, const void *key, void **storedkey, void **val);
+
+/*
+ * Works like ht_get() but is thread-safe with regard to other calls to
+ * ht_get_threadsafe() on the same hashtable. Note that the hash and compare
+ * functions supplied to the hashtable also have to be thread-safe (that
+ * requirement is of course met for those used by ht_string_init()).
+ */
+int ht_get_threadsafe(hashtable_t *ht, const void *key,
+		      void **storedkey, void **val);
+
+/* Works like the above but also removes the pair from ht if found. */
+int ht_rem(hashtable_t *ht, const void *key, void **storedkey, void **val);
+
+/*
+ * De-initializes the hashtable freeing all its structures. The programmer is
+ * responsible for freeing keys and values if they were allocated from the heap
+ * (see ht_map_destroy() below).
+ */
+void ht_destroy(hashtable_t *ht);
+
+/* Calls ht_finish_resizing(), then maps through ht. */
+void ht_map(hashtable_t *ht, void *arg,
+	    void (*mapfunc)(const void *key, void *val, void *arg));
+
+/*
+ * It might be tempting to use ht_map() to free() all keys and values stored in
+ * ht and then call ht_destroy(). If you think about it, ht_map() would leave
+ * hashtable in a broken state - with keys being deallocated. Depending on the
+ * implementation, ht_destroy() could cope with that, but we'd rather not
+ * guarrantee anything, so here's another function just for that - mapping
+ * through entries and destroying the hashtable immediately after, explicitly
+ * allowing the mapping function to deallocate keys.
+ */
+void ht_map_destroy(hashtable_t *ht, void *arg,
+		    void (*mapfunc)(void *key, void *val, void *arg));
+
+/*
+ * If hashtable is in the process of being rehashed, this function
+ * processes it to the end. Otherwise - it does nothing.
+ */
+void ht_finish_resizing(hashtable_t *ht);
+
+/* Included, since strings are commonly used as keys. */
+size_t ht_string_hash(const char *key);
+
+/*
+ * May fail with HT_NO_MEM. Initializes ht for use with string keys
+ * (using ht_string_hash() and strcmp()).
+ */
+int ht_string_init(hashtable_t *ht);
+
+#endif /* HASHTABLE_H */
diff --git a/licenses/agpl-3.0.txt b/licenses/agpl-3.0.txt
new file mode 100644
index 0000000..be3f7b2
--- /dev/null
+++ b/licenses/agpl-3.0.txt
@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.
diff --git a/licenses/alicense.txt b/licenses/alicense.txt
new file mode 100644
index 0000000..2513c24
--- /dev/null
+++ b/licenses/alicense.txt
@@ -0,0 +1,32 @@
+Asshole license 1.0
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. You agree that you're an asshole.
+2. You agree for the copyright owner of this software/work to call you an
+   asshole, both privately and publicly.
+3. You agree and promise not to sue the copyright owner of this
+   software/work nor anyone acting on behalf of the copyright owner of this
+   software/work for calling you an asshole.
+4. You agree and promise not to sue the copyright owner of this
+   software/work, nor anyone acting on behalf of the copyright owner of this
+   software/work, in relation with reverse-engineering actions performed on
+   your software/products.
+5. You agree and promise not issue DMCA claims against any software
+   developed and/or distributed by the copyright owner of this
+   software/work or anyone acting on behalf of the copyright owner of this
+   software/work. Should such claims happen regardless, they will be
+   automatically void.
+
+THIS SOFTWARE/WORK IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS''
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE/WORK, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
diff --git a/licenses/cc-by-4.0.txt b/licenses/cc-by-4.0.txt
new file mode 100644
index 0000000..da6ab6c
--- /dev/null
+++ b/licenses/cc-by-4.0.txt
@@ -0,0 +1,396 @@
+Attribution 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution 4.0 International Public License ("Public License"). To the
+extent this Public License may be interpreted as a contract, You are
+granted the Licensed Rights in consideration of Your acceptance of
+these terms and conditions, and the Licensor grants You such rights in
+consideration of benefits the Licensor receives from making the
+Licensed Material available under these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  i. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  j. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  k. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+
+            b. produce, reproduce, and Share Adapted Material.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.
+
diff --git a/licenses/cc0.txt b/licenses/cc0.txt
new file mode 100644
index 0000000..0e259d4
--- /dev/null
+++ b/licenses/cc0.txt
@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..99769f2
--- /dev/null
+++ b/main.c
@@ -0,0 +1,182 @@
+/**
+ * part of Hydrilla
+ * Program entry point.
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+#define _POSIX_C_SOURCE 200809L /* S_IFMT, S_IFDIR */
+
+#include <dirent.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+
+#include <cjson/cJSON.h>
+
+#include "string_buf.h"
+#include "hashtable.h"
+
+#include "scriptbase.h"
+
+#define PRESERVE_ERRNO(call)						\
+	do {								\
+		int VERY_UNLIKELY_TO_COLLIDE_NAME_$$$$$$$$##__LINE__ = errno; \
+		call;							\
+		errno = VERY_UNLIKELY_TO_COLLIDE_NAME_$$$$$$$$##__LINE__; \
+	} while (0)
+
+static const char default_search_path[] = "/var/lib/hydrilla/content/";
+
+static int process_scriptbase_subdir(struct scriptbase *base,
+				     struct dirent *subdir,
+				     struct stringbuf *path_buf,
+				     struct stringbuf *json_buf)
+{
+	struct stat statbuf;
+	cJSON *index_json;
+	int retval = -1;
+	size_t initial_len = path_buf->buf_filled, len_dirname;
+
+	if (sb_string(path_buf, subdir->d_name))
+		return -1;
+
+	len_dirname = path_buf->buf_filled;
+
+	if (stat(path_buf->buf, &statbuf))
+		return -1;
+
+	if ((statbuf.st_mode & S_IFMT) != S_IFDIR)
+		return 0;
+
+	if (sb_string(path_buf, "/index.json"))
+		return -1;
+
+	printf("Reading %s\n", path_buf->buf);
+
+	stringbuf_truncate(json_buf, 0);
+	if (sb_filepath(json_buf, path_buf->buf))
+		return -1;
+
+	index_json = cJSON_Parse(json_buf->buf);
+	if (!index_json) {
+		fprintf(stderr, "Failed to parse json.\n");
+		return -1;
+	}
+
+	stringbuf_truncate(path_buf, len_dirname);
+
+	retval = catalogue_component(path_buf->buf + initial_len,
+				     index_json, base);
+
+	PRESERVE_ERRNO(cJSON_Delete(index_json));
+
+	return retval;
+}
+
+static int prepare_scriptbase_from_dir(const char *dir_path,
+				       struct scriptbase *base)
+{
+	DIR *maindir;
+	struct dirent *subdir;
+	struct stringbuf path_buf;
+	struct stringbuf json_buf;
+	size_t base_path_len;
+	int retval = -1;
+
+	printf("Searching %s\n", dir_path);
+	stringbuf_init(&path_buf);
+	stringbuf_init(&json_buf);
+
+	maindir = opendir(dir_path);
+	if (!maindir)
+		goto end;
+
+	if (scriptbase_init(base, "https://hydrilla.koszko.org/resources"))
+		goto end;
+
+	if (sb_sprintf(&path_buf, "%s/", dir_path))
+		goto end;
+
+	base_path_len = path_buf.buf_filled;
+
+	while (true) {
+		errno = 0;
+		subdir = readdir(maindir);
+		if (!subdir) {
+			if (!errno)
+				retval = 0;
+			break;
+		}
+
+		if (!strcmp(subdir->d_name, "..") ||
+		    !strcmp(subdir->d_name, "."))
+			continue;
+
+		stringbuf_truncate(&path_buf, base_path_len);
+
+		errno = 0;
+		if (process_scriptbase_subdir(base, subdir,
+					       &path_buf, &json_buf)) {
+			fprintf(stderr, "Error processing subdirectory %s%s",
+				subdir->d_name, errno ? ": " : ".\n");
+			if (errno)
+				perror(NULL);
+		}
+	}
+
+end:
+	if (errno)
+		perror(NULL);
+	stringbuf_destroy(&path_buf);
+	stringbuf_destroy(&json_buf);
+	if (maindir)
+		closedir(maindir);
+	if (retval)
+		scriptbase_destroy(base);
+
+	printf("Search in %s %s.\n", dir_path, retval ? "failed" : "finished");
+
+	return retval;
+}
+
+static void print_component_name(const void *key, void *val, void *arg)
+{
+	char type = (char) (size_t) arg;
+	bool unfilled;
+
+	unfilled =
+		(type == 's' && !((struct script*) val)->filled) ||
+		(type == 'b' && !((struct bag*) val)->filled);
+
+	printf("%s%s\n", (const char*) key,
+	       unfilled ? " (referenced only)" : "");
+}
+
+int serve_scriptbase(struct scriptbase *base);
+
+int main(int argc, char *argv[])
+{
+	struct scriptbase base;
+	const char *search_path = default_search_path;
+
+	if (argc > 1)
+		search_path = argv[1];
+
+	if (prepare_scriptbase_from_dir(search_path, &base))
+		return -1;
+	puts("## LOADED SCRIPTS:");
+	ht_map(&base.scripts, (void*) 's', print_component_name);
+	puts("## LOADED BAGS:");
+	ht_map(&base.bags, (void*) 'b', print_component_name);
+	puts("## LOADED PAGES:");
+	ht_map(&base.pages, (void*) 'p', print_component_name);
+
+	if (serve_scriptbase(&base))
+		fprintf(stderr, "Error serving scriptbase.\n");
+
+	scriptbase_destroy(&base);
+	return 0;
+}
diff --git a/scriptbase.h b/scriptbase.h
new file mode 100644
index 0000000..f7694f7
--- /dev/null
+++ b/scriptbase.h
@@ -0,0 +1,77 @@
+/**
+ * part of Hydrilla
+ * Scriptbase struct and functions operating on it.
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+#ifndef SCRIPTBASE_H
+#define SCRIPTBASE_H
+
+#include <stdbool.h>
+
+#include <cjson/cJSON.h>
+
+#include "hashtable.h"
+
+union component {
+	struct script *script;
+	struct bag *bag;
+	void *any;
+};
+
+struct component_ref {
+	struct component_ref *next;
+	union component component;
+	const char *component_type;
+};
+
+struct script {
+	char *name;
+	char *location;
+	char *sha256;
+	bool filled;
+};
+
+struct bag {
+	char *name;
+	struct component_ref *components, *last_component;
+	bool filled;
+};
+
+struct page {
+	char *pattern;
+	union component payload;
+	const char *payload_type;
+};
+
+struct scriptbase {
+	char *repo_url;
+	hashtable_t scripts;
+	hashtable_t bags;
+	hashtable_t pages;
+};
+
+int catalogue_component(const char *path, cJSON *index_json,
+			struct scriptbase *base);
+
+int scriptbase_init(struct scriptbase *base, const char *repo_url);
+
+void scriptbase_destroy(struct scriptbase *base);
+
+const struct script *get_script(const char *name, struct scriptbase *base);
+const struct bag *get_bag(const char *name, struct scriptbase *base);
+const struct page *get_pattern(const char *pattern, struct scriptbase *base);
+
+char *get_script_json(const char *name, struct scriptbase *base);
+char *get_bag_json(const char *name, struct scriptbase *base);
+char *get_pattern_json(const char *name, struct scriptbase *base);
+char *get_page_query_json(const char *name, struct scriptbase *base);
+
+int init_url_lookup_regex(void);
+void destroy_url_lookup_regex(void);
+int lookup_url(const char *url, struct scriptbase *base,
+	       int (*callback)(struct page*, void*), void *data);
+
+#endif /* SCRIPTBASE_H */
diff --git a/scriptbase_build.c b/scriptbase_build.c
new file mode 100644
index 0000000..2bb9e80
--- /dev/null
+++ b/scriptbase_build.c
@@ -0,0 +1,534 @@
+/**
+ * part of Hydrilla
+ * Routines for building scriptbase from resources and configuratons (stored in
+ * `/var/lib/hydrilla/content/' or another, user-specified location.
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+#define _POSIX_C_SOURCE 200809L /* strdup() */
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "hashtable.h"
+#include "string_buf.h"
+
+#include "scriptbase.h"
+
+static const char scriptstr[] = "script", bagstr[] = "bag", pagestr[] = "page";
+
+
+static void *add_or_get(const char *component_name, char component_type,
+			struct scriptbase *base);
+
+static struct script *script_create(const char *name)
+{
+	struct script *script;
+
+	script = malloc(sizeof(struct script));
+	if (!script)
+		return NULL;
+
+	script->name = strdup(name);
+
+	if (!script->name)
+		goto free_script;
+
+	script->location = NULL;
+	script->sha256 = NULL;
+	script->filled = false;
+
+	return script;
+
+free_script:
+	free(script);
+
+	return NULL;
+}
+
+static int script_fill(struct script *script, const char *dir,
+		       const char *filename, const char *sha256)
+{
+	char *location = NULL;
+	size_t location_len = 0, location_filled = 0;
+
+	if (sb_raw_sprintf(&location, &location_len, &location_filled,
+			   "%s/%s", dir, filename))
+		goto free_location;
+	script->location = location;
+
+	script->sha256 = strdup(sha256);
+	if (!script->sha256)
+		goto free_location;
+
+	script->filled = true;
+
+	return 0;
+
+free_location:
+	free(location);
+	script->location = NULL;
+
+	return -1;
+}
+
+static void script_free(struct script *script)
+{
+	if (!script)
+		return;
+
+	free(script->name);
+	free(script->location);
+	free(script->sha256);
+	free(script);
+}
+
+static struct bag *bag_create(const char *name)
+{
+	struct bag *bag;
+
+	bag = malloc(sizeof(struct bag));
+	if (!bag)
+		return NULL;
+
+	bag->name = strdup(name);
+
+	if (!bag->name)
+		goto free_bag;
+
+	bag->components = NULL;
+	bag->last_component = NULL;
+	bag->filled = false;
+
+	return bag;
+
+free_bag:
+	free(bag);
+
+	return NULL;
+}
+
+static int bag_add(struct bag *bag, const char *component_name,
+		   const char *component_type, struct scriptbase *base)
+{
+	struct component_ref *new_ref;
+
+	new_ref = malloc(sizeof(struct component_ref));
+	if (!new_ref)
+		return -1;
+
+	new_ref->component.any =
+		add_or_get(component_name, *component_type, base);
+
+	if (!new_ref->component.any)
+		goto free_ref;
+
+	new_ref->component_type = component_type;
+	new_ref->next = NULL;
+
+	*(bag->components ? &bag->last_component->next : &bag->components) =
+		new_ref;
+	bag->last_component = new_ref;
+	bag->filled = true;
+
+	return 0;
+
+free_ref:
+	free(new_ref);
+
+	return -1;
+}
+
+static void bag_free(struct bag *bag)
+{
+	struct component_ref *tmp1, *tmp2;
+
+	if (!bag)
+		return;
+
+	tmp1 = bag->components;
+
+	while (tmp1) {
+		tmp2 = tmp1->next;
+		free(tmp1);
+		tmp1 = tmp2;
+	}
+
+	free(bag->name);
+	free(bag);
+}
+
+static struct page *page_create(const char *pattern, const char *payload_name,
+				const char *payload_type,
+				struct scriptbase *base)
+{
+	struct page *page;
+
+	page = malloc(sizeof(struct page));
+	if (!page)
+		return NULL;
+
+	page->pattern = strdup(pattern);
+	if (!page->pattern)
+		goto free_page;
+
+	if (payload_name) {
+		page->payload.any =
+			add_or_get(payload_name, *payload_type, base);
+		if (!page->payload.any)
+			goto free_pattern;
+	} else {
+		page->payload.any = NULL;
+	}
+
+	page->payload_type = payload_type;
+
+	return page;
+
+free_pattern:
+	free(page->pattern);
+
+free_page:
+	free(page);
+
+	return NULL;
+}
+
+static void page_free(struct page *page)
+{
+	if (!page)
+		return;
+
+	free(page->pattern);
+	free(page);
+}
+
+static void *add_or_get(const char *component_name, char component_type,
+			struct scriptbase *base)
+{
+	void *component;
+	hashtable_t *relevant_ht;
+	bool found = true;
+
+	relevant_ht = component_type == *bagstr ? &base->bags : &base->scripts;
+	if (ht_get(relevant_ht, component_name, NULL, &component)) {
+		if (component_type == *bagstr)
+			component = bag_create(component_name);
+		else
+			component = script_create(component_name);
+
+		found = false;
+	}
+
+	if (!component)
+		return NULL;
+
+	/* Name is at the same position in both struct bag and struct script. */
+	if (!found) {
+		switch (ht_add(relevant_ht, ((struct bag*) component)->name,
+			       component)) {
+		case HT_NO_MEM:
+			errno = ENOMEM;
+		case HT_KEY_PRESENT:
+			goto free_component;
+		}
+	}
+
+	return component;
+
+free_component:
+	if (component_type == *bagstr)
+		bag_free(component);
+	else
+		script_free(component);
+
+	return NULL;
+}
+
+int scriptbase_init(struct scriptbase *base, const char *repo_url)
+{
+	base->repo_url = strdup(repo_url);
+	if (!base->repo_url)
+		goto end;
+
+	if (ht_string_init(&base->scripts))
+		goto free_url;
+
+	if (ht_string_init(&base->bags))
+		goto free_scripts;
+
+	if (ht_string_init(&base->pages))
+		goto free_bags;
+
+	return 0;
+
+free_bags:
+	ht_destroy(&base->bags);
+
+free_scripts:
+	ht_destroy(&base->scripts);
+
+free_url:
+	free(base->repo_url);
+
+end:
+	errno = ENOMEM;
+	return -1;
+}
+
+static void destroy_cb(void *key, void *val, void *arg)
+{
+	char type = *((const char*) arg);
+
+	if (type == 's')
+		script_free(val);
+	else if (type == 'b')
+		bag_free(val);
+	else
+		page_free(val);
+}
+
+void scriptbase_destroy(struct scriptbase *base)
+{
+	char keys[] = {'s', 'b', 'p'};
+
+	ht_map_destroy(&base->scripts, keys, destroy_cb);
+	ht_map_destroy(&base->bags, keys + 1, destroy_cb);
+	ht_map_destroy(&base->pages, keys + 2, destroy_cb);
+
+	free(base->repo_url);
+}
+
+static int add_component_to_base(const char *name, const void *component,
+				 const char *type, struct scriptbase *base)
+{
+	hashtable_t *ht = *type == 's' ? &base->scripts :
+		*type == 'b' ? &base->bags : &base->pages;
+	bool name_collision = false;
+	void *old_val = NULL;
+
+	if (ht_set(ht, name, component, NULL, &old_val)) {
+		errno = ENOMEM;
+		return -1;
+	}
+
+	if (old_val) {
+		if (*type == 's') {
+			name_collision = ((struct script*) old_val)->filled;
+			script_free(old_val);
+		} else if (*type == 'b') {
+			name_collision = ((struct bag*) old_val)->filled;
+			bag_free(old_val);
+		} else {
+			name_collision = true;
+			page_free(old_val);
+		}
+	}
+
+	if (name_collision) {
+		fprintf(stderr, "Multiple occurences of %s %s.\n", type, name);
+		errno = 0;
+		return -1;
+	}
+
+	return 0;
+}
+
+static int catalogue_script(const char *path, cJSON *index_json,
+			    struct scriptbase *base)
+{
+	const cJSON *name, *sha256, *location;
+	const char *bad = NULL;
+	struct script *script;
+
+	name = cJSON_GetObjectItemCaseSensitive(index_json, "name");
+	sha256 = cJSON_GetObjectItemCaseSensitive(index_json, "sha256");
+	location = cJSON_GetObjectItemCaseSensitive(index_json, "location");
+
+	if (!cJSON_IsString(name) || name->valuestring == NULL)
+		bad = "name";
+	else if (!cJSON_IsString(sha256) || sha256->valuestring == NULL)
+		bad = "sha256";
+	else if (!cJSON_IsString(location) || location->valuestring == NULL)
+		bad = "location";
+
+	if (bad) {
+		fprintf(stderr, "Missing or invalid field \"%s\".\n", bad);
+		errno = 0;
+		return -1;
+	}
+
+	script = script_create(name->valuestring);
+	if (!script)
+		return -1;
+
+	if (script_fill(script, path, location->valuestring,
+			sha256->valuestring))
+		goto free_script;
+
+	return add_component_to_base(script->name, script, scriptstr, base);
+
+free_script:
+	script_free(script);
+	return -1;
+}
+
+static int component_ref_from_json(const cJSON *component_cJSON,
+				   const char **component_type,
+				   const char **component_name)
+{
+	const cJSON *component_type_cJSON, *component_name_cJSON;
+
+	if (!cJSON_IsArray(component_cJSON))
+		return -1;
+
+	component_type_cJSON = component_cJSON->child;
+	if (!component_type_cJSON)
+		return -1;
+	component_name_cJSON = component_type_cJSON->next;
+	if (!component_name_cJSON || component_name_cJSON->next)
+		return -1;
+
+	if (!cJSON_IsString(component_type_cJSON) ||
+	    !cJSON_IsString(component_name_cJSON))
+	  return -1;
+
+	if (!strcmp(scriptstr, component_type_cJSON->valuestring))
+		*component_type = scriptstr;
+	else if (!strcmp(bagstr, component_type_cJSON->valuestring))
+		*component_type = bagstr;
+	else
+		return -1;
+
+	*component_name = component_name_cJSON->valuestring;
+
+	return 0;
+}
+
+static int catalogue_bag(const char *path, cJSON *index_json,
+			 struct scriptbase *base)
+{
+	const cJSON *name, *components, *component;
+	const char *component_type, *component_name;
+	struct bag *bag;
+
+	name = cJSON_GetObjectItemCaseSensitive(index_json, "name");
+
+	if (!cJSON_IsString(name) || name->valuestring == NULL) {
+		fprintf(stderr, "Missing or invalid field \"name\".\n");
+		errno = 0;
+		return -1;
+	}
+
+	bag = bag_create(name->valuestring);
+	if (!bag)
+		return -1;
+
+	bag->filled = true;
+
+	components = cJSON_GetObjectItemCaseSensitive(index_json, "components");
+	if (!components)
+		return 0;
+	if (!cJSON_IsArray(components))
+		goto invalid_components;
+
+	cJSON_ArrayForEach(component, components) {
+		if (component_ref_from_json(component,
+					    &component_type, &component_name))
+			goto invalid_components;
+
+		/*
+		 * component_type now points to a static buffer and
+		 * component_name to cJSON-owned memory
+		 */
+
+		if (bag_add(bag, component_name, component_type, base))
+			goto free_bag;
+	}
+
+	if (add_component_to_base(bag->name, bag, bagstr, base))
+		goto free_bag;
+
+	return 0;
+
+invalid_components:
+	fprintf(stderr, "Invalid field \"components\"");
+	errno = 0;
+
+free_bag:
+	bag_free(bag);
+	return -1;
+}
+
+static int catalogue_page(const char *path, cJSON *index_json,
+			  struct scriptbase *base)
+{
+	const cJSON *pattern, *payload;
+	const char *payload_type = "", *payload_name = NULL;
+	struct page *page;
+
+	pattern = cJSON_GetObjectItemCaseSensitive(index_json, "pattern");
+	payload = cJSON_GetObjectItemCaseSensitive(index_json, "payload");
+
+	if (!cJSON_IsString(pattern) || pattern->valuestring == NULL) {
+		fprintf(stderr, "Missing or invalid field \"pattern\".\n");
+		errno = 0;
+		return -1;
+	}
+
+	if (!payload)
+		goto skip_payload;
+
+	if (component_ref_from_json(payload, &payload_type, &payload_name))
+		goto invalid_payload;
+
+skip_payload:
+	page = page_create(pattern->valuestring, payload_name, payload_type,
+			   base);
+	if (!page)
+		goto free_page;
+
+	if (add_component_to_base(page->pattern, page, pagestr, base))
+		goto free_page;
+
+	return 0;
+
+invalid_payload:
+	fprintf(stderr, "Invalid field \"payload\"");
+	errno = 0;
+
+free_page:
+	page_free(page);
+	return -1;
+}
+
+int catalogue_component(const char *path, cJSON *index_json,
+			struct scriptbase *base)
+{
+	const cJSON *type;
+
+	type = cJSON_GetObjectItemCaseSensitive(index_json, "type");
+	if (!cJSON_IsString(type) || type->valuestring == NULL)
+		goto bad_type;
+
+	if (!strcmp(type->valuestring, scriptstr))
+		return catalogue_script(path, index_json, base);
+	else if (!strcmp(type->valuestring, bagstr))
+		return catalogue_bag(path, index_json, base);
+	else if (!strcmp(type->valuestring, pagestr))
+		return catalogue_page(path, index_json, base);
+	else
+		goto bad_type;
+
+	return 0;
+
+bad_type:
+	fprintf(stderr, "Missing or invalid type.");
+
+	errno = 0;
+	return -1;
+}
diff --git a/scriptbase_json_query.c b/scriptbase_json_query.c
new file mode 100644
index 0000000..e413b3e
--- /dev/null
+++ b/scriptbase_json_query.c
@@ -0,0 +1,213 @@
+/**
+ * part of Hydrilla
+ * Routines that perform queries on in-memory scriptbase and return results in
+ * the form of JSON strings.
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+#include <errno.h>
+
+#include "scriptbase.h"
+
+#define ADD_COMPONENT(object, key, construct, adder)	\
+	new = cJSON_Create##construct;			\
+	if (!new)					\
+		goto free_json;				\
+	adder(object, key, new)
+
+#define ADD_TO_OBJECT(object, key, construct)				\
+	ADD_COMPONENT(object, key, construct, cJSON_AddItemToObject)
+
+#define ADD_KEY(key, construct) ADD_TO_OBJECT(json, key, construct)
+
+#define ARRAY_ADDER(object, key, var) cJSON_AddItemToArray(object, var)
+
+#define ADD_TO_ARRAY(object, construct)				\
+	ADD_COMPONENT(object, dummy, construct, ARRAY_ADDER)
+
+char *get_script_json(const char *name, struct scriptbase *base)
+{
+	const struct script *script;
+	cJSON *json, *new;
+	char *printed = NULL;
+
+	script = get_script(name, base);
+	if (!script || !script->filled)
+		return NULL;
+
+	json = cJSON_CreateObject();
+	if (!json)
+		goto free_json;
+
+	ADD_KEY("name", String(script->name));
+	ADD_KEY("location", String(script->location));
+	ADD_KEY("sha256", String(script->sha256));
+
+	printed = cJSON_Print(json);
+
+free_json:
+	cJSON_Delete(json);
+
+	if (!printed)
+		errno = ENOMEM;
+
+	return printed;
+}
+
+char *get_bag_json(const char *name, struct scriptbase *base)
+{
+	const struct bag *bag;
+	cJSON *json, *new, *components, *current_component;
+	struct component_ref *ref;
+	char type_prefix[] = "\0";
+	char *printed = NULL;
+
+	bag = get_bag(name, base);
+	if (!bag || !bag->filled)
+		return NULL;
+
+	json = cJSON_CreateObject();
+	if (!json)
+		goto free_json;
+
+	ADD_KEY("name", String(bag->name));
+	ADD_KEY("components", Array());
+	components = new;
+
+	for (ref = bag->components; ref; ref = ref->next) {
+		ADD_TO_ARRAY(components, Array());
+		current_component = new;
+		type_prefix[0] = ref->component_type[0];
+		ADD_TO_ARRAY(current_component, String(type_prefix));
+		/* name is at the same offset in struct bag and struct script */
+		ADD_TO_ARRAY(current_component,
+			     String(ref->component.bag->name));
+	}
+
+	printed = cJSON_Print(json);
+
+free_json:
+	cJSON_Delete(json);
+
+	if (!printed)
+		errno = ENOMEM;
+
+	return printed;
+}
+
+cJSON *page_to_cJSON(const struct page *page)
+{
+	cJSON *json, *new, *payload;
+	char type_prefix[] = "\0";
+
+	json = cJSON_CreateObject();
+	if (!json)
+		goto free_json;
+
+	ADD_KEY("pattern", String(page->pattern));
+	if (!page->payload.any)
+		goto skip_payload;
+	ADD_KEY("payload", Array());
+	payload = new;
+	type_prefix[0] = page->payload_type[0];
+	ADD_TO_ARRAY(payload, String(type_prefix));
+	/* name is at the same offset in struct bag and struct script */
+	ADD_TO_ARRAY(payload, String(page->payload.bag->name));
+
+skip_payload:
+	return json;
+
+free_json:
+	cJSON_Delete(json);
+
+	errno = ENOMEM;
+
+	return NULL;
+}
+
+char *get_pattern_json(const char *pattern, struct scriptbase *base)
+{
+	const struct page *page;
+	cJSON *json;
+	char *printed = NULL;
+
+	page = get_pattern(pattern, base);
+	if (!page)
+		return NULL;
+
+	json = page_to_cJSON(page);
+	if (!json)
+		return NULL;
+
+	printed = cJSON_Print(json);
+	cJSON_Delete(json);
+
+	if (!printed)
+		errno = ENOMEM;
+
+	return printed;
+}
+
+struct page_array_building {
+	cJSON *page_array;
+	bool OOM_error;
+};
+
+int lookup_callback(struct page *page, void *data)
+{
+	struct page_array_building *building = data;
+	cJSON *page_json;
+
+	page_json = page_to_cJSON(page);
+	if (!page_json) {
+		building->OOM_error = true;
+		return -1;
+	}
+
+	cJSON_AddItemToArray(building->page_array, page_json);
+
+	return 0;
+}
+
+#include <stdio.h>
+char *get_page_query_json(const char *url, struct scriptbase *base)
+{
+	struct page_array_building building = {NULL, false};
+	char *printed = NULL;
+	int result = -2;
+
+	building.page_array = cJSON_CreateArray();
+	if (!building.page_array)
+		goto free_json;
+
+	result = lookup_url(url, base, lookup_callback, &building);
+
+	printf("lookup returned value is %d\n", result);
+
+	if (building.OOM_error)
+		result = -2;
+	if (result < 0)
+		goto free_json;
+
+	printed = cJSON_Print(building.page_array);
+	if (!printed)
+		result = -2;
+
+free_json:
+	cJSON_Delete(building.page_array);
+
+	switch (result) {
+	case 0:
+		break;
+	case -1:
+	case -3:
+		errno = EINVAL;
+		break;
+	case -2:
+		errno = ENOMEM;
+	}
+
+	return printed;
+}
diff --git a/scriptbase_query.c b/scriptbase_query.c
new file mode 100644
index 0000000..fe9a910
--- /dev/null
+++ b/scriptbase_query.c
@@ -0,0 +1,278 @@
+/**
+ * part of Hydrilla
+ * Routines for querying in-memory scriptbase, operating on data structures from
+ * `scripbase.h'.
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+#include <stddef.h>
+#include <regex.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "hashtable.h"
+#include "string_buf.h"
+
+#include "scriptbase.h"
+
+const struct script *get_script(const char *name, struct scriptbase *base)
+{
+	void *val;
+
+	if (ht_get_threadsafe(&base->scripts, name, NULL, &val))
+		return NULL;
+
+	return ((struct script*) val)->filled ? val : NULL;
+}
+
+const struct bag *get_bag(const char *name, struct scriptbase *base)
+{
+	void *val;
+
+	if (ht_get_threadsafe(&base->bags, name, NULL, &val))
+		return NULL;
+
+	return ((struct bag*) val)->filled ? val : NULL;
+}
+
+const struct page *get_pattern(const char *pattern, struct scriptbase *base)
+{
+	void *val = NULL;
+
+	ht_get_threadsafe(&base->pages, pattern, NULL, &val);
+
+	return val;
+}
+
+static const char url_regex[] =
+	"^"
+	"([a-zA-Z]{1,20}://)" /* protocol */
+	"([^/?#]{1,253})"     /* domain */
+	"(/[^?#]*)?"          /* path */
+	"\\\\?[^#]*"          /* query */
+	"#?.*"                /* target */
+	"$";
+
+static regex_t url_regex_comp;
+static bool url_regex_ready;
+
+int init_url_lookup_regex(void)
+{
+	int retval;
+
+	retval = regcomp(&url_regex_comp, url_regex, REG_EXTENDED);
+
+	url_regex_ready = !retval;
+
+	return retval;
+}
+
+void destroy_url_lookup_regex(void)
+{
+	if (!url_regex_ready) {
+		fprintf(stderr, "Attempt to destroy uninitialized regex in " __FILE__ "\n");
+		return;
+	}
+
+	regfree(&url_regex_comp);
+}
+
+#define URL_REGEX_NMATCH 4
+
+#define PROTOCOL_MATCH 1
+#define DOMAIN_MATCH 2
+#define PATH_MATCH 3
+
+static int lookup_url_path(const char *path_begin, const char *path_end,
+			   struct stringbuf *buf, struct scriptbase *base,
+			   int (*callback)(struct page*, void*), void *data)
+{
+	const char *segment_end = path_begin;
+	int segments_dropped = 0;
+	int initial_len = buf->buf_filled;
+	size_t len_path, previous_segment;
+	void *val;
+	bool trailing_dash = path_end != path_begin && path_end[-1] == '/';
+	char asterisks[] = "/***";
+	int trailing_asterisks = 0, i;
+	int result;
+
+	while (true) {
+		do {
+			if (path_begin >= path_end)
+				goto after_path_normalization;
+		} while (*(path_begin++) == '/');
+		path_begin -= 2;
+
+		segment_end = path_begin + 1;
+		while (*segment_end != '/' && ++segment_end < path_end);
+
+		if (sb_bytes(buf, path_begin, segment_end - path_begin))
+			return -2;
+
+		path_begin = segment_end;
+	}
+
+after_path_normalization:
+#define TRY_WILDCARD(condition, wildcard)				\
+	if (condition) {						\
+		stringbuf_truncate(buf, len_path);			\
+		if (sb_string(buf, wildcard))				\
+			return -2;					\
+									\
+		result = ht_get_threadsafe(&base->pages, buf->buf,	\
+					   NULL, &val);			\
+		if (!result && callback(val, data))			\
+			return 1;					\
+	}
+
+	while (true) {
+		len_path = buf->buf_filled;
+		previous_segment = len_path;
+		while (previous_segment > initial_len &&
+		       buf->buf[--previous_segment] != '/');
+
+		if (!trailing_asterisks) {/* only on first iteration */
+			trailing_asterisks = -1;
+
+			for (i = 3; i > 0; i--) {
+				asterisks[i + 1] = '\0';
+
+				if (strncmp(buf->buf + previous_segment,
+					    asterisks, i + 1))
+					continue;
+
+				trailing_asterisks = i;
+
+				if (i != 3)
+					break;
+
+				if (buf->buf[previous_segment + i + 1] == '*')
+					trailing_asterisks = -1;
+
+				break;
+			}
+		}
+
+		TRY_WILDCARD(segments_dropped == 0, "");
+		TRY_WILDCARD(segments_dropped == 0 && trailing_dash, "/");
+		TRY_WILDCARD(segments_dropped == 1 && trailing_asterisks != 1,
+			     "/*");
+		TRY_WILDCARD(segments_dropped > 1, "/**");
+		TRY_WILDCARD(segments_dropped > 0 &&
+			     (segments_dropped > 1 || trailing_asterisks != 3),
+			     "/***");
+
+		stringbuf_truncate(buf, previous_segment);
+
+		if (previous_segment == len_path)
+			return 0;
+
+		/*
+		 * We only ever care if this count is 0, 1 or > 1,
+		 * hence size_t is not necessary.
+		 */
+		if (segments_dropped < 2)
+			segments_dropped++;
+	}
+
+#undef TRY_WILDCARD
+}
+
+static int lookup_url_domain(const char *domain_begin, const char *domain_end,
+			     const char *path_begin, const char *path_end,
+			     struct stringbuf *buf, struct scriptbase *base,
+			     int (*callback)(struct page*, void*), void *data)
+{
+	const char *next_label = domain_begin;
+	int labels_dropped = 0;
+	int initial_len = buf->buf_filled;
+	int result;
+
+#define TRY_WILDCARD(condition, wildcard)				\
+	if (condition) {						\
+		stringbuf_truncate(buf, initial_len);			\
+		if (sb_string(buf, wildcard) ||				\
+		    sb_bytes(buf, domain_begin, domain_end - domain_begin)) \
+			return -2;					\
+									\
+		result = lookup_url_path(path_begin, path_end,		\
+					 buf, base, callback, data);	\
+		if (result)						\
+			return result;					\
+	}
+
+	while (true) {
+		domain_begin = next_label;
+
+		while (*(next_label++) != '.') {
+			if (next_label >= domain_end)
+				return 0;
+		}
+
+		TRY_WILDCARD(labels_dropped == 0, "");
+		TRY_WILDCARD(labels_dropped == 1, "*.");
+		TRY_WILDCARD(labels_dropped > 0, "**.");
+		TRY_WILDCARD(true, "***.");
+
+		labels_dropped++;
+	}
+
+#undef TRY_WILDCARD
+}
+
+static int lookup_url_proto(const char *proto_begin, const char *proto_end,
+			    const char *domain_begin, const char *domain_end,
+			    const char *path_begin, const char *path_end,
+			    struct stringbuf *buf, struct scriptbase *base,
+			    int (*callback)(struct page*, void*), void *data)
+{
+	if (sb_bytes(buf, proto_begin, proto_end - proto_begin))
+		return -2;
+
+	return lookup_url_domain(domain_begin, domain_end, path_begin, path_end,
+				 buf, base, callback, data);
+}
+
+int lookup_url(const char *url, struct scriptbase *base,
+	       int (*callback)(struct page*, void*), void *data)
+{
+	regmatch_t reg_matched[URL_REGEX_NMATCH];
+	struct stringbuf buf;
+	const char *path_begin, *path_end;
+	int retval;
+
+	if (!url_regex_ready) {
+		fprintf(stderr, "Regex not initialized in " __FILE__ "\n");
+		return -3;
+	}
+
+	printf("matching: %s\n", url);
+
+	if (regexec(&url_regex_comp, url,
+		    URL_REGEX_NMATCH, reg_matched, 0) ||
+	    reg_matched[DOMAIN_MATCH].rm_so == -1)
+		return -1;
+
+	stringbuf_init(&buf);
+
+	path_begin = url + reg_matched[PATH_MATCH].rm_so;
+	path_end = url + reg_matched[PATH_MATCH].rm_eo;
+	if (path_begin == url - 1) {
+		path_begin = NULL;
+		path_end = NULL;
+	}
+
+	retval = lookup_url_proto(url + reg_matched[PROTOCOL_MATCH].rm_so,
+				  url + reg_matched[PROTOCOL_MATCH].rm_eo,
+				  url + reg_matched[DOMAIN_MATCH].rm_so,
+				  url + reg_matched[DOMAIN_MATCH].rm_eo,
+				  path_begin, path_end,
+				  &buf, base, callback, data);
+
+	stringbuf_destroy(&buf);
+
+	return retval;
+}
diff --git a/serve.c b/serve.c
new file mode 100644
index 0000000..dd61da1
--- /dev/null
+++ b/serve.c
@@ -0,0 +1,203 @@
+/**
+ * part of Hydrilla
+ * Serving data queries over HTTP using libmicrohttpd.
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ *
+ * This file is based on Christian Grothoff's public comain code from
+ * `doc/examples/logging.c' in libmicrohttpd source tree.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <sys/types.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+
+#include <microhttpd.h>
+
+#include "scriptbase.h"
+
+#define PORT 10111
+
+#define ARRLEN(array) (sizeof(array) / sizeof(*array))
+
+static struct MHD_Response *default_response, *error_response,
+	*not_found_response;
+
+static struct {
+	struct MHD_Response **response;
+	const char *const text;
+} static_responses[] = {
+	{&default_response,   "<html><body>Nothing to see here</body></html>"},
+	{&error_response,     "<html><body>Error occured</body></html>"},
+	{&not_found_response, "<html><body>Not found</body></html>"}
+};
+
+static int add_CORS_header(struct MHD_Response *response)
+{
+	return -1 * (MHD_add_response_header(response,
+					     "Access-Control-Allow-Origin",
+					     "*") == MHD_NO);
+}
+
+typedef char *(*request_handler_t)(const char *queried,
+				   struct scriptbase *base);
+
+static struct {
+	const char *path;
+	request_handler_t request_handler;
+} resources[] = {
+		 {"/script",  get_script_json},
+		 {"/bag",     get_bag_json},
+		 {"/pattern", get_pattern_json},
+		 {"/query",   get_page_query_json}
+};
+
+struct request_handling {
+	struct scriptbase *base;
+	request_handler_t handler;
+	char *json_response;
+	int error_number;
+};
+
+static int handle_query_argument(void *cls, enum MHD_ValueKind kind,
+				 const char *key, const char *value)
+{
+	struct request_handling *handling = cls;
+
+	if (strcmp(key, "n")) {
+		fprintf(stderr, "Unknown argument: \"%s\" = \"%s\"\n",
+			key, value);
+		return MHD_YES;
+	}
+
+	errno = 0;
+
+	handling->json_response = handling->handler(value, handling->base);
+
+	handling->error_number = errno;
+
+	return MHD_NO;
+}
+
+static int answer_with(struct MHD_Connection *connection,
+		       request_handler_t handler, struct scriptbase *base)
+{
+	struct request_handling handling = {base, handler, NULL, EINVAL};
+	struct MHD_Response *response;
+	int retval;
+
+	MHD_get_connection_values(connection, MHD_GET_ARGUMENT_KIND,
+				  handle_query_argument, &handling);
+
+	if (!handling.json_response) {
+		if (handling.error_number)
+			goto send_error;
+		goto send_not_found;
+	}
+
+	response = MHD_create_response_from_buffer
+		(strlen(handling.json_response), handling.json_response,
+		 MHD_RESPMEM_MUST_FREE);
+	if (!response || add_CORS_header(response))
+		goto send_error;
+
+	retval = MHD_queue_response(connection, MHD_HTTP_OK, response);
+	MHD_destroy_response(response);
+
+	return retval;
+
+send_not_found:
+	return MHD_queue_response(connection, MHD_HTTP_NOT_FOUND,
+				  not_found_response);
+
+send_error:
+	free(handling.json_response);
+	return MHD_queue_response(connection, MHD_HTTP_INTERNAL_SERVER_ERROR,
+				  error_response);
+}
+
+static int answer(void *data,
+		  struct MHD_Connection *connection,
+		  const char *url,
+		  const char *method,
+		  const char *version,
+		  const char *upload_data,
+		  size_t *upload_data_size,
+		  void **ptr)
+{
+	static int aptr;
+	int i;
+	struct scriptbase *base = data;
+
+	printf("New %s request for %s using version %s\n", method, url, version);
+
+	if (strcmp(method, "GET"))
+		return MHD_NO;
+
+	if (&aptr != *ptr) {
+		/* do never respond on first call */
+		*ptr = &aptr;
+		return MHD_YES;
+	}
+	*ptr = NULL; /* reset when done */
+
+	for (i = 0; i < ARRLEN(resources); i++) {
+		if (strcmp(resources[i].path, url))
+			continue;
+
+		return answer_with(connection, resources[i].request_handler,
+				   base);
+	}
+
+	return MHD_queue_response(connection, MHD_HTTP_OK, default_response);
+}
+
+int getchar(void);
+
+int serve_scriptbase(struct scriptbase *base)
+{
+	int i;
+	struct MHD_Daemon *daemon;
+	int retval = -1;
+
+	if (init_url_lookup_regex())
+	  return -1;
+
+	for (i = 0; i < ARRLEN(static_responses); i++) {
+		*static_responses[i].response = MHD_create_response_from_buffer
+			(strlen(static_responses[i].text),
+			 (char*) static_responses[i].text,
+			 MHD_RESPMEM_PERSISTENT);
+
+		if (!*static_responses[i].response ||
+		    add_CORS_header(*static_responses[i].response))
+			goto free_resources;
+	}
+
+	daemon = MHD_start_daemon(MHD_USE_INTERNAL_POLLING_THREAD, PORT, NULL,
+				  NULL, &answer, (void*) base, MHD_OPTION_END);
+	if (!daemon)
+		goto free_resources;
+
+	getchar();
+	MHD_stop_daemon(daemon);
+
+	retval = 0;
+
+free_resources:
+	for (i = 0; i < ARRLEN(static_responses); i++) {
+		if (*static_responses[i].response)
+			MHD_destroy_response(*static_responses[i].response);
+		*static_responses[i].response = NULL;
+	}
+
+	destroy_url_lookup_regex();
+
+	return retval;
+}
diff --git a/string_buf.c b/string_buf.c
new file mode 100644
index 0000000..332d023
--- /dev/null
+++ b/string_buf.c
@@ -0,0 +1,308 @@
+/**
+ * C string buffers for easy construction of complex strings
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include <unistd.h>
+
+#define STRING_BUF_C
+#include "string_buf.h"
+
+#define MINIMUM_EXTEND_BYTES 63
+
+void stringbuf_init(struct stringbuf *sb)
+{
+	sb->buf = NULL;
+	sb->buf_len = 0;
+	sb->buf_filled = 0;
+}
+
+void stringbuf_destroy(struct stringbuf *sb)
+{
+	free(sb->buf);
+}
+
+void stringbuf_truncate(struct stringbuf *sb, size_t len)
+{
+	if (sb->buf_len <= len)
+		return;
+
+	sb->buf_filled = len;
+	sb->buf[len] = '\0';
+}
+
+#define _UNPACKED_ARGS &sb->buf, &sb->buf_len, &sb->buf_filled
+
+int extend_buf(struct stringbuf *sb, size_t extend_len)
+{
+	return extend_buf_raw(_UNPACKED_ARGS, extend_len);
+}
+
+int extend_buf_raw(_RAW_BUF_ARGS, size_t extend_len)
+{
+	ssize_t space_left = *buf_len - *buf_filled - 1;
+	size_t new_size, size_required, size_more_space;
+	char *new_buf;
+
+	if (space_left >= 0 && space_left >= extend_len)
+		return 0;
+
+	size_required = *buf_filled + extend_len + 1;
+	size_more_space = size_required + MINIMUM_EXTEND_BYTES;
+	new_size = *buf_len * 2;
+	if (new_size < size_more_space)
+		new_size = size_more_space;
+
+	new_buf = realloc(*buf, new_size);
+	if (!new_buf) {
+		new_size = size_required;
+		new_buf = realloc(*buf, new_size);
+	}
+	if (!new_buf)
+		return -1;
+
+	*buf = new_buf;
+	*buf_len = new_size;
+	return 0;
+}
+
+_SB_HEAD(bytes, const void *bytes, size_t bytes_len)
+{
+	return sb_raw_bytes(_UNPACKED_ARGS, bytes, bytes_len);
+}
+
+_SB_RAW_HEAD(bytes, const void *bytes, size_t bytes_len)
+{
+	if (extend_buf_raw(buf, buf_len, buf_filled, bytes_len))
+		return -1;
+
+	memcpy(*buf + *buf_filled, bytes, bytes_len);
+	(*buf)[*buf_filled + bytes_len] = '\0';
+	*buf_filled += bytes_len;
+
+	return 0;
+}
+
+_SB_HEAD(string, const char *string)
+{
+	return sb_raw_string(_UNPACKED_ARGS, string);
+}
+
+_SB_RAW_HEAD(string, const char *string)
+{
+	size_t string_len = strlen(string);
+
+	return sb_raw_bytes(buf, buf_len, buf_filled, string, string_len);
+}
+
+_SB_HEAD(char, char c)
+{
+	return sb_raw_char(_UNPACKED_ARGS, c);
+}
+
+_SB_RAW_HEAD(char, char c)
+{
+	return sb_raw_bytes(buf, buf_len, buf_filled, &c, 1);
+}
+
+_SB_HEAD(long, long num)
+{
+	return sb_raw_long(_UNPACKED_ARGS, num);
+}
+
+_SB_RAW_HEAD(long, long num)
+{
+	unsigned char repr[3 * sizeof(long) + 1];
+	int i;
+	bool neg = num < 0;
+
+	for (i = sizeof(repr); num; num /= 10)
+		repr[--i] = '0' + num % 10;
+
+	if (i == sizeof(repr))
+		repr[--i] = '0';
+	else if (neg)
+		repr[--i] = '-';
+
+	sb_raw_bytes(buf, buf_len, buf_filled,
+		     repr + i, sizeof(repr) - i);
+
+	return 0;
+}
+
+_SB_HEAD(file, FILE *file)
+{
+	return sb_raw_file(_UNPACKED_ARGS, file);
+}
+
+_SB_RAW_HEAD(file, FILE *file)
+{
+	long file_size;
+
+	if (fseek(file, 0, SEEK_END))
+		return -1;
+
+	file_size = ftell(file);
+	if (file_size < 0)
+		return -1;
+
+	if (extend_buf_raw(buf, buf_len, buf_filled, file_size))
+		return -1;
+
+	rewind(file);
+
+	if (fread(*buf + *buf_filled, file_size, 1, file) != 1)
+		return -1;
+
+	(*buf)[*buf_filled + file_size] = '\0';
+	*buf_filled += file_size;
+
+	return 0;
+}
+
+_SB_HEAD(filepath, const char *path)
+{
+	return sb_raw_filepath(_UNPACKED_ARGS, path);
+}
+
+_SB_RAW_HEAD(filepath, const char *path)
+{
+	FILE *file;
+	int retval;
+
+	file = fopen(path, "r");
+	if (!file)
+		return -1;
+
+	retval = sb_raw_file(buf, buf_len, buf_filled, file);
+
+	fclose(file);
+	return retval;
+}
+
+_SB_HEAD(vsprintf, const char *fmt, va_list ap)
+{
+	return sb_raw_vsprintf(_UNPACKED_ARGS, fmt, ap);
+}
+
+_SB_RAW_HEAD(vsprintf, const char *fmt, va_list ap)
+{
+	const unsigned char *in_pos = (const unsigned char*) fmt;
+	char c;
+	size_t i = 0;
+	bool percent = false;
+
+	long num_arg;
+	int (*sb_cb)(char**, size_t*, size_t*, void*);
+
+	while (in_pos[i]) {
+		c = in_pos[i++];
+
+		if (!percent) {
+			if (c == '%') {
+				percent = true;
+				if (sb_raw_bytes(buf, buf_len, buf_filled,
+						 in_pos, i - 1))
+					return -1;
+			}
+
+			continue;
+		}
+
+		percent = false;
+		in_pos += i;
+		i = 0;
+
+		switch (c) {
+		case 'd':
+		case 'u':
+			num_arg = c == 'd' ?
+				va_arg(ap, int) : va_arg(ap, unsigned);
+
+			if (sb_raw_long(buf, buf_len, buf_filled, num_arg))
+				return -1;
+			break;
+		case 'f':
+			if (sb_raw_file(buf, buf_len, buf_filled,
+					va_arg(ap, FILE*)))
+				return -1;
+			break;
+		case 'p':
+			if (sb_raw_filepath(buf, buf_len, buf_filled,
+					    va_arg(ap, const char*)))
+				return -1;
+			break;
+		case 's':
+			if (sb_raw_string(buf, buf_len, buf_filled,
+					  va_arg(ap, const char*)))
+				return -1;
+			break;
+		case '_':
+			sb_cb = va_arg(ap, int (*)(char**, size_t*,
+						   size_t*, void*));
+			if (sb_cb(buf, buf_len, buf_filled,
+				  va_arg(ap, void*)))
+				return -1;
+			break;
+		case '%':
+			in_pos--;
+			i++;
+		}
+	}
+
+	if (!percent && sb_raw_bytes(buf, buf_len, buf_filled, in_pos, i))
+		return -1;
+
+	return 0;
+}
+
+_SB_HEAD(sprintf, const char *fmt, ...)
+{
+	va_list ap;
+	int res;
+
+	va_start(ap, fmt);
+	res = sb_raw_vsprintf(_UNPACKED_ARGS, fmt, ap);
+	va_end(ap);
+
+	return res;
+}
+
+_SB_RAW_HEAD(sprintf, const char *fmt, ...)
+{
+	va_list ap;
+	int res;
+
+	va_start(ap, fmt);
+	res = sb_raw_vsprintf(buf, buf_len, buf_filled, fmt, ap);
+	va_end(ap);
+
+	return res;
+}
+
+int crop_buf(struct stringbuf *sb)
+{
+	return crop_buf_raw(_UNPACKED_ARGS);
+}
+
+int crop_buf_raw(_RAW_BUF_ARGS)
+{
+	char *new_buf;
+
+	if (*buf_len <= *buf_filled + 1)
+		return 0;
+
+	new_buf = realloc(*buf, *buf_filled + 1);
+	if (!new_buf)
+		return -1;
+
+	*buf = new_buf;
+	*buf_len = *buf_filled + 1;
+	return 0;
+}
diff --git a/string_buf.h b/string_buf.h
new file mode 100644
index 0000000..160b7cb
--- /dev/null
+++ b/string_buf.h
@@ -0,0 +1,59 @@
+/**
+ * C string buffers for easy construction of complex strings
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+#ifndef STRING_BUF_H
+#define STRING_BUF_H
+
+#include <stdio.h>
+#include <stdarg.h>
+
+struct stringbuf {
+	char *buf;
+	size_t buf_len;
+	size_t buf_filled;
+};
+
+void stringbuf_init(struct stringbuf *sb);
+void stringbuf_destroy(struct stringbuf *sb);
+void stringbuf_truncate(struct stringbuf *sb, size_t len);
+
+#define _RAW_BUF_ARGS char **buf, size_t *buf_len, size_t *buf_filled
+
+#define _SB_HEAD(name, ...)					\
+	int sb_##name(struct stringbuf *sb, __VA_ARGS__)
+
+#define _SB_RAW_HEAD(name, ...)				\
+	int sb_raw_##name(_RAW_BUF_ARGS, __VA_ARGS__)
+
+#define _SB_DEFINE_2(name, ...)			\
+	_SB_HEAD(name, __VA_ARGS__);		\
+	_SB_RAW_HEAD(name, __VA_ARGS__)
+
+int extend_buf_raw(_RAW_BUF_ARGS, size_t extend_len);
+int extend_buf(struct stringbuf *sb, size_t extend_len);
+
+int crop_buf_raw(_RAW_BUF_ARGS);
+int crop_buf(struct stringbuf *sb);
+
+_SB_DEFINE_2(bytes, const void *bytes, size_t bytes_len);
+_SB_DEFINE_2(string, const char *string);
+_SB_DEFINE_2(char, char c);
+_SB_DEFINE_2(long, long num);
+_SB_DEFINE_2(file, FILE *file);
+_SB_DEFINE_2(filepath, const char *path);
+_SB_DEFINE_2(vsprintf, const char *fmt, va_list ap);
+_SB_DEFINE_2(sprintf, const char *fmt, ...);
+
+#undef _SB_DEFINE_2
+
+#ifndef STRING_BUF_C
+#undef _RAW_BUF_ARGS
+#undef _SB_HEAD
+#undef _SB_RAW_HEAD
+#endif
+
+#endif /* STRING_BUF_H */