Import new Cytoplasm library based off of code from Telodendria.

Telodendria doesn't use this library yet, but it will soon.

.cvsignore

@@ -0,0 +1,3 @@
+build
+out
+*-leaked.txt

.indent.pro

@@ -0,0 +1,28 @@
+-bad
+-bap
+-bbb
+-nbc
+-bl
+-c36
+-cd36
+-ncdb
+-nce
+-ci8
+-cli1
+-d0
+-di1
+-ndj
+-ei
+-fc1
+-i4
+-ip
+-l72
+-lc72
+-lp
+-npcs
+-psl
+-sc
+-nsob
+-nut
+-nv 
+

LICENSE.txt

@@ -0,0 +1,24 @@
+/*
+ * Cytoplasm (libcytoplasm)
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */

README.txt

@@ -0,0 +1,158 @@
+Cytoplasm (libcytoplasm)
+========================================================================
+
+Cytoplasm is a general-purpose C library and runtime stub for
+creating high-level (particularly networked and multi-threaded) C
+applications. It allows applications to take advantage of the speed,
+flexibility, and simplicity of the C programming language, while
+providing helpful code to perform various complex tasks. Cytoplasm
+provides high-level data structures, a basic logging facility, an
+HTTP client and server, and more.
+
+Cytoplasm aims not to only do one thing well, but to do many things
+good enough. The primary target of Cytoplasm is simple, yet higher
+level C applications that have to perform relatively complex tasks,
+but don't want to pull in a large number of dependencies.
+
+Cytoplasm is extremely opinionated on the way programs using it are
+written. It strives to create a comprehensive and tightly-integrated
+programming environment, while also maintaining C programming
+correctness. It doesn't do any macro magic or make C look like
+anything other than C. It is written entirely in C89, and depends
+only on a POSIX environment. This differentiates it from other
+general-purpose libraries that often require modern compilers and
+non-standard language and environment features. Cytoplasm is intended
+to be extremely portable and simple, while still providing some of
+the functionality expected in higher-level programming languages
+in a platform-agnostic manner. In the case of TLS, Cytoplasm wraps
+low-level TLS libraries to offer a single, unified interface to TLS
+so that programs do not have to care about the underlying
+implementation.
+
+Cytoplasm is probably not suitable for embedded programming. It makes
+liberal use of the heap, and while data structures are designed to
+conserve memory where possible and practical, minimal memory usage
+is not really a design goal for Cytoplasm, although Cytoplasm takes
+care not to use any more memory than it absolutely needs. Cytoplasm
+also wraps a few standard libraries with additional logic and
+checking. While this ensures better runtime safetly, this inevitably
+adds a little overhead. 
+
+Originally a part of Telodendria (https://telodendria.io), a Matrix
+homeserver written in C, Cytoplasm was split off into its own project
+due to the desire of some Telodendria developers to use Telodendria's
+code in other projects. Cytoplasm is still a Telodendria project,
+and is maintained along side of Telodendria itself, even living in
+the same CVS module, but it is designed specifically to be distributed
+and used totally independent of Telodendria.
+
+The name "Cytoplasm" was chosen for a few reasons. It plays off the
+precedent set up by the Matrix organization in naming projects after
+the parts of a neuron. It also speaks to the function of Cytoplasm.
+The cytoplasm of a cell is the supporting material. It is what gives
+the cell its shape, and it facilitates the movement of materials
+to the other cell parts. Likewise, Cytoplasm aims to provide a
+support mechanism for C applications that have to perform complex
+tasks.
+
+Cytoplasm also starts with a C, which I think is a nice touch for C
+libraries. It's also fun to say and unique enough that searching for
+"libcytoplasm" should bring you to this project and not some other
+one.
+
+Building
+------------------------------------------------------------------------
+
+If your operating system or software distribution provides a pre-built
+package of Cytoplasm, you should prefer to use that instead of
+building it from source.
+
+Cytoplasm aims to have zero dependencies beyond what is mandated
+by POSIX. You only need the standard math and pthread libraries to
+build it. TLS support can optionally be enabled by setting the
+TLS_IMPL environment variable. The supported TLS implementations
+are as follows:
+
+    * OpenSSL
+    * LibreSSL
+
+If TLS support is not enabled, all APIs that use it should fall
+back to non-TLS behavior in a sensible manner. For example, if TLS
+support is not enabled, then the HTTP client API will simply return
+an error if a TLS connection is requested.
+
+Cytoplasm uses a custom build script instead of Make, for the sake
+of portability. To build everything, just run the script:
+
+        $ sh make.sh
+
+This will produce the following out/ directory:
+
+    out/
+        lib/
+            libcytoplasm.so - The Cytoplasm shared library.
+            libcytoplasm.a - The Cytoplasm static library.
+            cytoplasm.o - The Cytoplasm runtime stub.
+        bin/
+            hdoc - The documentation generator tool.
+        man/ - All Cytoplasm API documentation.
+
+Usage
+------------------------------------------------------------------------
+
+Cytoplasm provides the typical .so and .a files, which can be used
+to link programs with it in the usual way. However, Cytoplasm also
+provides a minimal runtime environment that is intended to be used
+with the library. As such, it also provides a runtime stub, which
+is intended to be linked in with programs using Cytoplasm. This
+stub is responsible for setting up and tearing down some Cytoplasm
+APIs. While it isn't required by any means, it makes Cytoplasm a
+lot easier to use for programmers by abstracting out all of the
+common logic that most programs will want to use.
+
+Here is the canonical Hello World written with Cytoplasm:
+
+	#include <Log.h>
+
+	int Main(void)
+	{
+		Log(LOG_INFO, "Hello World!");
+		return 0;
+	}
+
+If this file is Hello.c, then you can compile it by doing something
+like this:
+
+	$ cc -o hello Hello.c cytoplasm.o -lcytoplasm
+
+This command assumes that the runtime stub resides in the current
+working directory, and that libcytoplasm.so is in your library path.
+If you're using the version of Cytoplasm installed by your operating
+system or software distribution, consult the documentation for the
+location of the runtime stub. It may be located in
+/usr/local/libexec or some other similar location. If you've built
+Cytoplasm from source and wish to link to it from there, you may wish
+to do something like this:
+
+	$ export CYTOPLASM=/path/to/Cytoplasm/out/lib
+	$ cc -o hello Hello.c "${CYTOPLASM}/cytoplasm.o" \
+		"-L${CYTOPLASM}" -lcytoplasm
+
+As you may have noticed, C programs using Cytoplasm's runtime stub
+don't write the main() function. Instead, they use Main(). The main()
+function is provided by the runtime stub. The full form of Main()
+expected by the stub is as follows:
+
+	int Main(Array *args, HashMap *env);
+
+The first argument is a Cytoplasm array of the command line
+arguments, and the second is a Cytoplasm hash map of environment
+variables. Most linkers will let programs omit the env argument,
+or both arguments if you don't need either. The return value of
+Main() is returned to the operating system.
+
+Note that both arguments to Main may be treated like any other
+array or hash map. However, do not invoke ArrayFree() or HashMapFree()
+on the passed pointers, because memory is cleaned up after Main()
+returns.
+

make.sh

@@ -0,0 +1,301 @@
+#!/usr/bin/env sh
+
+addprefix() {
+	prefix="$1"
+	shift
+	for thing in "$@"; do
+		echo "${prefix}${thing}"
+	done
+
+	unset prefix
+	unset thing
+}
+
+: "${NAME:=Cytoplasm}"
+: "${LIB_NAME:=$(echo ${NAME} | tr '[A-Z]' '[a-z]')}"
+: "${VERSION:=0.3.0}"
+
+: "${CVS_TAG:=${NAME}-$(echo ${VERSION} | sed 's/\./_/g')}"
+
+
+: "${SRC:=src}"
+: "${TOOLS:=tools}"
+: "${BUILD:=build}"
+: "${OUT:=out}"
+: "${STUB:=RtStub}"
+: "${LICENSE:=LICENSE.txt}"
+
+: "${CC:=cc}"
+: "${AR:=ar}"
+
+: "${DEFINES:=-D_DEFAULT_SOURCE -DLIB_NAME=\"${NAME}\" -DLIB_VERSION=\"${VERSION}\"}"
+: "${INCLUDE:=${SRC}/include}"
+
+: "${CFLAGS:=-Wall -Wextra -pedantic -std=c89 -O3 -pipe}"
+: "${LD_EXTRA:=-flto -fdata-sections -ffunction-sections -s -Wl,-gc-sections}"
+: "${LDFLAGS:=-lm -pthread}"
+
+if [ -n "${TLS_IMPL}" ]; then
+    case "${TLS_IMPL}" in
+        "LIBRESSL")
+            TLS_LIBS="-ltls -lcrypto -lssl"
+            ;;
+        "OPENSSL")
+            TLS_LIBS="-lcrypto -lssl"
+            ;;
+        *)
+            echo "Unrecognized TLS implementation: ${TLS_IMPL}"
+            echo "Consult Tls.h for supported implementations."
+            echo "Note that the TLS_ prefix is omitted in TLS_IMPL."
+            exit 1
+            ;;
+    esac
+
+    DEFINES="${DEFINES} -DTLS_IMPL=TLS_${TLS_IMPL}"
+    LDFLAGS="${LDFLAGS} ${TLS_LIBS}"
+fi
+
+CFLAGS="${CFLAGS} ${DEFINES} $(addprefix -I$(pwd)/ ${INCLUDE})"
+LDFLAGS="${LDFLAGS} ${LD_EXTRA}"
+
+# Check the modificiation time of a file. This is used to do
+# incremental builds; we only want to rebuild files that have
+# have changed.
+mod_time() {
+    if [ -n "$1" ] && [ -f "$1" ]; then
+        case "$(uname)" in
+            Linux | CYGWIN_NT* | Haiku)
+                stat -c %Y "$1"
+                ;;
+            *BSD | DragonFly | Minix)
+                stat -f %m "$1"
+                ;;
+            *)
+                # Platform unknown, force rebuilding the whole
+                # project every time.
+                echo "0"
+                ;;
+        esac
+    else
+        echo "0"
+    fi
+}
+
+# Substitute shell variables in a stream with their actual value
+# in this shell.
+setsubst() {
+    SED="/tmp/sed-$RANDOM.txt"
+
+    (
+        set | while IFS='=' read -r var val; do
+            val=$(echo "$val" | cut -d "'" -f 2- | rev | cut -d "'" -f 2- | rev)
+            echo "s|\\\${$var}|$val|g"
+        done
+
+        echo "s|\\\${[a-zA-Z_]*}||g"
+        echo "s|'''|'|g"
+    ) >"$SED"
+
+    sed -f "$SED" $@
+    rm "$SED"
+}
+
+recipe_docs() {
+	export LD_LIBRARY_PATH="${OUT}/lib"
+    mkdir -p "${OUT}/man/man3"
+
+    for header in $(find ${INCLUDE} -name '*.h'); do
+        basename=$(basename "$header")
+        man=$(echo "${OUT}/man/man3/$basename" | sed -e 's/\.h$/\.3/')
+
+        if [ $(mod_time "$header") -ge $(mod_time "$man") ]; then
+            echo "DOC $basename"
+            if ! "${OUT}/bin/hdoc" -D "Os=${NAME}" -i "$header" -o "$man"; then
+                rm "$man"
+                exit 1
+            fi
+        fi
+    done
+
+    if which makewhatis 2>&1 > /dev/null; then
+        makewhatis "${OUT}/man"
+    fi
+}
+
+recipe_build() {
+    mkdir -p "${BUILD}" ${OUT}/{bin,lib}
+    cd "${SRC}"
+
+    echo "CC = ${CC}"
+    echo "CFLAGS = ${CFLAGS}"
+    echo "LDFLAGS = ${LDFLAGS}"
+    echo
+
+    do_rebuild=0
+    objs=""
+    for src in $(find . -name '*.c' | cut -d '/' -f 2-); do
+        obj=$(echo "${BUILD}/$src" | sed -e 's/\.c$/\.o/')
+
+        if [ $(basename "$obj" .o) != "${STUB}" ]; then
+            objs="$objs $obj"
+        fi
+
+        if [ $(mod_time "$src") -ge $(mod_time "../$obj") ]; then
+            echo "CC $(basename $obj)"
+            obj_dir=$(dirname "../$obj")
+            mkdir -p "$obj_dir"
+            if ! $CC $CFLAGS -fPIC -c -o "../$obj" "$src"; then
+                exit 1
+            fi
+            do_rebuild=1
+        fi
+    done
+
+    cd ..
+
+    if [ $do_rebuild -eq 1 ] || [ ! -f "${OUT}/lib/lib${LIB_NAME}.a" ]; then
+        echo "AR lib${LIB_NAME}.a"
+        if ! $AR rcs "${OUT}/lib/lib${LIB_NAME}.a" $objs; then
+            exit 1
+        fi
+    fi
+
+    if [ $do_rebuild -eq 1 ] || [ ! -f "${OUT}/lib/lib${LIB_NAME}.so" ]; then
+        echo "LD lib${LIB_NAME}.so"
+        if ! $CC -shared -o "${OUT}/lib/lib${LIB_NAME}.so" $objs ${LDFLAGS}; then
+            exit 1
+        fi
+    fi
+
+	cp "${BUILD}/${STUB}.o" "${OUT}/lib/${LIB_NAME}.o"
+
+    for src in $(find "${TOOLS}" -name '*.c'); do
+        out=$(basename "$src" .c)
+        out="${OUT}/bin/$out"
+
+        if [ $(mod_time "$src") -ge $(mod_time "$out") ] || [ $do_rebuild -eq 1 ]; then
+            echo "CC $(basename $out)"
+            mkdir -p "$(dirname $out)"
+            if ! $CC $CFLAGS -o "$out" "$src" "${OUT}/lib/${LIB_NAME}.o" "-L${OUT}/lib" "-l${LIB_NAME}" ${LDFLAGS}; then
+                exit 1
+            fi
+        fi
+    done
+
+    recipe_docs
+}
+
+recipe_clean() {
+    rm -r "${BUILD}" "${OUT}"
+}
+
+# Update copyright comments in sources and header files.
+recipe_license() {
+    find . -name '*.[ch]' | while IFS= read -r src; do
+        if [ -t 1 ]; then
+            printf "LICENSE %s%*c\r" $(basename "$src") "16" " "
+        fi
+        srcHeader=$(grep -n -m 1 '^ \*/' "$src" | cut -d ':' -f 1)
+        head "-n$srcHeader" "$src" |
+            diff -u -p - "${LICENSE}" |
+            patch "$src" | grep -v "^Hmm"
+    done
+    if [ -t 1 ]; then
+        printf "%*c\n" "50" " "
+    fi
+}
+
+# Format source code files by running indent(1) on them.
+recipe_format() {
+    find . -name '*.c' | while IFS= read -r src; do
+        if [ -t 1 ]; then
+            printf "FMT %s%*c\r" $(basename "$src") "16" " "
+        fi
+        if indent "$src"; then
+            rm $(basename "$src").BAK
+        fi
+    done
+    if [ -t 1 ]; then
+        printf "%*c\n" "50" " "
+    fi
+}
+
+# Generate a release tarball, checksum and sign it, and push it to
+# the web root.
+recipe_release() {
+    # Tag the release at this point in time.
+    cvs tag "$CVS_TAG"
+
+	mkdir -p "${OUT}/release"
+    cd "${OUT}/release"
+
+    # Generate the release tarball.
+    cvs export "-r$CVS_TAG" "${NAME}"
+    mv "${NAME}" "${NAME}-v${VERSION}"
+    tar -czf "${NAME}-v${VERSION}.tar.gz" "${NAME}-v${VERSION}"
+    rm -r "${NAME}-v${VERSION}"
+
+    # Checksum the release tarball.
+    sha256 "${NAME}-v${VERSION}.tar.gz" > "${NAME}-v${VERSION}.tar.gz.sha256"
+
+    # Sign the release tarball.
+    if [ ! -z "${SIGNIFY_SECRET}" ]; then
+        signify -S -s "${SIGNIFY_SECRET}" \
+            -m "${NAME}-v${VERSION}.tar.gz" \
+            -x "${NAME}-v${VERSION}.tar.gz.sig"
+    else
+        echo "Warning: SIGNIFY_SECRET not net."
+        echo "The built tarball will not be signed."
+    fi
+}
+
+recipe_patch() {
+    # If the user has not set their MXID, try to deduce one from
+    # their system.
+    if [ -z "$MXID" ]; then
+        MXID="@${USER}:$(hostname)"
+    fi
+
+    # If the user has not set their EDITOR, use a safe default.
+    # (vi should be available on any POSIX system)
+    if [ -z "$EDITOR" ]; then
+        EDITOR=vi
+    fi
+
+    NORMALIZED_MXID=$(echo "$MXID" | sed -e 's/@//g' -e 's/:/-/g')
+    PATCH_FILE="${NORMALIZED_MXID}_$(date +%s).patch"
+
+    # Generate the actual patch file
+    # Here we write some nice headers, and then do a cvs diff.
+    (
+        printf 'From: "%s" <%s>\n' "$DISPLAY_NAME" "$MXID"
+        echo "Date: $(date)"
+        echo "Subject: "
+        echo
+        cvs -q diff -uNp $PATCHSET | grep -v '^\? '
+    ) >"$PATCH_FILE"
+
+    "$EDITOR" "$PATCH_FILE"
+    echo "$PATCH_FILE"
+}
+
+recipe_diff() {
+    tmp_patch="/tmp/${NAME}-$(date +%s).patch"
+    cvs -q diff -uNp $PATCHSET >"$tmp_patch"
+    if [ -z "$PAGER" ]; then
+        PAGER="less -F"
+    fi
+
+    $PAGER "$tmp_patch"
+    rm "$tmp_patch"
+}
+
+# Execute the user-specified recipes.
+for recipe in $@; do
+    recipe_$recipe
+done
+
+# If no recipe was provided, run a build.
+if [ -z "$1" ]; then
+    recipe_build
+fi

src/Args.c

@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Args.h>
+
+#include <Memory.h>
+#include <Log.h>
+#include <Str.h>
+
+#include <ctype.h>
+#include <string.h>
+
+void
+ArgParseStateInit(ArgParseState * state)
+{
+    state->optPos = 1;
+    state->optErr = 1;
+    state->optInd = 1;
+    state->optOpt = 0;
+    state->optArg = NULL;
+}
+
+int
+ArgParse(ArgParseState * state, Array * args, const char *optStr)
+{
+    const char *arg;
+
+    arg = ArrayGet(args, state->optInd);
+
+    if (arg && StrEquals(arg, "--"))
+    {
+        state->optInd++;
+        return -1;
+    }
+    else if (!arg || arg[0] != '-' || !isalnum((unsigned char) arg[1]))
+    {
+        return -1;
+    }
+    else
+    {
+        const char *opt = strchr(optStr, arg[state->optPos]);
+
+        state->optOpt = arg[state->optPos];
+
+        if (!opt)
+        {
+            if (state->optErr && *optStr != ':')
+            {
+                Log(LOG_ERR, "Illegal option: %c", ArrayGet(args, 0), state->optOpt);
+            }
+            if (!arg[++state->optPos])
+            {
+                state->optInd++;
+                state->optPos = 1;
+            }
+            return '?';
+        }
+        else if (opt[1] == ':')
+        {
+            if (arg[state->optPos + 1])
+            {
+                state->optArg = (char *) arg + state->optPos + 1;
+                state->optInd++;
+                state->optPos = 1;
+                return state->optOpt;
+            }
+            else if (ArrayGet(args, state->optInd + 1))
+            {
+                state->optArg = (char *) ArrayGet(args, state->optInd + 1);
+                state->optInd += 2;
+                state->optPos = 1;
+                return state->optOpt;
+            }
+            else
+            {
+                if (state->optErr && *optStr != ':')
+                {
+                    Log(LOG_ERR, "Option requires an argument: %c", state->optOpt);
+                }
+                if (!arg[++state->optPos])
+                {
+                    state->optInd++;
+                    state->optPos = 1;
+                }
+                return *optStr == ':' ? ':' : '?';
+            }
+        }
+        else
+        {
+            if (!arg[++state->optPos])
+            {
+                state->optInd++;
+                state->optPos = 1;
+            }
+            return state->optOpt;
+        }
+    }
+}

src/Array.c

@@ -0,0 +1,339 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Array.h>
+
+#ifndef ARRAY_BLOCK
+#define ARRAY_BLOCK 16
+#endif
+
+#include <stddef.h>
+#include <Memory.h>
+
+struct Array
+{
+    void **entries;                /* An array of void pointers, to
+                                    * store any data */
+    size_t allocated;              /* Elements allocated on the heap */
+    size_t size;                   /* Elements actually filled */
+};
+
+int
+ArrayAdd(Array * array, void *value)
+{
+    if (!array)
+    {
+        return 0;
+    }
+
+    return ArrayInsert(array, array->size, value);
+}
+
+Array *
+ArrayCreate(void)
+{
+    Array *array = Malloc(sizeof(Array));
+
+    if (!array)
+    {
+        return NULL;
+    }
+
+    array->size = 0;
+    array->allocated = ARRAY_BLOCK;
+    array->entries = Malloc(sizeof(void *) * ARRAY_BLOCK);
+
+    if (!array->entries)
+    {
+        Free(array);
+        return NULL;
+    }
+
+    return array;
+}
+
+void *
+ArrayDelete(Array * array, size_t index)
+{
+    size_t i;
+    void *element;
+
+    if (!array || array->size <= index)
+    {
+        return NULL;
+    }
+
+    element = array->entries[index];
+
+    for (i = index; i < array->size - 1; i++)
+    {
+        array->entries[i] = array->entries[i + 1];
+    }
+
+    array->size--;
+
+    return element;
+}
+
+void
+ArrayFree(Array * array)
+{
+    if (array)
+    {
+        Free(array->entries);
+        Free(array);
+    }
+}
+
+void *
+ArrayGet(Array * array, size_t index)
+{
+    if (!array)
+    {
+        return NULL;
+    }
+
+    if (index >= array->size)
+    {
+        return NULL;
+    }
+
+    return array->entries[index];
+}
+
+
+extern int
+ArrayInsert(Array * array, size_t index, void *value)
+{
+    size_t i;
+
+    if (!array || !value || index > array->size)
+    {
+        return 0;
+    }
+
+    if (array->size >= array->allocated)
+    {
+        void **tmp;
+        size_t newSize = array->allocated + ARRAY_BLOCK;
+
+        tmp = array->entries;
+
+        array->entries = Realloc(array->entries,
+                                 sizeof(void *) * newSize);
+
+        if (!array->entries)
+        {
+            array->entries = tmp;
+            return 0;
+        }
+
+        array->allocated = newSize;
+    }
+
+    for (i = array->size; i > index; i--)
+    {
+        array->entries[i] = array->entries[i - 1];
+    }
+
+    array->size++;
+
+    array->entries[index] = value;
+
+    return 1;
+}
+
+extern void *
+ArraySet(Array * array, size_t index, void *value)
+{
+    void *oldValue;
+
+    if (!value)
+    {
+        return ArrayDelete(array, index);
+    }
+
+    if (!array)
+    {
+        return NULL;
+    }
+
+    if (index >= array->size)
+    {
+        return NULL;
+    }
+
+    oldValue = array->entries[index];
+    array->entries[index] = value;
+
+    return oldValue;
+}
+
+size_t
+ArraySize(Array * array)
+{
+    if (!array)
+    {
+        return 0;
+    }
+
+    return array->size;
+}
+
+int
+ArrayTrim(Array * array)
+{
+    void **tmp;
+
+    if (!array)
+    {
+        return 0;
+    }
+
+    tmp = array->entries;
+
+    array->entries = Realloc(array->entries,
+                             sizeof(void *) * array->size);
+
+    if (!array->entries)
+    {
+        array->entries = tmp;
+        return 0;
+    }
+
+    return 1;
+}
+
+static void
+ArraySwap(Array * array, size_t i, size_t j)
+{
+    void *p = array->entries[i];
+
+    array->entries[i] = array->entries[j];
+    array->entries[j] = p;
+}
+
+static size_t
+ArrayPartition(Array * array, size_t low, size_t high, int (*compare) (void *, void *))
+{
+    void *pivot = array->entries[high];
+    size_t i = low - 1;
+    size_t j;
+
+    for (j = low; j <= high - 1; j++)
+    {
+        if (compare(array->entries[j], pivot) < 0)
+        {
+            i++;
+            ArraySwap(array, i, j);
+        }
+    }
+    ArraySwap(array, i + 1, high);
+    return i + 1;
+}
+
+static void
+ArrayQuickSort(Array * array, size_t low, size_t high, int (*compare) (void *, void *))
+{
+    if (low < high)
+    {
+        size_t pi = ArrayPartition(array, low, high, compare);
+
+        ArrayQuickSort(array, low, pi - 1, compare);
+        ArrayQuickSort(array, pi + 1, high, compare);
+    }
+}
+
+void
+ArraySort(Array * array, int (*compare) (void *, void *))
+{
+    if (!array)
+    {
+        return;
+    }
+    ArrayQuickSort(array, 0, array->size, compare);
+}
+
+/* Even though the following operations could be done using only the
+ * public Array API defined above, I opted for low-level struct
+ * manipulation because it allows much more efficient copying; we only
+ * allocate what we for sure need upfront, and don't have to
+ * re-allocate during the operation. */
+
+Array *
+ArrayFromVarArgs(size_t n, va_list ap)
+{
+    size_t i;
+    Array *arr = Malloc(sizeof(Array));
+
+    if (!arr)
+    {
+        return NULL;
+    }
+
+    arr->size = n;
+    arr->allocated = n;
+    arr->entries = Malloc(sizeof(void *) * arr->allocated);
+
+    if (!arr->entries)
+    {
+        Free(arr);
+        return NULL;
+    }
+
+    for (i = 0; i < n; i++)
+    {
+        arr->entries[i] = va_arg(ap, void *);
+    }
+
+    return arr;
+}
+
+Array *
+ArrayDuplicate(Array * arr)
+{
+    size_t i;
+    Array *arr2 = Malloc(sizeof(Array));
+
+    if (!arr2)
+    {
+        return NULL;
+    }
+
+    arr2->size = arr->size;
+    arr2->allocated = arr->size;
+    arr2->entries = Malloc(sizeof(void *) * arr->allocated);
+
+    if (!arr2->entries)
+    {
+        Free(arr2);
+        return NULL;
+    }
+
+    for (i = 0; i < arr2->size; i++)
+    {
+        arr2->entries[i] = arr->entries[i];
+    }
+
+    return arr2;
+}

src/Base64.c

@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Base64.h>
+
+#include <Memory.h>
+
+static const char Base64EncodeMap[] =
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static const int Base64DecodeMap[] = {
+    62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58,
+    59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5,
+    6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+    21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
+    29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+    43, 44, 45, 46, 47, 48, 49, 50, 51
+};
+
+size_t
+Base64EncodedSize(size_t inputSize)
+{
+    size_t size = inputSize;
+
+    if (inputSize % 3)
+    {
+        size += 3 - (inputSize % 3);
+    }
+
+    size /= 3;
+    size *= 4;
+
+    return size;
+}
+
+size_t
+Base64DecodedSize(const char *base64, size_t len)
+{
+    size_t ret;
+    size_t i;
+
+    if (!base64)
+    {
+        return 0;
+    }
+
+    ret = len / 4 * 3;
+
+    for (i = len; i > 0; i--)
+    {
+        if (base64[i] == '=')
+        {
+            ret--;
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    return ret;
+}
+
+char *
+Base64Encode(const char *input, size_t len)
+{
+    char *out;
+    size_t outLen;
+    size_t i, j, v;
+
+    if (!input || !len)
+    {
+        return NULL;
+    }
+
+    outLen = Base64EncodedSize(len);
+    out = Malloc(outLen + 1);
+    if (!out)
+    {
+        return NULL;
+    }
+    out[outLen] = '\0';
+
+    for (i = 0, j = 0; i < len; i += 3, j += 4)
+    {
+        v = input[i];
+        v = i + 1 < len ? v << 8 | input[i + 1] : v << 8;
+        v = i + 2 < len ? v << 8 | input[i + 2] : v << 8;
+
+        out[j] = Base64EncodeMap[(v >> 18) & 0x3F];
+        out[j + 1] = Base64EncodeMap[(v >> 12) & 0x3F];
+
+        if (i + 1 < len)
+        {
+            out[j + 2] = Base64EncodeMap[(v >> 6) & 0x3F];
+        }
+        else
+        {
+            out[j + 2] = '=';
+        }
+        if (i + 2 < len)
+        {
+            out[j + 3] = Base64EncodeMap[v & 0x3F];
+        }
+        else
+        {
+            out[j + 3] = '=';
+        }
+    }
+
+    return out;
+}
+
+static int
+Base64IsValidChar(char c)
+{
+    return (c >= '0' && c <= '9') ||
+    (c >= 'A' && c <= 'Z') ||
+    (c >= 'a' && c <= 'z') ||
+    (c == '+') ||
+    (c == '/') ||
+    (c == '=');
+}
+
+char *
+Base64Decode(const char *input, size_t len)
+{
+    size_t i, j;
+    int v;
+    size_t outLen;
+    char *out;
+
+    if (!input)
+    {
+        return NULL;
+    }
+
+    outLen = Base64DecodedSize(input, len);
+    if (len % 4)
+    {
+        /* Invalid length; must have incorrect padding */
+        return NULL;
+    }
+
+    /* Scan for invalid characters. */
+    for (i = 0; i < len; i++)
+    {
+        if (!Base64IsValidChar(input[i]))
+        {
+            return NULL;
+        }
+    }
+
+    out = Malloc(outLen + 1);
+    if (!out)
+    {
+        return NULL;
+    }
+
+    out[outLen] = '\0';
+
+    for (i = 0, j = 0; i < len; i += 4, j += 3)
+    {
+        v = Base64DecodeMap[input[i] - 43];
+        v = (v << 6) | Base64DecodeMap[input[i + 1] - 43];
+        v = input[i + 2] == '=' ? v << 6 : (v << 6) | Base64DecodeMap[input[i + 2] - 43];
+        v = input[i + 3] == '=' ? v << 6 : (v << 6) | Base64DecodeMap[input[i + 3] - 43];
+
+        out[j] = (v >> 16) & 0xFF;
+        if (input[i + 2] != '=')
+            out[j + 1] = (v >> 8) & 0xFF;
+        if (input[i + 3] != '=')
+            out[j + 2] = v & 0xFF;
+    }
+
+    return out;
+}
+
+extern void
+Base64Unpad(char *base64, size_t length)
+{
+    if (!base64)
+    {
+        return;
+    }
+
+    while (base64[length - 1] == '=')
+    {
+        length--;
+    }
+
+    base64[length] = '\0';
+}
+
+extern int
+Base64Pad(char **base64Ptr, size_t length)
+{
+    char *tmp;
+    size_t newSize;
+    size_t i;
+
+    if (length % 4 == 0)
+    {
+        return length;             /* Success: no padding needed */
+    }
+
+    newSize = length + (4 - (length % 4));
+
+    tmp = Realloc(*base64Ptr, newSize + 100);;
+    if (!tmp)
+    {
+        return 0;                  /* Memory error */
+    }
+    *base64Ptr = tmp;
+
+    for (i = length; i < newSize; i++)
+    {
+        (*base64Ptr)[i] = '=';
+    }
+
+    (*base64Ptr)[newSize] = '\0';
+
+    return newSize;
+}

src/Cron.c

@@ -0,0 +1,249 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Cron.h>
+
+#include <Array.h>
+#include <Memory.h>
+#include <Util.h>
+
+#include <pthread.h>
+
+struct Cron
+{
+    unsigned long tick;
+    Array *jobs;
+    pthread_mutex_t lock;
+    volatile unsigned int stop:1;
+    pthread_t thread;
+};
+
+typedef struct Job
+{
+    unsigned long interval;
+    unsigned long lastExec;
+    JobFunc *func;
+    void *args;
+} Job;
+
+static Job *
+JobCreate(long interval, JobFunc * func, void *args)
+{
+    Job *job;
+
+    if (!func)
+    {
+        return NULL;
+    }
+
+    job = Malloc(sizeof(Job));
+    if (!job)
+    {
+        return NULL;
+    }
+
+    job->interval = interval;
+    job->lastExec = 0;
+    job->func = func;
+    job->args = args;
+
+    return job;
+}
+
+static void *
+CronThread(void *args)
+{
+    Cron *cron = args;
+
+    while (!cron->stop)
+    {
+        size_t i;
+        unsigned long ts;          /* tick start */
+        unsigned long te;          /* tick end */
+
+        pthread_mutex_lock(&cron->lock);
+
+        ts = UtilServerTs();
+
+        for (i = 0; i < ArraySize(cron->jobs); i++)
+        {
+            Job *job = ArrayGet(cron->jobs, i);
+
+            if (ts - job->lastExec > job->interval)
+            {
+                job->func(job->args);
+                job->lastExec = ts;
+            }
+
+            if (!job->interval)
+            {
+                ArrayDelete(cron->jobs, i);
+                Free(job);
+            }
+        }
+        te = UtilServerTs();
+
+        pthread_mutex_unlock(&cron->lock);
+
+        /* Only sleep if the jobs didn't overrun the tick */
+        if (cron->tick > (te - ts))
+        {
+            const unsigned long microTick = 100;
+            unsigned long remainingTick = cron->tick - (te - ts);
+
+            /* Only sleep for microTick ms at a time because if the job
+             * scheduler is supposed to stop before the tick is up, we
+             * don't want to be stuck in a long sleep */
+            while (remainingTick >= microTick && !cron->stop)
+            {
+                UtilSleepMillis(microTick);
+                remainingTick -= microTick;
+            }
+
+            if (remainingTick && !cron->stop)
+            {
+                UtilSleepMillis(remainingTick);
+            }
+        }
+    }
+
+    return NULL;
+}
+
+Cron *
+CronCreate(unsigned long tick)
+{
+    Cron *cron = Malloc(sizeof(Cron));
+
+    if (!cron)
+    {
+        return NULL;
+    }
+
+    cron->jobs = ArrayCreate();
+    if (!cron->jobs)
+    {
+        Free(cron);
+        return NULL;
+    }
+
+    cron->tick = tick;
+    cron->stop = 1;
+
+    pthread_mutex_init(&cron->lock, NULL);
+
+    return cron;
+}
+
+void
+CronOnce(Cron * cron, JobFunc * func, void *args)
+{
+    Job *job;
+
+    if (!cron || !func)
+    {
+        return;
+    }
+
+    job = JobCreate(0, func, args);
+    if (!job)
+    {
+        return;
+    }
+
+    pthread_mutex_lock(&cron->lock);
+    ArrayAdd(cron->jobs, job);
+    pthread_mutex_unlock(&cron->lock);
+}
+
+void
+CronEvery(Cron * cron, unsigned long interval, JobFunc * func, void *args)
+{
+    Job *job;
+
+    if (!cron || !func)
+    {
+        return;
+    }
+
+    job = JobCreate(interval, func, args);
+    if (!job)
+    {
+        return;
+    }
+
+    pthread_mutex_lock(&cron->lock);
+    ArrayAdd(cron->jobs, job);
+    pthread_mutex_unlock(&cron->lock);
+}
+
+void
+CronStart(Cron * cron)
+{
+    if (!cron || !cron->stop)
+    {
+        return;
+    }
+
+    cron->stop = 0;
+
+    pthread_create(&cron->thread, NULL, CronThread, cron);
+}
+
+void
+CronStop(Cron * cron)
+{
+    if (!cron || cron->stop)
+    {
+        return;
+    }
+
+    cron->stop = 1;
+
+    pthread_join(cron->thread, NULL);
+}
+
+void
+CronFree(Cron * cron)
+{
+    size_t i;
+
+    if (!cron)
+    {
+        return;
+    }
+
+    CronStop(cron);
+
+    pthread_mutex_lock(&cron->lock);
+    for (i = 0; i < ArraySize(cron->jobs); i++)
+    {
+        Free(ArrayGet(cron->jobs, i));
+    }
+
+    ArrayFree(cron->jobs);
+    pthread_mutex_unlock(&cron->lock);
+    pthread_mutex_destroy(&cron->lock);
+
+    Free(cron);
+}

src/Db.c

@@ -0,0 +1,968 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Db.h>
+
+#include <Memory.h>
+#include <Json.h>
+#include <Util.h>
+#include <Str.h>
+#include <Stream.h>
+#include <Log.h>
+
+#include <sys/types.h>
+#include <dirent.h>
+
+#include <pthread.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <errno.h>
+#include <string.h>
+
+struct Db
+{
+    char *dir;
+    pthread_mutex_t lock;
+
+    size_t cacheSize;
+    size_t maxCache;
+    HashMap *cache;
+
+    /*
+     * The cache uses a double linked list (see DbRef
+     * below) to know which objects are most and least
+     * recently used. The following diagram helps me
+     * know what way all the pointers go, because it
+     * can get very confusing sometimes. For example,
+     * there's nothing stopping "next" from pointing to
+     * least recent, and "prev" from pointing to most
+     * recent, so hopefully this clarifies the pointer
+     * terminology used when dealing with the linked
+     * list:
+     *
+     *         mostRecent            leastRecent
+     *             |   prev       prev   |   prev
+     *           +---+ ---> +---+ ---> +---+ ---> NULL
+     *           |ref|      |ref|      |ref|
+     * NULL <--- +---+ <--- +---+ <--- +---+
+     *      next       next       next
+     */
+    DbRef *mostRecent;
+    DbRef *leastRecent;
+};
+
+struct DbRef
+{
+    HashMap *json;
+
+    unsigned long ts;
+    size_t size;
+
+    Array *name;
+
+    DbRef *prev;
+    DbRef *next;
+
+    int fd;
+    Stream *stream;
+};
+
+static void
+StringArrayFree(Array * arr)
+{
+    size_t i;
+
+    for (i = 0; i < ArraySize(arr); i++)
+    {
+        Free(ArrayGet(arr, i));
+    }
+
+    ArrayFree(arr);
+}
+
+static ssize_t DbComputeSize(HashMap *);
+
+static ssize_t
+DbComputeSizeOfValue(JsonValue * val)
+{
+    MemoryInfo *a;
+    ssize_t total = 0;
+
+    size_t i;
+
+    union
+    {
+        char *str;
+        Array *arr;
+    } u;
+
+    if (!val)
+    {
+        return -1;
+    }
+
+    a = MemoryInfoGet(val);
+    if (a)
+    {
+        total += MemoryInfoGetSize(a);
+    }
+
+    switch (JsonValueType(val))
+    {
+        case JSON_OBJECT:
+            total += DbComputeSize(JsonValueAsObject(val));
+            break;
+        case JSON_ARRAY:
+            u.arr = JsonValueAsArray(val);
+            a = MemoryInfoGet(u.arr);
+
+            if (a)
+            {
+                total += MemoryInfoGetSize(a);
+            }
+
+            for (i = 0; i < ArraySize(u.arr); i++)
+            {
+                total += DbComputeSizeOfValue(ArrayGet(u.arr, i));
+            }
+            break;
+        case JSON_STRING:
+            u.str = JsonValueAsString(val);
+            a = MemoryInfoGet(u.str);
+            if (a)
+            {
+                total += MemoryInfoGetSize(a);
+            }
+            break;
+        case JSON_NULL:
+        case JSON_INTEGER:
+        case JSON_FLOAT:
+        case JSON_BOOLEAN:
+        default:
+            /* These don't use any extra heap space */
+            break;
+    }
+    return total;
+}
+
+static ssize_t
+DbComputeSize(HashMap * json)
+{
+    char *key;
+    JsonValue *val;
+    MemoryInfo *a;
+    size_t total;
+
+    if (!json)
+    {
+        return -1;
+    }
+
+    total = 0;
+
+    a = MemoryInfoGet(json);
+    if (a)
+    {
+        total += MemoryInfoGetSize(a);
+    }
+
+    while (HashMapIterate(json, &key, (void **) &val))
+    {
+        a = MemoryInfoGet(key);
+        if (a)
+        {
+            total += MemoryInfoGetSize(a);
+        }
+
+        total += DbComputeSizeOfValue(val);
+    }
+
+    return total;
+}
+
+static char *
+DbHashKey(Array * args)
+{
+    size_t i;
+    char *str = NULL;
+
+    for (i = 0; i < ArraySize(args); i++)
+    {
+        char *tmp = StrConcat(2, str, ArrayGet(args, i));
+
+        Free(str);
+        str = tmp;
+    }
+
+    return str;
+}
+
+static char *
+DbDirName(Db * db, Array * args, size_t strip)
+{
+    size_t i;
+    char *str = StrConcat(2, db->dir, "/");
+
+    for (i = 0; i < ArraySize(args) - strip; i++)
+    {
+        char *tmp;
+
+        tmp = StrConcat(3, str, ArrayGet(args, i), "/");
+
+        Free(str);
+
+        str = tmp;
+    }
+
+    return str;
+}
+
+static char *
+DbFileName(Db * db, Array * args)
+{
+    size_t i;
+    char *str = StrConcat(2, db->dir, "/");
+
+    for (i = 0; i < ArraySize(args); i++)
+    {
+        char *tmp;
+        char *arg = StrDuplicate(ArrayGet(args, i));
+        size_t j = 0;
+
+        /* Sanitize name to prevent directory traversal attacks */
+        while (arg[j])
+        {
+            switch (arg[j])
+            {
+                case '/':
+                    arg[j] = '_';
+                    break;
+                case '.':
+                    arg[j] = '-';
+                    break;
+                default:
+                    break;
+            }
+            j++;
+        }
+
+        tmp = StrConcat(3, str, arg,
+                        (i < ArraySize(args) - 1) ? "/" : ".json");
+
+        Free(arg);
+        Free(str);
+
+        str = tmp;
+    }
+
+    return str;
+}
+
+static void
+DbCacheEvict(Db * db)
+{
+    DbRef *ref = db->leastRecent;
+    DbRef *tmp;
+
+    while (ref && db->cacheSize > db->maxCache)
+    {
+        char *hash;
+
+        JsonFree(ref->json);
+
+        hash = DbHashKey(ref->name);
+        HashMapDelete(db->cache, hash);
+        Free(hash);
+
+        StringArrayFree(ref->name);
+
+        db->cacheSize -= ref->size;
+
+        if (ref->next)
+        {
+            ref->next->prev = ref->prev;
+        }
+        else
+        {
+            db->mostRecent = ref->prev;
+        }
+
+        if (ref->prev)
+        {
+            ref->prev->next = ref->next;
+        }
+        else
+        {
+            db->leastRecent = ref->next;
+        }
+
+        tmp = ref->next;
+        Free(ref);
+
+        ref = tmp;
+    }
+}
+
+Db *
+DbOpen(char *dir, size_t cache)
+{
+    Db *db;
+    pthread_mutexattr_t attr;
+
+    if (!dir)
+    {
+        return NULL;
+    }
+
+    db = Malloc(sizeof(Db));
+    if (!db)
+    {
+        return NULL;
+    }
+
+    db->dir = dir;
+    db->maxCache = cache;
+
+    pthread_mutexattr_init(&attr);
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+    pthread_mutex_init(&db->lock, &attr);
+    pthread_mutexattr_destroy(&attr);
+
+    db->mostRecent = NULL;
+    db->leastRecent = NULL;
+    db->cacheSize = 0;
+
+    if (db->maxCache)
+    {
+        db->cache = HashMapCreate();
+        if (!db->cache)
+        {
+            return NULL;
+        }
+    }
+    else
+    {
+        db->cache = NULL;
+    }
+
+    return db;
+}
+
+void
+DbMaxCacheSet(Db * db, size_t cache)
+{
+    if (!db)
+    {
+        return;
+    }
+
+    pthread_mutex_lock(&db->lock);
+
+    db->maxCache = cache;
+    if (db->maxCache && !db->cache)
+    {
+        db->cache = HashMapCreate();
+        db->cacheSize = 0;
+    }
+
+    DbCacheEvict(db);
+
+    pthread_mutex_unlock(&db->lock);
+}
+
+void
+DbClose(Db * db)
+{
+    if (!db)
+    {
+        return;
+    }
+
+    pthread_mutex_lock(&db->lock);
+
+    DbMaxCacheSet(db, 0);
+    DbCacheEvict(db);
+    HashMapFree(db->cache);
+
+    pthread_mutex_unlock(&db->lock);
+    pthread_mutex_destroy(&db->lock);
+
+    Free(db);
+}
+
+static DbRef *
+DbLockFromArr(Db * db, Array * args)
+{
+    char *file;
+    char *hash;
+    DbRef *ref;
+    struct flock lock;
+
+    int fd;
+    Stream *stream;
+
+    if (!db || !args)
+    {
+        return NULL;
+    }
+
+    ref = NULL;
+    hash = NULL;
+
+    pthread_mutex_lock(&db->lock);
+
+    /* Check if the item is in the cache */
+    hash = DbHashKey(args);
+    ref = HashMapGet(db->cache, hash);
+    file = DbFileName(db, args);
+
+    fd = open(file, O_RDWR);
+    if (fd == -1)
+    {
+        if (ref)
+        {
+            HashMapDelete(db->cache, hash);
+            JsonFree(ref->json);
+            StringArrayFree(ref->name);
+
+            db->cacheSize -= ref->size;
+
+            if (ref->next)
+            {
+                ref->next->prev = ref->prev;
+            }
+            else
+            {
+                db->mostRecent = ref->prev;
+            }
+
+            if (ref->prev)
+            {
+                ref->prev->next = ref->next;
+            }
+            else
+            {
+                db->leastRecent = ref->next;
+            }
+
+            if (!db->leastRecent)
+            {
+                db->leastRecent = db->mostRecent;
+            }
+
+            Free(ref);
+        }
+        ref = NULL;
+        goto finish;
+    }
+
+    stream = StreamFd(fd);
+
+    lock.l_start = 0;
+    lock.l_len = 0;
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+
+    /* Lock the file on the disk */
+    if (fcntl(fd, F_SETLK, &lock) < 0)
+    {
+        StreamClose(stream);
+        ref = NULL;
+        goto finish;
+    }
+
+    if (ref)                       /* In cache */
+    {
+        unsigned long diskTs = UtilLastModified(file);
+
+        ref->fd = fd;
+        ref->stream = stream;
+
+        if (diskTs > ref->ts)
+        {
+            /* File was modified on disk since it was cached */
+            HashMap *json = JsonDecode(ref->stream);
+
+            if (!json)
+            {
+                StreamClose(ref->stream);
+                ref = NULL;
+                goto finish;
+            }
+
+            JsonFree(ref->json);
+            ref->json = json;
+            ref->ts = diskTs;
+            ref->size = DbComputeSize(ref->json);
+        }
+
+        /* Float this ref to mostRecent */
+        if (ref->next)
+        {
+            ref->next->prev = ref->prev;
+
+            if (!ref->prev)
+            {
+                db->leastRecent = ref->next;
+            }
+            else
+            {
+                ref->prev->next = ref->next;
+            }
+
+            ref->prev = db->mostRecent;
+            ref->next = NULL;
+            if (db->mostRecent)
+            {
+                db->mostRecent->next = ref;
+            }
+            db->mostRecent = ref;
+        }
+
+        /* If there is no least recent, this is the only thing in the
+         * cache, so it is also least recent. */
+        if (!db->leastRecent)
+        {
+            db->leastRecent = ref;
+        }
+
+        /* The file on disk may be larger than what we have in memory,
+         * which may require items in cache to be evicted. */
+        DbCacheEvict(db);
+    }
+    else
+    {
+        Array *name;
+        size_t i;
+
+        /* Not in cache; load from disk */
+
+        ref = Malloc(sizeof(DbRef));
+        if (!ref)
+        {
+            StreamClose(stream);
+            goto finish;
+        }
+
+        ref->json = JsonDecode(stream);
+
+        if (!ref->json)
+        {
+            Free(ref);
+            StreamClose(stream);
+            ref = NULL;
+            goto finish;
+        }
+
+        ref->fd = fd;
+        ref->stream = stream;
+
+        name = ArrayCreate();
+        for (i = 0; i < ArraySize(args); i++)
+        {
+            ArrayAdd(name, StrDuplicate(ArrayGet(args, i)));
+        }
+        ref->name = name;
+
+        if (db->cache)
+        {
+            ref->ts = UtilServerTs();
+            ref->size = DbComputeSize(ref->json);
+            HashMapSet(db->cache, hash, ref);
+            db->cacheSize += ref->size;
+
+            ref->next = NULL;
+            ref->prev = db->mostRecent;
+            if (db->mostRecent)
+            {
+                db->mostRecent->next = ref;
+            }
+            db->mostRecent = ref;
+
+            if (!db->leastRecent)
+            {
+                db->leastRecent = ref;
+            }
+
+            /* Adding this item to the cache may case it to grow too
+             * large, requiring some items to be evicted */
+            DbCacheEvict(db);
+        }
+    }
+
+finish:
+    if (!ref)
+    {
+        pthread_mutex_unlock(&db->lock);
+    }
+
+    Free(file);
+    Free(hash);
+
+    return ref;
+}
+
+DbRef *
+DbCreate(Db * db, size_t nArgs,...)
+{
+    Stream *fp;
+    char *file;
+    char *dir;
+    va_list ap;
+    Array *args;
+    DbRef *ret;
+
+    if (!db)
+    {
+        return NULL;
+    }
+
+    va_start(ap, nArgs);
+    args = ArrayFromVarArgs(nArgs, ap);
+    va_end(ap);
+
+    if (!args)
+    {
+        return NULL;
+    }
+
+    pthread_mutex_lock(&db->lock);
+
+    file = DbFileName(db, args);
+
+    if (UtilLastModified(file))
+    {
+        Free(file);
+        ArrayFree(args);
+        pthread_mutex_unlock(&db->lock);
+        return NULL;
+    }
+
+    dir = DbDirName(db, args, 1);
+    if (UtilMkdir(dir, 0750) < 0)
+    {
+        Free(file);
+        ArrayFree(args);
+        Free(dir);
+        pthread_mutex_unlock(&db->lock);
+        return NULL;
+    }
+
+    Free(dir);
+
+    fp = StreamOpen(file, "w");
+    Free(file);
+    if (!fp)
+    {
+        ArrayFree(args);
+        pthread_mutex_unlock(&db->lock);
+        return NULL;
+    }
+
+    StreamPuts(fp, "{}");
+    StreamClose(fp);
+
+    /* DbLockFromArr() will lock again for us */
+    pthread_mutex_unlock(&db->lock);
+
+    ret = DbLockFromArr(db, args);
+
+    ArrayFree(args);
+
+    return ret;
+}
+
+int
+DbDelete(Db * db, size_t nArgs,...)
+{
+    va_list ap;
+    Array *args;
+    char *file;
+    char *hash;
+    int ret = 1;
+    DbRef *ref;
+
+    if (!db)
+    {
+        return 0;
+    }
+
+    va_start(ap, nArgs);
+    args = ArrayFromVarArgs(nArgs, ap);
+    va_end(ap);
+
+    pthread_mutex_lock(&db->lock);
+
+    hash = DbHashKey(args);
+    file = DbFileName(db, args);
+
+    ref = HashMapGet(db->cache, hash);
+    if (ref)
+    {
+        HashMapDelete(db->cache, hash);
+        JsonFree(ref->json);
+        StringArrayFree(ref->name);
+
+        db->cacheSize -= ref->size;
+
+        if (ref->next)
+        {
+            ref->next->prev = ref->prev;
+        }
+        else
+        {
+            db->mostRecent = ref->prev;
+        }
+
+        if (ref->prev)
+        {
+            ref->prev->next = ref->next;
+        }
+        else
+        {
+            db->leastRecent = ref->next;
+        }
+
+        if (!db->leastRecent)
+        {
+            db->leastRecent = db->mostRecent;
+        }
+
+        Free(ref);
+    }
+
+    Free(hash);
+
+    if (UtilLastModified(file))
+    {
+        ret = remove(file) == 0;
+    }
+
+    pthread_mutex_unlock(&db->lock);
+
+    ArrayFree(args);
+    Free(file);
+    return ret;
+}
+
+DbRef *
+DbLock(Db * db, size_t nArgs,...)
+{
+    va_list ap;
+    Array *args;
+    DbRef *ret;
+
+    va_start(ap, nArgs);
+    args = ArrayFromVarArgs(nArgs, ap);
+    va_end(ap);
+
+    if (!args)
+    {
+        return NULL;
+    }
+
+    ret = DbLockFromArr(db, args);
+
+    ArrayFree(args);
+
+    return ret;
+}
+
+int
+DbUnlock(Db * db, DbRef * ref)
+{
+    int destroy;
+
+    if (!db || !ref)
+    {
+        return 0;
+    }
+
+    lseek(ref->fd, 0L, SEEK_SET);
+    if (ftruncate(ref->fd, 0) < 0)
+    {
+        pthread_mutex_unlock(&db->lock);
+        Log(LOG_ERR, "Failed to truncate file on disk.");
+        Log(LOG_ERR, "Error on fd %d: %s", ref->fd, strerror(errno));
+        return 0;
+    }
+
+    JsonEncode(ref->json, ref->stream, JSON_DEFAULT);
+    StreamClose(ref->stream);
+
+    if (db->cache)
+    {
+        char *key = DbHashKey(ref->name);
+
+        if (HashMapGet(db->cache, key))
+        {
+            db->cacheSize -= ref->size;
+            ref->size = DbComputeSize(ref->json);
+            db->cacheSize += ref->size;
+
+            /* If this ref has grown significantly since we last
+             * computed its size, it may have filled the cache and
+             * require some items to be evicted. */
+            DbCacheEvict(db);
+
+            destroy = 0;
+        }
+        else
+        {
+            destroy = 1;
+        }
+
+        Free(key);
+    }
+    else
+    {
+        destroy = 1;
+    }
+
+    if (destroy)
+    {
+        JsonFree(ref->json);
+        StringArrayFree(ref->name);
+
+        Free(ref);
+    }
+
+    pthread_mutex_unlock(&db->lock);
+    return 1;
+}
+
+int
+DbExists(Db * db, size_t nArgs,...)
+{
+    va_list ap;
+    Array *args;
+    char *file;
+    int ret;
+
+    va_start(ap, nArgs);
+    args = ArrayFromVarArgs(nArgs, ap);
+    va_end(ap);
+
+    if (!args)
+    {
+        return 0;
+    }
+
+    pthread_mutex_lock(&db->lock);
+
+    file = DbFileName(db, args);
+    ret = UtilLastModified(file);
+
+    pthread_mutex_unlock(&db->lock);
+
+    Free(file);
+    ArrayFree(args);
+
+    return ret;
+}
+
+Array *
+DbList(Db * db, size_t nArgs,...)
+{
+    Array *result;
+    Array *path;
+    DIR *files;
+    struct dirent *file;
+    char *dir;
+    va_list ap;
+
+    if (!db || !nArgs)
+    {
+        return NULL;
+    }
+
+    result = ArrayCreate();
+    if (!result)
+    {
+        return NULL;
+    }
+
+    va_start(ap, nArgs);
+    path = ArrayFromVarArgs(nArgs, ap);
+    dir = DbDirName(db, path, 0);
+
+    pthread_mutex_lock(&db->lock);
+
+    files = opendir(dir);
+    if (!files)
+    {
+        ArrayFree(path);
+        ArrayFree(result);
+        Free(dir);
+        pthread_mutex_unlock(&db->lock);
+        return NULL;
+    }
+    while ((file = readdir(files)))
+    {
+        size_t namlen = strlen(file->d_name);
+
+        if (namlen > 5)
+        {
+            int nameOffset = namlen - 5;
+
+            if (StrEquals(file->d_name + nameOffset, ".json"))
+            {
+                file->d_name[nameOffset] = '\0';
+                ArrayAdd(result, StrDuplicate(file->d_name));
+            }
+        }
+    }
+    closedir(files);
+
+    ArrayFree(path);
+    Free(dir);
+    pthread_mutex_unlock(&db->lock);
+
+    return result;
+}
+
+void
+DbListFree(Array * arr)
+{
+    StringArrayFree(arr);
+}
+
+HashMap *
+DbJson(DbRef * ref)
+{
+    return ref ? ref->json : NULL;
+}
+
+int
+DbJsonSet(DbRef * ref, HashMap * json)
+{
+    if (!ref || !json)
+    {
+        return 0;
+    }
+
+    JsonFree(ref->json);
+    ref->json = JsonDuplicate(json);
+    return 1;
+}

src/HashMap.c

@@ -0,0 +1,401 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <HashMap.h>
+
+#include <Memory.h>
+#include <Str.h>
+
+#include <stddef.h>
+#include <string.h>
+
+typedef struct HashMapBucket
+{
+    unsigned long hash;
+    char *key;
+    void *value;
+} HashMapBucket;
+
+struct HashMap
+{
+    size_t count;
+    size_t capacity;
+    HashMapBucket **entries;
+
+    unsigned long (*hashFunc) (const char *);
+
+    float maxLoad;
+    size_t iterator;
+};
+
+static unsigned long
+HashMapHashKey(const char *key)
+{
+    unsigned long hash = 2166136261u;
+    size_t i = 0;
+
+    while (key[i])
+    {
+        hash ^= (unsigned char) key[i];
+        hash *= 16777619;
+
+        i++;
+    }
+
+    return hash;
+}
+
+static int
+HashMapGrow(HashMap * map)
+{
+    size_t oldCapacity;
+    size_t i;
+    HashMapBucket **newEntries;
+
+    if (!map)
+    {
+        return 0;
+    }
+
+    oldCapacity = map->capacity;
+    map->capacity *= 2;
+
+    newEntries = Malloc(map->capacity * sizeof(HashMapBucket *));
+    if (!newEntries)
+    {
+        map->capacity /= 2;
+        return 0;
+    }
+
+    memset(newEntries, 0, map->capacity * sizeof(HashMapBucket *));
+
+    for (i = 0; i < oldCapacity; i++)
+    {
+        /* If there is a value here, and it isn't a tombstone */
+        if (map->entries[i] && map->entries[i]->hash)
+        {
+            /* Copy it to the new entries array */
+            size_t index = map->entries[i]->hash % map->capacity;
+
+            for (;;)
+            {
+                if (newEntries[index])
+                {
+                    if (!newEntries[index]->hash)
+                    {
+                        Free(newEntries[index]);
+                        newEntries[index] = map->entries[i];
+                        break;
+                    }
+                }
+                else
+                {
+                    newEntries[index] = map->entries[i];
+                    break;
+                }
+
+                index = (index + 1) % map->capacity;
+            }
+        }
+        else
+        {
+            /* Either NULL or a tombstone */
+            Free(map->entries[i]);
+        }
+    }
+
+    Free(map->entries);
+    map->entries = newEntries;
+    return 1;
+}
+
+HashMap *
+HashMapCreate(void)
+{
+    HashMap *map = Malloc(sizeof(HashMap));
+
+    if (!map)
+    {
+        return NULL;
+    }
+
+    map->maxLoad = 0.75;
+    map->count = 0;
+    map->capacity = 16;
+    map->iterator = 0;
+    map->hashFunc = HashMapHashKey;
+
+    map->entries = Malloc(map->capacity * sizeof(HashMapBucket *));
+    if (!map->entries)
+    {
+        Free(map);
+        return NULL;
+    }
+
+    memset(map->entries, 0, map->capacity * sizeof(HashMapBucket *));
+
+    return map;
+}
+
+void *
+HashMapDelete(HashMap * map, const char *key)
+{
+    unsigned long hash;
+    size_t index;
+
+    if (!map || !key)
+    {
+        return NULL;
+    }
+
+    hash = map->hashFunc(key);
+    index = hash % map->capacity;
+
+    for (;;)
+    {
+        HashMapBucket *bucket = map->entries[index];
+
+        if (!bucket)
+        {
+            break;
+        }
+
+        if (bucket->hash == hash)
+        {
+            bucket->hash = 0;
+            return bucket->value;
+        }
+
+        index = (index + 1) % map->capacity;
+    }
+
+    return NULL;
+}
+
+void
+HashMapFree(HashMap * map)
+{
+    if (map)
+    {
+        size_t i;
+
+        for (i = 0; i < map->capacity; i++)
+        {
+            if (map->entries[i])
+            {
+                Free(map->entries[i]->key);
+                Free(map->entries[i]);
+            }
+        }
+        Free(map->entries);
+        Free(map);
+    }
+}
+
+void *
+HashMapGet(HashMap * map, const char *key)
+{
+    unsigned long hash;
+    size_t index;
+
+    if (!map || !key)
+    {
+        return NULL;
+    }
+
+    hash = map->hashFunc(key);
+    index = hash % map->capacity;
+
+    for (;;)
+    {
+        HashMapBucket *bucket = map->entries[index];
+
+        if (!bucket)
+        {
+            break;
+        }
+
+        if (bucket->hash == hash)
+        {
+            return bucket->value;
+        }
+
+        index = (index + 1) % map->capacity;
+    }
+
+    return NULL;
+}
+
+int
+HashMapIterateReentrant(HashMap * map, char **key, void **value, size_t * i)
+{
+    if (!map)
+    {
+        return 0;
+    }
+
+    if (*i >= map->capacity)
+    {
+        *i = 0;
+        *key = NULL;
+        *value = NULL;
+        return 0;
+    }
+
+    while (*i < map->capacity)
+    {
+        HashMapBucket *bucket = map->entries[*i];
+
+        *i = *i + 1;
+
+        if (bucket && bucket->hash)
+        {
+            *key = bucket->key;
+            *value = bucket->value;
+            return 1;
+        }
+    }
+
+    *i = 0;
+    return 0;
+}
+
+int
+HashMapIterate(HashMap * map, char **key, void **value)
+{
+    if (!map)
+    {
+        return 0;
+    }
+    else
+    {
+        return HashMapIterateReentrant(map, key, value, &map->iterator);
+    }
+}
+
+void
+HashMapMaxLoadSet(HashMap * map, float load)
+{
+    if (!map || (load > 1.0 || load <= 0))
+    {
+        return;
+    }
+
+    map->maxLoad = load;
+}
+
+void
+HashMapFunctionSet(HashMap * map, unsigned long (*hashFunc) (const char *))
+{
+    if (!map || !hashFunc)
+    {
+        return;
+    }
+
+    map->hashFunc = hashFunc;
+}
+
+void *
+HashMapSet(HashMap * map, char *key, void *value)
+{
+    unsigned long hash;
+    size_t index;
+
+    if (!map || !key || !value)
+    {
+        return NULL;
+    }
+
+    key = StrDuplicate(key);
+    if (!key)
+    {
+        return NULL;
+    }
+
+    if (map->count + 1 > map->capacity * map->maxLoad)
+    {
+        HashMapGrow(map);
+    }
+
+    hash = map->hashFunc(key);
+    index = hash % map->capacity;
+
+    for (;;)
+    {
+        HashMapBucket *bucket = map->entries[index];
+
+        if (!bucket)
+        {
+            bucket = Malloc(sizeof(HashMapBucket));
+            if (!bucket)
+            {
+                break;
+            }
+
+            bucket->hash = hash;
+            bucket->key = key;
+            bucket->value = value;
+            map->entries[index] = bucket;
+            map->count++;
+            break;
+        }
+
+        if (!bucket->hash)
+        {
+            bucket->hash = hash;
+            Free(bucket->key);
+            bucket->key = key;
+            bucket->value = value;
+            break;
+        }
+
+        if (bucket->hash == hash)
+        {
+            void *oldValue = bucket->value;
+
+            Free(bucket->key);
+            bucket->key = key;
+
+            bucket->value = value;
+            return oldValue;
+        }
+
+        index = (index + 1) % map->capacity;
+    }
+
+    return NULL;
+}
+
+void
+HashMapIterateFree(char *key, void *value)
+{
+    if (key)
+    {
+        Free(key);
+    }
+
+    if (value)
+    {
+        Free(value);
+    }
+}

src/HeaderParser.c

@@ -0,0 +1,664 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <HeaderParser.h>
+
+#include <Memory.h>
+#include <Str.h>
+
+#include <string.h>
+#include <ctype.h>
+
+static int
+HeaderConsumeWhitespace(HeaderExpr * expr)
+{
+    int c;
+
+    while (1)
+    {
+        c = StreamGetc(expr->state.stream);
+
+        if (StreamEof(expr->state.stream) || StreamError(expr->state.stream))
+        {
+            expr->type = HP_EOF;
+            expr->data.error.msg = "End of stream reached.";
+            expr->data.error.lineNo = expr->state.lineNo;
+            break;
+        }
+
+        if (isspace(c))
+        {
+            if (c == '\n')
+            {
+                expr->state.lineNo++;
+            }
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    return c;
+}
+
+static char *
+HeaderConsumeWord(HeaderExpr * expr)
+{
+    char *str = Malloc(16 * sizeof(char));
+    int len = 16;
+    int i;
+    int c;
+
+    if (!str)
+    {
+        return NULL;
+    }
+
+    c = HeaderConsumeWhitespace(expr);
+
+    i = 0;
+    str[i] = c;
+    i++;
+
+    while (!isspace(c = StreamGetc(expr->state.stream)))
+    {
+        if (i >= len)
+        {
+            len *= 2;
+            str = Realloc(str, len * sizeof(char));
+        }
+
+        str[i] = c;
+        i++;
+    }
+
+    if (i >= len)
+    {
+        len++;
+        str = Realloc(str, len * sizeof(char));
+    }
+
+    str[i] = '\0';
+
+    if (c != EOF)
+    {
+        StreamUngetc(expr->state.stream, c);
+    }
+
+    return str;
+}
+
+static char *
+HeaderConsumeAlnum(HeaderExpr * expr)
+{
+    char *str = Malloc(16 * sizeof(char));
+    int len = 16;
+    int i;
+    int c;
+
+    if (!str)
+    {
+        return NULL;
+    }
+
+    c = HeaderConsumeWhitespace(expr);
+
+    i = 0;
+    str[i] = c;
+    i++;
+
+    while (isalnum(c = StreamGetc(expr->state.stream)))
+    {
+        if (i >= len)
+        {
+            len *= 2;
+            str = Realloc(str, len * sizeof(char));
+        }
+
+        str[i] = c;
+        i++;
+    }
+
+    if (i >= len)
+    {
+        len++;
+        str = Realloc(str, len * sizeof(char));
+    }
+
+    str[i] = '\0';
+
+    if (c != EOF)
+    {
+        StreamUngetc(expr->state.stream, c);
+    }
+
+    return str;
+}
+
+static char *
+HeaderConsumeArg(HeaderExpr * expr)
+{
+    char *str = Malloc(16 * sizeof(char));
+    int len = 16;
+    int i;
+    int c;
+    int block = 0;
+
+    if (!str)
+    {
+        return NULL;
+    }
+
+    c = HeaderConsumeWhitespace(expr);
+
+    i = 0;
+    str[i] = c;
+    i++;
+
+    while (((c = StreamGetc(expr->state.stream)) != ',' && c != ')') || block > 0)
+    {
+        if (i >= len)
+        {
+            len *= 2;
+            str = Realloc(str, len * sizeof(char));
+        }
+
+        str[i] = c;
+        i++;
+
+        if (c == '(')
+        {
+            block++;
+        }
+        else if (c == ')')
+        {
+            block--;
+        }
+        else if (c == '\n')
+        {
+            expr->state.lineNo++;
+        }
+    }
+
+    if (i >= len)
+    {
+        len++;
+        str = Realloc(str, len * sizeof(char));
+    }
+
+    str[i] = '\0';
+
+    if (c != EOF)
+    {
+        StreamUngetc(expr->state.stream, c);
+    }
+
+    return str;
+}
+
+void
+HeaderParse(Stream * stream, HeaderExpr * expr)
+{
+    int c;
+
+    if (!expr)
+    {
+        return;
+    }
+
+    if (!stream)
+    {
+        expr->type = HP_PARSE_ERROR;
+        expr->data.error.msg = "NULL pointer to stream.";
+        expr->data.error.lineNo = -1;
+        return;
+    }
+
+    if (expr->type == HP_DECLARATION && expr->data.declaration.args)
+    {
+        size_t i;
+
+        for (i = 0; i < ArraySize(expr->data.declaration.args); i++)
+        {
+            Free(ArrayGet(expr->data.declaration.args, i));
+        }
+
+        ArrayFree(expr->data.declaration.args);
+    }
+
+    expr->state.stream = stream;
+    if (!expr->state.lineNo)
+    {
+        expr->state.lineNo = 1;
+    }
+
+    c = HeaderConsumeWhitespace(expr);
+
+    if (StreamEof(stream) || StreamError(stream))
+    {
+        expr->type = HP_EOF;
+        expr->data.error.msg = "End of stream reached.";
+        expr->data.error.lineNo = expr->state.lineNo;
+        return;
+    }
+
+    if (c == '/')
+    {
+        int i = 0;
+
+        c = StreamGetc(expr->state.stream);
+        if (c != '*')
+        {
+            expr->type = HP_SYNTAX_ERROR;
+            expr->data.error.msg = "Expected comment opening.";
+            expr->data.error.lineNo = expr->state.lineNo;
+            return;
+        }
+
+        expr->type = HP_COMMENT;
+        while (1)
+        {
+            if (i >= HEADER_EXPR_MAX - 1)
+            {
+                expr->type = HP_PARSE_ERROR;
+                expr->data.error.msg = "Memory limit exceeded while parsing comment.";
+                expr->data.error.lineNo = expr->state.lineNo;
+                return;
+            }
+
+            c = StreamGetc(expr->state.stream);
+
+            if (StreamEof(expr->state.stream) || StreamError(expr->state.stream))
+            {
+                expr->type = HP_SYNTAX_ERROR;
+                expr->data.error.msg = "Unterminated comment.";
+                expr->data.error.lineNo = expr->state.lineNo;
+                return;
+            }
+
+            if (c == '*')
+            {
+                c = StreamGetc(expr->state.stream);
+                if (c == '/')
+                {
+                    expr->data.text[i] = '\0';
+                    break;
+                }
+                else
+                {
+                    expr->data.text[i] = '*';
+                    i++;
+                    expr->data.text[i] = c;
+                    i++;
+                    if (c == '\n')
+                    {
+                        expr->state.lineNo++;
+                    }
+                }
+            }
+            else
+            {
+                expr->data.text[i] = c;
+                i++;
+
+                if (c == '\n')
+                {
+                    expr->state.lineNo++;
+                }
+            }
+        }
+    }
+    else if (c == '#')
+    {
+        int i = 0;
+        char *word;
+
+        expr->type = HP_PREPROCESSOR_DIRECTIVE;
+        expr->data.text[i] = '#';
+        i++;
+
+        word = HeaderConsumeWord(expr);
+
+        strncpy(expr->data.text + i, word, HEADER_EXPR_MAX - i - 1);
+        i += strlen(word);
+
+        if (StrEquals(word, "include") ||
+            StrEquals(word, "undef") ||
+            StrEquals(word, "ifdef") ||
+            StrEquals(word, "ifndef"))
+        {
+            /* Read one more word */
+            Free(word);
+            word = HeaderConsumeWord(expr);
+
+            if (i + strlen(word) + 1 >= HEADER_EXPR_MAX)
+            {
+                expr->type = HP_PARSE_ERROR;
+                expr->data.error.msg = "Memory limit reached parsing preprocessor directive.";
+                expr->data.error.lineNo = expr->state.lineNo;
+            }
+            else
+            {
+                strncpy(expr->data.text + i + 1, word, HEADER_EXPR_MAX - i - 1);
+                expr->data.text[i] = ' ';
+            }
+
+            Free(word);
+        }
+        else if (StrEquals(word, "define") ||
+                 StrEquals(word, "if") ||
+                 StrEquals(word, "elif") ||
+                 StrEquals(word, "error"))
+        {
+            int pC = 0;
+
+            Free(word);
+            expr->data.text[i] = ' ';
+            i++;
+
+            while (1)
+            {
+                if (i >= HEADER_EXPR_MAX - 1)
+                {
+                    expr->type = HP_PARSE_ERROR;
+                    expr->data.error.msg = "Memory limit reached parsing preprocessor directive.";
+                    expr->data.error.lineNo = expr->state.lineNo;
+                    return;
+                }
+
+                c = StreamGetc(expr->state.stream);
+
+                if (StreamEof(expr->state.stream) || StreamError(expr->state.stream))
+                {
+                    expr->type = HP_SYNTAX_ERROR;
+                    expr->data.error.msg = "Unterminated preprocessor directive.";
+                    expr->data.error.lineNo = expr->state.lineNo;
+                    return;
+                }
+
+                if (c == '\n')
+                {
+                    expr->state.lineNo++;
+                    if (pC != '\\')
+                    {
+                        expr->data.text[i] = '\0';
+                        break;
+                    }
+                }
+
+                expr->data.text[i] = c;
+                i++;
+
+                pC = c;
+            }
+        }
+        else if (StrEquals(word, "else") ||
+                 StrEquals(word, "endif"))
+        {
+            /* Read no more words, that's the whole directive */
+        }
+        else
+        {
+            Free(word);
+
+            expr->type = HP_SYNTAX_ERROR;
+            expr->data.error.msg = "Unknown preprocessor directive.";
+            expr->data.error.lineNo = expr->state.lineNo;
+        }
+    }
+    else
+    {
+        char *word;
+
+        StreamUngetc(expr->state.stream, c);
+        word = HeaderConsumeWord(expr);
+
+        if (StrEquals(word, "typedef"))
+        {
+            int block = 0;
+            int i = 0;
+
+            expr->type = HP_TYPEDEF;
+            strncpy(expr->data.text, word, HEADER_EXPR_MAX - 1);
+            i += strlen(word);
+            expr->data.text[i] = ' ';
+            i++;
+
+            while (1)
+            {
+                if (i >= HEADER_EXPR_MAX - 1)
+                {
+                    expr->type = HP_PARSE_ERROR;
+                    expr->data.error.msg = "Memory limit exceeded while parsing typedef.";
+                    expr->data.error.lineNo = expr->state.lineNo;
+                    return;
+                }
+
+                c = StreamGetc(expr->state.stream);
+
+                if (StreamEof(expr->state.stream) || StreamError(expr->state.stream))
+                {
+                    expr->type = HP_SYNTAX_ERROR;
+                    expr->data.error.msg = "Unterminated typedef.";
+                    expr->data.error.lineNo = expr->state.lineNo;
+                    return;
+                }
+
+                expr->data.text[i] = c;
+                i++;
+
+                if (c == '{')
+                {
+                    block++;
+                }
+                else if (c == '}')
+                {
+                    block--;
+                }
+                else if (c == '\n')
+                {
+                    expr->state.lineNo++;
+                }
+
+                if (block <= 0 && c == ';')
+                {
+                    expr->data.text[i] = '\0';
+                    break;
+                }
+            }
+        }
+        else if (StrEquals(word, "extern"))
+        {
+            int wordLimit = sizeof(expr->data.declaration.returnType) - 8;
+            int wordLen;
+
+            Free(word);
+
+            word = HeaderConsumeWord(expr);
+            wordLen = strlen(word);
+            if (wordLen > wordLimit)
+            {
+                expr->type = HP_PARSE_ERROR;
+                expr->data.error.msg = "Return of declaration exceeds length limit.";
+                expr->data.error.lineNo = expr->state.lineNo;
+            }
+            else
+            {
+                int i = wordLen;
+
+                expr->type = HP_GLOBAL;
+                strncpy(expr->data.global.type, word, wordLimit);
+
+                if (StrEquals(word, "struct") ||
+                    StrEquals(word, "enum") ||
+                    StrEquals(word, "const") ||
+                    StrEquals(word, "unsigned"))
+                {
+                    Free(word);
+                    word = HeaderConsumeWord(expr);
+                    wordLen = strlen(word);
+                    expr->data.global.type[i] = ' ';
+
+                    strncpy(expr->data.global.type + i + 1, word, wordLen + 1);
+                    i += wordLen + 1;
+                }
+
+                Free(word);
+
+                c = HeaderConsumeWhitespace(expr);
+                if (c == '*')
+                {
+                    expr->data.global.type[i] = ' ';
+
+                    i++;
+                    expr->data.global.type[i] = '*';
+
+                    i++;
+                    while ((c = HeaderConsumeWhitespace(expr)) == '*')
+                    {
+                        expr->data.global.type[i] = c;
+
+                        i++;
+                    }
+                }
+
+                StreamUngetc(expr->state.stream, c);
+                word = HeaderConsumeAlnum(expr);
+
+                wordLen = strlen(word);
+                wordLimit = sizeof(expr->data.declaration.name) - 1;
+
+                if (wordLen > wordLimit)
+                {
+                    expr->type = HP_SYNTAX_ERROR;
+                    expr->data.error.msg = "Function name too long.";
+                    expr->data.error.lineNo = expr->state.lineNo;
+                }
+                else
+                {
+                    strncpy(expr->data.global.name, word, wordLimit);
+                    Free(word);
+                    word = NULL;
+
+                    c = HeaderConsumeWhitespace(expr);
+
+                    if (c == ';')
+                    {
+                        /* That's the end of the global. */
+                    }
+                    else if (c == '[')
+                    {
+                        /* Looks like we have an array. Slurp all the
+                         * dimensions */
+                        int i = wordLen;
+
+                        expr->data.global.name[i] = '[';
+
+                        i++;
+
+                        while (1)
+                        {
+                            if (i >= HEADER_EXPR_MAX - wordLen)
+                            {
+                                expr->type = HP_PARSE_ERROR;
+                                expr->data.error.msg = "Memory limit exceeded while parsing global array.";
+                                expr->data.error.lineNo = expr->state.lineNo;
+                                return;
+                            }
+
+                            c = StreamGetc(expr->state.stream);
+
+                            if (StreamEof(expr->state.stream) || StreamError(expr->state.stream))
+                            {
+                                expr->type = HP_SYNTAX_ERROR;
+                                expr->data.error.msg = "Unterminated global array.";
+                                expr->data.error.lineNo = expr->state.lineNo;
+                                return;
+                            }
+
+                            if (c == ';')
+                            {
+                                expr->data.global.name[i] = '\0';
+
+                                break;
+                            }
+                            else
+                            {
+                                expr->data.global.name[i] = c;
+
+                                i++;
+                            }
+                        }
+                    }
+                    else if (c == '(')
+                    {
+                        expr->type = HP_DECLARATION;
+                        expr->data.declaration.args = ArrayCreate();
+                        do
+                        {
+                            word = HeaderConsumeArg(expr);
+                            ArrayAdd(expr->data.declaration.args, word);
+                            word = NULL;
+                        }
+                        while ((!StreamEof(expr->state.stream)) && ((c = HeaderConsumeWhitespace(expr)) != ')'));
+
+                        if (StreamEof(expr->state.stream))
+                        {
+                            expr->type = HP_SYNTAX_ERROR;
+                            expr->data.error.msg = "End of file reached before ')'.";
+                            expr->data.error.lineNo = expr->state.lineNo;
+                            return;
+                        }
+
+                        c = HeaderConsumeWhitespace(expr);
+                        if (c != ';')
+                        {
+                            expr->type = HP_SYNTAX_ERROR;
+                            expr->data.error.msg = "Expected ';'.";
+                            expr->data.error.lineNo = expr->state.lineNo;
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        expr->type = HP_SYNTAX_ERROR;
+                        expr->data.error.msg = "Expected ';', '[', or '('";
+                        expr->data.error.lineNo = expr->state.lineNo;
+                        return;
+                    }
+
+                }
+            }
+        }
+        else
+        {
+            /* Cope with preprocessor macro expansions at the top
+             * level. */
+            expr->type = HP_UNKNOWN;
+            strncpy(expr->data.text, word, HEADER_EXPR_MAX);
+        }
+
+        Free(word);
+    }
+}

src/Http.c

@@ -0,0 +1,642 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Http.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include <Memory.h>
+#include <HashMap.h>
+#include <Util.h>
+#include <Str.h>
+
+#ifndef CYTOPLASM_STRING_CHUNK
+#define CYTOPLASM_STRING_CHUNK 64
+#endif
+
+const char *
+HttpRequestMethodToString(const HttpRequestMethod method)
+{
+    switch (method)
+    {
+            case HTTP_GET:
+            return "GET";
+        case HTTP_HEAD:
+            return "HEAD";
+        case HTTP_POST:
+            return "POST";
+        case HTTP_PUT:
+            return "PUT";
+        case HTTP_DELETE:
+            return "DELETE";
+        case HTTP_CONNECT:
+            return "CONNECT";
+        case HTTP_OPTIONS:
+            return "OPTIONS";
+        case HTTP_TRACE:
+            return "TRACE";
+        case HTTP_PATCH:
+            return "PATCH";
+        default:
+            return NULL;
+    }
+}
+
+HttpRequestMethod
+HttpRequestMethodFromString(const char *str)
+{
+    if (StrEquals(str, "GET"))
+    {
+        return HTTP_GET;
+    }
+
+    if (StrEquals(str, "HEAD"))
+    {
+        return HTTP_HEAD;
+    }
+
+    if (StrEquals(str, "POST"))
+    {
+        return HTTP_POST;
+    }
+
+    if (StrEquals(str, "PUT"))
+    {
+        return HTTP_PUT;
+    }
+
+    if (StrEquals(str, "DELETE"))
+    {
+        return HTTP_DELETE;
+    }
+
+    if (StrEquals(str, "CONNECT"))
+    {
+        return HTTP_CONNECT;
+    }
+
+    if (StrEquals(str, "OPTIONS"))
+    {
+        return HTTP_OPTIONS;
+    }
+
+    if (StrEquals(str, "TRACE"))
+    {
+        return HTTP_TRACE;
+    }
+
+    if (StrEquals(str, "PATCH"))
+    {
+        return HTTP_PATCH;
+    }
+
+    return HTTP_METHOD_UNKNOWN;
+}
+
+const char *
+HttpStatusToString(const HttpStatus status)
+{
+    switch (status)
+    {
+            case HTTP_CONTINUE:
+            return "Continue";
+        case HTTP_SWITCHING_PROTOCOLS:
+            return "Switching Protocols";
+        case HTTP_EARLY_HINTS:
+            return "Early Hints";
+        case HTTP_OK:
+            return "Ok";
+        case HTTP_CREATED:
+            return "Created";
+        case HTTP_ACCEPTED:
+            return "Accepted";
+        case HTTP_NON_AUTHORITATIVE_INFORMATION:
+            return "Non-Authoritative Information";
+        case HTTP_NO_CONTENT:
+            return "No Content";
+        case HTTP_RESET_CONTENT:
+            return "Reset Content";
+        case HTTP_PARTIAL_CONTENT:
+            return "Partial Content";
+        case HTTP_MULTIPLE_CHOICES:
+            return "Multiple Choices";
+        case HTTP_MOVED_PERMANENTLY:
+            return "Moved Permanently";
+        case HTTP_FOUND:
+            return "Found";
+        case HTTP_SEE_OTHER:
+            return "See Other";
+        case HTTP_NOT_MODIFIED:
+            return "Not Modified";
+        case HTTP_TEMPORARY_REDIRECT:
+            return "Temporary Redirect";
+        case HTTP_PERMANENT_REDIRECT:
+            return "Permanent Redirect";
+        case HTTP_BAD_REQUEST:
+            return "Bad Request";
+        case HTTP_UNAUTHORIZED:
+            return "Unauthorized";
+        case HTTP_FORBIDDEN:
+            return "Forbidden";
+        case HTTP_NOT_FOUND:
+            return "Not Found";
+        case HTTP_METHOD_NOT_ALLOWED:
+            return "Method Not Allowed";
+        case HTTP_NOT_ACCEPTABLE:
+            return "Not Acceptable";
+        case HTTP_PROXY_AUTH_REQUIRED:
+            return "Proxy Authentication Required";
+        case HTTP_REQUEST_TIMEOUT:
+            return "Request Timeout";
+        case HTTP_CONFLICT:
+            return "Conflict";
+        case HTTP_GONE:
+            return "Gone";
+        case HTTP_LENGTH_REQUIRED:
+            return "Length Required";
+        case HTTP_PRECONDITION_FAILED:
+            return "Precondition Failed";
+        case HTTP_PAYLOAD_TOO_LARGE:
+            return "Payload Too Large";
+        case HTTP_URI_TOO_LONG:
+            return "URI Too Long";
+        case HTTP_UNSUPPORTED_MEDIA_TYPE:
+            return "Unsupported Media Type";
+        case HTTP_RANGE_NOT_SATISFIABLE:
+            return "Range Not Satisfiable";
+        case HTTP_EXPECTATION_FAILED:
+            return "Expectation Failed";
+        case HTTP_TEAPOT:
+            return "I'm a Teapot";
+        case HTTP_UPGRADE_REQUIRED:
+            return "Upgrade Required";
+        case HTTP_PRECONDITION_REQUIRED:
+            return "Precondition Required";
+        case HTTP_TOO_MANY_REQUESTS:
+            return "Too Many Requests";
+        case HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE:
+            return "Request Header Fields Too Large";
+        case HTTP_UNAVAILABLE_FOR_LEGAL_REASONS:
+            return "Unavailable For Legal Reasons";
+        case HTTP_INTERNAL_SERVER_ERROR:
+            return "Internal Server Error";
+        case HTTP_NOT_IMPLEMENTED:
+            return "Not Implemented";
+        case HTTP_BAD_GATEWAY:
+            return "Bad Gateway";
+        case HTTP_SERVICE_UNAVAILABLE:
+            return "Service Unavailable";
+        case HTTP_GATEWAY_TIMEOUT:
+            return "Gateway Timeout";
+        case HTTP_VERSION_NOT_SUPPORTED:
+            return "Version Not Supported";
+        case HTTP_VARIANT_ALSO_NEGOTIATES:
+            return "Variant Also Negotiates";
+        case HTTP_NOT_EXTENDED:
+            return "Not Extended";
+        case HTTP_NETWORK_AUTH_REQUIRED:
+            return "Network Authentication Required";
+        default:
+            return NULL;
+    }
+}
+
+char *
+HttpUrlEncode(char *str)
+{
+    size_t size;
+    size_t len;
+    char *encoded;
+
+    if (!str)
+    {
+        return NULL;
+    }
+
+    size = CYTOPLASM_STRING_CHUNK;
+    len = 0;
+    encoded = Malloc(size);
+    if (!encoded)
+    {
+        return NULL;
+    }
+
+    while (*str)
+    {
+        char c = *str;
+
+        if (len >= size - 4)
+        {
+            char *tmp;
+
+            size += CYTOPLASM_STRING_CHUNK;
+            tmp = Realloc(encoded, size);
+            if (!tmp)
+            {
+                Free(encoded);
+                return NULL;
+            }
+
+            encoded = tmp;
+        }
+
+        /* Control characters and extended characters */
+        if (c <= 0x1F || c >= 0x7F)
+        {
+            goto percentEncode;
+        }
+
+        /* Reserved and unsafe characters */
+        switch (c)
+        {
+            case '$':
+            case '&':
+            case '+':
+            case ',':
+            case '/':
+            case ':':
+            case ';':
+            case '=':
+            case '?':
+            case '@':
+            case ' ':
+            case '"':
+            case '<':
+            case '>':
+            case '#':
+            case '%':
+            case '{':
+            case '}':
+            case '|':
+            case '\\':
+            case '^':
+            case '~':
+            case '[':
+            case ']':
+            case '`':
+                goto percentEncode;
+                break;
+            default:
+                encoded[len] = c;
+                len++;
+                str++;
+                continue;
+        }
+
+percentEncode:
+        encoded[len] = '%';
+        len++;
+        snprintf(encoded + len, 3, "%2X", c);
+        len += 2;
+
+        str++;
+    }
+
+    encoded[len] = '\0';
+    return encoded;
+}
+
+char *
+HttpUrlDecode(char *str)
+{
+    size_t i;
+    size_t inputLen;
+    char *decoded;
+
+    if (!str)
+    {
+        return NULL;
+    }
+
+    i = 0;
+    inputLen = strlen(str);
+    decoded = Malloc(inputLen + 1);
+
+    if (!decoded)
+    {
+        return NULL;
+    }
+
+    while (*str)
+    {
+        char c = *str;
+
+        if (c == '%')
+        {
+            unsigned int d;
+
+            str++;
+
+            if (sscanf(str, "%2X", &d) != 1)
+            {
+                /* Decoding error */
+                Free(decoded);
+                return NULL;
+            }
+
+            if (!d)
+            {
+                /* Null character given, don't put that in the string. */
+                continue;
+            }
+
+            c = (char) d;
+
+            str++;
+        }
+
+        decoded[i] = c;
+        i++;
+
+        str++;
+    }
+
+    decoded[i] = '\0';
+
+    return decoded;
+}
+
+HashMap *
+HttpParamDecode(char *in)
+{
+    HashMap *params;
+
+    if (!in)
+    {
+        return NULL;
+    }
+
+    params = HashMapCreate();
+    if (!params)
+    {
+        return NULL;
+    }
+
+    while (*in)
+    {
+        char *buf;
+        size_t allocated;
+        size_t len;
+
+        char *decKey;
+        char *decVal;
+
+        /* Read in key */
+
+        allocated = CYTOPLASM_STRING_CHUNK;
+        buf = Malloc(allocated);
+        len = 0;
+
+        while (*in && *in != '=')
+        {
+            if (len >= allocated - 1)
+            {
+                allocated += CYTOPLASM_STRING_CHUNK;
+                buf = Realloc(buf, allocated);
+            }
+
+            buf[len] = *in;
+            len++;
+            in++;
+        }
+
+        buf[len] = '\0';
+
+        /* Sanity check */
+        if (*in != '=')
+        {
+            /* Malformed param */
+            Free(buf);
+            HashMapFree(params);
+            return NULL;
+        }
+
+        in++;
+
+        /* Decode key */
+        decKey = HttpUrlDecode(buf);
+        Free(buf);
+
+        if (!decKey)
+        {
+            /* Decoding error */
+            HashMapFree(params);
+            return NULL;
+        }
+
+        /* Read in value */
+        allocated = CYTOPLASM_STRING_CHUNK;
+        buf = Malloc(allocated);
+        len = 0;
+
+        while (*in && *in != '&')
+        {
+            if (len >= allocated - 1)
+            {
+                allocated += CYTOPLASM_STRING_CHUNK;
+                buf = Realloc(buf, allocated);
+            }
+
+            buf[len] = *in;
+            len++;
+            in++;
+        }
+
+        buf[len] = '\0';
+
+        /* Decode value */
+        decVal = HttpUrlDecode(buf);
+        Free(buf);
+
+        if (!decVal)
+        {
+            /* Decoding error */
+            HashMapFree(params);
+            return NULL;
+        }
+
+        buf = HashMapSet(params, decKey, decVal);
+        if (buf)
+        {
+            Free(buf);
+        }
+        Free(decKey);
+
+        if (*in == '&')
+        {
+            in++;
+            continue;
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    return params;
+}
+
+char *
+HttpParamEncode(HashMap * params)
+{
+    char *key;
+    char *val;
+    char *out = NULL;
+
+    if (!params || !out)
+    {
+        return NULL;
+    }
+
+    while (HashMapIterate(params, &key, (void *) &val))
+    {
+        char *encKey;
+        char *encVal;
+
+        encKey = HttpUrlEncode(key);
+        encVal = HttpUrlEncode(val);
+
+        if (!encKey || !encVal)
+        {
+            /* Memory error */
+            Free(encKey);
+            Free(encVal);
+            return NULL;
+        }
+
+        /* TODO */
+
+        Free(encKey);
+        Free(encVal);
+    }
+
+    return out;
+}
+
+HashMap *
+HttpParseHeaders(Stream * fp)
+{
+    HashMap *headers;
+
+    char *line;
+    ssize_t lineLen;
+    size_t lineSize;
+
+    char *headerKey;
+    char *headerValue;
+
+    if (!fp)
+    {
+        return NULL;
+    }
+
+
+    headers = HashMapCreate();
+    if (!headers)
+    {
+        return NULL;
+    }
+
+    line = NULL;
+    lineLen = 0;
+
+    while ((lineLen = UtilGetLine(&line, &lineSize, fp)) != -1)
+    {
+        char *headerPtr;
+
+        ssize_t i;
+        size_t len;
+
+        if (StrEquals(line, "\r\n") || StrEquals(line, "\n"))
+        {
+            break;
+        }
+
+        for (i = 0; i < lineLen; i++)
+        {
+            if (line[i] == ':')
+            {
+                line[i] = '\0';
+                break;
+            }
+
+            line[i] = tolower((unsigned char) line[i]);
+        }
+
+        len = i + 1;
+        headerKey = Malloc(len * sizeof(char));
+        if (!headerKey)
+        {
+            goto error;
+        }
+
+        strncpy(headerKey, line, len);
+
+        headerPtr = line + i + 1;
+
+        while (isspace((unsigned char) *headerPtr))
+        {
+            headerPtr++;
+        }
+
+        for (i = lineLen - 1; i > (line + lineLen) - headerPtr; i--)
+        {
+            if (!isspace((unsigned char) line[i]))
+            {
+                break;
+            }
+            line[i] = '\0';
+        }
+
+        len = strlen(headerPtr) + 1;
+        headerValue = Malloc(len * sizeof(char));
+        if (!headerValue)
+        {
+            Free(headerKey);
+            goto error;
+        }
+
+        strncpy(headerValue, headerPtr, len);
+
+        HashMapSet(headers, headerKey, headerValue);
+        Free(headerKey);
+    }
+
+    Free(line);
+    return headers;
+
+error:
+    Free(line);
+
+    while (HashMapIterate(headers, &headerKey, (void **) &headerValue))
+    {
+        Free(headerValue);
+    }
+
+    HashMapFree(headers);
+
+    return NULL;
+}

src/HttpClient.c

@@ -0,0 +1,298 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <HttpClient.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include <unistd.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+
+#include <Http.h>
+#include <Memory.h>
+#include <Util.h>
+#include <Tls.h>
+
+struct HttpClientContext
+{
+    HashMap *responseHeaders;
+    Stream *stream;
+};
+
+HttpClientContext *
+HttpRequest(HttpRequestMethod method, int flags, unsigned short port, char *host, char *path)
+{
+    HttpClientContext *context;
+
+    int sd = -1;
+    struct addrinfo hints, *res, *res0;
+    int error;
+
+    char serv[8];
+
+    if (!method || !host || !path)
+    {
+        return NULL;
+    }
+
+#ifndef TLS_IMPL
+    if (flags & HTTP_FLAG_TLS)
+    {
+        return NULL;
+    }
+#endif
+
+    if (!port)
+    {
+        if (flags & HTTP_FLAG_TLS)
+        {
+            strcpy(serv, "https");
+        }
+        else
+        {
+            strcpy(serv, "www");
+        }
+    }
+    else
+    {
+        snprintf(serv, sizeof(serv), "%hu", port);
+    }
+
+
+    context = Malloc(sizeof(HttpClientContext));
+    if (!context)
+    {
+        return NULL;
+    }
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+    error = getaddrinfo(host, serv, &hints, &res0);
+
+    if (error)
+    {
+        Free(context);
+        return NULL;
+    }
+
+    for (res = res0; res; res = res->ai_next)
+    {
+        sd = socket(res->ai_family, res->ai_socktype,
+                    res->ai_protocol);
+
+        if (sd < 0)
+        {
+            continue;
+        }
+
+        if (connect(sd, res->ai_addr, res->ai_addrlen) < 0)
+        {
+            close(sd);
+            sd = -1;
+            continue;
+        }
+
+        break;
+    }
+
+    if (sd < 0)
+    {
+        Free(context);
+        return NULL;
+    }
+
+    freeaddrinfo(res0);
+
+#ifdef TLS_IMPL
+    if (flags & HTTP_FLAG_TLS)
+    {
+        context->stream = TlsClientStream(sd, host);
+    }
+    else
+    {
+        context->stream = StreamFd(sd);
+    }
+#else
+    context->stream = StreamFd(sd);
+#endif
+
+    if (!context->stream)
+    {
+        Free(context);
+        close(sd);
+        return NULL;
+    }
+
+    StreamPrintf(context->stream, "%s %s HTTP/1.0\r\n",
+                 HttpRequestMethodToString(method), path);
+
+    HttpRequestHeader(context, "Connection", "close");
+    HttpRequestHeader(context, "User-Agent", LIB_NAME "/" LIB_VERSION);
+    HttpRequestHeader(context, "Host", host);
+
+    return context;
+}
+
+void
+HttpRequestHeader(HttpClientContext * context, char *key, char *val)
+{
+    if (!context || !key || !val)
+    {
+        return;
+    }
+
+    StreamPrintf(context->stream, "%s: %s\r\n", key, val);
+}
+
+void
+HttpRequestSendHeaders(HttpClientContext * context)
+{
+    if (!context)
+    {
+        return;
+    }
+
+    StreamPuts(context->stream, "\r\n");
+    StreamFlush(context->stream);
+}
+
+HttpStatus
+HttpRequestSend(HttpClientContext * context)
+{
+    HttpStatus status;
+
+    char *line = NULL;
+    ssize_t lineLen;
+    size_t lineSize = 0;
+    char *tmp;
+
+    if (!context)
+    {
+        return 0;
+    }
+
+    StreamFlush(context->stream);
+
+    lineLen = UtilGetLine(&line, &lineSize, context->stream);
+
+    while (lineLen == -1 && errno == EAGAIN)
+    {
+        StreamClearError(context->stream);
+        lineLen = UtilGetLine(&line, &lineSize, context->stream);
+    }
+
+    if (lineLen == -1)
+    {
+        return 0;
+    }
+
+    /* Line must contain at least "HTTP/x.x xxx" */
+    if (lineLen < 12)
+    {
+        return 0;
+    }
+
+    if (!(strncmp(line, "HTTP/1.0", 8) == 0 ||
+          strncmp(line, "HTTP/1.1", 8) == 0))
+    {
+        return 0;
+    }
+
+    tmp = line + 9;
+
+    while (isspace((unsigned char) *tmp) && *tmp != '\0')
+    {
+        tmp++;
+    }
+
+    if (!*tmp)
+    {
+        return 0;
+    }
+
+    status = atoi(tmp);
+
+    if (!status)
+    {
+        return 0;
+    }
+
+    context->responseHeaders = HttpParseHeaders(context->stream);
+    if (!context->responseHeaders)
+    {
+        return 0;
+    }
+
+    return status;
+}
+
+HashMap *
+HttpResponseHeaders(HttpClientContext * context)
+{
+    if (!context)
+    {
+        return NULL;
+    }
+
+    return context->responseHeaders;
+}
+
+Stream *
+HttpClientStream(HttpClientContext * context)
+{
+    if (!context)
+    {
+        return NULL;
+    }
+
+    return context->stream;
+}
+
+void
+HttpClientContextFree(HttpClientContext * context)
+{
+    char *key;
+    void *val;
+
+    if (!context)
+    {
+        return;
+    }
+
+    while (HashMapIterate(context->responseHeaders, &key, &val))
+    {
+        Free(val);
+    }
+
+    HashMapFree(context->responseHeaders);
+
+    StreamClose(context->stream);
+    Free(context);
+}

src/HttpRouter.c

@@ -0,0 +1,296 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <HttpRouter.h>
+
+#include <Memory.h>
+#include <HashMap.h>
+#include <Str.h>
+
+#include <regex.h>
+#include <string.h>
+
+#define REG_FLAGS (REG_EXTENDED)
+#define REG_MAX_SUB 8
+
+typedef struct RouteNode
+{
+    HttpRouteFunc *exec;
+    HashMap *children;
+
+    regex_t regex;
+} RouteNode;
+
+struct HttpRouter
+{
+    RouteNode *root;
+};
+
+static RouteNode *
+RouteNodeCreate(char *regex, HttpRouteFunc * exec)
+{
+    RouteNode *node;
+
+    if (!regex)
+    {
+        return NULL;
+    }
+
+    node = Malloc(sizeof(RouteNode));
+
+    if (!node)
+    {
+        return NULL;
+    }
+
+    node->children = HashMapCreate();
+    if (!node->children)
+    {
+        Free(node);
+        return NULL;
+    }
+
+    /* Force the regex to match the entire path part exactly. */
+    regex = StrConcat(3, "^", regex, "$");
+    if (!regex)
+    {
+        Free(node);
+        return NULL;
+    }
+
+    if (regcomp(&node->regex, regex, REG_FLAGS) != 0)
+    {
+        HashMapFree(node->children);
+        Free(node);
+        Free(regex);
+        return NULL;
+    }
+
+    node->exec = exec;
+
+    Free(regex);
+    return node;
+}
+
+static void
+RouteNodeFree(RouteNode * node)
+{
+    char *key;
+    RouteNode *val;
+
+    if (!node)
+    {
+        return;
+    }
+
+    while (HashMapIterate(node->children, &key, (void **) &val))
+    {
+        RouteNodeFree(val);
+    }
+
+    HashMapFree(node->children);
+
+    regfree(&node->regex);
+
+    Free(node);
+}
+
+HttpRouter *
+HttpRouterCreate(void)
+{
+    HttpRouter *router = Malloc(sizeof(HttpRouter));
+
+    if (!router)
+    {
+        return NULL;
+    }
+
+    router->root = RouteNodeCreate("/", NULL);
+
+    return router;
+}
+
+void
+HttpRouterFree(HttpRouter * router)
+{
+    if (!router)
+    {
+        return;
+    }
+
+    RouteNodeFree(router->root);
+    Free(router);
+}
+
+int
+HttpRouterAdd(HttpRouter * router, char *regPath, HttpRouteFunc * exec)
+{
+    RouteNode *node;
+    char *pathPart;
+    char *tmp;
+
+    if (!router || !regPath || !exec)
+    {
+        return 0;
+    }
+
+    if (StrEquals(regPath, "/"))
+    {
+        router->root->exec = exec;
+        return 1;
+    }
+
+    regPath = StrDuplicate(regPath);
+    if (!regPath)
+    {
+        return 0;
+    }
+
+    tmp = regPath;
+    node = router->root;
+
+    while ((pathPart = strtok_r(tmp, "/", &tmp)))
+    {
+        RouteNode *tNode = HashMapGet(node->children, pathPart);
+
+        if (!tNode)
+        {
+            tNode = RouteNodeCreate(pathPart, NULL);
+            RouteNodeFree(HashMapSet(node->children, pathPart, tNode));
+        }
+
+        node = tNode;
+    }
+
+    node->exec = exec;
+
+    Free(regPath);
+
+    return 1;
+}
+
+int
+HttpRouterRoute(HttpRouter * router, char *path, void *args, void **ret)
+{
+    RouteNode *node;
+    char *pathPart;
+    char *tmp;
+    HttpRouteFunc *exec = NULL;
+    Array *matches;
+    size_t i;
+    int retval;
+
+    if (!router || !path)
+    {
+        return 0;
+    }
+
+    matches = ArrayCreate();
+    if (!matches)
+    {
+        return 0;
+    }
+
+    node = router->root;
+
+    if (StrEquals(path, "/"))
+    {
+        exec = node->exec;
+    }
+    else
+    {
+        path = StrDuplicate(path);
+        tmp = path;
+        while ((pathPart = strtok_r(tmp, "/", &tmp)))
+        {
+            char *key;
+            RouteNode *val = NULL;
+
+            regmatch_t pmatch[REG_MAX_SUB];
+
+            i = 0;
+
+            while (HashMapIterateReentrant(node->children, &key, (void **) &val, &i))
+            {
+                if (regexec(&val->regex, pathPart, REG_MAX_SUB, pmatch, 0) == 0)
+                {
+                    break;
+                }
+
+                val = NULL;
+            }
+
+            if (!val)
+            {
+                exec = NULL;
+                break;
+            }
+
+            node = val;
+            exec = node->exec;
+
+            /* If we want to pass an arg, the match must be in parens */
+            if (val->regex.re_nsub)
+            {
+                /* pmatch[0] is the whole string, not the first
+                 * subexpression */
+                for (i = 1; i < REG_MAX_SUB; i++)
+                {
+                    if (pmatch[i].rm_so == -1)
+                    {
+                        break;
+                    }
+
+                    ArrayAdd(matches, StrSubstr(pathPart, pmatch[i].rm_so, pmatch[i].rm_eo));
+                }
+            }
+        }
+        Free(path);
+    }
+
+    if (!exec)
+    {
+        retval = 0;
+        goto finish;
+    }
+
+    if (ret)
+    {
+        *ret = exec(matches, args);
+    }
+    else
+    {
+        exec(matches, args);
+    }
+
+    retval = 1;
+
+finish:
+    for (i = 0; i < ArraySize(matches); i++)
+    {
+        Free(ArrayGet(matches, i));
+    }
+    ArrayFree(matches);
+
+    return retval;
+}

src/HttpServer.c

@@ -0,0 +1,753 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <HttpServer.h>
+#include <Memory.h>
+#include <Queue.h>
+#include <Array.h>
+#include <Util.h>
+#include <Tls.h>
+#include <Log.h>
+#include <Str.h>
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <poll.h>
+#include <string.h>
+#include <ctype.h>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+
+#include <errno.h>
+
+static const char ENABLE = 1;
+
+struct HttpServer
+{
+    HttpServerConfig config;
+    int sd;
+    pthread_t socketThread;
+
+    volatile unsigned int stop:1;
+    volatile unsigned int isRunning:1;
+
+    Queue *connQueue;
+    pthread_mutex_t connQueueMutex;
+
+    Array *threadPool;
+};
+
+struct HttpServerContext
+{
+    HashMap *requestHeaders;
+    HttpRequestMethod requestMethod;
+    char *requestPath;
+    HashMap *requestParams;
+
+    HashMap *responseHeaders;
+    HttpStatus responseStatus;
+
+    Stream *stream;
+};
+
+typedef struct HttpServerWorkerThreadArgs
+{
+    HttpServer *server;
+    int id;
+    pthread_t thread;
+} HttpServerWorkerThreadArgs;
+
+static HttpServerContext *
+HttpServerContextCreate(HttpRequestMethod requestMethod,
+          char *requestPath, HashMap * requestParams, Stream * stream)
+{
+    HttpServerContext *c;
+
+    c = Malloc(sizeof(HttpServerContext));
+    if (!c)
+    {
+        return NULL;
+    }
+
+    c->responseHeaders = HashMapCreate();
+    if (!c->responseHeaders)
+    {
+        Free(c->requestHeaders);
+        Free(c);
+        return NULL;
+    }
+
+    c->requestMethod = requestMethod;
+    c->requestPath = requestPath;
+    c->requestParams = requestParams;
+    c->stream = stream;
+    c->responseStatus = HTTP_OK;
+
+    return c;
+}
+
+static void
+HttpServerContextFree(HttpServerContext * c)
+{
+    char *key;
+    void *val;
+
+    if (!c)
+    {
+        return;
+    }
+
+    while (HashMapIterate(c->requestHeaders, &key, &val))
+    {
+        Free(val);
+    }
+    HashMapFree(c->requestHeaders);
+
+    while (HashMapIterate(c->responseHeaders, &key, &val))
+    {
+        /*
+         * These are generated by code. As such, they may be either
+         * on the heap, or on the stack, depending on how they were
+         * added.
+         *
+         * Basically, if the memory API knows about a pointer, then
+         * it can be freed. If it doesn't know about a pointer, skip
+         * freeing it because it's probably a stack pointer.
+         */
+
+        if (MemoryInfoGet(val))
+        {
+            Free(val);
+        }
+    }
+
+    HashMapFree(c->responseHeaders);
+
+    while (HashMapIterate(c->requestParams, &key, &val))
+    {
+        Free(val);
+    }
+
+    HashMapFree(c->requestParams);
+
+    Free(c->requestPath);
+    StreamClose(c->stream);
+
+    Free(c);
+}
+
+HashMap *
+HttpRequestHeaders(HttpServerContext * c)
+{
+    if (!c)
+    {
+        return NULL;
+    }
+
+    return c->requestHeaders;
+}
+
+HttpRequestMethod
+HttpRequestMethodGet(HttpServerContext * c)
+{
+    if (!c)
+    {
+        return HTTP_METHOD_UNKNOWN;
+    }
+
+    return c->requestMethod;
+}
+
+char *
+HttpRequestPath(HttpServerContext * c)
+{
+    if (!c)
+    {
+        return NULL;
+    }
+
+    return c->requestPath;
+}
+
+HashMap *
+HttpRequestParams(HttpServerContext * c)
+{
+    if (!c)
+    {
+        return NULL;
+    }
+
+    return c->requestParams;
+}
+
+char *
+HttpResponseHeader(HttpServerContext * c, char *key, char *val)
+{
+    if (!c)
+    {
+        return NULL;
+    }
+
+    return HashMapSet(c->responseHeaders, key, val);
+}
+
+void
+HttpResponseStatus(HttpServerContext * c, HttpStatus status)
+{
+    if (!c)
+    {
+        return;
+    }
+
+    c->responseStatus = status;
+}
+
+HttpStatus
+HttpResponseStatusGet(HttpServerContext * c)
+{
+    if (!c)
+    {
+        return HTTP_STATUS_UNKNOWN;
+    }
+
+    return c->responseStatus;
+}
+
+Stream *
+HttpServerStream(HttpServerContext * c)
+{
+    if (!c)
+    {
+        return NULL;
+    }
+
+    return c->stream;
+}
+
+void
+HttpSendHeaders(HttpServerContext * c)
+{
+    Stream *fp = c->stream;
+
+    char *key;
+    char *val;
+
+    StreamPrintf(fp, "HTTP/1.0 %d %s\n", c->responseStatus, HttpStatusToString(c->responseStatus));
+
+    while (HashMapIterate(c->responseHeaders, &key, (void **) &val))
+    {
+        StreamPrintf(fp, "%s: %s\n", key, val);
+    }
+
+    StreamPuts(fp, "\n");
+}
+
+static Stream *
+DequeueConnection(HttpServer * server)
+{
+    Stream *fp;
+
+    if (!server)
+    {
+        return NULL;
+    }
+
+    pthread_mutex_lock(&server->connQueueMutex);
+    fp = QueuePop(server->connQueue);
+    pthread_mutex_unlock(&server->connQueueMutex);
+
+    return fp;
+}
+
+HttpServer *
+HttpServerCreate(HttpServerConfig * config)
+{
+    HttpServer *server;
+    struct sockaddr_in sa;
+
+    if (!config)
+    {
+        return NULL;
+    }
+
+    if (!config->handler)
+    {
+        return NULL;
+    }
+
+#ifndef TLS_IMPL
+    if (config->flags & HTTP_FLAG_TLS)
+    {
+        return NULL;
+    }
+#endif
+
+    server = Malloc(sizeof(HttpServer));
+    if (!server)
+    {
+        goto error;
+    }
+
+    memset(server, 0, sizeof(HttpServer));
+
+    server->config = *config;
+    server->config.tlsCert = StrDuplicate(config->tlsCert);
+    server->config.tlsKey = StrDuplicate(config->tlsKey);
+
+    server->threadPool = ArrayCreate();
+    if (!server->threadPool)
+    {
+        goto error;
+    }
+
+    server->connQueue = QueueCreate(config->maxConnections);
+    if (!server->connQueue)
+    {
+        goto error;
+    }
+
+    if (pthread_mutex_init(&server->connQueueMutex, NULL) != 0)
+    {
+        goto error;
+    }
+
+    server->sd = socket(AF_INET, SOCK_STREAM, 0);
+
+    if (server->sd < 0)
+    {
+        goto error;
+    }
+
+    if (fcntl(server->sd, F_SETFL, O_NONBLOCK) == -1)
+    {
+        goto error;
+    }
+
+    if (setsockopt(server->sd, SOL_SOCKET, SO_REUSEADDR, &ENABLE, sizeof(int)) < 0)
+    {
+        goto error;
+    }
+
+#ifdef SO_REUSEPORT
+    if (setsockopt(server->sd, SOL_SOCKET, SO_REUSEPORT, &ENABLE, sizeof(int)) < 0)
+    {
+        goto error;
+    }
+#endif
+
+    memset(&sa, 0, sizeof(struct sockaddr_in));
+
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(config->port);
+    sa.sin_addr.s_addr = htonl(INADDR_ANY);
+
+    if (bind(server->sd, (struct sockaddr *) & sa, sizeof(sa)) < 0)
+    {
+        goto error;
+    }
+
+    if (listen(server->sd, config->maxConnections) < 0)
+    {
+        goto error;
+    }
+
+    server->stop = 0;
+    server->isRunning = 0;
+
+    return server;
+
+error:
+    if (server)
+    {
+        if (server->connQueue)
+        {
+            QueueFree(server->connQueue);
+        }
+
+        pthread_mutex_destroy(&server->connQueueMutex);
+
+        if (server->threadPool)
+        {
+            ArrayFree(server->threadPool);
+        }
+
+        if (server->sd)
+        {
+            close(server->sd);
+        }
+
+        Free(server);
+    }
+    return NULL;
+}
+
+HttpServerConfig *
+HttpServerConfigGet(HttpServer * server)
+{
+    if (!server)
+    {
+        return NULL;
+    }
+
+    return &server->config;
+}
+
+void
+HttpServerFree(HttpServer * server)
+{
+    if (!server)
+    {
+        return;
+    }
+
+    close(server->sd);
+    QueueFree(server->connQueue);
+    pthread_mutex_destroy(&server->connQueueMutex);
+    ArrayFree(server->threadPool);
+    Free(server->config.tlsCert);
+    Free(server->config.tlsKey);
+    Free(server);
+}
+
+static void *
+HttpServerWorkerThread(void *args)
+{
+    HttpServerWorkerThreadArgs *wArgs = (HttpServerWorkerThreadArgs *) args;
+    HttpServer *server = wArgs->server;
+
+    while (!server->stop)
+    {
+        Stream *fp;
+        HttpServerContext *context;
+
+        char *line = NULL;
+        size_t lineSize = 0;
+        ssize_t lineLen = 0;
+
+        char *requestMethodPtr;
+        char *pathPtr;
+        char *requestPath;
+        char *requestProtocol;
+
+        HashMap *requestParams;
+        ssize_t requestPathLen;
+
+        ssize_t i = 0;
+        HttpRequestMethod requestMethod;
+
+        long firstRead;
+
+        fp = DequeueConnection(server);
+
+        if (!fp)
+        {
+            /* Block for 1 millisecond before continuing so we don't
+             * murder the CPU if the queue is empty. */
+            UtilSleepMillis(1);
+            continue;
+        }
+
+        /* Get the first line of the request.
+         * 
+         * Every once in a while, we're too fast for the client. When this
+         * happens, UtilGetLine() sets errno to EAGAIN. If we get
+         * EAGAIN, then clear the error on the stream and try again
+         * after a few ms. This is typically more than enough time for
+         * the client to send data. */
+        firstRead = UtilServerTs();
+        while ((lineLen = UtilGetLine(&line, &lineSize, fp)) == -1
+               && errno == EAGAIN)
+        {
+            StreamClearError(fp);
+
+            /* If the server is stopped, or it's been a while, just
+             * give up so we aren't wasting a thread on this client. */
+            if (server->stop || (UtilServerTs() - firstRead) > 1000 * 30)
+            {
+                goto finish;
+            }
+
+            UtilSleepMillis(5);
+        }
+
+        if (lineLen == -1)
+        {
+            goto bad_request;
+        }
+
+        requestMethodPtr = line;
+        for (i = 0; i < lineLen; i++)
+        {
+            if (line[i] == ' ')
+            {
+                line[i] = '\0';
+                break;
+            }
+        }
+
+        if (i == lineLen)
+        {
+            goto bad_request;
+        }
+
+        requestMethod = HttpRequestMethodFromString(requestMethodPtr);
+        if (requestMethod == HTTP_METHOD_UNKNOWN)
+        {
+            goto bad_request;
+        }
+
+        pathPtr = line + i + 1;
+
+        for (i = 0; i < (line + lineLen) - pathPtr; i++)
+        {
+            if (pathPtr[i] == ' ')
+            {
+                pathPtr[i] = '\0';
+                break;
+            }
+        }
+
+        requestPathLen = i;
+        requestPath = Malloc(((requestPathLen + 1) * sizeof(char)));
+        strncpy(requestPath, pathPtr, requestPathLen + 1);
+
+        requestProtocol = &pathPtr[i + 1];
+        line[lineLen - 2] = '\0';  /* Get rid of \r and \n */
+
+        if (!StrEquals(requestProtocol, "HTTP/1.1") && !StrEquals(requestProtocol, "HTTP/1.0"))
+        {
+            Free(requestPath);
+            goto bad_request;
+        }
+
+        /* Find request params */
+        for (i = 0; i < requestPathLen; i++)
+        {
+            if (requestPath[i] == '?')
+            {
+                break;
+            }
+        }
+
+        requestPath[i] = '\0';
+        requestParams = (i == requestPathLen) ? NULL : HttpParamDecode(requestPath + i + 1);
+
+        context = HttpServerContextCreate(requestMethod, requestPath, requestParams, fp);
+        if (!context)
+        {
+            Free(requestPath);
+            goto internal_error;
+        }
+
+        context->requestHeaders = HttpParseHeaders(fp);
+        if (!context->requestHeaders)
+        {
+            goto internal_error;
+        }
+
+        server->config.handler(context, server->config.handlerArgs);
+
+        HttpServerContextFree(context);
+        fp = NULL;                 /* The above call will close this
+                                    * Stream */
+        goto finish;
+
+internal_error:
+        StreamPuts(fp, "HTTP/1.0 500 Internal Server Error\n");
+        StreamPuts(fp, "Connection: close\n");
+        goto finish;
+
+bad_request:
+        StreamPuts(fp, "HTTP/1.0 400 Bad Request\n");
+        StreamPuts(fp, "Connection: close\n");
+        goto finish;
+
+finish:
+        Free(line);
+        if (fp)
+        {
+            StreamClose(fp);
+        }
+    }
+
+    return NULL;
+}
+
+static void *
+HttpServerEventThread(void *args)
+{
+    HttpServer *server = (HttpServer *) args;
+    struct pollfd pollFds[1];
+    Stream *fp;
+    size_t i;
+
+    server->isRunning = 1;
+    server->stop = 0;
+
+    pollFds[0].fd = server->sd;
+    pollFds[0].events = POLLIN;
+
+    for (i = 0; i < server->config.threads; i++)
+    {
+        HttpServerWorkerThreadArgs *workerThread = Malloc(sizeof(HttpServerWorkerThreadArgs));
+
+        if (!workerThread)
+        {
+            /* TODO: Make the event thread return an error to the main
+             * thread */
+            return NULL;
+        }
+
+        workerThread->server = server;
+        workerThread->id = i;
+
+        if (pthread_create(&workerThread->thread, NULL, HttpServerWorkerThread, workerThread) != 0)
+        {
+            /* TODO: Make the event thread return an error to the main
+             * thread */
+            return NULL;
+        }
+
+        ArrayAdd(server->threadPool, workerThread);
+    }
+
+    while (!server->stop)
+    {
+        struct sockaddr_storage addr;
+        socklen_t addrLen = sizeof(addr);
+        int connFd;
+        int pollResult;
+
+
+        pollResult = poll(pollFds, 1, 500);
+
+        if (pollResult < 0)
+        {
+            /* The poll either timed out, or was interrupted. */
+            continue;
+        }
+
+        pthread_mutex_lock(&server->connQueueMutex);
+
+        /* Don't even accept connections if the queue is full. */
+        if (!QueueFull(server->connQueue))
+        {
+            connFd = accept(server->sd, (struct sockaddr *) & addr, &addrLen);
+
+            if (connFd < 0)
+            {
+                pthread_mutex_unlock(&server->connQueueMutex);
+                continue;
+            }
+
+#ifdef TLS_IMPL
+            if (server->config.flags & HTTP_FLAG_TLS)
+            {
+                fp = TlsServerStream(connFd, server->config.tlsCert, server->config.tlsKey);
+            }
+            else
+            {
+                fp = StreamFd(connFd);
+            }
+#else
+            fp = StreamFd(connFd);
+#endif
+
+            if (!fp)
+            {
+                pthread_mutex_unlock(&server->connQueueMutex);
+                close(connFd);
+                continue;
+            }
+
+            QueuePush(server->connQueue, fp);
+        }
+        pthread_mutex_unlock(&server->connQueueMutex);
+    }
+
+    for (i = 0; i < server->config.threads; i++)
+    {
+        HttpServerWorkerThreadArgs *workerThread = ArrayGet(server->threadPool, i);
+
+        pthread_join(workerThread->thread, NULL);
+        Free(workerThread);
+    }
+
+    while ((fp = DequeueConnection(server)))
+    {
+        StreamClose(fp);
+    }
+
+    server->isRunning = 0;
+
+    return NULL;
+}
+
+int
+HttpServerStart(HttpServer * server)
+{
+    if (!server)
+    {
+        return 0;
+    }
+
+    if (server->isRunning)
+    {
+        return 1;
+    }
+
+    if (pthread_create(&server->socketThread, NULL, HttpServerEventThread, server) != 0)
+    {
+        return 0;
+    }
+
+    return 1;
+}
+
+void
+HttpServerJoin(HttpServer * server)
+{
+    if (!server)
+    {
+        return;
+    }
+
+    pthread_join(server->socketThread, NULL);
+}
+
+void
+HttpServerStop(HttpServer * server)
+{
+    if (!server)
+    {
+        return;
+    }
+
+    server->stop = 1;
+}

src/Io.c

@@ -0,0 +1,212 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Io.h>
+
+#include <Memory.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <fcntl.h>
+
+struct Io
+{
+    IoFunctions io;
+    void *cookie;
+};
+
+Io *
+IoCreate(void *cookie, IoFunctions funcs)
+{
+    Io *io;
+
+    /* Must have at least read or write */
+    if (!funcs.read && !funcs.write)
+    {
+        return NULL;
+    }
+
+    io = Malloc(sizeof(Io));
+
+    if (!io)
+    {
+        return NULL;
+    }
+
+    io->cookie = cookie;
+
+    io->io.read = funcs.read;
+    io->io.write = funcs.write;
+    io->io.seek = funcs.seek;
+    io->io.close = funcs.close;
+
+    return io;
+}
+
+ssize_t
+IoRead(Io * io, void *buf, size_t nBytes)
+{
+    if (!io || !io->io.read)
+    {
+        errno = EBADF;
+        return -1;
+    }
+
+    return io->io.read(io->cookie, buf, nBytes);
+}
+
+ssize_t
+IoWrite(Io * io, void *buf, size_t nBytes)
+{
+    if (!io || !io->io.write)
+    {
+        errno = EBADF;
+        return -1;
+    }
+
+    return io->io.write(io->cookie, buf, nBytes);
+}
+
+off_t
+IoSeek(Io * io, off_t offset, int whence)
+{
+    if (!io)
+    {
+        errno = EBADF;
+        return -1;
+    }
+
+    if (!io->io.seek)
+    {
+        errno = EINVAL;
+        return -1;
+    }
+
+    return io->io.seek(io->cookie, offset, whence);
+}
+
+int
+IoClose(Io * io)
+{
+    int ret;
+
+    if (!io)
+    {
+        errno = EBADF;
+        return -1;
+    }
+
+    if (io->io.close)
+    {
+        ret = io->io.close(io->cookie);
+    }
+    else
+    {
+        ret = 0;
+    }
+
+    Free(io);
+
+    return ret;
+}
+
+int
+IoVprintf(Io * io, const char *fmt, va_list ap)
+{
+    char *buf = NULL;
+    size_t bufSize = 0;
+    FILE *fp;
+
+    int ret;
+
+    if (!io || !fmt)
+    {
+        return -1;
+    }
+
+    fp = open_memstream(&buf, &bufSize);
+    if (!fp)
+    {
+        return -1;
+    }
+
+    ret = vfprintf(fp, fmt, ap);
+    fclose(fp);
+
+    if (ret >= 0)
+    {
+        ret = IoWrite(io, buf, bufSize);
+    }
+
+    free(buf);                     /* Allocated by stdlib, not Memory
+                                    * API */
+    return ret;
+}
+
+int
+IoPrintf(Io * io, const char *fmt,...)
+{
+    va_list ap;
+    int ret;
+
+    va_start(ap, fmt);
+    ret = IoVprintf(io, fmt, ap);
+    va_end(ap);
+
+    return ret;
+}
+
+ssize_t
+IoCopy(Io * in, Io * out)
+{
+    ssize_t nBytes = 0;
+    char buf[IO_BUFFER];
+    ssize_t rRes;
+    ssize_t wRes;
+
+    if (!in || !out)
+    {
+        errno = EBADF;
+        return -1;
+    }
+
+    while ((rRes = IoRead(in, &buf, IO_BUFFER)) != 0)
+    {
+        if (rRes == -1)
+        {
+            return -1;
+        }
+
+        wRes = IoWrite(out, &buf, rRes);
+
+        if (wRes == -1)
+        {
+            return -1;
+        }
+
+        nBytes += wRes;
+    }
+
+    return nBytes;
+}

src/Io/IoFd.c

@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Io.h>
+
+#include <Memory.h>
+
+#include <fcntl.h>
+
+static ssize_t
+IoReadFd(void *cookie, void *buf, size_t nBytes)
+{
+    int fd = *((int *) cookie);
+
+    return read(fd, buf, nBytes);
+}
+
+static ssize_t
+IoWriteFd(void *cookie, void *buf, size_t nBytes)
+{
+    int fd = *((int *) cookie);
+
+    return write(fd, buf, nBytes);
+}
+
+static off_t
+IoSeekFd(void *cookie, off_t offset, int whence)
+{
+    int fd = *((int *) cookie);
+
+    return lseek(fd, offset, whence);
+}
+
+static int
+IoCloseFd(void *cookie)
+{
+    int fd = *((int *) cookie);
+
+    Free(cookie);
+    return close(fd);
+}
+
+Io *
+IoFd(int fd)
+{
+    int *cookie = Malloc(sizeof(int));
+    IoFunctions f;
+
+    if (!cookie)
+    {
+        return NULL;
+    }
+
+    *cookie = fd;
+
+    f.read = IoReadFd;
+    f.write = IoWriteFd;
+    f.seek = IoSeekFd;
+    f.close = IoCloseFd;
+
+    return IoCreate(cookie, f);
+}
+
+Io *
+IoOpen(const char *path, int flags, mode_t mode)
+{
+    int fd = open(path, flags, mode);
+
+    if (fd == -1)
+    {
+        return NULL;
+    }
+
+    return IoFd(fd);
+}

src/Io/IoFile.c

@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Io.h>
+
+#include <stdio.h>
+
+static ssize_t
+IoReadFile(void *cookie, void *buf, size_t nBytes)
+{
+    FILE *fp = cookie;
+
+    return fread(buf, 1, nBytes, fp);
+}
+
+static ssize_t
+IoWriteFile(void *cookie, void *buf, size_t nBytes)
+{
+    FILE *fp = cookie;
+    size_t res = fwrite(buf, 1, nBytes, fp);
+
+    /*
+     * fwrite() may be buffered on some platforms, but at this low level,
+     * it should not be; buffering happens in Stream, not Io.
+     */
+    fflush(fp);
+
+    return res;
+}
+
+static off_t
+IoSeekFile(void *cookie, off_t offset, int whence)
+{
+    FILE *fp = cookie;
+    off_t ret = fseeko(fp, offset, whence);
+
+    if (ret > -1)
+    {
+        return ftello(fp);
+    }
+    else
+    {
+        return ret;
+    }
+}
+
+static int
+IoCloseFile(void *cookie)
+{
+    FILE *fp = cookie;
+
+    return fclose(fp);
+}
+
+Io *
+IoFile(FILE * fp)
+{
+    IoFunctions f;
+
+    if (!fp)
+    {
+        return NULL;
+    }
+
+    f.read = IoReadFile;
+    f.write = IoWriteFile;
+    f.seek = IoSeekFile;
+    f.close = IoCloseFile;
+
+    return IoCreate(fp, f);
+}

src/Log.c

@@ -0,0 +1,388 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Log.h>
+
+#include <Memory.h>
+
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include <pthread.h>
+
+#define LOG_TSBUFFER 64
+
+struct LogConfig
+{
+    int level;
+    size_t indent;
+    Stream *out;
+    int flags;
+    char *tsFmt;
+
+    pthread_mutex_t lock;
+};
+
+LogConfig *globalConfig = NULL;
+
+LogConfig *
+LogConfigCreate(void)
+{
+    LogConfig *config;
+
+    config = Malloc(sizeof(LogConfig));
+
+    if (!config)
+    {
+        return NULL;
+    }
+
+    memset(config, 0, sizeof(LogConfig));
+
+    LogConfigLevelSet(config, LOG_INFO);
+    LogConfigIndentSet(config, 0);
+    LogConfigOutputSet(config, NULL);   /* Will set to stdout */
+    LogConfigFlagSet(config, LOG_FLAG_COLOR);
+    LogConfigTimeStampFormatSet(config, "%y-%m-%d %H:%M:%S");
+
+    return config;
+}
+
+LogConfig *
+LogConfigGlobal(void)
+{
+    if (!globalConfig)
+    {
+        globalConfig = LogConfigCreate();
+    }
+
+    return globalConfig;
+}
+
+void
+LogConfigFlagClear(LogConfig * config, int flags)
+{
+    if (!config)
+    {
+        return;
+    }
+
+    config->flags &= ~flags;
+}
+
+static int
+LogConfigFlagGet(LogConfig * config, int flags)
+{
+    if (!config)
+    {
+        return 0;
+    }
+
+    return config->flags & flags;
+}
+
+void
+LogConfigFlagSet(LogConfig * config, int flags)
+{
+    if (!config)
+    {
+        return;
+    }
+
+    config->flags |= flags;
+}
+
+void
+LogConfigFree(LogConfig * config)
+{
+    if (!config)
+    {
+        return;
+    }
+
+    Free(config);
+
+    if (config == globalConfig)
+    {
+        globalConfig = NULL;
+    }
+}
+
+void
+LogConfigIndent(LogConfig * config)
+{
+    if (config)
+    {
+        config->indent += 2;
+    }
+}
+
+void
+LogConfigIndentSet(LogConfig * config, size_t indent)
+{
+    if (!config)
+    {
+        return;
+    }
+
+    config->indent = indent;
+}
+
+int
+LogConfigLevelGet(LogConfig * config)
+{
+    if (!config)
+    {
+        return -1;
+    }
+
+    return config->level;
+}
+
+void
+LogConfigLevelSet(LogConfig * config, int level)
+{
+    if (!config)
+    {
+        return;
+    }
+
+    switch (level)
+    {
+        case LOG_ERR:
+        case LOG_WARNING:
+        case LOG_INFO:
+        case LOG_DEBUG:
+            config->level = level;
+        default:
+            break;
+    }
+}
+
+void
+LogConfigOutputSet(LogConfig * config, Stream * out)
+{
+    if (!config)
+    {
+        return;
+    }
+
+    if (out)
+    {
+        config->out = out;
+    }
+    else
+    {
+        config->out = StreamStdout();
+    }
+
+}
+
+void
+LogConfigTimeStampFormatSet(LogConfig * config, char *tsFmt)
+{
+    if (config)
+    {
+        config->tsFmt = tsFmt;
+    }
+}
+
+void
+LogConfigUnindent(LogConfig * config)
+{
+    if (config && config->indent >= 2)
+    {
+        config->indent -= 2;
+    }
+}
+
+void
+Logv(LogConfig * config, int level, const char *msg, va_list argp)
+{
+    size_t i;
+    int doColor;
+    char indicator;
+
+    /*
+     * Only proceed if we have a config and its log level is set to a
+     * value that permits us to log. This is as close as we can get
+     * to a no-op function if we aren't logging anything, without doing
+     * some crazy macro magic.
+     */
+    if (!config || level > config->level)
+    {
+        return;
+    }
+
+    /* Misconfiguration */
+    if (!config->out)
+    {
+        return;
+    }
+
+    pthread_mutex_lock(&config->lock);
+
+    if (LogConfigFlagGet(config, LOG_FLAG_SYSLOG))
+    {
+        /* No further print logic is needed; syslog will handle it all
+         * for us. */
+        vsyslog(level, msg, argp);
+        pthread_mutex_unlock(&config->lock);
+        return;
+    }
+
+    doColor = LogConfigFlagGet(config, LOG_FLAG_COLOR)
+            && isatty(StreamFileno(config->out));
+
+    if (doColor)
+    {
+        char *ansi;
+
+        switch (level)
+        {
+            case LOG_EMERG:
+            case LOG_ALERT:
+            case LOG_CRIT:
+            case LOG_ERR:
+                /* Bold Red */
+                ansi = "\033[1;31m";
+                break;
+            case LOG_WARNING:
+                /* Bold Yellow */
+                ansi = "\033[1;33m";
+                break;
+            case LOG_NOTICE:
+                /* Bold Magenta */
+                ansi = "\033[1;35m";
+                break;
+            case LOG_INFO:
+                /* Bold Green */
+                ansi = "\033[1;32m";
+                break;
+            case LOG_DEBUG:
+                /* Bold Blue */
+                ansi = "\033[1;34m";
+                break;
+            default:
+                ansi = "";
+                break;
+        }
+
+        StreamPuts(config->out, ansi);
+    }
+
+    StreamPutc(config->out, '[');
+
+    if (config->tsFmt)
+    {
+        time_t timer = time(NULL);
+        struct tm *timeInfo = localtime(&timer);
+        char tsBuffer[LOG_TSBUFFER];
+
+        int tsLength = strftime(tsBuffer, LOG_TSBUFFER, config->tsFmt,
+                                timeInfo);
+
+        if (tsLength)
+        {
+            StreamPuts(config->out, tsBuffer);
+            if (!isspace((unsigned char) tsBuffer[tsLength - 1]))
+            {
+                StreamPutc(config->out, ' ');
+            }
+        }
+    }
+
+    switch (level)
+    {
+        case LOG_EMERG:
+            indicator = '#';
+            break;
+        case LOG_ALERT:
+            indicator = '@';
+            break;
+        case LOG_CRIT:
+            indicator = 'X';
+            break;
+        case LOG_ERR:
+            indicator = 'x';
+            break;
+        case LOG_WARNING:
+            indicator = '!';
+            break;
+        case LOG_NOTICE:
+            indicator = '~';
+            break;
+        case LOG_INFO:
+            indicator = '>';
+            break;
+        case LOG_DEBUG:
+            indicator = '*';
+            break;
+        default:
+            indicator = '?';
+            break;
+    }
+
+    StreamPrintf(config->out, "%c]", indicator);
+
+    if (doColor)
+    {
+        /* ANSI Reset */
+        StreamPuts(config->out, "\033[0m");
+    }
+
+    StreamPutc(config->out, ' ');
+    for (i = 0; i < config->indent; i++)
+    {
+        StreamPutc(config->out, ' ');
+    }
+
+    StreamVprintf(config->out, msg, argp);
+    StreamPutc(config->out, '\n');
+
+    StreamFlush(config->out);
+
+    pthread_mutex_unlock(&config->lock);
+}
+
+void
+LogTo(LogConfig * config, int level, const char *fmt,...)
+{
+    va_list argp;
+
+    va_start(argp, fmt);
+    Logv(config, level, fmt, argp);
+    va_end(argp);
+}
+
+extern void
+Log(int level, const char *fmt,...)
+{
+    va_list argp;
+
+    va_start(argp, fmt);
+    Logv(LogConfigGlobal(), level, fmt, argp);
+    va_end(argp);
+}

src/Memory.c

@@ -0,0 +1,493 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Memory.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <pthread.h>
+
+#ifndef MEMORY_TABLE_CHUNK
+#define MEMORY_TABLE_CHUNK 256
+#endif
+
+#ifndef MEMORY_HEXDUMP_WIDTH
+#define MEMORY_HEXDUMP_WIDTH 16
+#endif
+
+struct MemoryInfo
+{
+    size_t size;
+    const char *file;
+    int line;
+    void *pointer;
+};
+
+static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+static void (*hook) (MemoryAction, MemoryInfo *, void *) = NULL;
+static void *hookArgs = NULL;
+
+static MemoryInfo **allocations = NULL;
+static size_t allocationsSize = 0;
+static size_t allocationsLen = 0;
+
+static size_t
+MemoryHash(void *p)
+{
+    return (((size_t) p) >> 2 * 7) % allocationsSize;
+}
+
+static int
+MemoryInsert(MemoryInfo * a)
+{
+    size_t hash;
+
+    if (!allocations)
+    {
+        allocationsSize = MEMORY_TABLE_CHUNK;
+        allocations = calloc(allocationsSize, sizeof(void *));
+        if (!allocations)
+        {
+            return 0;
+        }
+    }
+
+    /* If the next insertion would cause the table to be at least 3/4
+     * full, re-allocate and re-hash. */
+    if ((allocationsLen + 1) >= ((allocationsSize * 3) >> 2))
+    {
+        size_t i;
+        size_t tmpAllocationsSize = allocationsSize;
+        MemoryInfo **tmpAllocations;
+
+        allocationsSize += MEMORY_TABLE_CHUNK;
+        tmpAllocations = calloc(allocationsSize, sizeof(void *));
+
+        if (!tmpAllocations)
+        {
+            return 0;
+        }
+
+        for (i = 0; i < tmpAllocationsSize; i++)
+        {
+            if (allocations[i])
+            {
+                hash = MemoryHash(allocations[i]->pointer);
+
+                while (tmpAllocations[hash])
+                {
+                    hash = (hash + 1) % allocationsSize;
+                }
+
+                tmpAllocations[hash] = allocations[i];
+            }
+        }
+
+        free(allocations);
+        allocations = tmpAllocations;
+    }
+
+    hash = MemoryHash(a->pointer);
+
+    while (allocations[hash])
+    {
+        hash = (hash + 1) % allocationsSize;
+    }
+
+    allocations[hash] = a;
+    allocationsLen++;
+
+    return 1;
+}
+
+static void
+MemoryDelete(MemoryInfo * a)
+{
+    size_t hash = MemoryHash(a->pointer);
+    size_t count = 0;
+
+    while (count <= allocationsSize)
+    {
+        if (allocations[hash] && allocations[hash] == a)
+        {
+            allocations[hash] = NULL;
+            allocationsLen--;
+            return;
+        }
+        else
+        {
+            hash = (hash + 1) % allocationsSize;
+            count++;
+        }
+    }
+}
+
+void *
+MemoryAllocate(size_t size, const char *file, int line)
+{
+    void *p;
+    MemoryInfo *a;
+
+    pthread_mutex_lock(&lock);
+
+    p = malloc(size);
+    if (!p)
+    {
+        pthread_mutex_unlock(&lock);
+        return NULL;
+    }
+
+    a = malloc(sizeof(MemoryInfo));
+    if (!a)
+    {
+        free(p);
+        pthread_mutex_unlock(&lock);
+        return NULL;
+    }
+
+    a->size = size;
+    a->file = file;
+    a->line = line;
+    a->pointer = p;
+
+    if (!MemoryInsert(a))
+    {
+        free(a);
+        free(p);
+        pthread_mutex_unlock(&lock);
+        return NULL;
+    }
+
+    if (hook)
+    {
+        hook(MEMORY_ALLOCATE, a, hookArgs);
+    }
+
+    pthread_mutex_unlock(&lock);
+    return p;
+}
+
+void *
+MemoryReallocate(void *p, size_t size, const char *file, int line)
+{
+    MemoryInfo *a;
+    void *new = NULL;
+
+    if (!p)
+    {
+        return MemoryAllocate(size, file, line);
+    }
+
+    a = MemoryInfoGet(p);
+    if (a)
+    {
+        pthread_mutex_lock(&lock);
+        new = realloc(a->pointer, size);
+        if (new)
+        {
+            MemoryDelete(a);
+            a->size = size;
+            a->file = file;
+            a->line = line;
+
+            a->pointer = new;
+            MemoryInsert(a);
+
+            if (hook)
+            {
+                hook(MEMORY_REALLOCATE, a, hookArgs);
+            }
+
+        }
+        pthread_mutex_unlock(&lock);
+    }
+    else if (hook)
+    {
+        a = malloc(sizeof(MemoryInfo));
+        if (a)
+        {
+            a->size = 0;
+            a->file = file;
+            a->line = line;
+            a->pointer = p;
+            hook(MEMORY_BAD_POINTER, a, hookArgs);
+            free(a);
+        }
+    }
+
+
+    return new;
+}
+
+void
+MemoryFree(void *p, const char *file, int line)
+{
+    MemoryInfo *a;
+
+    if (!p)
+    {
+        return;
+    }
+
+    a = MemoryInfoGet(p);
+    if (a)
+    {
+        pthread_mutex_lock(&lock);
+        if (hook)
+        {
+            a->file = file;
+            a->line = line;
+            hook(MEMORY_FREE, a, hookArgs);
+        }
+        MemoryDelete(a);
+        free(a->pointer);
+        free(a);
+
+        pthread_mutex_unlock(&lock);
+    }
+    else if (hook)
+    {
+        a = malloc(sizeof(MemoryInfo));
+        if (a)
+        {
+            a->file = file;
+            a->line = line;
+            a->size = 0;
+            a->pointer = p;
+            hook(MEMORY_BAD_POINTER, a, hookArgs);
+            free(a);
+        }
+    }
+}
+
+size_t
+MemoryAllocated(void)
+{
+    size_t i;
+    size_t total = 0;
+
+    pthread_mutex_lock(&lock);
+
+    for (i = 0; i < allocationsSize; i++)
+    {
+        if (allocations[i])
+        {
+            total += allocations[i]->size;
+        }
+    }
+
+    pthread_mutex_unlock(&lock);
+
+    return total;
+}
+
+void
+MemoryFreeAll(void)
+{
+    size_t i;
+
+    pthread_mutex_lock(&lock);
+
+    for (i = 0; i < allocationsSize; i++)
+    {
+        if (allocations[i])
+        {
+            free(allocations[i]->pointer);
+            free(allocations[i]);
+        }
+    }
+
+    free(allocations);
+    allocations = NULL;
+    allocationsSize = 0;
+    allocationsLen = 0;
+
+    pthread_mutex_unlock(&lock);
+}
+
+MemoryInfo *
+MemoryInfoGet(void *p)
+{
+    size_t hash, count;
+
+    pthread_mutex_lock(&lock);
+
+    hash = MemoryHash(p);
+
+    count = 0;
+    while (count <= allocationsSize)
+    {
+        if (!allocations[hash] || allocations[hash]->pointer != p)
+        {
+            hash = (hash + 1) % allocationsSize;
+            count++;
+        }
+        else
+        {
+            pthread_mutex_unlock(&lock);
+            return allocations[hash];
+        }
+    }
+
+    pthread_mutex_unlock(&lock);
+    return NULL;
+}
+
+size_t
+MemoryInfoGetSize(MemoryInfo * a)
+{
+    if (!a)
+    {
+        return 0;
+    }
+
+    return a->size;
+}
+
+const char *
+MemoryInfoGetFile(MemoryInfo * a)
+{
+    if (!a)
+    {
+        return NULL;
+    }
+
+    return a->file;
+}
+
+int
+MemoryInfoGetLine(MemoryInfo * a)
+{
+    if (!a)
+    {
+        return -1;
+    }
+
+    return a->line;
+}
+
+void *
+MemoryInfoGetPointer(MemoryInfo * a)
+{
+    if (!a)
+    {
+        return NULL;
+    }
+
+    return a->pointer;
+}
+
+void
+ MemoryIterate(void (*iterFunc) (MemoryInfo *, void *), void *args)
+{
+    size_t i;
+
+    pthread_mutex_lock(&lock);
+
+    for (i = 0; i < allocationsSize; i++)
+    {
+        if (allocations[i])
+        {
+            iterFunc(allocations[i], args);
+        }
+    }
+
+    pthread_mutex_unlock(&lock);
+}
+
+void
+ MemoryHook(void (*memHook) (MemoryAction, MemoryInfo *, void *), void *args)
+{
+    pthread_mutex_lock(&lock);
+    hook = memHook;
+    hookArgs = args;
+    pthread_mutex_unlock(&lock);
+}
+
+void
+ MemoryHexDump(MemoryInfo * info, void (*printFunc) (size_t, char *, char *, void *), void *args)
+{
+    char hexBuf[(MEMORY_HEXDUMP_WIDTH * 2) + MEMORY_HEXDUMP_WIDTH + 1];
+    char asciiBuf[MEMORY_HEXDUMP_WIDTH + 1];
+    size_t pI = 0;
+    size_t hI = 0;
+    size_t aI = 0;
+    const unsigned char *pc;
+
+    if (!info || !printFunc)
+    {
+        return;
+    }
+
+    pc = MemoryInfoGetPointer(info);
+
+    for (pI = 0; pI < MemoryInfoGetSize(info); pI++)
+    {
+        if (pI > 0 && pI % MEMORY_HEXDUMP_WIDTH == 0)
+        {
+            hexBuf[hI - 1] = '\0';
+            asciiBuf[aI] = '\0';
+
+            printFunc(pI - MEMORY_HEXDUMP_WIDTH, hexBuf, asciiBuf, args);
+
+            snprintf(hexBuf, 4, "%02x ", pc[pI]);
+            hI = 3;
+
+            asciiBuf[0] = isprint(pc[pI]) ? pc[pI] : '.';
+            asciiBuf[1] = '\0';
+            aI = 1;
+        }
+        else
+        {
+            asciiBuf[aI] = isprint(pc[pI]) ? pc[pI] : '.';
+            aI++;
+
+            snprintf(hexBuf + hI, 4, "%02x ", pc[pI]);
+            hI += 3;
+        }
+    }
+
+    hexBuf[hI] = '\0';
+    hI--;
+
+    while (hI < sizeof(hexBuf) - 2)
+    {
+        hexBuf[hI] = ' ';
+        hI++;
+    }
+
+    while (aI < sizeof(asciiBuf) - 1)
+    {
+        asciiBuf[aI] = ' ';
+        aI++;
+    }
+
+    hexBuf[hI] = '\0';
+    asciiBuf[aI] = '\0';
+
+    printFunc(pI - ((pI % MEMORY_HEXDUMP_WIDTH) ?
+                  (pI % MEMORY_HEXDUMP_WIDTH) : MEMORY_HEXDUMP_WIDTH),
+              hexBuf, asciiBuf, args);
+    printFunc(pI, NULL, NULL, args);
+}

src/Queue.c

@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Queue.h>
+
+#include <Memory.h>
+
+struct Queue
+{
+    void **items;
+    size_t size;
+    size_t front;
+    size_t rear;
+};
+
+Queue *
+QueueCreate(size_t size)
+{
+    Queue *q;
+
+    if (!size)
+    {
+        /* Can't have a queue of length zero */
+        return NULL;
+    }
+
+    q = Malloc(sizeof(Queue));
+    if (!q)
+    {
+        return NULL;
+    }
+
+    q->items = Malloc(size * sizeof(void *));
+    if (!q->items)
+    {
+        Free(q);
+        return NULL;
+    }
+
+    q->size = size;
+    q->front = size + 1;
+    q->rear = size + 1;
+
+    return q;
+}
+
+void
+QueueFree(Queue * q)
+{
+    if (q)
+    {
+        Free(q->items);
+    }
+
+    Free(q);
+}
+
+int
+QueueFull(Queue * q)
+{
+    if (!q)
+    {
+        return 0;
+    }
+
+    return ((q->front == q->rear + 1) || (q->front == 0 && q->rear == q->size - 1));
+}
+
+int
+QueueEmpty(Queue * q)
+{
+    if (!q)
+    {
+        return 0;
+    }
+
+    return q->front == q->size + 1;
+}
+
+int
+QueuePush(Queue * q, void *element)
+{
+    if (!q || !element)
+    {
+        return 0;
+    }
+
+    if (QueueFull(q))
+    {
+        return 0;
+    }
+
+    if (q->front == q->size + 1)
+    {
+        q->front = 0;
+    }
+
+    if (q->rear == q->size + 1)
+    {
+        q->rear = 0;
+    }
+    else
+    {
+        q->rear = (q->rear + 1) % q->size;
+    }
+
+    q->items[q->rear] = element;
+
+    return 1;
+}
+
+void *
+QueuePop(Queue * q)
+{
+    void *element;
+
+    if (!q)
+    {
+        return NULL;
+    }
+
+    if (QueueEmpty(q))
+    {
+        return NULL;
+    }
+
+    element = q->items[q->front];
+
+    if (q->front == q->rear)
+    {
+        q->front = q->size + 1;
+        q->rear = q->size + 1;
+    }
+    else
+    {
+        q->front = (q->front + 1) % q->size;
+    }
+
+    return element;
+}
+
+void *
+QueuePeek(Queue * q)
+{
+    if (!q)
+    {
+        return NULL;
+    }
+
+    if (QueueEmpty(q))
+    {
+        return NULL;
+    }
+
+    return q->items[q->front];
+}

src/Rand.c

@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Rand.h>
+
+#include <Int.h>
+#include <Util.h>
+#include <Memory.h>
+
+#include <stdlib.h>
+#include <pthread.h>
+#include <unistd.h>
+
+#define RAND_STATE_VECTOR_LENGTH 624
+#define RAND_STATE_VECTOR_M 397
+
+#define RAND_UPPER_MASK 0x80000000
+#define RAND_LOWER_MASK 0x7FFFFFFF
+#define RAND_TEMPER_B 0x9D2C5680
+#define RAND_TEMPER_C 0xEFC60000
+
+typedef struct RandState
+{
+    UInt32 mt[RAND_STATE_VECTOR_LENGTH];
+    int index;
+} RandState;
+
+static void
+RandSeed(RandState * state, UInt32 seed)
+{
+    state->mt[0] = seed & 0xFFFFFFFF;
+
+    for (state->index = 1; state->index < RAND_STATE_VECTOR_LENGTH; state->index++)
+    {
+        state->mt[state->index] = (6069 * state->mt[state->index - 1]) & 0xFFFFFFFF;
+    }
+}
+
+static UInt32
+RandGenerate(RandState * state)
+{
+    static const UInt32 mag[2] = {0x0, 0x9908B0DF};
+
+    UInt32 result;
+
+    if (state->index >= RAND_STATE_VECTOR_LENGTH || state->index < 0)
+    {
+        int kk;
+
+        if (state->index >= RAND_STATE_VECTOR_LENGTH + 1 || state->index < 0)
+        {
+            RandSeed(state, 4357);
+        }
+
+        for (kk = 0; kk < RAND_STATE_VECTOR_LENGTH - RAND_STATE_VECTOR_M; kk++)
+        {
+            result = (state->mt[kk] & RAND_UPPER_MASK) | (state->mt[kk + 1] & RAND_LOWER_MASK);
+            state->mt[kk] = state->mt[kk + RAND_STATE_VECTOR_M] ^ (result >> 1) ^ mag[result & 0x1];
+        }
+
+        for (; kk < RAND_STATE_VECTOR_LENGTH - 1; kk++)
+        {
+            result = (state->mt[kk] & RAND_UPPER_MASK) | (state->mt[kk + 1] & RAND_LOWER_MASK);
+            state->mt[kk] = state->mt[kk + (RAND_STATE_VECTOR_M - RAND_STATE_VECTOR_LENGTH)] ^ (result >> 1) ^ mag[result & 0x1];
+        }
+
+        result = (state->mt[RAND_STATE_VECTOR_LENGTH - 1] & RAND_UPPER_MASK) | (state->mt[0] & RAND_LOWER_MASK);
+        state->mt[RAND_STATE_VECTOR_LENGTH - 1] = state->mt[RAND_STATE_VECTOR_M - 1] ^ (result >> 1) ^ mag[result & 0x1];
+        state->index = 0;
+    }
+
+    result = state->mt[state->index++];
+    result ^= (result >> 11);
+    result ^= (result << 7) & RAND_TEMPER_B;
+    result ^= (result << 15) & RAND_TEMPER_C;
+    result ^= (result >> 18);
+
+    return result;
+}
+
+static void
+RandDestructor(void *p)
+{
+    Free(p);
+}
+
+/* Generate random numbers using rejection sampling. The basic idea is
+ * to "reroll" if a number happens to be outside the range. However
+ * this could be extremely inefficient.
+ * 
+ * Another idea would just be to "reroll" if the generated number ends up
+ * in the previously "biased" range, and THEN do a modulo.
+ * 
+ * This would be far more efficient for small values of max, and fixes the
+ * bias issue. */
+
+/* This algorithm therefore computes N random numbers generally in O(N)
+ * time, while being less biased. */
+void
+RandIntN(int *buf, size_t size, unsigned int max)
+{
+    static pthread_key_t stateKey;
+    static int createdKey = 0;
+
+    /* Limit the range to banish all previously biased results */
+    const int allowed = RAND_MAX - RAND_MAX % max;
+
+    RandState *state;
+    int tmp;
+    size_t i;
+
+    if (!createdKey)
+    {
+        pthread_key_create(&stateKey, RandDestructor);
+        createdKey = 1;
+    }
+
+    state = pthread_getspecific(stateKey);
+
+    if (!state)
+    {
+        /* Generate a seed from the system time, PID, and TID */
+        UInt32 seed = UtilServerTs() ^ getpid() ^ (unsigned long) pthread_self();
+
+        state = Malloc(sizeof(RandState));
+        RandSeed(state, seed);
+
+        pthread_setspecific(stateKey, state);
+    }
+
+    /* Generate {size} random numbers. */
+    for (i = 0; i < size; i++)
+    {
+        /* Most of the time, this will take about 1 loop */
+        do
+        {
+            tmp = RandGenerate(state);
+        } while (tmp > allowed);
+
+        buf[i] = tmp % max;
+    }
+}
+
+/* Generate just 1 random number */
+int
+RandInt(unsigned int max)
+{
+    int val = 0;
+
+    RandIntN(&val, 1, max);
+    return val;
+}

src/RtStub.c

@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Runtime.h>
+#include <Array.h>
+#include <HashMap.h>
+#include <Stream.h>
+#include <Log.h>
+#include <Memory.h>
+#include <Str.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+
+/* Specified by POSIX to contain environment variables */
+extern char **environ;
+
+/* The linking program is expected to provide Main */
+extern int Main(Array *, HashMap *);
+
+typedef struct MainArgs
+{
+    Array *args;
+    HashMap *env;
+} MainArgs;
+
+static void *
+MainThread(void *argp)
+{
+    long ret;
+    MainArgs *args = argp;
+
+    args = argp;
+    ret = Main(args->args, args->env);
+
+    return (void *) ret;
+}
+
+int
+main(int argc, char **argv)
+{
+    pthread_t mainThread;
+    size_t i;
+    int ret;
+
+    char *key;
+    char *val;
+    char **envp;
+
+    MainArgs args;
+
+    args.args = NULL;
+    args.env = NULL;
+
+    args.args = ArrayCreate();
+
+    if (!args.args)
+    {
+        Log(LOG_ERR, "Bootstrap error: Unable to allocate memory for arguments.");
+        ret = EXIT_FAILURE;
+        goto finish;
+    }
+
+    args.env = HashMapCreate();
+    if (!args.env)
+    {
+        Log(LOG_ERR, "Bootstrap error: Unable to allocate memory for environment.");
+        ret = EXIT_FAILURE;
+        goto finish;
+    }
+
+    for (i = 0; i < (size_t) argc; i++)
+    {
+        ArrayAdd(args.args, StrDuplicate(argv[i]));
+    }
+
+    envp = environ;
+    while (*envp)
+    {
+		size_t valInd;
+
+        /* It is unclear whether or not envp strings are writable, so
+         * we make our own copy to manipulate it */
+        key = StrDuplicate(*envp);
+        valInd = strcspn(key, "=");
+
+        key[valInd] = '\0';
+        val = key + valInd + 1;
+        HashMapSet(args.env, key, StrDuplicate(val));
+        Free(key);
+		envp++;
+    }
+
+    if (pthread_create(&mainThread, NULL, MainThread, &args) != 0)
+    {
+        Log(LOG_ERR, "Bootstrap error: Unable to create main thread.");
+        ret = EXIT_FAILURE;
+        goto finish;
+    }
+
+    if (pthread_join(mainThread, (void **) &ret) != 0)
+    {
+        /* Should never happen */
+        Log(LOG_ERR, "Unable to join main thread.");
+        ret = EXIT_FAILURE;
+        goto finish;
+    }
+
+finish:
+    if (args.args)
+    {
+        for (i = 0; i < ArraySize(args.args); i++)
+        {
+            Free(ArrayGet(args.args, i));
+        }
+        ArrayFree(args.args);
+    }
+
+    if (args.env)
+    {
+        while (HashMapIterate(args.env, &key, (void **) &val))
+        {
+            Free(val);
+        }
+        HashMapFree(args.env);
+    }
+
+	Log(LOG_DEBUG, "Exitting with code: %d", ret);
+
+    LogConfigFree(LogConfigGlobal());
+
+    StreamClose(StreamStdout());
+    StreamClose(StreamStdin());
+    StreamClose(StreamStderr());
+
+    GenerateMemoryReport(argv[0]);
+
+    MemoryFreeAll();
+
+    return ret;
+}

src/Runtime.c

@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Runtime.h>
+#include <Array.h>
+#include <Stream.h>
+#include <Log.h>
+#include <Memory.h>
+
+#include <stdlib.h>
+#include <time.h>
+#include <libgen.h>
+
+static void
+HexDump(size_t off, char *hexBuf, char *asciiBuf, void *args)
+{
+    FILE *report = args;
+
+    if (hexBuf && asciiBuf)
+    {
+        fprintf(report, "%04lx: %s | %s |\n", off, hexBuf, asciiBuf);
+    }
+    else
+    {
+        fprintf(report, "%04lx\n", off);
+    }
+}
+
+
+static void
+MemoryIterator(MemoryInfo * i, void *args)
+{
+    FILE *report = args;
+
+    fprintf(report, "%s:%d: %lu bytes at %p\n",
+            MemoryInfoGetFile(i), MemoryInfoGetLine(i),
+            MemoryInfoGetSize(i), MemoryInfoGetPointer(i));
+
+    MemoryHexDump(i, HexDump, report);
+
+    fprintf(report, "\n");
+}
+
+void
+GenerateMemoryReport(const char *prog)
+{
+    char reportName[128];
+    char *namePtr;
+
+    /*
+     * Use C standard IO instead of the Stream or Io APIs, because
+     * those use the Memory API, and that's exactly what we're trying
+     * to assess, so using it would generate false positives. None of
+     * this code should leak memory.
+     */
+    FILE *report;
+    time_t currentTime;
+    struct tm *timeInfo;
+    char tsBuffer[1024];
+
+    if (!MemoryAllocated())
+    {
+        /* No memory leaked, no need to write the report. This is the
+         * ideal situation; we only want the report to show up if leaks
+         * occurred. */
+        return;
+    }
+
+    snprintf(reportName, sizeof(reportName), "%s-leaked.txt", prog);
+    /* Make sure the report goes in the current working directory. */
+    namePtr = basename(reportName);
+    report = fopen(namePtr, "a");
+    if (!report)
+    {
+        return;
+    }
+
+    currentTime = time(NULL);
+    timeInfo = localtime(&currentTime);
+    strftime(tsBuffer, sizeof(tsBuffer), "%c", timeInfo);
+
+    fprintf(report, "---------- Memory Report ----------\n");
+    fprintf(report, "Program: %s\n", prog);
+    fprintf(report, "Date: %s\n", tsBuffer);
+    fprintf(report, "Total Bytes: %lu\n", MemoryAllocated());
+    fprintf(report, "\n");
+
+    MemoryIterate(MemoryIterator, report);
+
+    fclose(report);
+}

src/Sha2.c

@@ -0,0 +1,238 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Sha2.h>
+#include <Memory.h>
+#include <Int.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#include <limits.h>
+
+#define GET_UINT32(x) \
+    (((UInt32)(x)[0] << 24) | \
+     ((UInt32)(x)[1] << 16) | \
+     ((UInt32)(x)[2] << 8) | \
+     ((UInt32)(x)[3]))
+
+#define PUT_UINT32(dst, x) { \
+    (dst)[0] = (x) >> 24; \
+    (dst)[1] = (x) >> 16; \
+    (dst)[2] = (x) >> 8; \
+    (dst)[3] = (x); \
+}
+
+#define ROTR(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
+
+#define S0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ (x >> 3))
+#define S1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ (x >> 10))
+
+#define T0(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
+#define T1(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
+
+#define CH(a, b, c) (((a) & (b)) ^ ((~(a)) & (c)))
+#define MAJ(a, b, c) (((a) & (b)) ^ ((a) & (c)) ^ ((b) & (c)))
+#define WW(i) (w[i] = w[i - 16] + S0(w[i - 15]) + w[i - 7] + S1(w[i - 2]))
+
+#define ROUND(a, b, c, d, e, f, g, h, k, w) { \
+    UInt32 tmp0 = h + T0(e) + CH(e, f, g) + k + w; \
+    UInt32 tmp1 = T1(a) + MAJ(a, b, c); \
+    h = tmp0 + tmp1; \
+    d += tmp0; \
+}
+
+typedef struct Sha256Context
+{
+    size_t length;
+    UInt32 state[8];
+    size_t bufLen;
+    unsigned char buffer[64];
+} Sha256Context;
+
+static void
+Sha256Chunk(Sha256Context * context, unsigned char chunk[64])
+{
+    const UInt32 rk[64] = {
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+        0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+        0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+        0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+        0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+        0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+        0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+        0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+        0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+    };
+
+    UInt32 w[64];
+    UInt32 a, b, c, d, e, f, g, h;
+
+    int i;
+
+    for (i = 0; i < 16; i++)
+    {
+        w[i] = GET_UINT32(&chunk[4 * i]);
+    }
+
+    a = context->state[0];
+    b = context->state[1];
+    c = context->state[2];
+    d = context->state[3];
+    e = context->state[4];
+    f = context->state[5];
+    g = context->state[6];
+    h = context->state[7];
+
+    for (i = 0; i < 16; i += 8)
+    {
+        ROUND(a, b, c, d, e, f, g, h, rk[i], w[i]);
+        ROUND(h, a, b, c, d, e, f, g, rk[i + 1], w[i + 1]);
+        ROUND(g, h, a, b, c, d, e, f, rk[i + 2], w[i + 2]);
+        ROUND(f, g, h, a, b, c, d, e, rk[i + 3], w[i + 3]);
+        ROUND(e, f, g, h, a, b, c, d, rk[i + 4], w[i + 4]);
+        ROUND(d, e, f, g, h, a, b, c, rk[i + 5], w[i + 5]);
+        ROUND(c, d, e, f, g, h, a, b, rk[i + 6], w[i + 6]);
+        ROUND(b, c, d, e, f, g, h, a, rk[i + 7], w[i + 7]);
+    }
+
+    for (i = 16; i < 64; i += 8)
+    {
+        ROUND(a, b, c, d, e, f, g, h, rk[i], WW(i));
+        ROUND(h, a, b, c, d, e, f, g, rk[i + 1], WW(i + 1));
+        ROUND(g, h, a, b, c, d, e, f, rk[i + 2], WW(i + 2));
+        ROUND(f, g, h, a, b, c, d, e, rk[i + 3], WW(i + 3));
+        ROUND(e, f, g, h, a, b, c, d, rk[i + 4], WW(i + 4));
+        ROUND(d, e, f, g, h, a, b, c, rk[i + 5], WW(i + 5));
+        ROUND(c, d, e, f, g, h, a, b, rk[i + 6], WW(i + 6));
+        ROUND(b, c, d, e, f, g, h, a, rk[i + 7], WW(i + 7));
+    }
+
+    context->state[0] += a;
+    context->state[1] += b;
+    context->state[2] += c;
+    context->state[3] += d;
+    context->state[4] += e;
+    context->state[5] += f;
+    context->state[6] += g;
+    context->state[7] += h;
+}
+
+static void
+Sha256Process(Sha256Context * context, unsigned char *data, size_t length)
+{
+    context->length += length;
+
+    if (context->bufLen && context->bufLen + length >= 64)
+    {
+        int len = 64 - context->bufLen;
+
+        memcpy(context->buffer + context->bufLen, data, len);
+        Sha256Chunk(context, context->buffer);
+        data += len;
+        length -= len;
+        context->bufLen = 0;
+    }
+
+    while (length >= 64)
+    {
+        Sha256Chunk(context, data);
+        data += 64;
+        length -= 64;
+    }
+
+    if (length)
+    {
+        memcpy(context->buffer + context->bufLen, data, length);
+        context->bufLen += length;
+    }
+}
+
+char *
+Sha256(char *str)
+{
+    Sha256Context context;
+    size_t i;
+    unsigned char out[32];
+    char *outStr;
+
+    unsigned char fill[64];
+    UInt32 fillLen;
+    unsigned char buf[8];
+    UInt32 hiLen;
+    UInt32 loLen;
+
+    if (!str)
+    {
+        return NULL;
+    }
+
+    outStr = Malloc(65);
+    if (!outStr)
+    {
+        return NULL;
+    }
+
+    context.state[0] = 0x6a09e667;
+    context.state[1] = 0xbb67ae85;
+    context.state[2] = 0x3c6ef372;
+    context.state[3] = 0xa54ff53a;
+    context.state[4] = 0x510e527f;
+    context.state[5] = 0x9b05688c;
+    context.state[6] = 0x1f83d9ab;
+    context.state[7] = 0x5be0cd19;
+
+    context.bufLen = 0;
+    context.length = 0;
+    memset(context.buffer, 0, 64);
+
+    Sha256Process(&context, (unsigned char *) str, strlen(str));
+
+    memset(fill, 0, 64);
+    fill[0] = 0x80;
+
+    fillLen = (context.bufLen < 56) ? 56 - context.bufLen : 120 - context.bufLen;
+    hiLen = (UInt32) (context.length >> 29);
+    loLen = (UInt32) (context.length << 3);
+
+    PUT_UINT32(&buf[0], hiLen);
+    PUT_UINT32(&buf[4], loLen);
+
+    Sha256Process(&context, fill, fillLen);
+    Sha256Process(&context, buf, 8);
+
+    for (i = 0; i < 8; i++)
+    {
+        PUT_UINT32(&out[4 * i], context.state[i]);
+    }
+
+    /* Convert to string */
+    for (i = 0; i < 32; i++)
+    {
+        snprintf(outStr + (2 * i), 3, "%02x", out[i]);
+    }
+
+    return outStr;
+}

src/Str.c

@@ -0,0 +1,297 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Str.h>
+
+#include <Memory.h>
+#include <Util.h>
+#include <Rand.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include <pthread.h>
+#include <unistd.h>
+
+char *
+StrUtf8Encode(unsigned long utf8)
+{
+    char *str;
+
+    str = Malloc(5 * sizeof(char));
+    if (!str)
+    {
+        return NULL;
+    }
+
+    if (utf8 <= 0x7F)              /* Plain ASCII */
+    {
+        str[0] = (char) utf8;
+        str[1] = '\0';
+    }
+    else if (utf8 <= 0x07FF)       /* 2-byte */
+    {
+        str[0] = (char) (((utf8 >> 6) & 0x1F) | 0xC0);
+        str[1] = (char) (((utf8 >> 0) & 0x3F) | 0x80);
+        str[2] = '\0';
+    }
+    else if (utf8 <= 0xFFFF)       /* 3-byte */
+    {
+        str[0] = (char) (((utf8 >> 12) & 0x0F) | 0xE0);
+        str[1] = (char) (((utf8 >> 6) & 0x3F) | 0x80);
+        str[2] = (char) (((utf8 >> 0) & 0x3F) | 0x80);
+        str[3] = '\0';
+    }
+    else if (utf8 <= 0x10FFFF)     /* 4-byte */
+    {
+        str[0] = (char) (((utf8 >> 18) & 0x07) | 0xF0);
+        str[1] = (char) (((utf8 >> 12) & 0x3F) | 0x80);
+        str[2] = (char) (((utf8 >> 6) & 0x3F) | 0x80);
+        str[3] = (char) (((utf8 >> 0) & 0x3F) | 0x80);
+        str[4] = '\0';
+    }
+    else
+    {
+        /* Send replacement character */
+        str[0] = (char) 0xEF;
+        str[1] = (char) 0xBF;
+        str[2] = (char) 0xBD;
+        str[3] = '\0';
+    }
+
+    return str;
+}
+
+char *
+StrDuplicate(const char *inStr)
+{
+    size_t len;
+    char *outStr;
+
+    if (!inStr)
+    {
+        return NULL;
+    }
+
+    len = strlen(inStr);
+    outStr = Malloc(len + 1);      /* For the null terminator */
+    if (!outStr)
+    {
+        return NULL;
+    }
+
+    strncpy(outStr, inStr, len + 1);
+
+    return outStr;
+}
+
+char *
+StrSubstr(const char *inStr, size_t start, size_t end)
+{
+    size_t len;
+    size_t i;
+    size_t j;
+
+    char *outStr;
+
+    if (!inStr)
+    {
+        return NULL;
+    }
+
+    if (start >= end)
+    {
+        return NULL;
+    }
+
+    len = end - start;
+
+    outStr = Malloc(len + 1);
+    if (!outStr)
+    {
+        return NULL;
+    }
+
+    j = 0;
+    for (i = start; i < end; i++)
+    {
+        if (inStr[i] == '\0')
+        {
+            break;
+        }
+
+        outStr[j] = inStr[i];
+        j++;
+    }
+
+    outStr[j] = '\0';
+
+    return outStr;
+}
+
+char *
+StrConcat(size_t nStr,...)
+{
+    va_list argp;
+    char *str;
+    char *strp;
+    size_t strLen = 0;
+    size_t i;
+
+    va_start(argp, nStr);
+    for (i = 0; i < nStr; i++)
+    {
+        char *argStr = va_arg(argp, char *);
+
+        if (argStr)
+        {
+            strLen += strlen(argStr);
+        }
+    }
+    va_end(argp);
+
+    str = Malloc(strLen + 1);
+    strp = str;
+
+    va_start(argp, nStr);
+
+    for (i = 0; i < nStr; i++)
+    {
+        /* Manually copy chars instead of using strcopy() so we don't
+         * have to call strlen() on the strings again, and we aren't
+         * writing useless null chars. */
+
+        char *argStr = va_arg(argp, char *);
+
+        if (argStr)
+        {
+            while (*argStr)
+            {
+                *strp = *argStr;
+                strp++;
+                argStr++;
+            }
+        }
+    }
+
+    va_end(argp);
+    str[strLen] = '\0';
+    return str;
+}
+
+int
+StrBlank(const char *str)
+{
+    int blank = 1;
+    size_t i = 0;
+
+    while (str[i])
+    {
+        blank &= isspace((unsigned char) str[i]);
+        /* No need to continue if we don't have a blank */
+        if (!blank)
+        {
+            break;
+        }
+        i++;
+    }
+    return blank;
+}
+
+char *
+StrRandom(size_t len)
+{
+    static const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+    char *str;
+    int *nums;
+    size_t i;
+
+    if (!len)
+    {
+        return NULL;
+    }
+
+    str = Malloc(len + 1);
+
+    if (!str)
+    {
+        return NULL;
+    }
+
+    nums = Malloc(len * sizeof(int));
+    if (!nums)
+    {
+        Free(str);
+        return NULL;
+    }
+
+    /* TODO: This seems slow. */
+    RandIntN(nums, len, sizeof(charset) - 1);
+    for (i = 0; i < len; i++)
+    {
+        str[i] = charset[nums[i]];
+    }
+
+    Free(nums);
+    str[len] = '\0';
+    return str;
+}
+
+char *
+StrInt(long i)
+{
+    char *str;
+    int len;
+
+    len = snprintf(NULL, 0, "%ld", i);
+    str = Malloc(len + 1);
+    if (!str)
+    {
+        return NULL;
+    }
+
+    snprintf(str, len + 1, "%ld", i);
+
+    return str;
+}
+
+int
+StrEquals(const char *str1, const char *str2)
+{
+    /* Both strings are NULL, they're equal */
+    if (!str1 && !str2)
+    {
+        return 1;
+    }
+
+    /* One or the other is NULL, they're not equal */
+    if (!str1 || !str2)
+    {
+        return 0;
+    }
+
+    /* Neither are NULL, do a regular string comparison */
+    return strcmp(str1, str2) == 0;
+}

src/Stream.c

@@ -0,0 +1,657 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Stream.h>
+
+#include <Io.h>
+#include <Memory.h>
+#include <Util.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#ifndef STREAM_RETRIES
+#define STREAM_RETRIES 10
+#endif
+
+#ifndef STREAM_DELAY
+#define STREAM_DELAY 2
+#endif
+
+#define STREAM_EOF (1 << 0)
+#define STREAM_ERR (1 << 1)
+#define STREAM_TTY (1 << 2)
+
+struct Stream
+{
+    Io *io;
+
+    char *rBuf;
+    size_t rLen;
+    size_t rOff;
+
+    char *wBuf;
+    size_t wLen;
+
+    char *ugBuf;
+    size_t ugSize;
+    size_t ugLen;
+
+    int flags;
+
+    int fd;
+};
+
+Stream *
+StreamIo(Io * io)
+{
+    Stream *stream;
+
+    if (!io)
+    {
+        return NULL;
+    }
+
+    stream = Malloc(sizeof(Stream));
+    if (!stream)
+    {
+        return NULL;
+    }
+
+    memset(stream, 0, sizeof(Stream));
+    stream->io = io;
+    stream->fd = -1;
+
+    return stream;
+}
+
+Stream *
+StreamFd(int fd)
+{
+    Io *io = IoFd(fd);
+    Stream *stream;
+
+    if (!io)
+    {
+        return NULL;
+    }
+
+    stream = StreamIo(io);
+    if (!stream)
+    {
+        return NULL;
+    }
+
+    stream->fd = fd;
+
+    if (isatty(stream->fd))
+    {
+        stream->flags |= STREAM_TTY;
+    }
+
+    return stream;
+}
+
+Stream *
+StreamFile(FILE * fp)
+{
+    Io *io = IoFile(fp);
+    Stream *stream;
+
+    if (!io)
+    {
+        return NULL;
+    }
+
+    stream = StreamIo(io);
+    if (!stream)
+    {
+        return NULL;
+    }
+
+    stream->fd = fileno(fp);
+
+    if (isatty(stream->fd))
+    {
+        stream->flags |= STREAM_TTY;
+    }
+
+    return stream;
+}
+
+Stream *
+StreamOpen(const char *path, const char *mode)
+{
+    FILE *fp = fopen(path, mode);
+
+    if (!fp)
+    {
+        return NULL;
+    }
+
+    return StreamFile(fp);
+}
+
+Stream *
+StreamStdout(void)
+{
+    static Stream *stdOut = NULL;
+
+    if (!stdOut)
+    {
+        stdOut = StreamFd(STDOUT_FILENO);
+    }
+
+    return stdOut;
+}
+
+Stream *
+StreamStderr(void)
+{
+    static Stream *stdErr = NULL;
+
+    if (!stdErr)
+    {
+        stdErr = StreamFd(STDERR_FILENO);
+    }
+
+    return stdErr;
+}
+
+Stream *
+StreamStdin(void)
+{
+    static Stream *stdIn = NULL;
+
+    if (!stdIn)
+    {
+        stdIn = StreamFd(STDIN_FILENO);
+    }
+
+    return stdIn;
+}
+
+int
+StreamClose(Stream * stream)
+{
+    int ret = 0;
+
+    if (!stream)
+    {
+        errno = EBADF;
+        return EOF;
+    }
+
+    if (stream->rBuf)
+    {
+        Free(stream->rBuf);
+    }
+
+    if (stream->wBuf)
+    {
+        ssize_t writeRes = IoWrite(stream->io, stream->wBuf, stream->wLen);
+
+        Free(stream->wBuf);
+
+        if (writeRes == -1)
+        {
+            ret = EOF;
+        }
+    }
+
+    if (stream->ugBuf)
+    {
+        Free(stream->ugBuf);
+    }
+
+    ret = IoClose(stream->io);
+    Free(stream);
+
+    return ret;
+}
+
+int
+StreamVprintf(Stream * stream, const char *fmt, va_list ap)
+{
+    /* This might look like very similar code to IoVprintf(), but I
+     * chose not to defer to IoVprintf() because that would require us
+     * to immediately flush the buffer, since the Io API is unbuffered.
+     * StreamPuts() uses StreamPutc() under the hood, which is
+     * buffered. It therefore allows us to finish filling the buffer
+     * and then only flush it when necessary, preventing superfluous
+     * writes. */
+
+    char *buf = NULL;
+    size_t bufSize = 0;
+    FILE *fp;
+
+    int ret;
+
+    if (!fmt)
+    {
+        return -1;
+    }
+
+    fp = open_memstream(&buf, &bufSize);
+    if (!fp)
+    {
+        return -1;
+    }
+
+    ret = vfprintf(fp, fmt, ap);
+    fclose(fp);
+
+    if (ret >= 0 && stream)
+    {
+        if (StreamPuts(stream, buf) < 0)
+        {
+            ret = -1;
+        };
+    }
+
+    free(buf);                     /* Allocated by stdlib, not Memory
+                                    * API */
+
+    return ret;
+}
+
+int
+StreamPrintf(Stream * stream, const char *fmt,...)
+{
+    int ret;
+    va_list ap;
+
+    va_start(ap, fmt);
+    ret = StreamVprintf(stream, fmt, ap);
+    va_end(ap);
+
+    return ret;
+}
+
+int
+StreamGetc(Stream * stream)
+{
+    int c;
+
+    if (!stream)
+    {
+        errno = EBADF;
+        return EOF;
+    }
+
+    /* Empty the ungetc stack first */
+    if (stream->ugLen)
+    {
+        c = stream->ugBuf[stream->ugLen - 1];
+        stream->ugLen--;
+        return c;
+    }
+
+    if (stream->flags & STREAM_EOF)
+    {
+        return EOF;
+    }
+
+    if (!stream->rBuf)
+    {
+        /* No buffer allocated yet */
+        stream->rBuf = Malloc(IO_BUFFER);
+        if (!stream->rBuf)
+        {
+            stream->flags |= STREAM_ERR;
+            return EOF;
+        }
+
+        stream->rOff = 0;
+        stream->rLen = 0;
+    }
+
+    if (stream->rOff >= stream->rLen)
+    {
+        /* We read through the entire buffer; get a new one */
+        ssize_t readRes = IoRead(stream->io, stream->rBuf, IO_BUFFER);
+
+        if (readRes == 0)
+        {
+            stream->flags |= STREAM_EOF;
+            return EOF;
+        }
+
+        if (readRes == -1)
+        {
+            stream->flags |= STREAM_ERR;
+            return EOF;
+        }
+
+        stream->rOff = 0;
+        stream->rLen = readRes;
+    }
+
+    /* Read the character in the buffer and advance the offset */
+    c = stream->rBuf[stream->rOff];
+    stream->rOff++;
+
+    return c;
+}
+
+int
+StreamUngetc(Stream * stream, int c)
+{
+    if (!stream)
+    {
+        errno = EBADF;
+        return EOF;
+    }
+
+    if (!stream->ugBuf)
+    {
+        stream->ugSize = IO_BUFFER;
+        stream->ugBuf = Malloc(stream->ugSize);
+
+        if (!stream->ugBuf)
+        {
+            stream->flags |= STREAM_ERR;
+            return EOF;
+        }
+    }
+
+    if (stream->ugLen >= stream->ugSize)
+    {
+        char *new;
+
+        stream->ugSize += IO_BUFFER;
+        new = Realloc(stream->ugBuf, stream->ugSize);
+        if (!new)
+        {
+            stream->flags |= STREAM_ERR;
+            Free(stream->ugBuf);
+            stream->ugBuf = NULL;
+            return EOF;
+        }
+
+        Free(stream->ugBuf);
+        stream->ugBuf = new;
+    }
+
+    stream->ugBuf[stream->ugLen] = c;
+    stream->ugLen++;
+
+    return c;
+}
+
+int
+StreamPutc(Stream * stream, int c)
+{
+    if (!stream)
+    {
+        errno = EBADF;
+        return EOF;
+    }
+
+    if (!stream->wBuf)
+    {
+        stream->wBuf = Malloc(IO_BUFFER);
+        if (!stream->wBuf)
+        {
+            stream->flags |= STREAM_ERR;
+            return EOF;
+        }
+    }
+
+    if (stream->wLen == IO_BUFFER)
+    {
+        /* Buffer full; write it */
+        ssize_t writeRes = IoWrite(stream->io, stream->wBuf, stream->wLen);
+
+        if (writeRes == -1)
+        {
+            stream->flags |= STREAM_ERR;
+            return EOF;
+        }
+
+        stream->wLen = 0;
+    }
+
+    stream->wBuf[stream->wLen] = c;
+    stream->wLen++;
+
+    if (stream->flags & STREAM_TTY && c == '\n')
+    {
+        /* Newline encountered on a TTY; write now. This fixes some
+         * strange behavior on certain TTYs where a newline is written
+         * to the screen upon flush even when no newline exists in the
+         * stream. We just flush on newlines, but only if we're
+         * directly writing to a TTY. */
+        ssize_t writeRes = IoWrite(stream->io, stream->wBuf, stream->wLen);
+
+        if (writeRes == -1)
+        {
+            stream->flags |= STREAM_ERR;
+            return EOF;
+        }
+
+        stream->wLen = 0;
+    }
+
+    return c;
+}
+
+int
+StreamPuts(Stream * stream, char *str)
+{
+    int ret = 0;
+
+    if (!stream)
+    {
+        errno = EBADF;
+        return -1;
+    }
+
+    while (*str)
+    {
+        if (StreamPutc(stream, *str) == EOF)
+        {
+            ret = -1;
+            break;
+        }
+
+        str++;
+    }
+
+    return ret;
+}
+
+char *
+StreamGets(Stream * stream, char *str, int size)
+{
+    int i;
+
+    if (!stream)
+    {
+        errno = EBADF;
+        return NULL;
+    }
+
+    if (size <= 0)
+    {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    for (i = 0; i < size - 1; i++)
+    {
+        int c = StreamGetc(stream);
+
+        if (StreamEof(stream) || StreamError(stream))
+        {
+            break;
+        }
+
+        str[i] = c;
+
+        if (c == '\n')
+        {
+            i++;
+            break;
+        }
+    }
+
+    str[i] = '\0';
+
+    return str;
+}
+
+off_t
+StreamSeek(Stream * stream, off_t offset, int whence)
+{
+    off_t result;
+
+    if (!stream)
+    {
+        errno = EBADF;
+        return -1;
+    }
+
+    result = IoSeek(stream->io, offset, whence);
+    if (result < 0)
+    {
+        return result;
+    }
+
+    /* Successful seek; clear the buffers */
+    stream->rOff = 0;
+    stream->wLen = 0;
+    stream->ugLen = 0;
+
+    return result;
+}
+
+int
+StreamEof(Stream * stream)
+{
+    return stream && (stream->flags & STREAM_EOF);
+}
+
+int
+StreamError(Stream * stream)
+{
+    return stream && (stream->flags & STREAM_ERR);
+}
+
+void
+StreamClearError(Stream * stream)
+{
+    if (stream)
+    {
+        stream->flags &= ~STREAM_ERR;
+    }
+}
+
+int
+StreamFlush(Stream * stream)
+{
+    if (!stream)
+    {
+        errno = EBADF;
+        return EOF;
+    }
+
+    if (stream->wLen)
+    {
+        ssize_t writeRes = IoWrite(stream->io, stream->wBuf, stream->wLen);
+
+        if (writeRes == -1)
+        {
+            stream->flags |= STREAM_ERR;
+            return EOF;
+        }
+
+        stream->wLen = 0;
+    }
+
+    return 0;
+}
+
+ssize_t
+StreamCopy(Stream * in, Stream * out)
+{
+    ssize_t nBytes = 0;
+    int c;
+    int tries = 0;
+    int readFlg = 0;
+
+    while (1)
+    {
+        c = StreamGetc(in);
+
+        if (StreamEof(in))
+        {
+            break;
+        }
+
+        if (StreamError(in))
+        {
+            if (errno == EAGAIN)
+            {
+                StreamClearError(in);
+                tries++;
+
+                if (tries >= STREAM_RETRIES || readFlg)
+                {
+                    break;
+                }
+                else
+                {
+                    UtilSleepMillis(STREAM_DELAY);
+                    continue;
+                }
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        /* As soon as we've successfully read a byte, treat future
+         * EAGAINs as EOF, because somebody might have forgotten to
+         * close their stream. */
+
+        readFlg = 1;
+        tries = 0;
+
+        StreamPutc(out, c);
+        nBytes++;
+    }
+
+    StreamFlush(out);
+    return nBytes;
+}
+
+int
+StreamFileno(Stream * stream)
+{
+    return stream ? stream->fd : -1;
+}

src/Tls.c

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Tls.h>
+
+#ifdef TLS_IMPL
+
+#include <Io.h>
+#include <Stream.h>
+
+Stream *
+TlsClientStream(int fd, const char *serverName)
+{
+    Io *io;
+    void *cookie;
+    IoFunctions funcs;
+
+    cookie = TlsInitClient(fd, serverName);
+    if (!cookie)
+    {
+        return NULL;
+    }
+
+    funcs.read = TlsRead;
+    funcs.write = TlsWrite;
+    funcs.seek = NULL;
+    funcs.close = TlsClose;
+
+    io = IoCreate(cookie, funcs);
+    if (!io)
+    {
+        return NULL;
+    }
+
+    return StreamIo(io);
+}
+
+Stream *
+TlsServerStream(int fd, const char *crt, const char *key)
+{
+    Io *io;
+    void *cookie;
+    IoFunctions funcs;
+
+    cookie = TlsInitServer(fd, crt, key);
+    if (!cookie)
+    {
+        return NULL;
+    }
+
+    funcs.read = TlsRead;
+    funcs.write = TlsWrite;
+    funcs.seek = NULL;
+    funcs.close = TlsClose;
+
+    io = IoCreate(cookie, funcs);
+    if (!io)
+    {
+        return NULL;
+    }
+
+    return StreamIo(io);
+}
+
+#endif

src/Tls/TlsLibreSSL.c

@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Tls.h>
+
+#if TLS_IMPL == TLS_LIBRESSL
+
+#include <Memory.h>
+#include <Log.h>
+
+#include <errno.h>
+
+#include <tls.h>                   /* LibreSSL TLS */
+
+typedef struct LibreSSLCookie
+{
+    int fd;
+    struct tls *ctx;
+    struct tls *cctx;
+    struct tls_config *cfg;
+} LibreSSLCookie;
+
+void *
+TlsInitClient(int fd, const char *serverName)
+{
+    LibreSSLCookie *cookie = Malloc(sizeof(LibreSSLCookie));
+
+    if (!cookie)
+    {
+        return NULL;
+    }
+
+    cookie->ctx = tls_client();
+    cookie->cctx = NULL;
+    cookie->cfg = tls_config_new();
+    cookie->fd = fd;
+
+
+    if (!cookie->ctx || !cookie->cfg)
+    {
+        goto error;
+    }
+
+    if (tls_config_set_ca_file(cookie->cfg, tls_default_ca_cert_file()) == -1)
+    {
+        goto error;
+    }
+
+    if (tls_configure(cookie->ctx, cookie->cfg) == -1)
+    {
+        goto error;
+    }
+
+    if (tls_connect_socket(cookie->ctx, fd, serverName) == -1)
+    {
+        goto error;
+    }
+
+    if (tls_handshake(cookie->ctx) == -1)
+    {
+        goto error;
+    }
+
+    return cookie;
+
+error:
+    if (cookie->ctx)
+    {
+        if (tls_error(cookie->ctx))
+        {
+            Log(LOG_ERR, "TlsInitClient(): %s", tls_error(cookie->ctx));
+        }
+
+        tls_free(cookie->ctx);
+    }
+
+    if (cookie->cfg)
+    {
+        tls_config_free(cookie->cfg);
+    }
+
+    Free(cookie);
+
+    return NULL;
+}
+
+void *
+TlsInitServer(int fd, const char *crt, const char *key)
+{
+    LibreSSLCookie *cookie = Malloc(sizeof(LibreSSLCookie));
+
+    if (!cookie)
+    {
+        return NULL;
+    }
+
+    cookie->ctx = tls_server();
+    cookie->cctx = NULL;
+    cookie->cfg = tls_config_new();
+    cookie->fd = fd;
+
+    if (!cookie->ctx || !cookie->cfg)
+    {
+        goto error;
+    }
+
+    if (tls_config_set_cert_file(cookie->cfg, crt) == -1)
+    {
+        goto error;
+    }
+
+    if (tls_config_set_key_file(cookie->cfg, key) == -1)
+    {
+        goto error;
+    }
+
+    if (tls_configure(cookie->ctx, cookie->cfg) == -1)
+    {
+        goto error;
+    }
+
+    if (tls_accept_fds(cookie->ctx, &cookie->cctx, fd, fd) == -1)
+    {
+        goto error;
+    }
+
+    if (tls_handshake(cookie->cctx) == -1)
+    {
+        goto error;
+    }
+
+    return cookie;
+
+error:
+    if (cookie->ctx)
+    {
+        if (tls_error(cookie->ctx))
+        {
+            Log(LOG_ERR, "TlsInitServer(): %s", tls_error(cookie->ctx));
+        }
+        tls_free(cookie->ctx);
+    }
+
+    if (cookie->cctx)
+    {
+        if (tls_error(cookie->cctx))
+        {
+            Log(LOG_ERR, "TlsInitServer(): %s", tls_error(cookie->cctx));
+        }
+
+        tls_free(cookie->cctx);
+    }
+
+    if (cookie->cfg)
+    {
+        tls_config_free(cookie->cfg);
+    }
+
+    Free(cookie);
+
+    return NULL;
+}
+
+ssize_t
+TlsRead(void *cookie, void *buf, size_t nBytes)
+{
+    LibreSSLCookie *tls = cookie;
+    struct tls *ctx = tls->cctx ? tls->cctx : tls->ctx;
+    ssize_t ret = tls_read(ctx, buf, nBytes);
+
+    if (ret == -1)
+    {
+        errno = EIO;
+    }
+    else if (ret == TLS_WANT_POLLIN || ret == TLS_WANT_POLLOUT)
+    {
+        errno = EAGAIN;
+        ret = -1;
+    }
+
+    return ret;
+}
+
+ssize_t
+TlsWrite(void *cookie, void *buf, size_t nBytes)
+{
+    LibreSSLCookie *tls = cookie;
+    struct tls *ctx = tls->cctx ? tls->cctx : tls->ctx;
+    ssize_t ret = tls_write(ctx, buf, nBytes);
+
+    if (ret == -1)
+    {
+        errno = EIO;
+    }
+    else if (ret == TLS_WANT_POLLIN || ret == TLS_WANT_POLLOUT)
+    {
+        errno = EAGAIN;
+        ret = -1;
+    }
+
+    return ret;
+}
+
+int
+TlsClose(void *cookie)
+{
+    LibreSSLCookie *tls = cookie;
+
+    int tlsRet = tls_close(tls->cctx ? tls->cctx : tls->ctx);
+    int sdRet;
+
+    if (tls->cctx)
+    {
+        tls_free(tls->cctx);
+    }
+
+    tls_free(tls->ctx);
+    tls_config_free(tls->cfg);
+
+    sdRet = close(tls->fd);
+
+    Free(tls);
+
+    return (tlsRet == -1 || sdRet == -1) ? -1 : 0;
+}
+
+#endif

src/Tls/TlsOpenSSL.c

@@ -0,0 +1,296 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Tls.h>
+
+#if TLS_IMPL == TLS_OPENSSL
+
+#include <Memory.h>
+#include <Log.h>
+
+#include <string.h>
+
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+
+typedef struct OpenSSLCookie
+{
+    int fd;
+    const SSL_METHOD *method;
+    SSL_CTX *ctx;
+    SSL *ssl;
+} OpenSSLCookie;
+
+static char *
+SSLErrorString(int err)
+{
+    switch (err)
+    {
+            case SSL_ERROR_NONE:
+            return "No error.";
+        case SSL_ERROR_ZERO_RETURN:
+            return "The TLS/SSL connection has been closed.";
+        case SSL_ERROR_WANT_READ:
+        case SSL_ERROR_WANT_WRITE:
+        case SSL_ERROR_WANT_CONNECT:
+        case SSL_ERROR_WANT_ACCEPT:
+            return "The operation did not complete.";
+        case SSL_ERROR_WANT_X509_LOOKUP:
+            return "X509 lookup failed.";
+        case SSL_ERROR_SYSCALL:
+            return "I/O Error.";
+        case SSL_ERROR_SSL:
+            return "SSL library error.";
+    }
+    return NULL;
+}
+
+void *
+TlsInitClient(int fd, const char *serverName)
+{
+    OpenSSLCookie *cookie;
+    char errorStr[256];
+
+    /*
+     * TODO: Seems odd that this isn't needed to make the
+     * connection... we should figure out how to verify the
+     * certificate matches the server we think we're
+     * connecting to.
+     */
+    (void) serverName;
+
+    cookie = Malloc(sizeof(OpenSSLCookie));
+    if (!cookie)
+    {
+        return NULL;
+    }
+
+    memset(cookie, 0, sizeof(OpenSSLCookie));
+
+    cookie->method = TLS_client_method();
+    cookie->ctx = SSL_CTX_new(cookie->method);
+    if (!cookie->ctx)
+    {
+        goto error;
+    }
+
+    cookie->ssl = SSL_new(cookie->ctx);
+    if (!cookie->ssl)
+    {
+        goto error;
+    }
+
+    if (!SSL_set_fd(cookie->ssl, fd))
+    {
+        goto error;
+    }
+
+    if (SSL_connect(cookie->ssl) <= 0)
+    {
+        goto error;
+    }
+
+    return cookie;
+
+error:
+    Log(LOG_ERR, "TlsClientInit(): %s", ERR_error_string(ERR_get_error(), errorStr));
+
+    if (cookie->ssl)
+    {
+        SSL_shutdown(cookie->ssl);
+        SSL_free(cookie->ssl);
+    }
+
+    close(cookie->fd);
+
+    if (cookie->ctx)
+    {
+        SSL_CTX_free(cookie->ctx);
+    }
+
+    return NULL;
+}
+
+void *
+TlsInitServer(int fd, const char *crt, const char *key)
+{
+    OpenSSLCookie *cookie;
+    char errorStr[256];
+    int acceptRet = 0;
+
+    cookie = Malloc(sizeof(OpenSSLCookie));
+    if (!cookie)
+    {
+        return NULL;
+    }
+
+    memset(cookie, 0, sizeof(OpenSSLCookie));
+
+    cookie->method = TLS_server_method();
+    cookie->ctx = SSL_CTX_new(cookie->method);
+    if (!cookie->ctx)
+    {
+        Log(LOG_ERR, "TlsInitServer(): Unable to create SSL Context.");
+        goto error;
+    }
+
+    if (SSL_CTX_use_certificate_file(cookie->ctx, crt, SSL_FILETYPE_PEM) <= 0)
+    {
+        Log(LOG_ERR, "TlsInitServer(): Unable to set certificate file: %s", crt);
+        goto error;
+    }
+
+    if (SSL_CTX_use_PrivateKey_file(cookie->ctx, key, SSL_FILETYPE_PEM) <= 0)
+    {
+        Log(LOG_ERR, "TlsInitServer(): Unable to set key file.");
+        goto error;
+    }
+
+    cookie->ssl = SSL_new(cookie->ctx);
+    if (!cookie->ssl)
+    {
+        Log(LOG_ERR, "TlsInitServer(): Unable to create SSL object.");
+        goto error;
+    }
+
+    if (!SSL_set_fd(cookie->ssl, fd))
+    {
+        Log(LOG_ERR, "TlsInitServer(): Unable to set file descriptor.");
+        goto error;
+    }
+
+    while ((acceptRet = SSL_accept(cookie->ssl)) <= 0)
+    {
+        switch (SSL_get_error(cookie->ssl, acceptRet))
+        {
+            case SSL_ERROR_WANT_READ:
+            case SSL_ERROR_WANT_WRITE:
+            case SSL_ERROR_WANT_CONNECT:
+            case SSL_ERROR_WANT_ACCEPT:
+                continue;
+            default:
+                Log(LOG_ERR, "TlsInitServer(): Unable to accept connection.");
+                goto error;
+        }
+    }
+
+    return cookie;
+
+error:
+    Log(LOG_ERR, "TlsServerInit(): %s", SSLErrorString(SSL_get_error(cookie->ssl, acceptRet)));
+    Log(LOG_ERR, "TlsServerInit(): %s", ERR_error_string(ERR_get_error(), errorStr));
+
+    if (cookie->ssl)
+    {
+        SSL_shutdown(cookie->ssl);
+        SSL_free(cookie->ssl);
+    }
+
+    close(cookie->fd);
+
+    if (cookie->ctx)
+    {
+        SSL_CTX_free(cookie->ctx);
+    }
+
+    Free(cookie);
+
+    return NULL;
+}
+
+ssize_t
+TlsRead(void *cookie, void *buf, size_t nBytes)
+{
+    OpenSSLCookie *ssl = cookie;
+    int ret = SSL_read(ssl->ssl, buf, nBytes);
+
+    if (ret <= 0)
+    {
+        switch (SSL_get_error(ssl->ssl, ret))
+        {
+            case SSL_ERROR_WANT_READ:
+            case SSL_ERROR_WANT_WRITE:
+            case SSL_ERROR_WANT_CONNECT:
+            case SSL_ERROR_WANT_ACCEPT:
+            case SSL_ERROR_WANT_X509_LOOKUP:
+                errno = EAGAIN;
+                break;
+            case SSL_ERROR_ZERO_RETURN:
+                ret = 0;
+                break;
+            default:
+                errno = EIO;
+                break;
+        }
+        ret = -1;
+    }
+
+    return ret;
+}
+
+ssize_t
+TlsWrite(void *cookie, void *buf, size_t nBytes)
+{
+    OpenSSLCookie *ssl = cookie;
+    int ret = SSL_write(ssl->ssl, buf, nBytes);
+
+    if (ret <= 0)
+    {
+        switch (SSL_get_error(ssl->ssl, ret))
+        {
+            case SSL_ERROR_WANT_READ:
+            case SSL_ERROR_WANT_WRITE:
+            case SSL_ERROR_WANT_CONNECT:
+            case SSL_ERROR_WANT_ACCEPT:
+            case SSL_ERROR_WANT_X509_LOOKUP:
+                errno = EAGAIN;
+                break;
+            case SSL_ERROR_ZERO_RETURN:
+                ret = 0;
+                break;
+            default:
+                errno = EIO;
+                break;
+        }
+        ret = -1;
+    }
+
+    return ret;
+}
+
+int
+TlsClose(void *cookie)
+{
+    OpenSSLCookie *ssl = cookie;
+
+    SSL_shutdown(ssl->ssl);
+    SSL_free(ssl->ssl);
+    close(ssl->fd);
+    SSL_CTX_free(ssl->ctx);
+
+    Free(ssl);
+
+    return 0;
+}
+
+#endif

src/Uri.c

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Uri.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#include <Memory.h>
+
+Uri *
+UriParse(const char *str)
+{
+    Uri *uri;
+    int res;
+
+    if (!str)
+    {
+        return NULL;
+    }
+
+    uri = Malloc(sizeof(Uri));
+    if (!uri)
+    {
+        return NULL;
+    }
+
+    memset(uri, 0, sizeof(Uri));
+
+    res = sscanf(str, "%7[^:]://%127[^:]:%hu%255[^\n]", uri->proto, uri->host, &uri->port, uri->path) == 4
+            || sscanf(str, "%7[^:]://%127[^/]%255[^\n]", uri->proto, uri->host, uri->path) == 3
+            || sscanf(str, "%7[^:]://%127[^:]:%hu[^\n]", uri->proto, uri->host, &uri->port) == 3
+            || sscanf(str, "%7[^:]://%127[^\n]", uri->proto, uri->host) == 2;
+
+    if (!res)
+    {
+        Free(uri);
+        return NULL;
+    }
+
+    if (!uri->path[0])
+    {
+        strcpy(uri->path, "/");
+    }
+
+    return uri;
+}
+
+void
+UriFree(Uri * uri)
+{
+    Free(uri);
+}

src/Util.c

@@ -0,0 +1,246 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <Util.h>
+
+#include <Memory.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+#include <time.h>
+
+#include <unistd.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <limits.h>
+#include <pthread.h>
+
+#ifndef PATH_MAX
+#define PATH_MAX 256
+#endif
+
+#ifndef SSIZE_MAX
+#define SSIZE_MAX LONG_MAX
+#endif
+
+unsigned long
+UtilServerTs(void)
+{
+    struct timeval tv;
+    unsigned long ts;
+
+    gettimeofday(&tv, NULL);
+    ts = (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
+
+    return ts;
+}
+
+unsigned long
+UtilLastModified(char *path)
+{
+    struct stat st;
+    unsigned long ts;
+
+    if (stat(path, &st) == 0)
+    {
+        ts = (st.st_mtim.tv_sec * 1000) + (st.st_mtim.tv_nsec / 1000000);
+        return ts;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+int
+UtilMkdir(const char *dir, const mode_t mode)
+{
+    char tmp[PATH_MAX];
+    char *p = NULL;
+
+    struct stat st;
+
+    size_t len;
+
+    len = strnlen(dir, PATH_MAX);
+    if (!len || len == PATH_MAX)
+    {
+        errno = ENAMETOOLONG;
+        return -1;
+    }
+
+    memcpy(tmp, dir, len);
+    tmp[len] = '\0';
+
+    if (tmp[len - 1] == '/')
+    {
+        tmp[len - 1] = '\0';
+    }
+
+    if (stat(tmp, &st) == 0 && S_ISDIR(st.st_mode))
+    {
+        return 0;
+    }
+
+    for (p = tmp + 1; *p; p++)
+    {
+        if (*p == '/')
+        {
+            *p = 0;
+
+            if (stat(tmp, &st) != 0)
+            {
+                if (mkdir(tmp, mode) < 0)
+                {
+                    /* errno already set by mkdir() */
+                    return -1;
+                }
+            }
+            else if (!S_ISDIR(st.st_mode))
+            {
+                errno = ENOTDIR;
+                return -1;
+            }
+
+            *p = '/';
+        }
+    }
+
+    if (stat(tmp, &st) != 0)
+    {
+        if (mkdir(tmp, mode) < 0)
+        {
+            /* errno already set by mkdir() */
+            return -1;
+        }
+    }
+    else if (!S_ISDIR(st.st_mode))
+    {
+        errno = ENOTDIR;
+        return -1;
+    }
+
+    return 0;
+}
+
+int
+UtilSleepMillis(long ms)
+{
+    struct timespec ts;
+    int res;
+
+    ts.tv_sec = ms / 1000;
+    ts.tv_nsec = (ms % 1000) * 1000000;
+
+    res = nanosleep(&ts, &ts);
+
+    return res;
+}
+
+ssize_t
+UtilGetDelim(char **linePtr, size_t * n, int delim, Stream * stream)
+{
+    char *curPos, *newLinePtr;
+    size_t newLinePtrLen;
+    int c;
+
+    if (!linePtr || !n || !stream)
+    {
+        errno = EINVAL;
+        return -1;
+    }
+
+    if (*linePtr == NULL)
+    {
+        *n = 128;
+
+        if (!(*linePtr = Malloc(*n)))
+        {
+            errno = ENOMEM;
+            return -1;
+        }
+    }
+
+    curPos = *linePtr;
+
+    while (1)
+    {
+        c = StreamGetc(stream);
+
+        if (StreamError(stream) || (c == EOF && curPos == *linePtr))
+        {
+            return -1;
+        }
+
+        if (c == EOF)
+        {
+            break;
+        }
+
+        if ((*linePtr + *n - curPos) < 2)
+        {
+            if (SSIZE_MAX / 2 < *n)
+            {
+#ifdef EOVERFLOW
+                errno = EOVERFLOW;
+#else
+                errno = ERANGE;
+#endif
+                return -1;
+            }
+
+            newLinePtrLen = *n * 2;
+
+            if (!(newLinePtr = Realloc(*linePtr, newLinePtrLen)))
+            {
+                errno = ENOMEM;
+                return -1;
+            }
+
+            curPos = newLinePtr + (curPos - *linePtr);
+            *linePtr = newLinePtr;
+            *n = newLinePtrLen;
+        }
+
+        *curPos++ = (char) c;
+
+        if (c == delim)
+        {
+            break;
+        }
+    }
+
+    *curPos = '\0';
+    return (ssize_t) (curPos - *linePtr);
+}
+
+ssize_t
+UtilGetLine(char **linePtr, size_t * n, Stream * stream)
+{
+    return UtilGetDelim(linePtr, n, '\n', stream);
+}

src/include/Args.h

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_ARGS_H
+#define CYTOPLASM_ARGS_H
+
+/***
+ * @Nm Args
+ * @Nd Getopt-style argument parser that operates on arrays.
+ * @Dd May 12 2023
+ * @Xr Array
+ *
+ * .Nm
+ * provides a simple argument parser in the style of
+ * .Xr getopt 3 .
+ * It exists because the runtime passes the program arguments as
+ * an Array, and it is often useful to parse the arguments to
+ * provide the standard command line interface.
+ */
+
+#include <Array.h>
+
+/**
+ * All state is stored in this structure, instead of global
+ * variables. This makes
+ * .Nm
+ * thread-safe and easy to reset.
+ */
+typedef struct ArgParseState
+{
+    int optInd;
+    int optErr;
+    int optOpt;
+    char *optArg;
+
+    int optPos;
+} ArgParseState;
+
+/**
+ * Initialize the variables in the given parser state structure
+ * to their default values. This should be called before
+ * .Fn ArgParse
+ * is called with the parser state. It should also be called if
+ * .Fn ArgParse
+ * will be used again on a different array, or the same array all
+ * over again.
+ */
+extern void ArgParseStateInit(ArgParseState *);
+
+/**
+ * Parse command line arguments stored in the given array, using
+ * the given state and option string. This function behaves
+ * identically to the POSIX
+ * .Fn getopt
+ * function, and should be used in exactly the same way. Refer to
+ * your system's
+ * .Xr getopt 3
+ * page for details.
+ */
+extern int ArgParse(ArgParseState *, Array *, const char *);
+
+#endif /* CYTOPLASM_ARGS_H */

src/include/Array.h

@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef CYTOPLASM_ARRAY_H
+#define CYTOPLASM_ARRAY_H
+
+/***
+ * @Nm Array
+ * @Nd A simple dynamic array data structure.
+ * @Dd November 24 2022
+ * @Xr HashMap Queue
+ *
+ * These functions implement a simple array data structure that is
+ * automatically resized as necessary when new values are added.  This
+ * implementation does not actually store the values of the items in it;
+ * it only stores pointers to the data. As such, you will still have to
+ * manually maintain all your data. The advantage of this is that these
+ * functions don't have to copy data, and thus don't care how big the
+ * data is. Furthermore, arbitrary data can be stored in the array.
+ * .Pp
+ * This array implementation is optimized for storage space and
+ * appending. Deletions are expensive in that all the items of the list
+ * above a deletion are moved down to fill the hole where the deletion
+ * occurred. Insertions are also expensive in that all the elements
+ * above the given index must be shifted up to make room for the new
+ * element.
+ * .Pp
+ * Due to these design choices, this array implementation is best
+ * suited to linear writing, and then linear or random reading.
+ */
+
+#include <stddef.h>
+#include <stdarg.h>
+
+/**
+ * The functions in this API operate on an array structure which is
+ * opaque to the caller.
+ */
+typedef struct Array Array;
+
+/**
+ * Allocate a new array. This function returns a pointer that can be
+ * used with the other functions in this API, or NULL if there was an
+ * error allocating memory for the array.
+ */
+extern Array * ArrayCreate(void);
+
+/**
+ * Deallocate an array. Note that this function does not free any of
+ * the values stored in the array; it is the caller's job to manage the
+ * memory for each item. Typically, the caller would iterate over all
+ * the items in the array and free them before freeing the array.
+ */
+extern void ArrayFree(Array *);
+
+/**
+ * Get the size, in number of elements, of the given array.
+ */
+extern size_t ArraySize(Array *);
+
+/**
+ * Get the element at the specified index from the specified array.
+ * This function will return NULL if the array is NULL, or the index
+ * is out of bounds. Otherwise, it will return a pointer to a value
+ * put into the array using
+ * .Fn ArrayInsert
+ * or
+ * .Fn ArraySet .
+ */
+extern void * ArrayGet(Array *, size_t);
+
+/**
+ * Insert the specified element at the specified index in the specified
+ * array. This function will shift the element currently at that index,
+ * and any elements after it before inserting the given element.
+ * .Pp
+ * This function returns a boolean value indicating whether or not it
+ * suceeded.
+ */
+extern int ArrayInsert(Array *, size_t, void *);
+
+/**
+ * Set the value at the specified index in the specified array to the
+ * specified value. This function will return the old value at that
+ * index, if any.
+ */
+extern void * ArraySet(Array *, size_t, void *);
+
+/**
+ * Append the specified element to the end of the specified array. This
+ * function uses
+ * .Fn ArrayInsert
+ * under the hood to insert an element at the end. It thus has the same
+ * return value as
+ * .Fn ArrayInsert .
+ */
+extern int ArrayAdd(Array *, void *);
+
+/**
+ * Remove the element at the specified index from the specified array.
+ * This function returns the element removed, if any.
+ */
+extern void * ArrayDelete(Array *, size_t);
+
+/**
+ * Sort the specified array using the specified sort function. The
+ * sort function compares two elements. It takes two void pointers as
+ * parameters, and returns an integer. The return value indicates to
+ * the sorting algorithm how the elements relate to each other. A
+ * return value of 0 indicates that the elements are identical. A
+ * return value greater than 0 indicates that the first item is
+ * ``bigger'' than the second item and should thus appear after it in
+ * the array. A return value less than 0 indicates the opposite: the
+ * second element should appear after the first in the array.
+ */
+extern void ArraySort(Array *, int (*) (void *, void *));
+
+/**
+ * If possible, reduce the amount of memory allocated to this array
+ * by calling
+ * .Fn Realloc
+ * on the internal structure to perfectly fit the elements in the
+ * array. This function is intended to be used by functions that return
+ * relatively read-only arrays that will be long-lived.
+ */
+extern int ArrayTrim(Array *);
+
+/**
+ * Convert a variadic arguments list into an Array. In most cases, the
+ * Array API is much easier to work with than
+ * .Fn va_arg
+ * and friends.
+ */
+extern Array * ArrayFromVarArgs(size_t, va_list);
+
+/**
+ * Duplicate an existing array. Note that arrays only hold pointers to
+ * their data, not the data itself, so the duplicated array will point
+ * to the same places in memory as the original array.
+ */
+extern Array * ArrayDuplicate(Array *);
+
+#endif                             /* CYTOPLASM_ARRAY_H */

src/include/Base64.h

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef CYTOPLASM_BASE64_H
+#define CYTOPLASM_BASE64_H
+
+/***
+ * @Nm Base64
+ * @Nd A simple base64 encoder/decoder with unpadded base64 support.
+ * @Dd September 30 2022
+ * @Xr Sha2
+ *
+ * This is an efficient yet simple base64 encoding and decoding API
+ * that supports regular base64, as well as the Matrix specification's
+ * extension to base64, called ``unpadded base64.'' This API provides
+ * the ability to convert between the two, instead of just implementing
+ * unpadded base64.
+ */
+
+#include <stddef.h>
+
+/**
+ * This function computes the amount of bytes needed to store a message
+ * of the specified number of bytes as base64.
+ */
+extern size_t
+ Base64EncodedSize(size_t);
+
+/**
+ * This function computes the amount of bytes needed to store a decoded
+ * representation of the encoded message. It takes a pointer to the
+ * encoded string because it must read a few bytes off the end in order
+ * to accurately compute the size.
+ */
+extern size_t
+ Base64DecodedSize(const char *, size_t);
+
+/**
+ * Encode the specified number of bytes from the specified buffer as
+ * base64. This function returns a string on the heap that should be
+ * freed with
+ * .Fn Free ,
+ * or NULL if a memory allocation error ocurred.
+ */
+extern char *
+ Base64Encode(const char *, size_t);
+
+/**
+ * Decode the specified number of bytes from the specified buffer of
+ * base64. This function returns a string on the heap that should be
+ * freed with
+ * .Fn Free ,
+ * or NULL if a memory allocation error occured.
+ */
+extern char *
+ Base64Decode(const char *, size_t);
+
+/**
+ * Remove the padding from a specified base64 string. This function
+ * modifies the specified string in place. It thus has no return value
+ * because it cannot fail. If the passed pointer is invalid, the
+ * behavior is undefined.
+ */
+extern void
+ Base64Unpad(char *, size_t);
+
+/**
+ * Add padding to an unpadded base64 string. This function takes a
+ * pointer to a pointer because it may be necessary to grow the memory
+ * allocated to the string. This function returns a boolean value
+ * indicating whether the pad operation was successful. In practice,
+ * this means it will only fail if a bigger string is necessary, but it
+ * could not be automatically allocated on the heap.
+ */
+extern int
+ Base64Pad(char **, size_t);
+
+#endif                             /* CYTOPLASM_BASE64_H */

src/include/Cron.h

@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_CRON_H
+#define CYTOPLASM_CRON_H
+
+/***
+ * @Nm Cron
+ * @Nd Basic periodic job scheduler.
+ * @Dd December 24 2022
+ * 
+ * This is an extremely basic job scheduler. So basic, in fact, that
+ * it currently runs all jobs on a single thread, which means that it
+ * is intended for short-lived jobs. In the future, it might be
+ * extended to support a one-thread-per-job model, but for now, jobs
+ * should take into consideration the fact that they are sharing their
+ * thread, so they should not be long-running.
+ * .Pp
+ * .Nm
+ * works by ``ticking'' at an interval defined by the caller of
+ * .Fn CronCreate .
+ * At each tick, all the registered jobs are queried, and if they are
+ * due to run again, their function is executed. As much as possible,
+ * .Nm
+ * tries to tick at constant intervals, however it is possible that one
+ * or more jobs may overrun the tick duration. If this happens,
+ * .Nm
+ * ticks again immediately after all the jobs for the previous tick
+ * have completed. This is in an effort to compensate for lost time,
+ * however it is important to note that when jobs overrun the tick
+ * interval, the interval is pushed back by the amount that it was
+ * overrun. Because of this,
+ * .Nm
+ * is best suited for scheduling jobs that should happen
+ * ``aproximately'' every so often; it is not a real-time scheduler
+ * by any means.
+ */
+
+/**
+ * All functions defined here operate on a structure opaque to the
+ * caller.
+ */
+typedef struct Cron Cron;
+
+/**
+ * A job function is a function that takes a void pointer and returns
+ * nothing. The pointer is passed when the job is scheduled, and
+ * is expected to remain valid until the job is no longer registered.
+ * The pointer is passed each time the job executes.
+ */
+typedef void (JobFunc) (void *);
+
+/**
+ * Create a new
+ * .Nm
+ * object that all other functions operate on. Like most of the other
+ * APIs in this project, it must be freed with
+ * .Fn CronFree
+ * when it is no longer needed.
+ * .Pp
+ * This function takes the tick interval in milliseconds.
+ */
+extern Cron *
+ CronCreate(unsigned long);
+
+/**
+ * Schedule a one-off job to be executed only at the next tick, and
+ * then immediately discarded. This is useful for scheduling tasks that
+ * only have to happen once, or very infrequently depending on
+ * conditions other than the current time, but don't have to happen
+ * immediately. The caller simply indicates that it wishes for the task
+ * to execute at some time in the future. How far into the future this
+ * practically ends up being is determined by how long it takes for
+ * other registered jobs to finish, and what the tick interval is.
+ * .Pp
+ * This function takes a job function and a pointer to pass to that
+ * function when it is executed.
+ */
+extern void
+ CronOnce(Cron *, JobFunc *, void *);
+
+/**
+ * Schedule a repetitive task to be executed at aproximately the given
+ * interval. As stated above, this is as fuzzy interval; depending on
+ * the jobs being run and the tick interval, tasks may not execute at
+ * exactly the scheduled time, but they will eventually execute.
+ * .Pp
+ * This function takes an interval in milliseconds, a job function,
+ * and a pointer to pass to that function when it is executed.
+ */
+extern void
+ CronEvery(Cron *, unsigned long, JobFunc *, void *);
+
+/**
+ * Start ticking the clock and executing registered jobs.
+ */
+extern void
+ CronStart(Cron *);
+
+/**
+ * Stop ticking the clock. Jobs that are already executing will
+ * continue to execute, but when they are finished, no new jobs will
+ * be executed until
+ * .Fn CronStart
+ * is called.
+ */
+extern void
+ CronStop(Cron *);
+
+/**
+ * Discard all job references and free all memory associated with the
+ * given
+ * .Nm Cron
+ * instance.
+ */
+extern void
+ CronFree(Cron *);
+
+#endif                             /* CYTOPLASM_CRON_H */

src/include/Db.h

@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_DB_H
+#define CYTOPLASM_DB_H
+
+/***
+ * @Nm Db
+ * @Nd A minimal flat-file database with mutex locking and cache.
+ * @Dd April 27 2023
+ * @Xr Json
+ *
+ * Cytoplasm operates on a flat-file database instead of a
+ * traditional relational database. This greatly simplifies the
+ * persistent storage code, and creates a relatively basic API,
+ * described here.
+ */
+
+#include <stddef.h>
+
+#include <HashMap.h>
+#include <Array.h>
+
+/**
+ * All functions in this API operate on a database structure that is
+ * opaque to the caller.
+ */
+typedef struct Db Db;
+
+/**
+ * When an object is locked, a reference is returned. This reference
+ * is owned by the current thread, and the database is inaccessible to
+ * other threads until all references have been returned to the
+ * database.
+ * .Pp
+ * This reference is opaque, but can be manipulated by the functions
+ * defined here.
+ */
+typedef struct DbRef DbRef;
+
+/**
+ * Open a data directory. This function takes a path to open, and a
+ * cache size in bytes. If the cache size is 0, then caching is
+ * disabled and objects are loaded off the disk every time they are
+ * locked. Otherwise, objects are stored in the cache, and they are
+ * evicted in a least-recently-used manner.
+ */
+extern Db * DbOpen(char *, size_t);
+
+/**
+ * Close the database. This function will flush anything in the cache
+ * to the disk, and then close the data directory. It assumes that
+ * all references have been unlocked. If a reference has not been
+ * unlocked, undefined behavior results.
+ */
+extern void DbClose(Db *);
+
+/**
+ * Set the maximum cache size allowed before
+ * .Nm
+ * starts evicting old objects. If this is set to 0, everything in the
+ * cache is immediately evicted and caching is disabled. If the
+ * database was opened with a cache size of 0, setting this will
+ * initialize the cache, and subsequent calls to
+ * .Fn DbLock
+ * will begin caching objects.
+ */
+extern void DbMaxCacheSet(Db *, size_t);
+
+/**
+ * Create a new object in the database with the specified name. This
+ * function will fail if the object already exists in the database. It
+ * takes a variable number of C strings, with the exact number being
+ * specified by the second parameter. These C strings are used to
+ * generate a filesystem path at which to store the object. These paths
+ * ensure each object is uniquely identifiable, and provides semantic
+ * meaning to an object.
+ */
+extern DbRef * DbCreate(Db *, size_t,...);
+
+/**
+ * Lock an existing object in the database. This function will fail
+ * if the object does not exist. It takes a variable number of C
+ * strings, with the exact number being specified by the second
+ * parameter. These C strings are used to generate the filesystem path
+ * at which to load the object. These paths ensure each object is
+ * uniquely identifiable, and provides semantic meaning to an object.
+ */
+extern DbRef * DbLock(Db *, size_t,...);
+
+/**
+ * Immediately and permanently remove an object from the database.
+ * This function assumes the object is not locked, otherwise undefined
+ * behavior will result.
+ */
+extern int DbDelete(Db *, size_t,...);
+
+/**
+ * Unlock an object and return it back to the database. This function
+ * immediately syncs the object to the filesystem. The cache is a
+ * read cache; writes are always immediate to ensure data integrity in
+ * the event of a system failure.
+ */
+extern int DbUnlock(Db *, DbRef *);
+
+/**
+ * Check the existence of the given database object in a more efficient
+ * manner than attempting to lock it with
+ * .Fn DbLock .
+ * This function does not lock the object, nor does it load it into
+ * memory if it exists.
+ */
+extern int DbExists(Db *, size_t,...);
+
+/**
+ * List all of the objects at a given path. Unlike the other varargs
+ * functions, this one does not take a path to a specific object; it
+ * takes a directory to be iterated, where each path part is its own
+ * C string. Note that the resulting list only contains the objects
+ * in the specified directory, it does not list any subdirectories.
+ * .Pp
+ * The array returned is an array of C strings containing the object
+ * name.
+ */
+extern Array * DbList(Db *, size_t,...);
+
+/**
+ * Free the list returned by 
+ * .Fn DbListFree .
+ */
+extern void DbListFree(Array *);
+
+/**
+ * Convert a database reference into JSON that can be manipulated.
+ * At this time, the database actually stores objects as JSON on the
+ * disk, so this function just returns an internal pointer, but in the
+ * future it may have to be generated by decompressing a binary blob,
+ * or something of that nature.
+ */
+extern HashMap * DbJson(DbRef *);
+
+/**
+ * Free the existing JSON associated with the given reference, and
+ * replace it with new JSON. This is more efficient than duplicating
+ * a separate object into the database reference.
+ */
+extern int DbJsonSet(DbRef *, HashMap *);
+
+#endif

src/include/HashMap.h

@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef CYTOPLASM_HASHMAP_H
+#define CYTOPLASM_HASHMAP_H
+
+/***
+ * @Nm HashMap
+ * @Nd A simple hash map implementation.
+ * @Dd October 11 2022
+ * @Xr Array Queue
+ *
+ * This is the public interface for Cytoplasm's hash map
+ * implementation. This hash map is designed to be simple,
+ * well-documented, and generally readable and understandable, yet also
+ * performant enough to be useful, because it is used extensively
+ * throughout the project.
+ * .Pp
+ * Fundamentally, this is an entirely generic map implementation. It
+ * can be used for many general purposes, but it is designed only to
+ * implement the features Cytoplasm needs to be functional. One
+ * example of a Cytoplasm-specific feature is that keys cannot be
+ * arbitrary data; they are NULL-terminated C strings.
+ */
+
+#include <stddef.h>
+
+/**
+ * These functions operate on an opaque structure, which the caller
+ * has no knowledge about.
+ */
+typedef struct HashMap HashMap;
+
+/**
+ * Create a new hash map that is ready to be used with the rest of the
+ * functions defined here.
+ */
+extern HashMap * HashMapCreate(void);
+
+/**
+ * Free the specified hash map such that it becomes invalid and any
+ * future use results in undefined behavior. Note that this function
+ * does not free the values stored in the hash map, but since it stores
+ * the keys internally, it will free the keys. You should use
+ * .Fn HashMapIterate
+ * to free the values stored in this map appropriately before calling
+ * this function.
+ */
+extern void HashMapFree(HashMap *);
+
+/**
+ * Control the maximum load of the hash map before it is expanded.
+ * When the hash map reaches the given capacity, it is grown. You
+ * don't want to only grow hash maps when they are full, because that
+ * makes them perform very poorly. The maximum load value is a
+ * percentage of how full the hash map is, and it should be between
+ * 0 and 1, where 0 means that no elements will cause the map to be
+ * expanded, and 1 means that the hash map must  be completely full
+ * before it is expanded. The default maximum load on a new hash map
+ * is 0.75, which should be good enough for most purposes, however,
+ * this function exists specifically so that the maximum load can be
+ * fine-tuned.
+ */
+extern void HashMapMaxLoadSet(HashMap *, float);
+
+/**
+ * Use a custom hashing function with the given hash map. New hash
+ * maps have a sane hashing function that should work okay for most
+ * use cases, but if you have a better hashing function, it can be
+ * specified this way. Do not change the hash function after keys have
+ * been added; doing so results in undefined behavior. Only set a new
+ * hash function immediately after constructing a new hash map, before
+ * anything has been added to it.
+ * .Pp
+ * The hash function takes a pointer to a C string, and is expected
+ * to return a fairly unique numerical hash value which will be
+ * converted into an array index.
+ */
+extern void
+HashMapFunctionSet(HashMap *, unsigned long (*) (const char *));
+
+/**
+ * Set the given string key to the given value. Note that the key is
+ * copied into the hash map's own memory space, but the value is not.
+ * It is the caller's job to ensure that the value pointer remains
+ * valid for the life of the hash map, and are freed when no longer
+ * needed.
+ */
+extern void * HashMapSet(HashMap *, char *, void *);
+
+/**
+ * Retrieve the value for the given key, or return NULL if no such
+ * key exists in the hash map.
+ */
+extern void * HashMapGet(HashMap *, const char *);
+
+/**
+ * Remove a value specified by the given key from the hash map, and
+ * return it to the caller to deal with. This function returns NULL
+ * if no such key exists.
+ */
+extern void * HashMapDelete(HashMap *, const char *);
+
+/**
+ * Iterate over all the keys and values of a hash map. This function
+ * works very similarly to
+ * .Xr getopt 3 ,
+ * where calls are repeatedly made in a while loop until there are no
+ * more items to go over. The difference is that this function does not
+ * rely on globals; it takes pointer pointers, and stores all
+ * necessary state inside the hash map itself.
+ * .Pp
+ * Note that this function is not thread-safe; two threads cannot be
+ * iterating over any given hash map at the same time, though they
+ * can each be iterating over different hash maps.
+ * .Pp
+ * This function can be tricky to use in some scenarios, as it
+ * continues where it left off on each call, until there are no more
+ * elements to go through in the hash map. If you are not iterating
+ * over the entire map in one go, and happen to break the loop, then
+ * the next time you attempt to iterate the hash map, you'll start
+ * somewhere in the middle, which is most likely not the intended
+ * behavior. Thus, it is always recommended to iterate over the entire
+ * hash map if you're going to use this function.
+ * .Pp
+ * Also note that the behavior of this function is undefined if
+ * insertions or deletions occur during the iteration. This
+ * functionality has not been tested, and will likely not work.
+ */
+extern int HashMapIterate(HashMap *, char **, void **);
+
+/**
+ * A reentrant version of
+ * .Fn HashMapIterate
+ * that allows the caller to overcome the flaws of that function by
+ * storing the cursor outside of the hash map structure itself. This
+ * allows multiple threads to iterate over the same hash map at the
+ * same time, and it allows the iteration to be halted midway through
+ * without causing any unintended side effects.
+ * .Pp
+ * The cursor should be initialized to 0 at the start of iteration.
+ */
+extern int
+HashMapIterateReentrant(HashMap *, char **, void **, size_t *);
+
+#endif                             /* CYTOPLASM_HASHMAP_H */

src/include/HeaderParser.h

@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_HEADERPARSER_H
+#define CYTOPLASM_HEADERPARSER_H
+
+/***
+ * @Nm HeaderParser
+ * @Nd Parse simple C header files.
+ * @Dd April 29 2023
+ * 
+ * .Nm
+ * is an extremely simple parser that lacks most of the functionality
+ * one would expect from a C code parser. It simply maps a stream
+ * of tokens into a few categories, parsing major ``milestones'' in
+ * a header, without actually understanding any of the details.
+ * .Pp
+ * This exists because it is used to generate man pages from headers.
+ * See
+ * .Xr hdoc 1 
+ * for example usage of this parser.
+ */
+
+#include <Stream.h>
+#include <Array.h>
+
+#define HEADER_EXPR_MAX 4096
+
+/**
+ * Headers are parsed as expressions. These are the expressions that
+ * this parser recognizes.
+ */
+typedef enum HeaderExprType
+{
+    HP_COMMENT,
+    HP_PREPROCESSOR_DIRECTIVE,
+    HP_TYPEDEF,
+    HP_DECLARATION,
+    HP_GLOBAL,
+    HP_UNKNOWN,
+    HP_SYNTAX_ERROR,
+    HP_PARSE_ERROR,
+    HP_EOF
+} HeaderExprType;
+
+/**
+ * A representation of a function declaration.
+ */
+typedef struct HeaderDeclaration
+{
+    char returnType[64];
+    char name[32]; /* Enforced by ANSI C */
+    Array *args;
+} HeaderDeclaration;
+
+/**
+ * A global variable declaration. The type must be of the same size
+ * as the function declaration's return type due to the way parsing
+ * them is implemented.
+ */
+typedef struct HeaderGlobal
+{
+    char type[64];
+    char name[HEADER_EXPR_MAX - 64];
+} HeaderGlobal;
+
+/**
+ * A representation of a single header expression. Note that that state
+ * structure is entirely internally managed, so it should not be
+ * accessed or manipulated by functions outside the functions defined
+ * here.
+ * .Pp
+ * The type field should be used to determine which field in the data
+ * union is valid.
+ */
+typedef struct HeaderExpr
+{
+    HeaderExprType type;
+    union
+    {
+        char text[HEADER_EXPR_MAX];
+        HeaderDeclaration declaration;
+        HeaderGlobal global;
+        struct
+        {
+            int lineNo;
+            char *msg;
+        } error;
+    } data;
+
+    struct
+    {
+        Stream *stream;
+        int lineNo;
+    } state;
+} HeaderExpr;
+
+/**
+ * Parse the next expression into the given header expression structure.
+ * To parse an entire C header, this function should be called in a 
+ * loop until the type of the expression is HP_EOF.
+ */
+extern void HeaderParse(Stream *, HeaderExpr *);
+
+#endif /* CYTOPLASM_HEADERPARSER_H */

src/include/Http.h

@@ -0,0 +1,211 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_HTTP_H
+#define CYTOPLASM_HTTP_H
+
+/***
+ * @Nm Http
+ * @Nd Encode and decode various parts of the HTTP protocol.
+ * @Dd March 12 2023
+ * @Xr HttpClient HttpServer HashMap Queue Memory
+ *
+ * .Nm
+ * is a collection of utility functions and type definitions that are
+ * useful for dealing with HTTP. HTTP is not a complex protocol, but
+ * this API makes it a lot easier to work with.
+ * .Pp
+ * Note that this API doesn't target any particular HTTP version, but
+ * it is currently used with HTTP 1.0 clients and servers, and
+ * therefore may be lacking functionality added in later HTTP versions.
+ */
+
+#include <stdio.h>
+
+#include <HashMap.h>
+#include <Stream.h>
+
+#define HTTP_FLAG_NONE 0
+#define HTTP_FLAG_TLS (1 << 0)
+
+/**
+ * The request methods defined by the HTTP standard. These numeric
+ * constants should be preferred to strings when building HTTP APIs
+ * because they are more efficient.
+ */
+typedef enum HttpRequestMethod
+{
+    HTTP_METHOD_UNKNOWN,
+    HTTP_GET,
+    HTTP_HEAD,
+    HTTP_POST,
+    HTTP_PUT,
+    HTTP_DELETE,
+    HTTP_CONNECT,
+    HTTP_OPTIONS,
+    HTTP_TRACE,
+    HTTP_PATCH
+} HttpRequestMethod;
+
+/**
+ * An enumeration that corresponds to the actual integer values of the
+ * valid HTTP response codes.
+ */
+typedef enum HttpStatus
+{
+    HTTP_STATUS_UNKNOWN = 0,
+
+    /* Informational responses */
+    HTTP_CONTINUE = 100,
+    HTTP_SWITCHING_PROTOCOLS = 101,
+    HTTP_EARLY_HINTS = 103,
+
+    /* Successful responses */
+    HTTP_OK = 200,
+    HTTP_CREATED = 201,
+    HTTP_ACCEPTED = 202,
+    HTTP_NON_AUTHORITATIVE_INFORMATION = 203,
+    HTTP_NO_CONTENT = 204,
+    HTTP_RESET_CONTENT = 205,
+    HTTP_PARTIAL_CONTENT = 206,
+
+    /* Redirection messages */
+    HTTP_MULTIPLE_CHOICES = 300,
+    HTTP_MOVED_PERMANENTLY = 301,
+    HTTP_FOUND = 302,
+    HTTP_SEE_OTHER = 303,
+    HTTP_NOT_MODIFIED = 304,
+    HTTP_TEMPORARY_REDIRECT = 307,
+    HTTP_PERMANENT_REDIRECT = 308,
+
+    /* Client error messages */
+    HTTP_BAD_REQUEST = 400,
+    HTTP_UNAUTHORIZED = 401,
+    HTTP_FORBIDDEN = 403,
+    HTTP_NOT_FOUND = 404,
+    HTTP_METHOD_NOT_ALLOWED = 405,
+    HTTP_NOT_ACCEPTABLE = 406,
+    HTTP_PROXY_AUTH_REQUIRED = 407,
+    HTTP_REQUEST_TIMEOUT = 408,
+    HTTP_CONFLICT = 409,
+    HTTP_GONE = 410,
+    HTTP_LENGTH_REQUIRED = 411,
+    HTTP_PRECONDITION_FAILED = 412,
+    HTTP_PAYLOAD_TOO_LARGE = 413,
+    HTTP_URI_TOO_LONG = 414,
+    HTTP_UNSUPPORTED_MEDIA_TYPE = 415,
+    HTTP_RANGE_NOT_SATISFIABLE = 416,
+    HTTP_EXPECTATION_FAILED = 417,
+    HTTP_TEAPOT = 418,
+    HTTP_UPGRADE_REQUIRED = 426,
+    HTTP_PRECONDITION_REQUIRED = 428,
+    HTTP_TOO_MANY_REQUESTS = 429,
+    HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+    HTTP_UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+
+    /* Server error responses */
+    HTTP_INTERNAL_SERVER_ERROR = 500,
+    HTTP_NOT_IMPLEMENTED = 501,
+    HTTP_BAD_GATEWAY = 502,
+    HTTP_SERVICE_UNAVAILABLE = 503,
+    HTTP_GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505,
+    HTTP_VARIANT_ALSO_NEGOTIATES = 506,
+    HTTP_NOT_EXTENDED = 510,
+    HTTP_NETWORK_AUTH_REQUIRED = 511
+} HttpStatus;
+
+/**
+ * Convert an HTTP status enumeration value into a string description
+ * of the status, which is to be used in server response to a client,
+ * or a client response to a user. For example, calling
+ * .Fn HttpStatusToString "HTTP_GATEWAY_TIMEOUT"
+ * (or
+ * .Fn HttpStatusToString "504" )
+ * produces the string "Gateway Timeout". Note that the returned
+ * pointers point to static space, so their manipulation is forbidden.
+ */
+extern const char * HttpStatusToString(const HttpStatus);
+
+/**
+ * Convert a string into a numeric code that can be used throughout
+ * the code of a program in an efficient manner. See the definition
+ * of HttpRequestMethod. This function does case-sensitive matching,
+ * and does not trim or otherwise process the input string.
+ */
+extern HttpRequestMethod HttpRequestMethodFromString(const char *);
+
+/**
+ * Convert a numeric code as defined by HttpRequestMethod into a
+ * string that can be sent to a server. Note that the returned pointers
+ * point to static space, so their manipulation is forbidden.
+ */
+extern const char * HttpRequestMethodToString(const HttpRequestMethod);
+
+/**
+ * Encode a C string such that it can safely appear in a URL by
+ * performing the necessary percent escaping. A new string on the
+ * heap is returned. It should be freed with
+ * .Fn Free ,
+ * defined in the
+ * .Xr Memory 3
+ * API.
+ */
+extern char * HttpUrlEncode(char *);
+
+/**
+ * Decode a percent-encoded string into a C string, ignoring encoded
+ * null characters entirely, because those would do nothing but cause
+ * problems.
+ */
+extern char * HttpUrlDecode(char *);
+
+/**
+ * Decode an encoded parameter string in the form of
+ * ``key=val&key2=val2'' into a hash map whose values are C strings.
+ * This function properly decodes keys and values using the functions
+ * defined above.
+ */
+extern HashMap * HttpParamDecode(char *);
+
+/**
+ * Encode a hash map whose values are strings as an HTTP parameter
+ * string suitable for GET or POST requests.
+ */
+extern char * HttpParamEncode(HashMap *);
+
+/**
+ * Read HTTP headers from a stream and return a hash map whose values
+ * are strings. All keys are lowercased to make querying them
+ * consistent and not dependent on the case that was read from the
+ * stream. This is useful for both client and server code, since the
+ * headers are in the same format. This function should be used after
+ * parsing the HTTP status line, because it does not parse that line.
+ * It will stop when it encounters the first blank line, which
+ * indicates that the body is beginning. After this function completes,
+ * the body may be immediately read from the stream without any
+ * additional processing.
+ */
+extern HashMap * HttpParseHeaders(Stream *);
+
+#endif

src/include/HttpClient.h

@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_HTTPCLIENT_H
+#define CYTOPLASM_HTTPCLIENT_H
+
+/***
+ * @Nm HttpClient
+ * @Nd Extremely simple HTTP client.
+ * @Dd April 29 2023
+ * @Xr Http HttpServer Tls
+ * 
+ * .Nm
+ * HttpClient
+ * builds on the HTTP API to provide a simple yet functional HTTP
+ * client. It aims at being easy to use and minimal, yet also
+ * efficient.
+ */
+
+#include <stdio.h>
+
+#include <HashMap.h>
+#include <Http.h>
+
+/**
+ * A server response is represented by a client context. It is
+ * opaque, so the functions defined in this API should be used to
+ * fetch data from and manipulate it.
+ */
+typedef struct HttpClientContext HttpClientContext;
+
+/**
+ * Make an HTTP request. This function takes the request method,
+ * any flags defined in the HTTP API, the port, hostname, and path,
+ * all in that order. It returns NULL if there was an error making
+ * the request. Otherwise it returns a client context. Note that this
+ * function does not actually send any data, it simply makes the
+ * connection. Use
+ * .Fn HttpRequestHeader
+ * to add headers to the request. Then, send headers with
+ * .Fn HttpRequestSendHeaders .
+ * Finally, the request body, if any, can be written to the output
+ * stream, and then the request can be fully sent using
+ * .Fn HttpRequestSend .
+ */
+extern HttpClientContext *
+ HttpRequest(HttpRequestMethod, int, unsigned short, char *, char *);
+
+/**
+ * Set a request header to send to the server when making the
+ * request.
+ */
+extern void HttpRequestHeader(HttpClientContext *, char *, char *);
+
+/**
+ * Send the request headers to the server. This must be called before
+ * the request body can be written or a response body can be read.
+ */
+extern void HttpRequestSendHeaders(HttpClientContext *);
+
+/**
+ * Flush the request stream to the server. This function should be
+ * called before the response body is read.
+ */
+extern HttpStatus HttpRequestSend(HttpClientContext *);
+
+/**
+ * Get the headers returned by the server.
+ */
+extern HashMap * HttpResponseHeaders(HttpClientContext *);
+
+/**
+ * Get the stream used to write the request body and read the
+ * response body.
+ */
+extern Stream * HttpClientStream(HttpClientContext *);
+
+/**
+ * Free all memory associated with the client context. This closes the
+ * connection, if it was still open.
+ */
+extern void HttpClientContextFree(HttpClientContext *);
+
+#endif                             /* CYTOPLASM_HTTPCLIENT_H */

src/include/HttpRouter.h

@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_HTTPROUTER_H
+#define CYTOPLASM_HTTPROUTER_H
+
+/***
+ * @Nm HttpRouter
+ * @Nd Simple HTTP request router with regular expression support.
+ * @Dd April 29 2023
+ * @Xr HttpServer Http
+ *
+ * .Nm
+ * provides a simple mechanism for assigning functions to an HTTP
+ * request path. It is a simple tree data structure that parses the
+ * registered request paths and maps functions onto each part of the
+ * path. Then, requests can be easily routed to their appropriate
+ * handler functions.
+ */
+
+#include <Array.h>
+
+/**
+ * The router structure is opaque and thus managed entirely  by the
+ * functions defined in this API.
+ */
+typedef struct HttpRouter HttpRouter;
+
+/**
+ * A function written to handle an HTTP request takes an array
+ * consisting of the matched path parts in the order they appear in
+ * the path, and a pointer to caller-provided arguments, if any.
+ * It returns a pointer that the caller is assumed to know how to
+ * handle.
+ */
+typedef void *(HttpRouteFunc) (Array *, void *);
+
+/**
+ * Create a new empty routing tree.
+ */
+extern HttpRouter * HttpRouterCreate(void);
+
+/**
+ * Free all the memory associated with the given routing tree.
+ */
+extern void HttpRouterFree(HttpRouter *);
+
+/**
+ * Register the specified route function to be executed upon requests
+ * for the specified HTTP path. The path is parsed by splitting at
+ * each path separator. Each part of the path is a regular expression
+ * that matches the entire path part. A regular expression cannot
+ * match more than one path part. This allows for paths like
+ * .Pa /some/path/(.*)/parts
+ * to work as one would expect.
+ */
+extern int HttpRouterAdd(HttpRouter *, char *, HttpRouteFunc *);
+
+/**
+ * Route the specified request path using the specified routing
+ * tree. This function will parse the path and match it to the 
+ * appropriate route handler function. The return value is a boolean
+ * value that indicates whether or not an appropriate route function
+ * was found. If an appropriate function was found, then the void
+ * pointer is passed to it as arguments that it is expected to know
+ * how to handle, and the pointer to a void pointer is where the
+ * route function's response will be placed.
+ */
+extern int HttpRouterRoute(HttpRouter *, char *, void *, void **);
+
+#endif                             /* CYTOPLASM_HTTPROUTER_H */

src/include/HttpServer.h

@@ -0,0 +1,234 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_HTTPSERVER_H
+#define CYTOPLASM_HTTPSERVER_H
+
+/***
+ * @Nm HttpServer
+ * @Nd Extremely simple HTTP server.
+ * @Dd December 13 2022
+ * @Xr Http HttpClient
+ *
+ * .Nm
+ * builds on the
+ * .Xr Http 3
+ * API, and provides a very simple, yet very functional API for
+ * creating an HTTP server. It aims at being easy to use and minimal,
+ * yet also efficient. It uses non-blocking I/O, is fully
+ * multi-threaded, and is very configurable. It can be set up in just
+ * two function calls and minimal supporting code.
+ * .Pp
+ * This API should be familar to those that have dealt with the HTTP
+ * server libraries of other programming languages, particularly Java.
+ * In fact, much of the terminology used in this API came from Java,
+ * and you'll notice that the way responses are sent and received very
+ * closely resembles Java.
+ */
+
+#include <Http.h>
+
+#include <stdio.h>
+
+#include <HashMap.h>
+#include <Stream.h>
+
+/**
+ * The functions on this API operate on an opaque structure.
+ */
+typedef struct HttpServer HttpServer;
+
+/**
+ * Each request receives a context structure. It is opaque, so the
+ * functions defined in this API should be used to fetch data from
+ * it. These functions allow the handler to figure out the context of
+ * the request, which includes the path requested, any parameters,
+ * and the headers and method used to make the request. The context
+ * also provides the means by which the handler responds to the
+ * request, allowing it to set the status code, headers, and body.
+ */
+typedef struct HttpServerContext HttpServerContext;
+
+/**
+ * The request handler function is executed when an HTTP request is
+ * received. It takes a request context, and a pointer as specified
+ * in the server configuration.
+ */
+typedef void (HttpHandler) (HttpServerContext *, void *);
+
+/**
+ * The number of arguments to
+ * .Fn HttpServerCreate
+ * has grown so large that arguments are now stuffed into a
+ * configuration structure, which is in turn passed to
+ * .Fn HttpServerCreate .
+ * This configuration is copied by value into the internal
+ * structures of the server. It is copied with very minimal
+ * validation, so ensure that all values are sensible. It may
+ * make sense to use
+ * .Fn memset
+ * to zero out everything in here before assigning values.
+ */
+typedef struct HttpServerConfig
+{
+    unsigned short port;
+    unsigned int threads;
+    unsigned int maxConnections;
+
+    int flags;     /* Http(3) flags */
+    char *tlsCert; /* File path */
+    char *tlsKey;  /* File path */
+
+    HttpHandler *handler;
+    void *handlerArgs;
+} HttpServerConfig;
+
+/**
+ * Create a new HTTP server using the specified configuration.
+ * This will set up all internal structures used by the server,
+ * and bind the socket and start listening for connections. However,
+ * it will not start accepting connections.
+ */
+extern HttpServer * HttpServerCreate(HttpServerConfig *);
+
+/**
+ * Retrieve the configuration that was used to instantiate the given
+ * server. Note that this configuration is not necessarily the exact
+ * one that was provided; even though its values are the same, it
+ * should be treated as an entirely separate configuration with no
+ * connection to the original.
+ */
+extern HttpServerConfig * HttpServerConfigGet(HttpServer *);
+
+/**
+ * Free the resources associated with the given HTTP server. Note that
+ * the server can only be freed after it has been stopped. Calling this
+ * function while the server is still running results in undefined
+ * behavior.
+ */
+extern void HttpServerFree(HttpServer *);
+
+/**
+ * Attempt to start the HTTP server, and return immediately with the
+ * status. This API is fully multi-threaded and asynchronous, so the
+ * caller can continue working while the HTTP server is running in a
+ * separate thread and managing a pool of threads to handle responses.
+ */
+extern int HttpServerStart(HttpServer *);
+
+/**
+ * Typically, at some point after calling
+ * .Fn HttpServerStart ,
+ * the program will have no more work to do, so it will want to wait
+ * for the HTTP server to finish. This is accomplished via this
+ * function, which joins the HTTP worker thread to the calling thread,
+ * pausing the calling thread until the HTTP server has stopped.
+ */
+extern void HttpServerJoin(HttpServer *);
+
+/**
+ * Stop the HTTP server. Only the execution of this function will
+ * cause the proper shutdown of the HTTP server. If the main program
+ * is joined to the HTTP thread, then either another thread or a
+ * signal handler will have to stop the server using this function.
+ * The typical use case is to install a signal handler that executes
+ * this function on a global HTTP server.
+ */
+extern void HttpServerStop(HttpServer *);
+
+/**
+ * Get the request headers for the request represented by the given
+ * context. The data in the returned hash map should be treated as
+ * read only and should not be freed; it is managed entirely by the
+ * server.
+ */
+extern HashMap * HttpRequestHeaders(HttpServerContext *);
+
+/**
+ * Get the request method used to make the request represented by
+ * the given context.
+ */
+extern HttpRequestMethod HttpRequestMethodGet(HttpServerContext *);
+
+/**
+ * Get the request path for the request represented by the given
+ * context. The return value of this function should be treated as
+ * read-only, and should not be freed; it is managed entirely by the
+ * server.
+ */
+extern char * HttpRequestPath(HttpServerContext *);
+
+/**
+ * Retrieve the parsed GET parameters for the request represented by
+ * the given context. The returned hash map should be treated as
+ * read-only, and should not be freed; it is managed entirely by the
+ * server.
+ */
+extern HashMap * HttpRequestParams(HttpServerContext *);
+
+/**
+ * Set a response header to return to the client. The old value for
+ * the given header is returned, if any, otherwise NULL is returned.
+ */
+extern char * HttpResponseHeader(HttpServerContext *, char *, char *);
+
+/**
+ * Set the response status to return to the client.
+ */
+extern void HttpResponseStatus(HttpServerContext *, HttpStatus);
+
+/**
+ * Get the current response status that will be sent to the client
+ * making the request represented by the given context.
+ */
+extern HttpStatus HttpResponseStatusGet(HttpServerContext *);
+
+/**
+ * Send the response headers to the client that made the request
+ * represented by the specified context. This function must be called
+ * before the response body can be written, otherwise a malformed
+ * response will be sent.
+ */
+extern void HttpSendHeaders(HttpServerContext *);
+
+/**
+ * Get a stream that is both readable and writable. Reading from the
+ * stream reads the request body that the client sent, if there is one.
+ * Note that the rquest headers have already been read, so the stream
+ * is correctly positioned at the beginning of the body of the request.
+ * .Fn HttpSendHeaders
+ * must be called before the stream is written, otherwise a malformed
+ * HTTP response will be sent. An HTTP handler should properly set all
+ * the headers it itends to send, send those headers, and then write
+ * the response body to this stream.
+ * .Pp
+ * Note that the stream does not need to be closed by the HTTP
+ * handler; in fact doing so results in undefined behavior. The stream
+ * is managed entirely by the server itself, so it will close it when
+ * necessary. This allows the underlying protocol to differ: for
+ * instance, an HTTP/1.1 connection may stay for multiple requests and
+ * responses.
+ */
+extern Stream * HttpServerStream(HttpServerContext *);
+
+#endif /* CYTOPLASM_HTTPSERVER_H */

src/include/Int.h

@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_INT_H
+#define CYTOPLASM_INT_H
+
+/***
+ * @Nm Int
+ * @Nd Fixed-width integer types.
+ * @Dd April 27 2023
+ *
+ * This header provides cross-platform, fixed-width integer types.
+ * Specifically, it uses preprocessor magic to define the following
+ * types:
+ * .Bl -bullet -offset indent
+ * .It
+ * Int8 and UInt8
+ * .It
+ * Int16 and UInt16
+ * .It
+ * Int32 and UInt32
+ * .El
+ * .Pp
+ * Note that there is no 64-bit integer type, because the ANSI C
+ * standard makes no guarantee that such a type will exist, even
+ * though it does on most platforms.
+ * .Pp
+ * The reason Cytoplasm provides its own header for this is
+ * because ANSI C does not define fixed-width types, and while it
+ * should be safe to rely on C99 fixed-width types in most cases,
+ * there may be cases where even that is not possible.
+ *
+ * @ignore-typedefs
+ */
+
+#include <limits.h>
+
+#define BIT64_MAX 18446744073709551615
+#define BIT32_MAX 4294967295
+#define BIT16_MAX 65535
+#define BIT8_MAX 255
+
+#ifndef UCHAR_MAX
+#error Size of char data type is unknown. Define UCHAR_MAX.
+#endif
+
+#ifndef USHRT_MAX
+#error Size of short data type is unknown. Define USHRT_MAX.
+#endif
+
+#ifndef UINT_MAX
+#error Size of int data type is unknown. Define UINT_MAX.
+#endif
+
+#ifndef ULONG_MAX
+#error Size of long data type is unknown. Define ULONG_MAX.
+#endif
+
+#if UCHAR_MAX == BIT8_MAX
+typedef signed char Int8;
+typedef unsigned char UInt8;
+
+#else
+#error Unable to determine suitable data type for 8-bit integers.
+#endif
+
+#if UINT_MAX == BIT16_MAX
+typedef signed int Int16;
+typedef unsigned int UInt16;
+
+#elif USHRT_MAX == BIT16_MAX
+typedef signed short Int16;
+typedef unsigned short UInt16;
+
+#elif UCHAR_MAX == BIT16_MAX
+typedef signed char Int16;
+typedef unsigned char UInt16;
+
+#else
+#error Unable to determine suitable data type for 16-bit integers.
+#endif
+
+#if ULONG_MAX == BIT32_MAX
+typedef signed long Int32;
+typedef unsigned long UInt32;
+
+#elif UINT_MAX == BIT32_MAX
+typedef signed int Int32;
+typedef unsigned int UInt32;
+
+#elif USHRT_MAX == BIT32_MAX
+typedef signed short Int32;
+typedef unsigned short UInt32;
+
+#elif UCHAR_MAX == BIT32_MAX
+typedef signed char Int32;
+typedef unsigned char UInt32;
+
+#else
+#error Unable to determine suitable data type for 32-bit integers.
+#endif
+
+/* The ANSI C standard only guarantees a data size of up to 32 bits. */
+
+#endif

src/include/Io.h

@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_IO_H
+#define CYTOPLASM_IO_H
+
+/***
+ * @Nm Io
+ * @Nd Source/sink-agnostic I/O for implementing custom streams.
+ * @Dd April 29 2023
+ * @Xr Stream Tls
+ *
+ * Many systems provide platform-specific means of implementing custom
+ * streams using file pointers. However, POSIX does not define a way
+ * of programmatically creating custom streams.
+ * .Nm
+ * therefore fills this gap in POSIX by mimicking all of the
+ * functionality of these platform-specific functions, but in pure
+ * POSIX C. It defines a number of callback funtions to be executed
+ * in place of the standard POSIX I/O functions, which are used to
+ * implement arbitrary streams that may not be to a file or socket.
+ * Additionally, streams can now be pipelined; the sink of one stream
+ * may be the source of another lower-level stream. Additionally, all
+ * streams, regardless of their source or sink, share the same API, so
+ * streams can be handled in a much more generic manner. This allows
+ * the HTTP client and server libraries to seemlessly support TLS and
+ * plain connections without having to handle each separately.
+ * .Pp
+ * .Nm
+ * was heavily inspired by GNU's
+ * .Fn fopencookie
+ * and BSD's
+ * .Fn funopen .
+ * It aims to combine the best of both of these functions into a single
+ * API that is intuitive and easy to use.
+ */ 
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+#ifndef IO_BUFFER
+#define IO_BUFFER 4096
+#endif
+
+/**
+ * An opaque structure analogous to a POSIX file descriptor.
+ */
+typedef struct Io Io;
+
+/**
+ * Read input from the source of a stream. This function should
+ * attempt to read the specified number of bytes of data from the
+ * given cookie into the given buffer. It should behave identically
+ * to the POSIX
+ * .Xr read 2
+ * system call, except instead of using an integer descriptor as the
+ * first parameter, a pointer to an implementation-defined cookie
+ * stores any information the function needs to read from the source.
+ */
+typedef ssize_t (IoReadFunc) (void *, void *, size_t);
+
+/**
+ * Write output to a sink. This function should attempt to write the
+ * specified number of bytes of data from the given buffer into the
+ * stream described by the given cookie. It should behave identically
+ * to the POSIX
+ * .Xr write 2
+ * system call, except instead of using an integer descriptor as the
+ * first parameter, a pointer to an implementation-defined cookie
+ * stores any information the function needs to write to the sink.
+ */
+typedef ssize_t (IoWriteFunc) (void *, void *, size_t);
+
+/**
+ * Repositions the offset of the stream described by the specified
+ * cookie. This function should behave identically to the POSIX
+ * .Xr lseek 2
+ * system call, except instead of using an integer descriptor as the
+ * first parameter, a pointer to an implementation-defined cookie
+ * stores any information the function needs to seek the stream.
+ */
+typedef off_t (IoSeekFunc) (void *, off_t, int);
+
+/**
+ * Close the given stream, making future reads or writes result in
+ * undefined behavior. This function should also free all memory
+ * associated with the cookie. It should behave identically to the
+ * .Xr close 2
+ * system call, except instead of using an integer descriptor for the
+ * parameter, a pointer to an implementation-defined cookie stores any
+ * information the function needs to close the stream.
+ */
+typedef int (IoCloseFunc) (void *);
+
+/**
+ * A simple mechanism for grouping together a set of stream functions,
+ * to be passed to
+ * .Fn IoCreate .
+ */
+typedef struct IoFunctions
+{
+    IoReadFunc *read;
+    IoWriteFunc *write;
+    IoSeekFunc *seek;
+    IoCloseFunc *close;
+} IoFunctions;
+
+/**
+ * Create a new stream using the specified cookie and the specified
+ * I/O functions.
+ */
+extern Io * IoCreate(void *, IoFunctions);
+
+/**
+ * Read the specified number of bytes from the specified stream into
+ * the specified buffer. This calls the stream's underlying IoReadFunc,
+ * which should behave identically to the POSIX
+ * .Xr read 2
+ * system call.
+ */
+extern ssize_t IoRead(Io *, void *, size_t);
+
+/**
+ * Write the specified number of bytes from the specified stream into
+ * the specified buffer. This calls the stream's underlying
+ * IoWriteFunc, which should behave identically to the POSIX
+ * .Xr write 2
+ * system call.
+ */
+extern ssize_t IoWrite(Io *, void *, size_t);
+
+/**
+ * Seek the specified stream using the specified offset and whence
+ * value. This calls the stream's underlying IoSeekFunc, which should
+ * behave identically to the POSIX
+ * .Xr lseek 2
+ * system call.
+ */
+extern off_t IoSeek(Io *, off_t, int);
+
+/**
+ * Close the specified stream. This calls the stream's underlying
+ * IoCloseFunc, which should behave identically to the POSIX
+ * .Xr close 2
+ * system call.
+ */
+extern int IoClose(Io *);
+
+/**
+ * Print a formatted string to the given stream. This is a
+ * re-implementation of the standard library function
+ * .Xr vfprintf 3 ,
+ * and behaves identically.
+ */
+extern int IoVprintf(Io *, const char *, va_list);
+
+/**
+ * Print a formatted string to the given stream. This is a
+ * re-implementation of the standard library function
+ * .Xr fprintf 3 ,
+ * and behaves identically.
+ */
+extern int IoPrintf(Io *, const char *,...);
+
+/**
+ * Read all the bytes from the first stream and write them to the
+ * second stream. Neither stream is closed upon the completion of this
+ * function. This can be used for quick and convenient buffered
+ * copying of data from one stream into another.
+ */
+extern ssize_t IoCopy(Io *, Io *);
+
+/**
+ * Wrap a POSIX file descriptor to take advantage of this API. The
+ * common use case for this function is when a regular file descriptor
+ * needs to be accessed by an application that uses this API to also
+ * access non-POSIX streams.
+ */
+extern Io * IoFd(int);
+
+/**
+ * Open or create a file for reading or writing. The specified file
+ * name is opened for reading or writing as specified by the given
+ * flags and mode. This function is a simple convenience wrapper around
+ * the POSIX
+ * .Xr open 2
+ * system call that passes the opened file descriptor into
+ * .Fn IoFd .
+ */
+extern Io * IoOpen(const char *, int, mode_t);
+
+/**
+ * Wrap a standard C file pointer to take advantage of this API. The
+ * common use case for this function is when a regular C file pointer
+ * needs to be accessed by an application that uses this API to also
+ * access custom streams.
+ */
+extern Io * IoFile(FILE *);
+
+#endif                             /* CYTOPLASM_IO_H */

src/include/Json.h

@@ -0,0 +1,322 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef CYTOPLASM_JSON_H
+#define CYTOPLASM_JSON_H
+
+/***
+ * @Nm Json
+ * @Nd A fully-featured JSON API.
+ * @Dd March 12 2023
+ * @Xr HashMap Array Stream
+ *
+ * .Nm
+ * is a fully-featured JSON API for C using the array and hash map
+ * APIs. It can parse JSON, ans serialize an in-memory structure to
+ * JSON. It build on the foundation of Array and HashMap because that's
+ * all JSON really is, just arrays and maps.
+ * .Nm
+ * also provides a structure for encapsulating an arbitrary value and
+ * identifying its type, making it easy for a strictly-typed language
+ * like C to work with loosely-typed JSON data.
+ * .Nm
+ * is very strict and tries to adhere as closely as possible to the
+ * proper definition of JSON. It will fail on syntax errors of any
+ * kind, which is fine for a Matrix homeserver that can just return
+ * M_BAD_JSON if anything in here fails, but this behavior may not be
+ * suitable for other purposes.
+ * .Pp
+ * This JSON implementation focuses primarily on serialization and
+ * deserialization to and from streams. It does not provide facilities
+ * for handling JSON strings; it only writes JSON to output streams,
+ * and reads them from input streams. Of course, you can use the
+ * POSIX
+ * .Xr fmemopen 3
+ * and
+ * .Xr open_memstream 3
+ * functions if you want to deal with JSON strings, but JSON is
+ * intended to be an exchange format. Data should be converted to JSON
+ * right when it is leaving the program, and converted from JSON to the
+ * in-memory format as soon as it is coming in.
+ * .Pp
+ * JSON objects are represented as hash maps consisting entirely of
+ * JsonValue structures, and arrays are represented as arrays
+ * consisting entirely of JsonValue structures. When generating a
+ * JSON object, any attempt to stuff a value into a hash map or array
+ * without first encoding it as a JsonValue will result in undefined
+ * behavior.
+ */
+
+#include <HashMap.h>
+#include <Array.h>
+#include <Stream.h>
+
+#include <stdio.h>
+#include <stddef.h>
+
+#define JSON_DEFAULT -1
+#define JSON_PRETTY 0
+
+/**
+ * This opaque structure encapsulates all the possible types that can
+ * be stored in JSON. It is managed entirely by the functions defined
+ * in this API. It is important to note that strings, integers, floats,
+ * booleans, and the NULL value are all stored by value, but objects
+ * and arrays are stored by reference. That is, it doesn't store these
+ * itself, just pointers to them, however, the data
+ * .Em is
+ * freed when using
+ * .Fn JsonFree .
+ */
+typedef struct JsonValue JsonValue;
+
+/**
+ * These are the types that can be used to identify a JsonValue
+ * and act on it accordingly.
+ */
+typedef enum JsonType
+{
+    JSON_NULL,    /* Maps to a C NULL */
+    JSON_OBJECT,  /* Maps to a HashMap of JsonValues */
+    JSON_ARRAY,   /* Maps to an Array of JsonValues */
+    JSON_STRING,  /* Maps to a null-terminated C string */
+    JSON_INTEGER, /* Maps to a C long */
+    JSON_FLOAT,   /* Maps to a C double */
+    JSON_BOOLEAN  /* Maps to a C integer of either 0 or 1 */
+} JsonType;
+
+/**
+ * Determine the type of the specified JSON value.
+ */
+extern JsonType JsonValueType(JsonValue *);
+
+/**
+ * Encode a JSON object as a JSON value that can be added to another
+ * object, or an array.
+ */
+extern JsonValue * JsonValueObject(HashMap *);
+
+/**
+ * Unwrap a JSON value that represents an object. This function will
+ * return NULL if the value is not actually an object.
+ */
+extern HashMap * JsonValueAsObject(JsonValue *);
+
+/**
+ * Encode a JSON array as a JSON value that can be added to an object
+ * or another array.
+ */
+extern JsonValue * JsonValueArray(Array *);
+
+/**
+ * Unwrap a JSON value that represents an array. This function will
+ * return NULL if the value is not actually an array.
+ */
+extern Array * JsonValueAsArray(JsonValue *);
+
+/**
+ * Encode a C string as a JSON value that can be added to an object or
+ * an array.
+ */
+extern JsonValue * JsonValueString(char *);
+
+/**
+ * Unwrap a JSON value that represents a string. This function will
+ * return NULL if the value is not actually a string.
+ */
+extern char * JsonValueAsString(JsonValue *);
+
+/**
+ * Encode a number as a JSON value that can be added to an object or
+ * an array.
+ */
+extern JsonValue * JsonValueInteger(long);
+
+/**
+ * Unwrap a JSON value that represents a number. This function will
+ * return 0 if the value is not actually a number, which may be
+ * misleading. Check the type of the value before making assumptions
+ * about its value.
+ */
+extern long JsonValueAsInteger(JsonValue *);
+
+/**
+ * Encode a floating point number as a JSON value that can be added
+ * to an object or an array.
+ */
+extern JsonValue * JsonValueFloat(double);
+
+/**
+ * Unwrap a JSON value that represents a floating point number. This
+ * function will return 0 if the value is not actually a floating
+ * point number, which may be misleading. Check the type of the value
+ * before making assumptions about its type.
+ */
+extern double JsonValueAsFloat(JsonValue *);
+
+/**
+ * Encode a C integer according to the way C treats integers in boolean
+ * expressions as a JSON value that can be added to an object or an
+ * array.
+ */
+extern JsonValue * JsonValueBoolean(int);
+
+/**
+ * Unwrap a JSON value that represents a boolean. This function will
+ * return 0 if the value is not actually a boolean, which may be
+ * misleading. Check the type of the value before making assumptions
+ * about its type.
+ */
+extern int JsonValueAsBoolean(JsonValue *);
+
+/**
+ * This is a special case that represents a JSON null. Because the
+ * Array and HashMap APIs do not accept NULL values, this function
+ * should be used to represent NULL in JSON. Even though a small
+ * amount of memory is allocated just to be a placeholder for nothing,
+ * this keeps the APIs clean.
+ */
+extern JsonValue * JsonValueNull(void);
+
+/**
+ * Free the memory being used by a JSON value. Note that this will
+ * recursively free all Arrays, HashMaps, and other JsonValues that are
+ * reachable from the given value, including any strings attached to
+ * this value.
+ */
+extern void JsonValueFree(JsonValue *);
+
+/**
+ * Recursively duplicate the given JSON value. This returns a new
+ * JSON value that is completely identical to the specified value, but
+ * in no way connected to it.
+ */
+extern JsonValue * JsonValueDuplicate(JsonValue *);
+
+/**
+ * Recursively duplicate the given JSON object. This returns a new
+ * JSON object that is completely identical to the specified object,
+ * but in no way connect to it.
+ */
+extern HashMap * JsonDuplicate(HashMap *);
+
+/**
+ * Recursively free a JSON object by iterating over all of its values
+ * and freeing them using
+ * .Fn JsonValueFree .
+ */
+extern void JsonFree(HashMap *);
+
+/**
+ * Encode the given string in such a way that it can be safely
+ * embedded in a JSON stream. This entails:
+ * .Bl -bullet -offset indent
+ * .It
+ * Escaping quotes, backslashes, and other special characters using
+ * their backslash escape.
+ * .It
+ * Encoding bytes that are not UTF-8 using escapes.
+ * .It
+ * Wrapping the entire string in double quotes.
+ * .El
+ * .Pp
+ * This function is only provided via the public
+ * .Nm
+ * API so that it is accessible to custom JSON encoders, such as the
+ * CanonicalJson encoder. This will typically be used for encoding
+ * object keys; to encode values, just use
+ * .Fn JsonEncodeValue .
+ * .Pp
+ * This function returns the number of bytes written to the stream,
+ * or if the stream is NULL, the number of bytes that would have
+ * been written.
+ */
+extern int JsonEncodeString(const char *, Stream *);
+
+/**
+ * Serialize a JSON value as it would appear in JSON output. This is
+ * a recursive function that also encodes all child values reachable
+ * from the given value. This function is exposed via the public
+ * .Nm
+ * API so that it is accessible to custom JSON encoders. Normal users
+ * that are not writing custom encoders should in most cases just use
+ * .Fn JsonEncode
+ * to encode an entire object.
+ * .Pp
+ * The third parameter is an integer that represents the indent level
+ * of the value to be printed, or a negative number if pretty-printing
+ * should be disabled and JSON should be printed as minimized as
+ * possible. To pretty-print a JSON object, set this to
+ * .Va JSON_PRETTY .
+ * To get minified output, set it to
+ * .Va JSON_DEFAULT .
+ * .Pp
+ * This function returns the number of bytes written to the stream,
+ * or if the stream is NULL, the number of bytes that would have
+ * been written.
+ */
+extern int JsonEncodeValue(JsonValue *, Stream *, int);
+
+/**
+ * Encode a JSON object as it would appear in JSON output, writing it
+ * to the given output stream. This function is recursive; it will
+ * serialize everything accessible from the passed object. The third
+ * parameter has the same behavior as described above.
+ * .Pp
+ * This function returns the number of bytes written to the stream,
+ * or if the stream is NULL, the number of bytes that would have
+ * been written.
+ */
+extern int JsonEncode(HashMap *, Stream *, int);
+
+/**
+ * Decode a JSON object from the given input stream and parse it into
+ * a hash map of JSON values.
+ */
+extern HashMap * JsonDecode(Stream *);
+
+/**
+ * A convenience function that allows the caller to retrieve and
+ * arbitrarily deep keys within a JSON object. It takes a root JSON
+ * object, the number of levels deep to go, and then that number of
+ * keys as a varargs list. All keys must have objects as values, with
+ * the exception of the last one, which is the value that will be
+ * returned. Otherwise, NULL indicates the specified path doas not
+ * exist.
+ */
+extern JsonValue * JsonGet(HashMap *, size_t,...);
+
+/**
+ * A convenience function that allows the caller to set arbitrarily
+ * deep keys within a JSON object. It takes a root JSON object, the
+ * number of levels deep to go, and then that number of keys as a
+ * varargs list. All keys must have object as values, with the
+ * exception of the last one, which is the value that will be set.
+ * The value currently at that key, if any, will be returned.
+ * This function will create any intermediate objects as necessary to
+ * set the proper key.
+ */
+extern JsonValue * JsonSet(HashMap *, JsonValue *, size_t,...);
+
+#endif                             /* CYTOPLASM_JSON_H */

src/include/Log.h

@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef CYTOPLASM_LOG_H
+#define CYTOPLASM_LOG_H
+
+/***
+ * @Nm Log
+ * @Nd A simple logging framework for logging to multiple destinations.
+ * @Dd April 27 2023
+ * @Xr Stream
+ *
+ * .Nm
+ * is a simple C logging library that allows for colorful outputs,
+ * timestamps, and custom log levels. It also features the ability to
+ * have multiple logs open at one time, although Cytoplasm primarily
+ * utilizes the global log. All logs are thread safe.
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+#include <syslog.h>
+
+#include <Stream.h>
+
+#define LOG_FLAG_COLOR  (1 << 0)
+#define LOG_FLAG_SYSLOG (1 << 1)
+
+/**
+ * A log is defined as a configuration that describes the properties
+ * of the log. This opaque structure can be manipulated by the
+ * functions defined in this API.
+ */
+typedef struct LogConfig LogConfig;
+
+/**
+ * Create a new log configuration with sane defaults that can be used
+ * immediately with the logging functions.
+ */
+extern LogConfig * LogConfigCreate(void);
+
+/**
+ * Get the global log configuration, creating a new one with
+ * .Fn LogConfigCreate
+ * if necessary.
+ */
+extern LogConfig * LogConfigGlobal(void);
+
+/**
+ * Free the given log configuration. Note that this does not close the
+ * underlying stream associated with the log, if there is one. Also
+ * note that to avoid memory leaks, the global log configuration must
+ * also be freed, but it cannot be used after it is freed.
+ */
+extern void LogConfigFree(LogConfig *);
+
+/**
+ * Set the current log level on the specified log configuration.
+ * This indicates that only messages at or above this level should be
+ * logged; all others are silently discarded. The passed log level
+ * should be one of the log levels defined by
+ * .Xr syslog 3 .
+ * Refer to that page for a complete list of acceptable log levels,
+ * and note that passing an invalid log level will result in undefined
+ * behavior.
+ */
+extern void LogConfigLevelSet(LogConfig *, int);
+
+/**
+ * Cause the log output to be indented two more spaces than it was
+ * previously. This can be helpful when generating stack traces or
+ * other hierarchical output. This is a simple convenience wrapper
+ * around
+ * .Fn LogConfigIndentSet .
+ */
+extern void LogConfigIndent(LogConfig *);
+
+/**
+ * Cause the log output to be indented two less spaces than it was
+ * previously. This is a simple convenience wrapper around
+ * .Fn LogConfigIndentSet .
+ */
+extern void LogConfigUnindent(LogConfig *);
+
+/**
+ * Indent future log output using the specified config by some
+ * arbitrary amount.
+ */
+extern void LogConfigIndentSet(LogConfig *, size_t);
+
+/**
+ * Set the file stream that logging output should be written to. This
+ * defaults to standard output, but it can be set to standard error,
+ * or any other arbitrary stream. Passing a NULL value for the stream
+ * pointer sets the log output to the standard output. Note that the
+ * output stream is only used if
+ * .Va LOG_FLAG_SYSLOG
+ * is not set.
+ */
+extern void LogConfigOutputSet(LogConfig *, Stream *);
+
+/**
+ * Set a number of boolean options on a log configuration. This
+ * function uses bitwise operators, so multiple options can be set with
+ * a single function call using bitwise OR operators. The flags are
+ * defined as preprocessor macros, and are as follows:
+ * .Bl -tag -width Ds
+ * .It LOG_FLAG_COLOR
+ * When set, enable color-coded output on TTYs. Note that colors are
+ * implemented as ANSI escape sequences, and are not written to file
+ * streams that are not actually connected to a TTY, to prevent those
+ * sequences from being written to a file.
+ * .Xr isatty 3
+ * is checked before writing any terminal sequences.
+ * .It LOG_FLAG_SYSLOG
+ * When set, log output to the syslog using
+ * .Xr syslog 3 ,
+ * instead of logging to the file set by
+ * .Fn LogConfigOutputSet .
+ * This flag always overrides the stream set by that function,
+ * regardless of when it was set, even if it was set after this flag
+ * was set.
+ * .El
+ */
+extern void LogConfigFlagSet(LogConfig *, int);
+
+/**
+ * Clear a boolean flag from the specified log format. See above for
+ * the list of flags.
+ */
+extern void LogConfigFlagClear(LogConfig *, int);
+
+/**
+ * Set a custom timestamp to be prepended to each message if the
+ * output is not going to the system log. Consult your system's
+ * documentation for
+ * .Xr strftime 3 .
+ * A value of NULL disables the timestamp output before messages.
+ */
+extern void LogConfigTimeStampFormatSet(LogConfig *, char *);
+
+/**
+ * This function does the actual logging of messages using a
+ * specified configuration. It takes the configuration, the log
+ * level, a format string, and then a list of arguments, all in that
+ * order. This function only logs messages if their level is above
+ * or equal to the currently configured log level, making it easy to
+ * turn some messages on or off.
+ * .Pp
+ * This function has the same usage as
+ * .Xr vprintf 3 .
+ * Consult that page for the list of format specifiers and their
+ * arguments. This function is typically not used directly, see the
+ * other log functions for the most common use cases.
+ */
+extern void Logv(LogConfig *, int, const char *, va_list);
+
+/**
+ * Log a message using
+ * .Fn Logv .
+ * with the specified configuration. This function has the same usage
+ * as
+ * .Xr printf 3 .
+ */
+extern void LogTo(LogConfig *, int, const char *, ...);
+
+/**
+ * Log a message to the global log using
+ * .Fn Logv .
+ * This function has the same usage as
+ * .Xr printf 3 .
+ */
+extern void Log(int, const char *, ...);
+
+#endif

src/include/Memory.h

@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_MEMORY_H
+#define CYTOPLASM_MEMORY_H
+
+/***
+ * @Nm Memory
+ * @Nd Smart memory management.
+ * @Dd January 9 2023
+ *
+ * .Nm
+ * is an API that allows for smart memory management and profiling. It
+ * wraps the standard library functions
+ * .Xr malloc 3 ,
+ * .Xr realloc 3 ,
+ * and
+ * .Xr free 3 ,
+ * and offers identical semantics, while providing functionality that
+ * the standard library doesn't have, such as getting statistics on the
+ * total memory allocated on the heap, and getting the size of a block
+ * given a pointer. Additionally, thanks to preprocessor macros, the
+ * exact file and line number at which an allocation, re-allocation, or
+ * free occured can be obtained given a pointer. Finally, all the
+ * blocks allocated on the heap can be iterated and evaluated, and a
+ * callback function can be executed every time a memory operation
+ * occurs.
+ * .Pp
+ * In the future, this API could include a garbage collector that
+ * automatically frees memory it detects as being no longer in use.
+ * However, this feature does not yet exist.
+ * .Pp
+ * A number of macros are available, which make the
+ * .Nm
+ * API much easier to use. They are as follows:
+ * .Bl -bullet -offset indent
+ * .It
+ * .Fn Malloc "x"
+ * .It
+ * .Fn Realloc "x" "y"
+ * .It
+ * .Fn Free "x"
+ * .El
+ * .Pp
+ * These macros expand to
+ * .Fn MemoryAllocate ,
+ * .Fn MemoryReallocate ,
+ * and
+ * .Fn MemoryFree
+ * with the second and third parameters set to __FILE__ and __LINE__.
+ * This allows
+ * .Nm
+ * to be used exactly how the standard library functions would be
+ * used. In fact, the functions to which these macros expand are not
+ * intended to be used directly; for the best results, use these
+ * macros.
+ */
+#include <stddef.h>
+
+/**
+ * These values are passed into the memory hook function to indicate
+ * the action that just happened.
+ */
+typedef enum MemoryAction
+{
+    MEMORY_ALLOCATE,
+    MEMORY_REALLOCATE,
+    MEMORY_FREE,
+    MEMORY_BAD_POINTER
+} MemoryAction;
+
+#define Malloc(x) MemoryAllocate(x, __FILE__, __LINE__)
+#define Realloc(x, s) MemoryReallocate(x, s, __FILE__, __LINE__)
+#define Free(x) MemoryFree(x, __FILE__, __LINE__)
+
+/**
+ * The memory information is opaque, but can be accessed using the
+ * functions defined by this API.
+ */
+typedef struct MemoryInfo MemoryInfo;
+
+/**
+ * Allocate the specified number of bytes on the heap. This function
+ * has the same semantics as
+ * .Xr malloc 3 ,
+ * except that it takes the file name and line number at which the
+ * allocation occurred.
+ */
+extern void * MemoryAllocate(size_t, const char *, int);
+
+/**
+ * Change the size of the object pointed to by the given pointer
+ * to the given number of bytes. This function has the same semantics
+ * as
+ * .Xr realloc 3 ,
+ * except that it takes the file name and line number at which the
+ * reallocation occurred.
+ */
+extern void * MemoryReallocate(void *, size_t, const char *, int);
+
+/**
+ * Free the memory at the given pointer. This function has the same
+ * semantics as
+ * .Xr free 3 ,
+ * except that it takes the file name and line number at which the
+ * free occurred.
+ */
+extern void MemoryFree(void *, const char *, int);
+
+/**
+ * Get the total number of bytes that the program has allocated on the
+ * heap. This operation iterates over all heap allocations made with
+ * .Fn MemoryAllocate
+ * and then returns a total count, in bytes.
+ */
+extern size_t MemoryAllocated(void);
+
+/**
+ * Iterate over all heap allocations made with
+ * .Fn MemoryAllocate
+ * and call
+ * .Fn MemoryFree
+ * on them. This function immediately invalidates all pointers to
+ * blocks on the heap, and any subsequent attempt to read or write to
+ * data on the heap will result in undefined behavior. This is
+ * typically called at the end of the program, just before exit.
+ */
+extern void MemoryFreeAll(void);
+
+/**
+ * Fetch information about an allocation. This function takes a raw
+ * pointer, and if
+ * . Nm
+ * knows about the pointer, it returns a structure that can be used
+ * to obtain information about the block of memory that the pointer
+ * points to.
+ */
+extern MemoryInfo * MemoryInfoGet(void *);
+
+/**
+ * Get the size in bytes of the block of memory represented by the
+ * specified memory info structure.
+ */
+extern size_t MemoryInfoGetSize(MemoryInfo *);
+
+/**
+ * Get the file name in which the block of memory represented by the
+ * specified memory info structure was allocated.
+ */
+extern const char * MemoryInfoGetFile(MemoryInfo *);
+
+/**
+ * Get the line number on which the block of memory represented by the
+ * specified memory info structure was allocated.
+ */
+extern int MemoryInfoGetLine(MemoryInfo *);
+
+/**
+ * Get a pointer to the block of memory represented by the specified
+ * memory info structure.
+ */
+extern void * MemoryInfoGetPointer(MemoryInfo *);
+
+/**
+ * This function takes a pointer to a function that takes the memory
+ * info structure, as well as a void pointer for caller-provided
+ * arguments. It iterates over all the heap memory currently allocated
+ * at the time of calling, executing the function on each allocation.
+ */
+extern void MemoryIterate(void (*) (MemoryInfo *, void *), void *);
+
+/**
+ * Specify a function to be executed whenever a memory operation
+ * occurs. The MemoryAction argument specifies the operation that
+ * occurred on the block of memory represented by the memory info
+ * structure. The function also takes a void pointer to caller-provided
+ * arguments.
+ */
+extern void MemoryHook(void (*) (MemoryAction, MemoryInfo *, void *), void *);
+
+/**
+ * Read over the block of memory represented by the given memory info
+ * structure and generate a hexadecimal and ASCII string for each
+ * chunk of the block. This function takes a callback function that
+ * takes the following parameters in order:
+ * .Bl -bullet -offset indent
+ * .It
+ * The current offset from the beginning of the block of memory in
+ * bytes.
+ * .It
+ * A null-terminated string containing the next 16 bytes of the block
+ * encoded as space-separated hex values.
+ * .It
+ * A null-terminated string containing the ASCII representation of the
+ * same 16 bytes of memory. This ASCII representation is safe to print
+ * to a terminal or other text device, because non-printable characters
+ * are encoded as a . (period).
+ * .It
+ * Caller-passed pointer.
+ * .El
+ */
+extern void
+MemoryHexDump(MemoryInfo *, void (*) (size_t, char *, char *, void *), void *);
+
+#endif

src/include/Queue.h

@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_QUEUE_H
+#define CYTOPLASM_QUEUE_H
+
+/***
+ * @Nm Queue
+ * @Nd A simple static queue data structure.
+ * @Dd November 25 2022
+ * @Xr Array HashMap
+ *
+ * .Nm
+ * implements a simple queue data structure that is statically sized.
+ * This implementation does not actually store the values of the items
+ * in it; it only stores pointers to the data. As such, you will have
+ * to manually maintain data and make sure it remains valid as long as
+ * it is in the queue. The advantage of this is that
+ * .Nm
+ * doesn't have to copy data, and thus doesn't care how big the data
+ * is. Furthermore, any arbitrary data can be stored in the queue.
+ * .Pp
+ * This queue implementation operates on the heap. It is a circular
+ * queue, and it does not grow as it is used. Once the size is set,
+ * the queue never gets any bigger.
+ */
+
+#include <stddef.h>
+
+/**
+ * These functions operate on a queue structure that is opaque to the
+ * caller.
+ */
+typedef struct Queue Queue;
+
+/**
+ * Allocate a new queue that is able to store the specified number of
+ * items in it.
+ */
+extern Queue * QueueCreate(size_t);
+
+/**
+ * Free the memory associated with the specified queue structure. Note
+ * that this function does not free any of the values stored in the
+ * queue; it is the caller's job to manage memory for each item.
+ * Typically, the caller would dequeue all the items in the queue and
+ * deal with them before freeing the queue itself.
+ */
+extern void QueueFree(Queue *);
+
+/**
+ * Push an element into the queue. This function returns a boolean
+ * value indicating whether or not the push succeeded. Pushing items
+ * into the queue will fail if the queue is full.
+ */
+extern int QueuePush(Queue *, void *);
+
+/**
+ * Pop an element out of the queue. This function returns NULL if the
+ * queue is empty. Otherwise, it returns a pointer to the item that is
+ * next up in the queue.
+ */
+extern void * QueuePop(Queue *);
+
+/**
+ * Retrieve a pointer to the item that is next up in the queue without
+ * actually discarding it, such that the next call to
+ * .Fn QueuePeek
+ * or
+ * .Fn QueuePop
+ * will return the same pointer.
+ */
+extern void * QueuePeek(Queue *);
+
+/**
+ * Determine whether or not the queue is full.
+ */
+extern int QueueFull(Queue *);
+
+/**
+ * Determine whether or not the queue is empty.
+ */
+extern int QueueEmpty(Queue *);
+
+#endif

src/include/Rand.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef CYTOPLASM_RAND_H
+#define CYTOPLASM_RAND_H
+
+/***
+ * @Nm Rand
+ * @Nd Thread-safe random numbers.
+ * @Dd February 16 2023
+ * @Xr Util
+ *
+ * .Nm
+ * is used for generating random numbers in a thread-safe way.
+ * Currently, one generator state is shared across all threads, which
+ * means that only one thread can generate random numbers at a time.
+ * This state is protected with a mutex to guarantee this behavior.
+ * In the future, a seed pool may be maintained to allow multiple
+ * threads to generate random numbers at the same time.
+ * .Pp
+ * The generator state is seeded on the first call to a function that
+ * needs it. The seed is determined by the current timestamp, the ID
+ * of the process, and the thread ID. These should all be sufficiently
+ * random sources, so the seed should be secure enough.
+ * .Pp
+ * .Nm
+ * currently uses a simple Mersenne Twister algorithm to generate
+ * random numbers. This algorithm was chosen because it is extremely
+ * popular and widespread. While it is likely not cryptographically
+ * secure, and does suffer some unfortunate pitfalls, this algorithm
+ * has stood the test of time and is simple enough to implement, so
+ * it was chosen over the alternatives.
+ * .Pp
+ * .Nm
+ * does not use any random number generator functions from the C
+ * standard library, since these are often flawed.
+ */
+
+#include <stddef.h>
+
+/**
+ * Generate a single random integer between 0 and the passed value.
+ */
+extern int RandInt(unsigned int);
+
+/**
+ * Generate the number of integers specified by the second argument
+ * storing them into the buffer pointed to in the first argument.
+ * Ensure that each number is between 0 and the third argument.
+ * .Pp
+ * This function allows a caller to get multiple random numbers at once
+ * in a more efficient manner than repeatedly calling
+ * .Fn RandInt ,
+ * since each call to these functions
+ * has to lock and unlock a mutex. It is therefore better to obtain
+ * multiple random numbers in one pass if multiple are needed.
+ */
+extern void RandIntN(int *, size_t, unsigned int);
+
+#endif                             /* CYTOPLASM_RAND_H */

src/include/Runtime.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_RUNTIME_H
+#define CYTOPLASM_RUNTIME_H
+
+/***
+ * @Nm Runtime
+ * @Nd Supporting functions for the Cytoplasm runtime.
+ * @Dd May 23 2023
+ * @Xr Memory
+ *
+ * .Nm
+ * provides supporting functions for the Cytoplasm runtime. These
+ * functions are not intended to be called directly by programs,
+ * but are used internally. They're exposed via a header because
+ * the runtime stub needs to know their definitions.
+ */
+
+#include <Array.h>
+
+/**
+ * Write a memory report to a file in the current directory, using
+ * the provided string as the name of the program currently being
+ * executed. This function is to be called after all memory is
+ * supposed to have been freed. It iterates over all remaining
+ * memory and generates a text file containing all of the
+ * recorded information about each block, including a hex dump of
+ * the data stored in them.
+ */
+extern void GenerateMemoryReport(const char *);
+
+#endif /* CYTOPLASM_RUNTIME_H */

src/include/Sha2.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef CYTOPLASM_SHA2_H
+#define CYTOPLASM_SHA2_H
+
+/***
+ * @Nm Sha2
+ * @Nd A simple implementation of the SHA2 hashing functions.
+ * @Dd December 19 2022
+ * @Xr Memory Base64
+ *
+ * This API defines simple functions for computing SHA2 hashes.
+ * At the moment, it only defines
+ * .Fn Sha256 ,
+ * which computes the SHA-256 hash of the given C string. It is
+ * not trivial to implement SHA-512 in ANSI C due to the lack of
+ * a 64-bit integer type, so that hash function has been omitted.
+ */
+
+/**
+ * This function takes a pointer to a NULL-terminated C string, and
+ * returns a string allocated on the heap using the Memory API, or
+ * NULL if there was an error allocating memory. The returned string
+ * should be freed when it is no longer needed.
+ */
+extern char * Sha256(char *);
+
+#endif                             /* CYTOPLASM_SHA2_H */

src/include/Str.h

@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_STR_H
+#define CYTOPLASM_STR_H
+
+/***
+ * @Nm Str
+ * @Nd Functions for creating and manipulating strings.
+ * @Dd February 15 2023
+ * @Xr Memory
+ *
+ * .Nm
+ * provides string-related functions. It is called
+ * .Nm ,
+ * not String, because some platforms (Windows) do not have
+ * case-sensitive filesystems, which poses a problem since
+ * .Pa string.h
+ * is a standard library header.
+ */
+
+#include <stddef.h>
+
+/**
+ * Take a UTF-8 codepoint and encode it into a string buffer containing
+ * between 1 and 4 bytes. The string buffer is allocated on the heap,
+ * so it should be freed when it is no longer needed.
+ */
+extern char * StrUtf8Encode(unsigned long);
+
+/**
+ * Duplicate a null-terminated string, returning a new string on the
+ * heap. This is useful when a function takes in a string that it needs
+ * to store for long amounts of time, even perhaps after the original
+ * string is gone.
+ */
+extern char * StrDuplicate(const char *);
+
+/**
+ * Extract part of a null-terminated string, returning a new string on
+ * the heap containing only the requested subsection. Like the
+ * substring functions included with most programming languages, the
+ * starting index is inclusive, and the ending index is exclusive.
+ */
+extern char * StrSubstr(const char *, size_t, size_t);
+
+/**
+ * A varargs function that takes a number of null-terminated strings
+ * specified by the first argument, and returns a new string that
+ * contains their concatenation. It works similarly to
+ * .Xr strcat 3 ,
+ * but it takes care of allocating memory big enough to hold all the
+ * strings. Any string in the list may be NULL. If a NULL pointer is
+ * passed, it is treated like an empty string.
+ */
+extern char * StrConcat(size_t,...);
+
+/**
+ * Return a boolean value indicating whether or not the null-terminated
+ * string consists only of blank characters, as determined by
+ * .Xr isblank 3 .
+ */
+extern int StrBlank(const char *str);
+
+/**
+ * Generate a string of the specified length, containing random
+ * lowercase and uppercase letters.
+ */
+extern char * StrRandom(size_t);
+
+/**
+ * Convert the specified integer into a string, returning the string
+ * on the heap, or NULL if there was a memory allocation error. The
+ * returned string should be freed by the caller after it is no longer
+ * needed.
+ */
+extern char * StrInt(long);
+
+/**
+ * Compare two strings and determine whether or not they are equal.
+ * This is the most common use case of strcmp() in Cytoplasm, but
+ * strcmp() doesn't like NULL pointers, so these have to be checked
+ * explicitly and can cause problems if they aren't. This function,
+ * on the other hand, makes NULL pointers special cases. If both
+ * arguments are NULL, then they are considered equal. If only one
+ * argument is NULL, they are considered not equal. Otherwise, if
+ * no arguments are NULL, a regular strcmp() takes place and this
+ * function returns a boolean value indicating whether or not
+ * strcmp() returned 0.
+ */
+extern int StrEquals(const char *, const char *);
+
+#endif                             /* CYTOPLASM_STR_H */

src/include/Stream.h

@@ -0,0 +1,223 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_STREAM_H
+#define CYTOPLASM_STREAM_H
+
+/***
+ * @Nm Stream
+ * @Nd An abstraction over the Io API that implements standard C I/O.
+ * @Dd April 29 2023
+ * @Xr Io
+ *
+ * .Nm
+ * implements an abstraction layer over the Io API. This layer buffers
+ * I/O and makes it much easier to work with, mimicking the standard
+ * C library and offering some more convenience features.
+ */
+
+#include <Io.h>
+
+#include <stdarg.h>
+
+/**
+ * An opaque structure analogous to C's FILE pointers.
+ */
+typedef struct Stream Stream;
+
+/**
+ * Create a new stream using the specified Io for underlying I/O
+ * operations.
+ */
+extern Stream * StreamIo(Io * io);
+
+/**
+ * Create a new stream using the specified POSIX file descriptor.
+ * This is a convenience function for calling
+ * .Fn IoFd
+ * and then passing the result into
+ * .Fn StreamIo .
+ */
+extern Stream * StreamFd(int);
+
+/**
+ * Create a new stream using the specified C FILE pointer. This is a
+ * convenience function for calling
+ * .Fn IoFile
+ * and then passing the result into
+ * .Fn StreamIo .
+ */
+extern Stream * StreamFile(FILE *);
+
+/**
+ * Create a new stream using the specified path and mode. This is a
+ * convenience function for calling
+ * .Xr fopen 3
+ * and then passing the result into
+ * .Fn StreamFile .
+ */
+extern Stream * StreamOpen(const char *, const char *);
+
+/**
+ * Get a stream that writes to the standard output.
+ */
+extern Stream * StreamStdout(void);
+
+/**
+ * Get a stream that writes to the standard error.
+ */
+extern Stream * StreamStderr(void);
+
+/**
+ * Get a stream that reads from the standard input.
+ */
+extern Stream * StreamStdin(void);
+
+/**
+ * Close the stream. This flushes the buffers and closes the underlying
+ * Io. It is analogous to the standard
+ * .Xr fclose 3
+ * function.
+ */
+extern int StreamClose(Stream *);
+
+/**
+ * Print a formatted string. This function is analogous to the standard
+ * .Xr vfprintf 3
+ * function.
+ */
+extern int StreamVprintf(Stream *, const char *, va_list);
+
+/**
+ * Print a formatted string. This function is analogous to the
+ * standard
+ * .Xr fprintf 3
+ * function.
+ */
+extern int StreamPrintf(Stream *, const char *,...);
+
+/**
+ * Get a single character from a stream. This function is analogous to
+ * the standard
+ * .Xr fgetc 3
+ * function.
+ */
+extern int StreamGetc(Stream *);
+
+/**
+ * Push a character back onto the input stream. This function is
+ * analogous to the standard
+ * .Xr ungetc 3
+ * function.
+ */
+extern int StreamUngetc(Stream *, int);
+
+/**
+ * Write a single character to the stream. This function is analogous
+ * to the standard
+ * .Xr fputc 3
+ * function.
+ */
+extern int StreamPutc(Stream *, int);
+
+/**
+ * Write a null-terminated string to the stream. This function is
+ * analogous to the standard
+ * .Xr fputs 3
+ * function.
+ */
+extern int StreamPuts(Stream *, char *);
+
+/**
+ * Read at most the specified number of characters minus 1 from the
+ * specified stream and store them at the memory located at the
+ * specified pointer. This function is analogous to the standard
+ * .Xr fgets 3
+ * function.
+ */
+extern char * StreamGets(Stream *, char *, int);
+
+/**
+ * Set the file position indicator for the specified stream. This
+ * function is analogous to the standard
+ * .Xr fseeko
+ * function.
+ */
+extern off_t StreamSeek(Stream *, off_t, int);
+
+/**
+ * Test the end-of-file indicator for the given stream, returning a
+ * boolean value indicating whether or not it is set. This is analogous
+ * to the standard
+ * .Xr feof 3
+ * function.
+ */
+extern int StreamEof(Stream *);
+
+/**
+ * Test the stream for an error condition, returning a boolean value
+ * indicating whether or not one is present. This is analogous to the
+ * standard
+ * .Xr ferror 3
+ * function.
+ */
+extern int StreamError(Stream *);
+
+/**
+ * Clear the error condition associated with the given stream, allowing
+ * future reads or writes to potentially be successful. This functio
+ * is analogous to the standard
+ * .Xr clearerr 3
+ * function.
+ */
+extern void StreamClearError(Stream *);
+
+/**
+ * Flush all buffered data using the streams underlying write function.
+ * This function is analogous to the standard
+ * .Xr fflush 3
+ * function.
+ */
+extern int StreamFlush(Stream *);
+
+/**
+ * Read all the bytes from the first stream and write them to the
+ * second stream. This is analogous to
+ * .Fn IoCopy ,
+ * but it uses the internal buffers of the streams. It is probably
+ * less efficient than doing a
+ * .Fn IoCopy
+ * instead, but it is more convenient.
+ */
+extern ssize_t StreamCopy(Stream *, Stream *);
+
+/**
+ * Get the file descriptor associated with the given stream, or -1 if
+ * the stream is not associated with any file descriptor. This function
+ * is analogous to the standard
+ * .Xr fileno 3
+ * function.
+ */
+extern int StreamFileno(Stream *);
+
+#endif                             /* CYTOPLASM_STREAM_H */

src/include/Tls.h

@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_TLS_H
+#define CYTOPLASM_TLS_H
+
+/***
+ * @Nm Tls
+ * @Nd Interface to platform-dependent TLS libraries.
+ * @Dd April 29 2023
+ * @Xr Stream Io
+ *
+ * .Nm
+ * provides an interface to platform-dependent TLS libraries. It allows
+ * Cytoplasm to support any TLS library with no changes to existing
+ * code. Support for additional TLS libraries is added by creating a
+ * new compilation unit that implements all the functions here, with
+ * the exception of a few, which are noted.
+ * .Pp
+ * Currently, Cytoplasm has support for the following TLS libraries:
+ * .Bl -bullet -offset indent
+ * .It
+ * LibreSSL
+ * .It
+ * OpenSSL
+ * .El
+ */
+
+#include <Stream.h>
+
+#define TLS_LIBRESSL 2
+#define TLS_OPENSSL 3
+
+/**
+ * Create a new TLS client stream using the given file descriptor and
+ * the given server hostname. The hostname should be used to verify
+ * that the server actually is who it says it is.
+ * .Pp
+ * This function does not need to be implemented by the individual
+ * TLS support stubs.
+ */
+extern Stream * TlsClientStream(int, const char *);
+
+/**
+ * Create a new TLS server stream using the given certificate and key
+ * file, in the format natively supported by the TLS library.
+ * .Pp
+ * This function does not need to be implemented by the individual
+ * TLS support stubs.
+ */
+extern Stream * TlsServerStream(int, const char *, const char *);
+
+/**
+ * Initialize a cookie that stores information about the given client
+ * connection. This cookie will be passed into the other functions
+ * defined by this API.
+ */
+extern void * TlsInitClient(int, const char *);
+
+/**
+ * Initialize a cookie that stores information about the given
+ * server connection. This cookie will be passed into the other
+ * functions defined by this API.
+ */
+extern void * TlsInitServer(int, const char *, const char *);
+
+/**
+ * Read from a TLS stream, decrypting it and storing the result in the
+ * specified buffer. This function takes the cookie, buffer, and
+ * number of decrypted bytes to read into it. See the documentation for
+ * .Fn IoRead .
+ */
+extern ssize_t TlsRead(void *, void *, size_t);
+
+/**
+ * Write to a TLS stream, encrypting the buffer. This function takes
+ * the cookie, buffer, and number of unencrypted bytes to write to
+ * the stream. See the documentation for
+ * .Fn IoWrite .
+ */
+extern ssize_t TlsWrite(void *, void *, size_t);
+
+/**
+ * Close the TLS stream, also freeing all memory associated with the
+ * cookie.
+ */
+extern int TlsClose(void *);
+
+#endif                             /* CYTOPLASM_TLS_H */

src/include/Uri.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef CYTOPLASM_URI_H
+#define CYTOPLASM_URI_H
+
+/***
+ * @Nm Uri
+ * @Nd Parse a URI. Typically used to parse HTTP(s) URLs.
+ * @Dd April 29 2023
+ * @Xr Http
+ *
+ * .Nm
+ * provides a simple mechanism for parsing URIs. This is an extremely
+ * basic parser that (ab)uses
+ * .Xr sscanf 3
+ * to parse URIs, so it may not be the most reliable, but it should
+ * work in most cases and on reasonable URIs that aren't too long, as
+ * the _MAX definitions are modest.
+ */
+
+#define URI_PROTO_MAX 8
+#define URI_HOST_MAX 128
+#define URI_PATH_MAX 256
+
+/**
+ * The parsed URI is stored in this structure.
+ */
+typedef struct Uri
+{
+    char proto[URI_PROTO_MAX];
+    char host[URI_HOST_MAX];
+    char path[URI_PATH_MAX];
+    unsigned short port;
+} Uri;
+
+/**
+ * Parse a URI string into the Uri structure as described above, or
+ * return NULL if there was a parsing error.
+ */
+extern Uri * UriParse(const char *);
+
+/**
+ * Free the memory associated with a Uri structure returned by
+ * .Fn UriParse .
+ */
+extern void UriFree(Uri *);
+
+#endif                             /* CYTOPLASM_URI_H */

src/include/Util.h

@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef CYTOPLASM_UTIL_H
+#define CYTOPLASM_UTIL_H
+
+/***
+ * @Nm Util
+ * @Nd Some misc. helper functions that don't need their own headers.
+ * @Dd February 15 2023
+ * 
+ * This header holds a number of random functions related to strings,
+ * time, the filesystem, and other simple tasks that don't require a
+ * full separate API. For the most part, the functions here are
+ * entirely standalone, depending only on POSIX functions, however
+ * there are a few that depend explicitly on a few other APIs. Those
+ * are noted.
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+#include <Stream.h>
+
+/**
+ * Get the current timestamp in milliseconds since the Unix epoch. This
+ * uses
+ * .Xr gettimeofday 2 
+ * and time_t, and converts it to a single number, which is then
+ * returned to the caller.
+ * .Pp
+ * A note on the 2038 problem: as long as sizeof(long) >= 8, that is,
+ * as long as the long data type is 64 bits or more, then everything
+ * should be fine. On most, if not, all, 64-bit systems, long is 64
+ * bits. I would expect Cytoplasm to break for 32 bit systems
+ * eventually, but we should have a ways to go before that happens.
+ * I didn't want to try to hack together some system to store larger
+ * numbers than the architecture supports. But we can always
+ * re-evaluate over the next few years.
+ */
+extern unsigned long UtilServerTs(void);
+
+/**
+ * Use
+ * .Xr stat 2
+ * to get the last modified time of the given file, or zero if there
+ * was an error getting the last modified time of a file. This is
+ * primarily useful for caching file data.
+ */
+extern unsigned long UtilLastModified(char *);
+
+/**
+ * This function behaves just like the system call
+ * .Xr mkdir 2 ,
+ * but it creates any intermediate directories as necessary, unlike
+ * .Xr mkdir 2 .
+ */
+extern int UtilMkdir(const char *, const mode_t);
+
+/**
+ * Sleep the calling thread for the given number of milliseconds.
+ * POSIX does not have a very friendly way to sleep, so this wraps
+ * .Xr nanosleep 2
+ * to make its usage much, much simpler.
+ */
+extern int UtilSleepMillis(long);
+
+/**
+ * This function works identically to the POSIX
+ * .Xr getdelim 3 ,
+ * except that it assumes pointers were allocated with the Memory API
+ * and it reads from a Stream instead of a file pointer.
+ */
+extern ssize_t UtilGetDelim(char **, size_t *, int, Stream *);
+
+/**
+ * This function is just a special case of 
+ * .Fn UtilGetDelim
+ * that sets the delimiter to the newline character.
+ */
+extern ssize_t UtilGetLine(char **, size_t *, Stream *);
+
+#endif                             /* CYTOPLASM_UTIL_H */

tools/hdoc.c

@@ -0,0 +1,556 @@
+/*
+ * Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <HeaderParser.h>
+
+#include <HashMap.h>
+#include <Str.h>
+#include <Memory.h>
+#include <Args.h>
+
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include <errno.h>
+
+typedef struct DocDecl
+{
+    char docs[HEADER_EXPR_MAX];
+    HeaderDeclaration decl;
+} DocDecl;
+
+typedef struct DocTypedef
+{
+    char docs[HEADER_EXPR_MAX];
+    char text[HEADER_EXPR_MAX];
+} DocTypedef;
+
+typedef struct DocGlobal
+{
+    char docs[HEADER_EXPR_MAX];
+    HeaderGlobal global;
+} DocGlobal;
+
+static void
+ParseMainBlock(HashMap * registers, Array * descr, char *comment)
+{
+    char *line = strtok(comment, "\n");
+
+    while (line)
+    {
+        while (*line && (isspace(*line) || *line == '*'))
+        {
+            line++;
+        }
+
+        if (!*line)
+        {
+            goto next;
+        }
+
+        if (*line == '@')
+        {
+            int i = 0;
+
+            line++;
+
+            while (!isspace(line[i]))
+            {
+                i++;
+            }
+
+            line[i] = '\0';
+
+            Free(HashMapSet(registers, line, StrDuplicate(line + i + 1)));
+        }
+        else
+        {
+            ArrayAdd(descr, StrDuplicate(line));
+        }
+
+next:
+        line = strtok(NULL, "\n");
+    }
+}
+
+int
+Main(Array * args)
+{
+    HeaderExpr expr;
+    size_t i;
+    char *key;
+    char *val;
+    int exit = EXIT_SUCCESS;
+    ArgParseState arg;
+
+    HashMap *registers = HashMapCreate();
+    Array *descr = ArrayCreate();
+
+    Array *declarations = ArrayCreate();
+    DocDecl *decl = NULL;
+
+    Array *typedefs = ArrayCreate();
+    DocTypedef *type = NULL;
+
+    Array *globals = ArrayCreate();
+    DocGlobal *global = NULL;
+
+    char comment[HEADER_EXPR_MAX];
+    int isDocumented = 0;
+
+    Stream *in = NULL;
+    Stream *out = NULL;
+
+    int opt;
+
+    ArgParseStateInit(&arg);
+    while ((opt = ArgParse(&arg, args, "i:o:D:")) != -1)
+    {
+        switch (opt)
+        {
+            case 'i':
+                if (in)
+                {
+                    break;
+                }
+
+                if (StrEquals(arg.optArg, "-"))
+                {
+                    in = StreamStdin();
+                }
+                else
+                {
+                    int len = strlen(arg.optArg);
+
+                    in = StreamOpen(arg.optArg, "r");
+                    if (!in)
+                    {
+                        StreamPrintf(StreamStderr(), "Error: %s:%s",
+                                     arg.optArg, strerror(errno));
+                        exit = EXIT_FAILURE;
+                        goto finish;
+                    }
+
+                    while (arg.optArg[len - 1] != '.')
+                    {
+                        arg.optArg[len - 1] = '\0';
+                        len--;
+                    }
+
+                    arg.optArg[len - 1] = '\0';
+                    len--;
+
+                    HashMapSet(registers, "Nm", StrDuplicate(arg.optArg));
+                }
+                break;
+            case 'o':
+                if (out)
+                {
+                    break;
+                }
+
+                if (StrEquals(arg.optArg, "-"))
+                {
+                    out = StreamStdout();
+                }
+                else
+                {
+                    out = StreamOpen(arg.optArg, "w");
+                    if (!out)
+                    {
+                        StreamPrintf(StreamStderr(), "Error: %s:%s",
+                                     arg.optArg, strerror(errno));
+                        exit = EXIT_FAILURE;
+                        goto finish;
+                    }
+                }
+                break;
+            case 'D':
+                val = arg.optArg;
+                while (*val && *val != '=')
+                {
+                    val++;
+                }
+                if (!*val || *val != '=')
+                {
+                    StreamPrintf(StreamStderr(), "Bad register definition: %s",
+                                 arg.optArg);
+                    exit = EXIT_FAILURE;
+                    goto finish;
+                }
+
+                *val = '\0';
+                val++;
+                HashMapSet(registers, arg.optArg, StrDuplicate(val));
+                break;
+        }
+    }
+
+    if (!in)
+    {
+        in = StreamStdin();
+    }
+
+    if (!out)
+    {
+        out = StreamStdout();
+    }
+
+    memset(&expr, 0, sizeof(expr));
+
+    while (1)
+    {
+        HeaderParse(in, &expr);
+
+        switch (expr.type)
+        {
+            case HP_PREPROCESSOR_DIRECTIVE:
+                /* Ignore */
+                break;
+            case HP_EOF:
+                /* Done parsing */
+                goto last;
+            case HP_PARSE_ERROR:
+            case HP_SYNTAX_ERROR:
+                StreamPrintf(StreamStderr(), "Parse Error: (line %d) %s\n",
+                         expr.data.error.lineNo, expr.data.error.msg);
+                exit = EXIT_FAILURE;
+                goto finish;
+            case HP_COMMENT:
+                if (expr.data.text[0] != '*')
+                {
+                    break;
+                }
+
+                if (strncmp(expr.data.text, "**", 2) == 0)
+                {
+                    ParseMainBlock(registers, descr, expr.data.text);
+                }
+                else
+                {
+                    strncpy(comment, expr.data.text, sizeof(comment));
+                    isDocumented = 1;
+                }
+                break;
+            case HP_TYPEDEF:
+                if (HashMapGet(registers, "ignore-typedefs"))
+                {
+                    break;
+                }
+
+                if (!isDocumented)
+                {
+                    StreamPrintf(StreamStderr(),
+                                 "Error: Undocumented typedef:\n%s\n",
+                                 expr.data.text);
+                    exit = EXIT_FAILURE;
+                    goto finish;
+                }
+                else
+                {
+                    type = Malloc(sizeof(DocTypedef));
+                    strncpy(type->docs, comment, sizeof(type->docs));
+                    strncpy(type->text, expr.data.text, sizeof(type->text));
+                    ArrayAdd(typedefs, type);
+                    isDocumented = 0;
+                }
+                break;
+            case HP_DECLARATION:
+                if (!isDocumented)
+                {
+                    StreamPrintf(StreamStderr(),
+                                 "Error: %s() is undocumented.\n",
+                                 expr.data.declaration.name);
+                    exit = EXIT_FAILURE;
+                    goto finish;
+                }
+                else
+                {
+                    decl = Malloc(sizeof(DocDecl));
+                    decl->decl = expr.data.declaration;
+                    decl->decl.args = ArrayCreate();
+                    strncpy(decl->docs, comment, sizeof(decl->docs));
+                    for (i = 0; i < ArraySize(expr.data.declaration.args); i++)
+                    {
+                        ArrayAdd(decl->decl.args, StrDuplicate(ArrayGet(expr.data.declaration.args, i)));
+                    }
+                    ArrayAdd(declarations, decl);
+                    isDocumented = 0;
+                }
+                break;
+            case HP_GLOBAL:
+                if (!isDocumented)
+                {
+                    StreamPrintf(StreamStderr(),
+                                 "Error: Global %s is undocumented.\n",
+                                 expr.data.global.name);
+                    exit = EXIT_FAILURE;
+                    goto finish;
+                }
+                else
+                {
+                    global = Malloc(sizeof(DocGlobal));
+                    global->global = expr.data.global;
+
+                    strncpy(global->docs, comment, sizeof(global->docs));
+                    ArrayAdd(globals, global);
+                    isDocumented = 0;
+                }
+                break;
+            case HP_UNKNOWN:
+                if (HashMapGet(registers, "suppress-warnings"))
+                {
+                    break;
+                }
+                StreamPrintf(StreamStderr(), "Warning: Unknown expression: %s\n",
+                             expr.data.text);
+                break;
+            default:
+                StreamPrintf(StreamStderr(), "Unknown header type: %d\n", expr.type);
+                StreamPrintf(StreamStderr(), "This is a programming error.\n");
+                exit = EXIT_FAILURE;
+                goto finish;
+        }
+    }
+
+last:
+    val = HashMapGet(registers, "Nm");
+    if (!val)
+    {
+        HashMapSet(registers, "Nm", StrDuplicate("Unnamed"));
+    }
+
+    val = HashMapGet(registers, "Dd");
+    if (!val)
+    {
+        time_t currentTime;
+        struct tm *timeInfo;
+        char tsBuf[1024];
+
+        currentTime = time(NULL);
+        timeInfo = localtime(&currentTime);
+        strftime(tsBuf, sizeof(tsBuf), "%B %d %Y", timeInfo);
+
+        val = tsBuf;
+    }
+    StreamPrintf(out, ".Dd $%s: %s $\n", "Mdocdate", val);
+
+    val = HashMapGet(registers, "Os");
+    if (val)
+    {
+        StreamPrintf(out, ".Os %s\n", val);
+    }
+
+    val = HashMapGet(registers, "Nm");
+    StreamPrintf(out, ".Dt %s 3\n", val);
+    StreamPrintf(out, ".Sh NAME\n");
+    StreamPrintf(out, ".Nm %s\n", val);
+
+    val = HashMapGet(registers, "Nd");
+    if (!val)
+    {
+        val = "No Description.";
+    }
+    StreamPrintf(out, ".Nd %s\n", val);
+
+    StreamPrintf(out, ".Sh SYNOPSIS\n");
+    val = HashMapGet(registers, "Nm");
+    StreamPrintf(out, ".In %s.h\n", val);
+    for (i = 0; i < ArraySize(declarations); i++)
+    {
+        size_t j;
+
+        decl = ArrayGet(declarations, i);
+        StreamPrintf(out, ".Ft %s\n", decl->decl.returnType);
+        StreamPrintf(out, ".Fn %s ", decl->decl.name);
+        for (j = 0; j < ArraySize(decl->decl.args); j++)
+        {
+            StreamPrintf(out, "\"%s\" ", ArrayGet(decl->decl.args, j));
+        }
+        StreamPutc(out, '\n');
+    }
+
+    if (ArraySize(globals))
+    {
+        StreamPrintf(out, ".Sh GLOBALS\n");
+        for (i = 0; i < ArraySize(globals); i++)
+        {
+            char *line;
+            global = ArrayGet(globals, i);
+
+            StreamPrintf(out, ".Ss %s %s\n", global->global.type, global->global.name);
+
+            line = strtok(global->docs, "\n");
+            while (line)
+            {
+                while (*line && (isspace(*line) || *line == '*'))
+                {
+                    line++;
+                }
+
+                if (*line)
+                {
+                    StreamPrintf(out, "%s\n", line);
+                }
+
+                line = strtok(NULL, "\n");
+            }
+        }
+    }
+
+    if (ArraySize(typedefs))
+    {
+        StreamPrintf(out, ".Sh TYPE DECLARATIONS\n");
+        for (i = 0; i < ArraySize(typedefs); i++)
+        {
+            char *line;
+
+            type = ArrayGet(typedefs, i);
+            StreamPrintf(out, ".Bd -literal -offset indent\n");
+            StreamPrintf(out, "%s\n", type->text);
+            StreamPrintf(out, ".Ed\n.Pp\n");
+
+            line = strtok(type->docs, "\n");
+            while (line)
+            {
+                while (*line && (isspace(*line) || *line == '*'))
+                {
+                    line++;
+                }
+
+                if (*line)
+                {
+                    StreamPrintf(out, "%s\n", line);
+                }
+
+                line = strtok(NULL, "\n");
+            }
+        }
+    }
+
+    StreamPrintf(out, ".Sh DESCRIPTION\n");
+    for (i = 0; i < ArraySize(descr); i++)
+    {
+        StreamPrintf(out, "%s\n", ArrayGet(descr, i));
+    }
+
+    for (i = 0; i < ArraySize(declarations); i++)
+    {
+        size_t j;
+        char *line;
+
+        decl = ArrayGet(declarations, i);
+        StreamPrintf(out, ".Ss %s %s(",
+                     decl->decl.returnType, decl->decl.name);
+        for (j = 0; j < ArraySize(decl->decl.args); j++)
+        {
+            StreamPrintf(out, "%s", ArrayGet(decl->decl.args, j));
+            if (j < ArraySize(decl->decl.args) - 1)
+            {
+                StreamPuts(out, ", ");
+            }
+        }
+        StreamPuts(out, ")\n");
+
+        line = strtok(decl->docs, "\n");
+        while (line)
+        {
+            while (*line && (isspace(*line) || *line == '*'))
+            {
+                line++;
+            }
+
+            if (*line)
+            {
+                StreamPrintf(out, "%s\n", line);
+            }
+
+            line = strtok(NULL, "\n");
+        }
+    }
+
+    val = HashMapGet(registers, "Xr");
+    if (val)
+    {
+        char *xr = strtok(val, " ");
+
+        StreamPrintf(out, ".Sh SEE ALSO\n");
+        while (xr)
+        {
+            if (*xr)
+            {
+                StreamPrintf(out, ".Xr %s 3 ", xr);
+            }
+
+            xr = strtok(NULL, " ");
+
+            if (xr)
+            {
+                StreamPutc(out, ',');
+            }
+            StreamPutc(out, '\n');
+        }
+    }
+
+finish:
+    if (in != StreamStdin())
+    {
+        StreamClose(in);
+    }
+
+    if (out != StreamStdout())
+    {
+        StreamClose(out);
+    }
+
+    for (i = 0; i < ArraySize(declarations); i++)
+    {
+        Free(ArrayGet(declarations, i));
+    }
+
+    for (i = 0; i < ArraySize(typedefs); i++)
+    {
+        Free(ArrayGet(typedefs, i));
+    }
+
+    for (i = 0; i < ArraySize(globals); i++)
+    {
+        Free(ArrayGet(globals, i));
+    }
+
+    for (i = 0; i < ArraySize(descr); i++)
+    {
+        Free(ArrayGet(descr, i));
+    }
+
+    while (HashMapIterate(registers, &key, (void **) &val))
+    {
+        Free(val);
+    }
+
+    HashMapFree(registers);
+
+    return exit;
+}