nserver/ -> ./

23 files changed, 0 insertions, 6042 deletions

diff --git a/nserver/src/bstrlib.c b/nserver/src/bstrlib.c
deleted file mode 100644
index 8161319..0000000
--- a/nserver/src/bstrlib.c
+++ /dev/null
@@ -1,3149 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2014 Paul Hsieh
- * Copyright © 2020 rsiddharth
- */
-
-/*
- * This is a slightly modified version of bstrlib.c from the bstrlib
- * library (https://github.com/websnarf/bstrlib/releases/tag/v1.0.0).
- */
-
-/*
- * This source file is part of the bstring string library.  This code was
- * written by Paul Hsieh in 2002-2015, and is covered by the BSD open source
- * license and the GPL. Refer to the accompanying documentation for details
- * on usage and license.
- */
-
-/*
- * bstrlib.c
- *
- * This file is the core module for implementing the bstring functions.
- */
-
-#if defined (_MSC_VER)
-# define _CRT_SECURE_NO_WARNINGS
-#endif
-
-#include <stdio.h>
-#include <stddef.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <limits.h>
-#include <bstrlib.h>
-
-/* Optionally include a mechanism for debugging memory */
-
-#if defined(MEMORY_DEBUG) || defined(BSTRLIB_MEMORY_DEBUG)
-#include "memdbg.h"
-#endif
-
-#ifndef bstr__alloc
-#if defined (BSTRLIB_TEST_CANARY)
-void* bstr__alloc (size_t sz) {
-	char* p = (char *) malloc (sz);
-	memset (p, 'X', sz);
-	return p;
-}
-#else
-#define bstr__alloc(x) malloc (x)
-#endif
-#endif
-
-#ifndef bstr__free
-#define bstr__free(p) free (p)
-#endif
-
-#ifndef bstr__realloc
-#define bstr__realloc(p,x) realloc ((p), (x))
-#endif
-
-#ifndef bstr__memcpy
-#define bstr__memcpy(d,s,l) memcpy ((d), (s), (l))
-#endif
-
-#ifndef bstr__memmove
-#define bstr__memmove(d,s,l) memmove ((d), (s), (l))
-#endif
-
-#ifndef bstr__memset
-#define bstr__memset(d,c,l) memset ((d), (c), (l))
-#endif
-
-#ifndef bstr__memcmp
-#define bstr__memcmp(d,c,l) memcmp ((d), (c), (l))
-#endif
-
-#ifndef bstr__memchr
-#define bstr__memchr(s,c,l) memchr ((s), (c), (l))
-#endif
-
-/* Just a length safe wrapper for memmove. */
-
-#define bBlockCopy(D,S,L) { if ((L) > 0) bstr__memmove ((D),(S),(L)); }
-
-/* Compute the snapped size for a given requested size.  By snapping to powers
-   of 2 like this, repeated reallocations are avoided. */
-static int snapUpSize (int i) {
-	if (i < 8) {
-		i = 8;
-	} else {
-		unsigned int j;
-		j = (unsigned int) i;
-
-		j |= (j >>  1);
-		j |= (j >>  2);
-		j |= (j >>  4);
-		j |= (j >>  8);		/* Ok, since int >= 16 bits */
-#if (UINT_MAX != 0xffff)
-		j |= (j >> 16);		/* For 32 bit int systems */
-#if (UINT_MAX > 0xffffffffUL)
-		j |= (j >> 32);		/* For 64 bit int systems */
-#endif
-#endif
-		/* Least power of two greater than i */
-		j++;
-		if ((int) j >= i) i = (int) j;
-	}
-	return i;
-}
-
-/*  int balloc (bstring b, int len)
- *
- *  Increase the size of the memory backing the bstring b to at least len.
- */
-int balloc (bstring b, int olen) {
-	int len;
-	if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen <= 0 ||
-	    b->mlen < b->slen || olen <= 0) {
-		return BSTR_ERR;
-	}
-
-	if (olen >= b->mlen) {
-		unsigned char * x;
-
-		if ((len = snapUpSize (olen)) <= b->mlen) return BSTR_OK;
-
-		/* Assume probability of a non-moving realloc is 0.125 */
-		if (7 * b->mlen < 8 * b->slen) {
-
-			/* If slen is close to mlen in size then use realloc to reduce
-			   the memory defragmentation */
-
-			reallocStrategy:;
-
-			x = (unsigned char *) bstr__realloc (b->data, (size_t) len);
-			if (x == NULL) {
-
-				/* Since we failed, try allocating the tighest possible
-				   allocation */
-
-				len = olen;
-				x = (unsigned char *) bstr__realloc (b->data, (size_t) olen);
-				if (NULL == x) {
-					return BSTR_ERR;
-				}
-			}
-		} else {
-
-			/* If slen is not close to mlen then avoid the penalty of copying
-			   the extra bytes that are allocated, but not considered part of
-			   the string */
-
-			if (NULL == (x = (unsigned char *) bstr__alloc ((size_t) len))) {
-
-				/* Perhaps there is no available memory for the two
-				   allocations to be in memory at once */
-
-				goto reallocStrategy;
-
-			} else {
-				if (b->slen) bstr__memcpy ((char *) x, (char *) b->data,
-				                           (size_t) b->slen);
-				bstr__free (b->data);
-			}
-		}
-		b->data = x;
-		b->mlen = len;
-		b->data[b->slen] = (unsigned char) '\0';
-
-#if defined (BSTRLIB_TEST_CANARY)
-		if (len > b->slen + 1) {
-			memchr (b->data + b->slen + 1, 'X', len - (b->slen + 1));
-		}
-#endif
-	}
-
-	return BSTR_OK;
-}
-
-/*  int ballocmin (bstring b, int len)
- *
- *  Set the size of the memory backing the bstring b to len or b->slen+1,
- *  whichever is larger.  Note that repeated use of this function can degrade
- *  performance.
- */
-int ballocmin (bstring b, int len) {
-	unsigned char * s;
-
-	if (b == NULL || b->data == NULL) return BSTR_ERR;
-	if (b->slen >= INT_MAX || b->slen < 0) return BSTR_ERR;
-	if (b->mlen <= 0 || b->mlen < b->slen || len <= 0) {
-		return BSTR_ERR;
-	}
-
-	if (len < b->slen + 1) len = b->slen + 1;
-
-	if (len != b->mlen) {
-		s = (unsigned char *) bstr__realloc (b->data, (size_t) len);
-		if (NULL == s) return BSTR_ERR;
-		s[b->slen] = (unsigned char) '\0';
-		b->data = s;
-		b->mlen = len;
-	}
-
-	return BSTR_OK;
-}
-
-/*  bstring bfromcstr (const char * str)
- *
- *  Create a bstring which contains the contents of the '\0' terminated char *
- *  buffer str.
- */
-bstring bfromcstr (const char * str) {
-bstring b;
-int i;
-size_t j;
-
-	if (str == NULL) return NULL;
-	j = (strlen) (str);
-	i = snapUpSize ((int) (j + (2 - (j != 0))));
-	if (i <= (int) j) return NULL;
-
-	b = (bstring) bstr__alloc (sizeof (struct tagbstring));
-	if (NULL == b) return NULL;
-	b->slen = (int) j;
-	if (NULL == (b->data = (unsigned char *) bstr__alloc (b->mlen = i))) {
-		bstr__free (b);
-		return NULL;
-	}
-
-	bstr__memcpy (b->data, str, j+1);
-	return b;
-}
-
-/*  bstring bfromcstrrangealloc (int minl, int maxl, const char* str)
- *
- *  Create a bstring which contains the contents of the '\0' terminated
- *  char* buffer str.  The memory buffer backing the string is at least
- *  minl characters in length, but an attempt is made to allocate up to
- *  maxl characters.
- */
-bstring bfromcstrrangealloc (int minl, int maxl, const char* str) {
-bstring b;
-int i;
-size_t j;
-
-	/* Bad parameters? */
-	if (str == NULL) return NULL;
-	if (maxl < minl || minl < 0) return NULL;
-
-	/* Adjust lengths */
-	j = (strlen) (str);
-	if ((size_t) minl < (j+1)) minl = (int) (j+1);
-	if (maxl < minl) maxl = minl;
-	i = maxl;
-
-	b = (bstring) bstr__alloc (sizeof (struct tagbstring));
-	if (b == NULL) return NULL;
-	b->slen = (int) j;
-
-	while (NULL == (b->data = (unsigned char *) bstr__alloc (b->mlen = i))) {
-		int k = (i >> 1) + (minl >> 1);
-		if (i == k || i < minl) {
-			bstr__free (b);
-			return NULL;
-		}
-		i = k;
-	}
-
-	bstr__memcpy (b->data, str, j+1);
-	return b;
-}
-
-/*  bstring bfromcstralloc (int mlen, const char * str)
- *
- *  Create a bstring which contains the contents of the '\0' terminated
- *  char* buffer str.  The memory buffer backing the string is at least
- *  mlen characters in length.
- */
-bstring bfromcstralloc (int mlen, const char * str) {
-	return bfromcstrrangealloc (mlen, mlen, str);
-}
-
-/*  bstring blk2bstr (const void * blk, int len)
- *
- *  Create a bstring which contains the content of the block blk of length
- *  len.
- */
-bstring blk2bstr (const void * blk, int len) {
-bstring b;
-int i;
-
-	if (blk == NULL || len < 0) return NULL;
-	b = (bstring) bstr__alloc (sizeof (struct tagbstring));
-	if (b == NULL) return NULL;
-	b->slen = len;
-
-	i = len + (2 - (len != 0));
-	i = snapUpSize (i);
-
-	b->mlen = i;
-
-	b->data = (unsigned char *) bstr__alloc ((size_t) b->mlen);
-	if (b->data == NULL) {
-		bstr__free (b);
-		return NULL;
-	}
-
-	if (len > 0) bstr__memcpy (b->data, blk, (size_t) len);
-	b->data[len] = (unsigned char) '\0';
-
-	return b;
-}
-
-/*  char * bstr2cstr (const_bstring s, char z)
- *
- *  Create a '\0' terminated char * buffer which is equal to the contents of
- *  the bstring s, except that any contained '\0' characters are converted
- *  to the character in z. This returned value should be freed with a
- *  bcstrfree () call, by the calling application.
- */
-char * bstr2cstr (const_bstring b, char z) {
-int i, l;
-char * r;
-
-	if (b == NULL || b->slen < 0 || b->data == NULL) return NULL;
-	l = b->slen;
-	r = (char *) bstr__alloc ((size_t) (l + 1));
-	if (r == NULL) return r;
-
-	for (i=0; i < l; i ++) {
-		r[i] = (char) ((b->data[i] == '\0') ? z : (char) (b->data[i]));
-	}
-
-	r[l] = (unsigned char) '\0';
-
-	return r;
-}
-
-/*  int bcstrfree (char * s)
- *
- *  Frees a C-string generated by bstr2cstr ().  This is normally unnecessary
- *  since it just wraps a call to bstr__free (), however, if bstr__alloc ()
- *  and bstr__free () have been redefined as a macros within the bstrlib
- *  module (via defining them in memdbg.h after defining
- *  BSTRLIB_MEMORY_DEBUG) with some difference in behaviour from the std
- *  library functions, then this allows a correct way of freeing the memory
- *  that allows higher level code to be independent from these macro
- *  redefinitions.
- */
-int bcstrfree (char * s) {
-	if (s) {
-		bstr__free (s);
-		return BSTR_OK;
-	}
-	return BSTR_ERR;
-}
-
-/*  int bconcat (bstring b0, const_bstring b1)
- *
- *  Concatenate the bstring b1 to the bstring b0.
- */
-int bconcat (bstring b0, const_bstring b1) {
-int len, d;
-bstring aux = (bstring) b1;
-
-	if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL)
-		return BSTR_ERR;
-
-	d = b0->slen;
-	len = b1->slen;
-	if ((d | (b0->mlen - d) | len | (d + len)) < 0) return BSTR_ERR;
-
-	if (b0->mlen <= d + len + 1) {
-		ptrdiff_t pd = b1->data - b0->data;
-		if (0 <= pd && pd < b0->mlen) {
-			if (NULL == (aux = bstrcpy (b1))) return BSTR_ERR;
-		}
-		if (balloc (b0, d + len + 1) != BSTR_OK) {
-			if (aux != b1) bdestroy (aux);
-			return BSTR_ERR;
-		}
-	}
-
-	bBlockCopy (&b0->data[d], &aux->data[0], (size_t) len);
-	b0->data[d + len] = (unsigned char) '\0';
-	b0->slen = d + len;
-	if (aux != b1) bdestroy (aux);
-	return BSTR_OK;
-}
-
-/*  int bconchar (bstring b, char c)
- *
- *  Concatenate the single character c to the bstring b.
- */
-int bconchar (bstring b, char c) {
-int d;
-
-	if (b == NULL) return BSTR_ERR;
-	d = b->slen;
-	if ((d | (b->mlen - d)) < 0 || balloc (b, d + 2) != BSTR_OK)
-		return BSTR_ERR;
-	b->data[d] = (unsigned char) c;
-	b->data[d + 1] = (unsigned char) '\0';
-	b->slen++;
-	return BSTR_OK;
-}
-
-/*  int bcatcstr (bstring b, const char * s)
- *
- *  Concatenate a char * string to a bstring.
- */
-int bcatcstr (bstring b, const char * s) {
-char * d;
-int i, l;
-
-	if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen < b->slen
-	 || b->mlen <= 0 || s == NULL) return BSTR_ERR;
-
-	/* Optimistically concatenate directly */
-	l = b->mlen - b->slen;
-	d = (char *) &b->data[b->slen];
-	for (i=0; i < l; i++) {
-		if ((*d++ = *s++) == '\0') {
-			b->slen += i;
-			return BSTR_OK;
-		}
-	}
-	b->slen += i;
-
-	/* Need to explicitely resize and concatenate tail */
-	return bcatblk (b, (const void *) s, (int) strlen (s));
-}
-
-/*  int bcatblk (bstring b, const void * s, int len)
- *
- *  Concatenate a fixed length buffer to a bstring.
- */
-int bcatblk (bstring b, const void * s, int len) {
-int nl;
-
-	if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen < b->slen
-	 || b->mlen <= 0 || s == NULL || len < 0) return BSTR_ERR;
-
-	if (0 > (nl = b->slen + len)) return BSTR_ERR; /* Overflow? */
-	if (b->mlen <= nl && 0 > balloc (b, nl + 1)) return BSTR_ERR;
-
-	bBlockCopy (&b->data[b->slen], s, (size_t) len);
-	b->slen = nl;
-	b->data[nl] = (unsigned char) '\0';
-	return BSTR_OK;
-}
-
-/*  bstring bstrcpy (const_bstring b)
- *
- *  Create a copy of the bstring b.
- */
-bstring bstrcpy (const_bstring b) {
-bstring b0;
-int i,j;
-
-	/* Attempted to copy an invalid string? */
-	if (b == NULL || b->slen < 0 || b->data == NULL) return NULL;
-
-	b0 = (bstring) bstr__alloc (sizeof (struct tagbstring));
-	if (b0 == NULL) {
-		/* Unable to allocate memory for string header */
-		return NULL;
-	}
-
-	i = b->slen;
-	j = snapUpSize (i + 1);
-
-	b0->data = (unsigned char *) bstr__alloc (j);
-	if (b0->data == NULL) {
-		j = i + 1;
-		b0->data = (unsigned char *) bstr__alloc (j);
-		if (b0->data == NULL) {
-			/* Unable to allocate memory for string data */
-			bstr__free (b0);
-			return NULL;
-		}
-	}
-
-	b0->mlen = j;
-	b0->slen = i;
-
-	if (i) bstr__memcpy ((char *) b0->data, (char *) b->data, i);
-	b0->data[b0->slen] = (unsigned char) '\0';
-
-	return b0;
-}
-
-/*  int bassign (bstring a, const_bstring b)
- *
- *  Overwrite the string a with the contents of string b.
- */
-int bassign (bstring a, const_bstring b) {
-	if (b == NULL || b->data == NULL || b->slen < 0)
-		return BSTR_ERR;
-	if (b->slen != 0) {
-		if (balloc (a, b->slen) != BSTR_OK) return BSTR_ERR;
-		bstr__memmove (a->data, b->data, b->slen);
-	} else {
-		if (a == NULL || a->data == NULL || a->mlen < a->slen ||
-		    a->slen < 0 || a->mlen == 0)
-			return BSTR_ERR;
-	}
-	a->data[b->slen] = (unsigned char) '\0';
-	a->slen = b->slen;
-	return BSTR_OK;
-}
-
-/*  int bassignmidstr (bstring a, const_bstring b, int left, int len)
- *
- *  Overwrite the string a with the middle of contents of string b
- *  starting from position left and running for a length len.  left and
- *  len are clamped to the ends of b as with the function bmidstr.
- */
-int bassignmidstr (bstring a, const_bstring b, int left, int len) {
-	if (b == NULL || b->data == NULL || b->slen < 0)
-		return BSTR_ERR;
-
-	if (left < 0) {
-		len += left;
-		left = 0;
-	}
-
-	if (len > b->slen - left) len = b->slen - left;
-
-	if (a == NULL || a->data == NULL || a->mlen < a->slen ||
-	    a->slen < 0 || a->mlen == 0)
-		return BSTR_ERR;
-
-	if (len > 0) {
-		if (balloc (a, len) != BSTR_OK) return BSTR_ERR;
-		bstr__memmove (a->data, b->data + left, len);
-		a->slen = len;
-	} else {
-		a->slen = 0;
-	}
-	a->data[a->slen] = (unsigned char) '\0';
-	return BSTR_OK;
-}
-
-/*  int bassigncstr (bstring a, const char * str)
- *
- *  Overwrite the string a with the contents of char * string str.  Note that
- *  the bstring a must be a well defined and writable bstring.  If an error
- *  occurs BSTR_ERR is returned however a may be partially overwritten.
- */
-int bassigncstr (bstring a, const char * str) {
-int i;
-size_t len;
-	if (a == NULL || a->data == NULL || a->mlen < a->slen ||
-	    a->slen < 0 || a->mlen == 0 || NULL == str)
-		return BSTR_ERR;
-
-	for (i=0; i < a->mlen; i++) {
-		if ('\0' == (a->data[i] = str[i])) {
-			a->slen = i;
-			return BSTR_OK;
-		}
-	}
-
-	a->slen = i;
-	len = strlen (str + i);
-	if (len + 1 > (size_t) INT_MAX - i ||
-	    0 > balloc (a, (int) (i + len + 1))) return BSTR_ERR;
-	bBlockCopy (a->data + i, str + i, (size_t) len + 1);
-	a->slen += (int) len;
-	return BSTR_OK;
-}
-
-/*  int bassignblk (bstring a, const void * s, int len)
- *
- *  Overwrite the string a with the contents of the block (s, len).  Note that
- *  the bstring a must be a well defined and writable bstring.  If an error
- *  occurs BSTR_ERR is returned and a is not overwritten.
- */
-int bassignblk (bstring a, const void * s, int len) {
-	if (a == NULL || a->data == NULL || a->mlen < a->slen ||
-	    a->slen < 0 || a->mlen == 0 || NULL == s || len < 0 || len >= INT_MAX)
-		return BSTR_ERR;
-	if (len + 1 > a->mlen && 0 > balloc (a, len + 1)) return BSTR_ERR;
-	bBlockCopy (a->data, s, (size_t) len);
-	a->data[len] = (unsigned char) '\0';
-	a->slen = len;
-	return BSTR_OK;
-}
-
-/*  int btrunc (bstring b, int n)
- *
- *  Truncate the bstring to at most n characters.
- */
-int btrunc (bstring b, int n) {
-	if (n < 0 || b == NULL || b->data == NULL || b->mlen < b->slen ||
-	    b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
-	if (b->slen > n) {
-		b->slen = n;
-		b->data[n] = (unsigned char) '\0';
-	}
-	return BSTR_OK;
-}
-
-#define   upcase(c) (toupper ((unsigned char) c))
-#define downcase(c) (tolower ((unsigned char) c))
-#define   wspace(c) (isspace ((unsigned char) c))
-
-/*  int btoupper (bstring b)
- *
- *  Convert contents of bstring to upper case.
- */
-int btoupper (bstring b) {
-int i, len;
-	if (b == NULL || b->data == NULL || b->mlen < b->slen ||
-	    b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
-	for (i=0, len = b->slen; i < len; i++) {
-		b->data[i] = (unsigned char) upcase (b->data[i]);
-	}
-	return BSTR_OK;
-}
-
-/*  int btolower (bstring b)
- *
- *  Convert contents of bstring to lower case.
- */
-int btolower (bstring b) {
-int i, len;
-	if (b == NULL || b->data == NULL || b->mlen < b->slen ||
-	    b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
-	for (i=0, len = b->slen; i < len; i++) {
-		b->data[i] = (unsigned char) downcase (b->data[i]);
-	}
-	return BSTR_OK;
-}
-
-/*  int bstricmp (const_bstring b0, const_bstring b1)
- *
- *  Compare two strings without differentiating between case.  The return
- *  value is the difference of the values of the characters where the two
- *  strings first differ after lower case transformation, otherwise 0 is
- *  returned indicating that the strings are equal.  If the lengths are
- *  different, then a difference from 0 is given, but if the first extra
- *  character is '\0', then it is taken to be the value UCHAR_MAX+1.
- */
-int bstricmp (const_bstring b0, const_bstring b1) {
-int i, v, n;
-
-	if (bdata (b0) == NULL || b0->slen < 0 ||
-	    bdata (b1) == NULL || b1->slen < 0) return SHRT_MIN;
-	if ((n = b0->slen) > b1->slen) n = b1->slen;
-	else if (b0->slen == b1->slen && b0->data == b1->data) return BSTR_OK;
-
-	for (i = 0; i < n; i ++) {
-		v  = (char) downcase (b0->data[i])
-		   - (char) downcase (b1->data[i]);
-		if (0 != v) return v;
-	}
-
-	if (b0->slen > n) {
-		v = (char) downcase (b0->data[n]);
-		if (v) return v;
-		return UCHAR_MAX + 1;
-	}
-	if (b1->slen > n) {
-		v = - (char) downcase (b1->data[n]);
-		if (v) return v;
-		return - (int) (UCHAR_MAX + 1);
-	}
-	return BSTR_OK;
-}
-
-/*  int bstrnicmp (const_bstring b0, const_bstring b1, int n)
- *
- *  Compare two strings without differentiating between case for at most n
- *  characters.  If the position where the two strings first differ is
- *  before the nth position, the return value is the difference of the values
- *  of the characters, otherwise 0 is returned.  If the lengths are different
- *  and less than n characters, then a difference from 0 is given, but if the
- *  first extra character is '\0', then it is taken to be the value
- *  UCHAR_MAX+1.
- */
-int bstrnicmp (const_bstring b0, const_bstring b1, int n) {
-int i, v, m;
-
-	if (bdata (b0) == NULL || b0->slen < 0 ||
-	    bdata (b1) == NULL || b1->slen < 0 || n < 0) return SHRT_MIN;
-	m = n;
-	if (m > b0->slen) m = b0->slen;
-	if (m > b1->slen) m = b1->slen;
-
-	if (b0->data != b1->data) {
-		for (i = 0; i < m; i ++) {
-			v  = (char) downcase (b0->data[i]);
-			v -= (char) downcase (b1->data[i]);
-			if (v != 0) return b0->data[i] - b1->data[i];
-		}
-	}
-
-	if (n == m || b0->slen == b1->slen) return BSTR_OK;
-
-	if (b0->slen > m) {
-		v = (char) downcase (b0->data[m]);
-		if (v) return v;
-		return UCHAR_MAX + 1;
-	}
-
-	v = - (char) downcase (b1->data[m]);
-	if (v) return v;
-	return - (int) (UCHAR_MAX + 1);
-}
-
-/*  int biseqcaselessblk (const_bstring b, const void * blk, int len)
- *
- *  Compare content of b and the array of bytes in blk for length len for
- *  equality without differentiating between character case.  If the content
- *  differs other than in case, 0 is returned, if, ignoring case, the content
- *  is the same, 1 is returned, if there is an error, -1 is returned.  If the
- *  length of the strings are different, this function is O(1).  '\0'
- *  characters are not treated in any special way.
- */
-int biseqcaselessblk (const_bstring b, const void * blk, int len) {
-int i;
-
-	if (bdata (b) == NULL || b->slen < 0 ||
-	    blk == NULL || len < 0) return BSTR_ERR;
-	if (b->slen != len) return 0;
-	if (len == 0 || b->data == blk) return 1;
-	for (i=0; i < len; i++) {
-		if (b->data[i] != ((unsigned char*)blk)[i]) {
-			unsigned char c = (unsigned char) downcase (b->data[i]);
-			if (c != (unsigned char) downcase (((unsigned char*)blk)[i]))
-				return 0;
-		}
-	}
-	return 1;
-}
-
-
-/*  int biseqcaseless (const_bstring b0, const_bstring b1)
- *
- *  Compare two strings for equality without differentiating between case.
- *  If the strings differ other than in case, 0 is returned, if the strings
- *  are the same, 1 is returned, if there is an error, -1 is returned.  If
- *  the length of the strings are different, this function is O(1).  '\0'
- *  termination characters are not treated in any special way.
- */
-int biseqcaseless (const_bstring b0, const_bstring b1) {
-	if (NULL == b1) return BSTR_ERR;
-	return biseqcaselessblk (b0, b1->data, b1->slen);
-}
-
-/*  int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len)
- *
- *  Compare beginning of string b0 with a block of memory of length len
- *  without differentiating between case for equality.  If the beginning of b0
- *  differs from the memory block other than in case (or if b0 is too short),
- *  0 is returned, if the strings are the same, 1 is returned, if there is an
- *  error, -1 is returned.  '\0' characters are not treated in any special
- *  way.
- */
-int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len) {
-int i;
-
-	if (bdata (b0) == NULL || b0->slen < 0 || NULL == blk || len < 0)
-		return BSTR_ERR;
-	if (b0->slen < len) return BSTR_OK;
-	if (b0->data == (const unsigned char *) blk || len == 0) return 1;
-
-	for (i = 0; i < len; i ++) {
-		if (b0->data[i] != ((const unsigned char *) blk)[i]) {
-			if (downcase (b0->data[i]) !=
-			    downcase (((const unsigned char *) blk)[i])) return 0;
-		}
-	}
-	return 1;
-}
-
-/*
- * int bltrimws (bstring b)
- *
- * Delete whitespace contiguous from the left end of the string.
- */
-int bltrimws (bstring b) {
-int i, len;
-
-	if (b == NULL || b->data == NULL || b->mlen < b->slen ||
-	    b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
-
-	for (len = b->slen, i = 0; i < len; i++) {
-		if (!wspace (b->data[i])) {
-			return bdelete (b, 0, i);
-		}
-	}
-
-	b->data[0] = (unsigned char) '\0';
-	b->slen = 0;
-	return BSTR_OK;
-}
-
-/*
- * int brtrimws (bstring b)
- *
- * Delete whitespace contiguous from the right end of the string.
- */
-int brtrimws (bstring b) {
-int i;
-
-	if (b == NULL || b->data == NULL || b->mlen < b->slen ||
-	    b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
-
-	for (i = b->slen - 1; i >= 0; i--) {
-		if (!wspace (b->data[i])) {
-			if (b->mlen > i) b->data[i+1] = (unsigned char) '\0';
-			b->slen = i + 1;
-			return BSTR_OK;
-		}
-	}
-
-	b->data[0] = (unsigned char) '\0';
-	b->slen = 0;
-	return BSTR_OK;
-}
-
-/*
- * int btrimws (bstring b)
- *
- * Delete whitespace contiguous from both ends of the string.
- */
-int btrimws (bstring b) {
-int i, j;
-
-	if (b == NULL || b->data == NULL || b->mlen < b->slen ||
-	    b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
-
-	for (i = b->slen - 1; i >= 0; i--) {
-		if (!wspace (b->data[i])) {
-			if (b->mlen > i) b->data[i+1] = (unsigned char) '\0';
-			b->slen = i + 1;
-			for (j = 0; wspace (b->data[j]); j++) {}
-			return bdelete (b, 0, j);
-		}
-	}
-
-	b->data[0] = (unsigned char) '\0';
-	b->slen = 0;
-	return BSTR_OK;
-}
-
-/*  int biseqblk (const_bstring b, const void * blk, int len)
- *
- *  Compare the string b with the character block blk of length len.  If the
- *  content differs, 0 is returned, if the content is the same, 1 is returned,
- *  if there is an error, -1 is returned.  If the length of the strings are
- *  different, this function is O(1).  '\0' characters are not treated in any
- *  special way.
- */
-int biseqblk (const_bstring b, const void * blk, int len) {
-	if (len < 0 || b == NULL || blk == NULL || b->data == NULL || b->slen < 0)
-		return BSTR_ERR;
-	if (b->slen != len) return 0;
-	if (len == 0 || b->data == blk) return 1;
-	return !bstr__memcmp (b->data, blk, len);
-}
-
-/*  int biseq (const_bstring b0, const_bstring b1)
- *
- *  Compare the string b0 and b1.  If the strings differ, 0 is returned, if
- *  the strings are the same, 1 is returned, if there is an error, -1 is
- *  returned.  If the length of the strings are different, this function is
- *  O(1).  '\0' termination characters are not treated in any special way.
- */
-int biseq (const_bstring b0, const_bstring b1) {
-	if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL ||
-		b0->slen < 0 || b1->slen < 0) return BSTR_ERR;
-	if (b0->slen != b1->slen) return BSTR_OK;
-	if (b0->data == b1->data || b0->slen == 0) return 1;
-	return !bstr__memcmp (b0->data, b1->data, b0->slen);
-}
-
-/*  int bisstemeqblk (const_bstring b0, const void * blk, int len)
- *
- *  Compare beginning of string b0 with a block of memory of length len for
- *  equality.  If the beginning of b0 differs from the memory block (or if b0
- *  is too short), 0 is returned, if the strings are the same, 1 is returned,
- *  if there is an error, -1 is returned.  '\0' characters are not treated in
- *  any special way.
- */
-int bisstemeqblk (const_bstring b0, const void * blk, int len) {
-int i;
-
-	if (bdata (b0) == NULL || b0->slen < 0 || NULL == blk || len < 0)
-		return BSTR_ERR;
-	if (b0->slen < len) return BSTR_OK;
-	if (b0->data == (const unsigned char *) blk || len == 0) return 1;
-
-	for (i = 0; i < len; i ++) {
-		if (b0->data[i] != ((const unsigned char *) blk)[i]) return BSTR_OK;
-	}
-	return 1;
-}
-
-/*  int biseqcstr (const_bstring b, const char *s)
- *
- *  Compare the bstring b and char * string s.  The C string s must be '\0'
- *  terminated at exactly the length of the bstring b, and the contents
- *  between the two must be identical with the bstring b with no '\0'
- *  characters for the two contents to be considered equal.  This is
- *  equivalent to the condition that their current contents will be always be
- *  equal when comparing them in the same format after converting one or the
- *  other.  If the strings are equal 1 is returned, if they are unequal 0 is
- *  returned and if there is a detectable error BSTR_ERR is returned.
- */
-int biseqcstr (const_bstring b, const char * s) {
-int i;
-	if (b == NULL || s == NULL || b->data == NULL || b->slen < 0)
-		return BSTR_ERR;
-	for (i=0; i < b->slen; i++) {
-		if (s[i] == '\0' || b->data[i] != (unsigned char) s[i])
-			return BSTR_OK;
-	}
-	return s[i] == '\0';
-}
-
-/*  int biseqcstrcaseless (const_bstring b, const char *s)
- *
- *  Compare the bstring b and char * string s.  The C string s must be '\0'
- *  terminated at exactly the length of the bstring b, and the contents
- *  between the two must be identical except for case with the bstring b with
- *  no '\0' characters for the two contents to be considered equal.  This is
- *  equivalent to the condition that their current contents will be always be
- *  equal ignoring case when comparing them in the same format after
- *  converting one or the other.  If the strings are equal, except for case,
- *  1 is returned, if they are unequal regardless of case 0 is returned and
- *  if there is a detectable error BSTR_ERR is returned.
- */
-int biseqcstrcaseless (const_bstring b, const char * s) {
-int i;
-	if (b == NULL || s == NULL || b->data == NULL || b->slen < 0)
-		return BSTR_ERR;
-	for (i=0; i < b->slen; i++) {
-		if (s[i] == '\0' ||
-		    (b->data[i] != (unsigned char) s[i] &&
-		     downcase (b->data[i]) != (unsigned char) downcase (s[i])))
-			return BSTR_OK;
-	}
-	return s[i] == '\0';
-}
-
-/*  int bstrcmp (const_bstring b0, const_bstring b1)
- *
- *  Compare the string b0 and b1.  If there is an error, SHRT_MIN is returned,
- *  otherwise a value less than or greater than zero, indicating that the
- *  string pointed to by b0 is lexicographically less than or greater than
- *  the string pointed to by b1 is returned.  If the the string lengths are
- *  unequal but the characters up until the length of the shorter are equal
- *  then a value less than, or greater than zero, indicating that the string
- *  pointed to by b0 is shorter or longer than the string pointed to by b1 is
- *  returned.  0 is returned if and only if the two strings are the same.  If
- *  the length of the strings are different, this function is O(n).  Like its
- *  standard C library counter part strcmp, the comparison does not proceed
- *  past any '\0' termination characters encountered.
- */
-int bstrcmp (const_bstring b0, const_bstring b1) {
-int i, v, n;
-
-	if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL ||
-		b0->slen < 0 || b1->slen < 0) return SHRT_MIN;
-	n = b0->slen; if (n > b1->slen) n = b1->slen;
-	if (b0->slen == b1->slen && (b0->data == b1->data || b0->slen == 0))
-		return BSTR_OK;
-
-	for (i = 0; i < n; i ++) {
-		v = ((char) b0->data[i]) - ((char) b1->data[i]);
-		if (v != 0) return v;
-		if (b0->data[i] == (unsigned char) '\0') return BSTR_OK;
-	}
-
-	if (b0->slen > n) return 1;
-	if (b1->slen > n) return -1;
-	return BSTR_OK;
-}
-
-/*  int bstrncmp (const_bstring b0, const_bstring b1, int n)
- *
- *  Compare the string b0 and b1 for at most n characters.  If there is an
- *  error, SHRT_MIN is returned, otherwise a value is returned as if b0 and
- *  b1 were first truncated to at most n characters then bstrcmp was called
- *  with these new strings are paremeters.  If the length of the strings are
- *  different, this function is O(n).  Like its standard C library counter
- *  part strcmp, the comparison does not proceed past any '\0' termination
- *  characters encountered.
- */
-int bstrncmp (const_bstring b0, const_bstring b1, int n) {
-int i, v, m;
-
-	if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL ||
-		b0->slen < 0 || b1->slen < 0) return SHRT_MIN;
-	m = n;
-	if (m > b0->slen) m = b0->slen;
-	if (m > b1->slen) m = b1->slen;
-
-	if (b0->data != b1->data) {
-		for (i = 0; i < m; i ++) {
-			v = ((char) b0->data[i]) - ((char) b1->data[i]);
-			if (v != 0) return v;
-			if (b0->data[i] == (unsigned char) '\0') return BSTR_OK;
-		}
-	}
-
-	if (n == m || b0->slen == b1->slen) return BSTR_OK;
-
-	if (b0->slen > m) return 1;
-	return -1;
-}
-
-/*  bstring bmidstr (const_bstring b, int left, int len)
- *
- *  Create a bstring which is the substring of b starting from position left
- *  and running for a length len (clamped by the end of the bstring b.)  If
- *  b is detectably invalid, then NULL is returned.  The section described
- *  by (left, len) is clamped to the boundaries of b.
- */
-bstring bmidstr (const_bstring b, int left, int len) {
-
-	if (b == NULL || b->slen < 0 || b->data == NULL) return NULL;
-
-	if (left < 0) {
-		len += left;
-		left = 0;
-	}
-
-	if (len > b->slen - left) len = b->slen - left;
-
-	if (len <= 0) return bfromcstr ("");
-	return blk2bstr (b->data + left, len);
-}
-
-/*  int bdelete (bstring b, int pos, int len)
- *
- *  Removes characters from pos to pos+len-1 inclusive and shifts the tail of
- *  the bstring starting from pos+len to pos.  len must be positive for this
- *  call to have any effect.  The section of the string described by (pos,
- *  len) is clamped to boundaries of the bstring b.
- */
-int bdelete (bstring b, int pos, int len) {
-	/* Clamp to left side of bstring */
-	if (pos < 0) {
-		len += pos;
-		pos = 0;
-	}
-
-	if (len < 0 || b == NULL || b->data == NULL || b->slen < 0 ||
-	    b->mlen < b->slen || b->mlen <= 0)
-		return BSTR_ERR;
-	if (len > 0 && pos < b->slen) {
-		if (pos + len >= b->slen) {
-			b->slen = pos;
-		} else {
-			bBlockCopy ((char *) (b->data + pos),
-			            (char *) (b->data + pos + len),
-			            b->slen - (pos+len));
-			b->slen -= len;
-		}
-		b->data[b->slen] = (unsigned char) '\0';
-	}
-	return BSTR_OK;
-}
-
-/*  int bdestroy (bstring b)
- *
- *  Free up the bstring.  Note that if b is detectably invalid or not writable
- *  then no action is performed and BSTR_ERR is returned.  Like a freed memory
- *  allocation, dereferences, writes or any other action on b after it has
- *  been bdestroyed is undefined.
- */
-int bdestroy (bstring b) {
-	if (b == NULL || b->slen < 0 || b->mlen <= 0 || b->mlen < b->slen ||
-	    b->data == NULL)
-		return BSTR_ERR;
-
-	bstr__free (b->data);
-
-	/* In case there is any stale usage, there is one more chance to
-	   notice this error. */
-
-	b->slen = -1;
-	b->mlen = -__LINE__;
-	b->data = NULL;
-
-	bstr__free (b);
-	return BSTR_OK;
-}
-
-/*  int binstr (const_bstring b1, int pos, const_bstring b2)
- *
- *  Search for the bstring b2 in b1 starting from position pos, and searching
- *  forward.  If it is found then return with the first position where it is
- *  found, otherwise return BSTR_ERR.  Note that this is just a brute force
- *  string searcher that does not attempt clever things like the Boyer-Moore
- *  search algorithm.  Because of this there are many degenerate cases where
- *  this can take much longer than it needs to.
- */
-int binstr (const_bstring b1, int pos, const_bstring b2) {
-int j, ii, ll, lf;
-unsigned char * d0;
-unsigned char c0;
-register unsigned char * d1;
-register unsigned char c1;
-register int i;
-
-	if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
-	    b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
-	if (b1->slen == pos) return (b2->slen == 0)?pos:BSTR_ERR;
-	if (b1->slen < pos || pos < 0) return BSTR_ERR;
-	if (b2->slen == 0) return pos;
-
-	/* No space to find such a string? */
-	if ((lf = b1->slen - b2->slen + 1) <= pos) return BSTR_ERR;
-
-	/* An obvious alias case */
-	if (b1->data == b2->data && pos == 0) return 0;
-
-	i = pos;
-
-	d0 = b2->data;
-	d1 = b1->data;
-	ll = b2->slen;
-
-	/* Peel off the b2->slen == 1 case */
-	c0 = d0[0];
-	if (1 == ll) {
-		for (;i < lf; i++) if (c0 == d1[i]) return i;
-		return BSTR_ERR;
-	}
-
-	c1 = c0;
-	j = 0;
-	lf = b1->slen - 1;
-
-	ii = -1;
-	if (i < lf) do {
-		/* Unrolled current character test */
-		if (c1 != d1[i]) {
-			if (c1 != d1[1+i]) {
-				i += 2;
-				continue;
-			}
-			i++;
-		}
-
-		/* Take note if this is the start of a potential match */
-		if (0 == j) ii = i;
-
-		/* Shift the test character down by one */
-		j++;
-		i++;
-
-		/* If this isn't past the last character continue */
-		if (j < ll) {
-			c1 = d0[j];
-			continue;
-		}
-
-		N0:;
-
-		/* If no characters mismatched, then we matched */
-		if (i == ii+j) return ii;
-
-		/* Shift back to the beginning */
-		i -= j;
-		j  = 0;
-		c1 = c0;
-	} while (i < lf);
-
-	/* Deal with last case if unrolling caused a misalignment */
-	if (i == lf && ll == j+1 && c1 == d1[i]) goto N0;
-
-	return BSTR_ERR;
-}
-
-/*  int binstrr (const_bstring b1, int pos, const_bstring b2)
- *
- *  Search for the bstring b2 in b1 starting from position pos, and searching
- *  backward.  If it is found then return with the first position where it is
- *  found, otherwise return BSTR_ERR.  Note that this is just a brute force
- *  string searcher that does not attempt clever things like the Boyer-Moore
- *  search algorithm.  Because of this there are many degenerate cases where
- *  this can take much longer than it needs to.
- */
-int binstrr (const_bstring b1, int pos, const_bstring b2) {
-int j, i, l;
-unsigned char * d0, * d1;
-
-	if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
-	    b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
-	if (b1->slen == pos && b2->slen == 0) return pos;
-	if (b1->slen < pos || pos < 0) return BSTR_ERR;
-	if (b2->slen == 0) return pos;
-
-	/* Obvious alias case */
-	if (b1->data == b2->data && pos == 0 && b2->slen <= b1->slen) return 0;
-
-	i = pos;
-	if ((l = b1->slen - b2->slen) < 0) return BSTR_ERR;
-
-	/* If no space to find such a string then snap back */
-	if (l + 1 <= i) i = l;
-	j = 0;
-
-	d0 = b2->data;
-	d1 = b1->data;
-	l  = b2->slen;
-
-	for (;;) {
-		if (d0[j] == d1[i + j]) {
-			j ++;
-			if (j >= l) return i;
-		} else {
-			i --;
-			if (i < 0) break;
-			j=0;
-		}
-	}
-
-	return BSTR_ERR;
-}
-
-/*  int binstrcaseless (const_bstring b1, int pos, const_bstring b2)
- *
- *  Search for the bstring b2 in b1 starting from position pos, and searching
- *  forward but without regard to case.  If it is found then return with the
- *  first position where it is found, otherwise return BSTR_ERR.  Note that
- *  this is just a brute force string searcher that does not attempt clever
- *  things like the Boyer-Moore search algorithm.  Because of this there are
- *  many degenerate cases where this can take much longer than it needs to.
- */
-int binstrcaseless (const_bstring b1, int pos, const_bstring b2) {
-int j, i, l, ll;
-unsigned char * d0, * d1;
-
-	if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
-	    b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
-	if (b1->slen == pos) return (b2->slen == 0)?pos:BSTR_ERR;
-	if (b1->slen < pos || pos < 0) return BSTR_ERR;
-	if (b2->slen == 0) return pos;
-
-	l = b1->slen - b2->slen + 1;
-
-	/* No space to find such a string? */
-	if (l <= pos) return BSTR_ERR;
-
-	/* An obvious alias case */
-	if (b1->data == b2->data && pos == 0) return BSTR_OK;
-
-	i = pos;
-	j = 0;
-
-	d0 = b2->data;
-	d1 = b1->data;
-	ll = b2->slen;
-
-	for (;;) {
-		if (d0[j] == d1[i + j] || downcase (d0[j]) == downcase (d1[i + j])) {
-			j ++;
-			if (j >= ll) return i;
-		} else {
-			i ++;
-			if (i >= l) break;
-			j=0;
-		}
-	}
-
-	return BSTR_ERR;
-}
-
-/*  int binstrrcaseless (const_bstring b1, int pos, const_bstring b2)
- *
- *  Search for the bstring b2 in b1 starting from position pos, and searching
- *  backward but without regard to case.  If it is found then return with the
- *  first position where it is found, otherwise return BSTR_ERR.  Note that
- *  this is just a brute force string searcher that does not attempt clever
- *  things like the Boyer-Moore search algorithm.  Because of this there are
- *  many degenerate cases where this can take much longer than it needs to.
- */
-int binstrrcaseless (const_bstring b1, int pos, const_bstring b2) {
-int j, i, l;
-unsigned char * d0, * d1;
-
-	if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
-	    b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
-	if (b1->slen == pos && b2->slen == 0) return pos;
-	if (b1->slen < pos || pos < 0) return BSTR_ERR;
-	if (b2->slen == 0) return pos;
-
-	/* Obvious alias case */
-	if (b1->data == b2->data && pos == 0 && b2->slen <= b1->slen)
-		return BSTR_OK;
-
-	i = pos;
-	if ((l = b1->slen - b2->slen) < 0) return BSTR_ERR;
-
-	/* If no space to find such a string then snap back */
-	if (l + 1 <= i) i = l;
-	j = 0;
-
-	d0 = b2->data;
-	d1 = b1->data;
-	l  = b2->slen;
-
-	for (;;) {
-		if (d0[j] == d1[i + j] || downcase (d0[j]) == downcase (d1[i + j])) {
-			j ++;
-			if (j >= l) return i;
-		} else {
-			i --;
-			if (i < 0) break;
-			j=0;
-		}
-	}
-
-	return BSTR_ERR;
-}
-
-
-/*  int bstrchrp (const_bstring b, int c, int pos)
- *
- *  Search for the character c in b forwards from the position pos
- *  (inclusive).
- */
-int bstrchrp (const_bstring b, int c, int pos) {
-unsigned char * p;
-
-	if (b == NULL || b->data == NULL || b->slen <= pos || pos < 0)
-		return BSTR_ERR;
-	p = (unsigned char *) bstr__memchr ((b->data + pos), (unsigned char) c,
-		                                (b->slen - pos));
-	if (p) return (int) (p - b->data);
-	return BSTR_ERR;
-}
-
-/*  int bstrrchrp (const_bstring b, int c, int pos)
- *
- *  Search for the character c in b backwards from the position pos in string
- *  (inclusive).
- */
-int bstrrchrp (const_bstring b, int c, int pos) {
-int i;
-
-	if (b == NULL || b->data == NULL || b->slen <= pos || pos < 0)
-		return BSTR_ERR;
-	for (i=pos; i >= 0; i--) {
-		if (b->data[i] == (unsigned char) c) return i;
-	}
-	return BSTR_ERR;
-}
-
-#if !defined (BSTRLIB_AGGRESSIVE_MEMORY_FOR_SPEED_TRADEOFF)
-#define LONG_LOG_BITS_QTY (3)
-#define LONG_BITS_QTY (1 << LONG_LOG_BITS_QTY)
-#define LONG_TYPE unsigned char
-
-#define CFCLEN ((1 << CHAR_BIT) / LONG_BITS_QTY)
-struct charField { LONG_TYPE content[CFCLEN]; };
-#define testInCharField(cf,c) ((cf)->content[(c) >> LONG_LOG_BITS_QTY] & \
-	                           (((long)1) << ((c) & (LONG_BITS_QTY-1))))
-#define setInCharField(cf,idx) { \
-	unsigned int c = (unsigned int) (idx); \
-	(cf)->content[c >> LONG_LOG_BITS_QTY] |= \
-		(LONG_TYPE) (1ul << (c & (LONG_BITS_QTY-1))); \
-}
-
-#else
-
-#define CFCLEN (1 << CHAR_BIT)
-struct charField { unsigned char content[CFCLEN]; };
-#define testInCharField(cf,c) ((cf)->content[(unsigned char) (c)])
-#define setInCharField(cf,idx) (cf)->content[(unsigned int) (idx)] = ~0
-
-#endif
-
-/* Convert a bstring to charField */
-static int buildCharField (struct charField * cf, const_bstring b) {
-int i;
-	if (b == NULL || b->data == NULL || b->slen <= 0) return BSTR_ERR;
-	memset ((void *) cf->content, 0, sizeof (struct charField));
-	for (i=0; i < b->slen; i++) {
-		setInCharField (cf, b->data[i]);
-	}
-	return BSTR_OK;
-}
-
-static void invertCharField (struct charField * cf) {
-int i;
-	for (i=0; i < CFCLEN; i++) cf->content[i] = ~cf->content[i];
-}
-
-/* Inner engine for binchr */
-static int binchrCF (const unsigned char * data, int len, int pos,
-					 const struct charField * cf) {
-int i;
-	for (i=pos; i < len; i++) {
-		unsigned char c = (unsigned char) data[i];
-		if (testInCharField (cf, c)) return i;
-	}
-	return BSTR_ERR;
-}
-
-/*  int binchr (const_bstring b0, int pos, const_bstring b1);
- *
- *  Search for the first position in b0 starting from pos or after, in which
- *  one of the characters in b1 is found and return it.  If such a position
- *  does not exist in b0, then BSTR_ERR is returned.
- */
-int binchr (const_bstring b0, int pos, const_bstring b1) {
-struct charField chrs;
-	if (pos < 0 || b0 == NULL || b0->data == NULL ||
-	    b0->slen <= pos) return BSTR_ERR;
-	if (1 == b1->slen) return bstrchrp (b0, b1->data[0], pos);
-	if (0 > buildCharField (&chrs, b1)) return BSTR_ERR;
-	return binchrCF (b0->data, b0->slen, pos, &chrs);
-}
-
-/* Inner engine for binchrr */
-static int binchrrCF (const unsigned char * data, int pos,
-                      const struct charField * cf) {
-int i;
-	for (i=pos; i >= 0; i--) {
-		unsigned int c = (unsigned int) data[i];
-		if (testInCharField (cf, c)) return i;
-	}
-	return BSTR_ERR;
-}
-
-/*  int binchrr (const_bstring b0, int pos, const_bstring b1);
- *
- *  Search for the last position in b0 no greater than pos, in which one of
- *  the characters in b1 is found and return it.  If such a position does not
- *  exist in b0, then BSTR_ERR is returned.
- */
-int binchrr (const_bstring b0, int pos, const_bstring b1) {
-struct charField chrs;
-	if (pos < 0 || b0 == NULL || b0->data == NULL || b1 == NULL ||
-	    b0->slen < pos) return BSTR_ERR;
-	if (pos == b0->slen) pos--;
-	if (1 == b1->slen) return bstrrchrp (b0, b1->data[0], pos);
-	if (0 > buildCharField (&chrs, b1)) return BSTR_ERR;
-	return binchrrCF (b0->data, pos, &chrs);
-}
-
-/*  int bninchr (const_bstring b0, int pos, const_bstring b1);
- *
- *  Search for the first position in b0 starting from pos or after, in which
- *  none of the characters in b1 is found and return it.  If such a position
- *  does not exist in b0, then BSTR_ERR is returned.
- */
-int bninchr (const_bstring b0, int pos, const_bstring b1) {
-struct charField chrs;
-	if (pos < 0 || b0 == NULL || b0->data == NULL ||
-	    b0->slen <= pos) return BSTR_ERR;
-	if (buildCharField (&chrs, b1) < 0) return BSTR_ERR;
-	invertCharField (&chrs);
-	return binchrCF (b0->data, b0->slen, pos, &chrs);
-}
-
-/*  int bninchrr (const_bstring b0, int pos, const_bstring b1);
- *
- *  Search for the last position in b0 no greater than pos, in which none of
- *  the characters in b1 is found and return it.  If such a position does not
- *  exist in b0, then BSTR_ERR is returned.
- */
-int bninchrr (const_bstring b0, int pos, const_bstring b1) {
-struct charField chrs;
-	if (pos < 0 || b0 == NULL || b0->data == NULL ||
-	    b0->slen < pos) return BSTR_ERR;
-	if (pos == b0->slen) pos--;
-	if (buildCharField (&chrs, b1) < 0) return BSTR_ERR;
-	invertCharField (&chrs);
-	return binchrrCF (b0->data, pos, &chrs);
-}
-
-/*  int bsetstr (bstring b0, int pos, bstring b1, unsigned char fill)
- *
- *  Overwrite the string b0 starting at position pos with the string b1. If
- *  the position pos is past the end of b0, then the character "fill" is
- *  appended as necessary to make up the gap between the end of b0 and pos.
- *  If b1 is NULL, it behaves as if it were a 0-length string.
- */
-int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill) {
-int d, newlen;
-ptrdiff_t pd;
-bstring aux = (bstring) b1;
-
-	if (pos < 0 || b0 == NULL || b0->slen < 0 || NULL == b0->data ||
-	    b0->mlen < b0->slen || b0->mlen <= 0) return BSTR_ERR;
-	if (b1 != NULL && (b1->slen < 0 || b1->data == NULL)) return BSTR_ERR;
-
-	d = pos;
-
-	/* Aliasing case */
-	if (NULL != aux) {
-		if ((pd = (ptrdiff_t) (b1->data - b0->data)) >= 0 &&
-		    pd < (ptrdiff_t) b0->mlen) {
-			if (NULL == (aux = bstrcpy (b1))) return BSTR_ERR;
-		}
-		d += aux->slen;
-	}
-
-	/* Increase memory size if necessary */
-	if (balloc (b0, d + 1) != BSTR_OK) {
-		if (aux != b1) bdestroy (aux);
-		return BSTR_ERR;
-	}
-
-	newlen = b0->slen;
-
-	/* Fill in "fill" character as necessary */
-	if (pos > newlen) {
-		bstr__memset (b0->data + b0->slen, (int) fill,
-		              (size_t) (pos - b0->slen));
-		newlen = pos;
-	}
-
-	/* Copy b1 to position pos in b0. */
-	if (aux != NULL) {
-		bBlockCopy ((char *) (b0->data + pos), (char *) aux->data, aux->slen);
-		if (aux != b1) bdestroy (aux);
-	}
-
-	/* Indicate the potentially increased size of b0 */
-	if (d > newlen) newlen = d;
-
-	b0->slen = newlen;
-	b0->data[newlen] = (unsigned char) '\0';
-
-	return BSTR_OK;
-}
-
-/*  int binsertblk (bstring b, int pos, const void * blk, int len,
- *                  unsigned char fill)
- *
- *  Inserts the block of characters at blk with length len into b at position
- *  pos.  If the position pos is past the end of b, then the character "fill"
- *  is appended as necessary to make up the gap between the end of b1 and pos.
- *  Unlike bsetstr, binsert does not allow b2 to be NULL.
- */
-int binsertblk (bstring b, int pos, const void * blk, int len,
-                unsigned char fill) {
-int d, l;
-unsigned char* aux = (unsigned char*) blk;
-
-	if (b == NULL || blk == NULL || pos < 0 || len < 0 || b->slen < 0 ||
-	    b->mlen <= 0 || b->mlen < b->slen) return BSTR_ERR;
-
-	/* Compute the two possible end pointers */
-	d = b->slen + len;
-	l = pos + len;
-	if ((d|l) < 0) return BSTR_ERR; /* Integer wrap around. */
-
-	/* Aliasing case */
-	if (((size_t) ((unsigned char*) blk + len)) >= ((size_t) b->data) &&
-		((size_t) blk) < ((size_t) (b->data + b->mlen))) {
-		if (NULL == (aux = (unsigned char*) bstr__alloc (len)))
-			return BSTR_ERR;
-		bstr__memcpy (aux, blk, len);
-	}
-
-	if (l > d) {
-		/* Inserting past the end of the string */
-		if (balloc (b, l + 1) != BSTR_OK) {
-			if (aux != (unsigned char*) blk) bstr__free (aux);
-			return BSTR_ERR;
-		}
-		bstr__memset (b->data + b->slen, (int) fill,
-		              (size_t) (pos - b->slen));
-		b->slen = l;
-	} else {
-		/* Inserting in the middle of the string */
-		if (balloc (b, d + 1) != BSTR_OK) {
-			if (aux != (unsigned char*) blk) bstr__free (aux);
-			return BSTR_ERR;
-		}
-		bBlockCopy (b->data + l, b->data + pos, d - l);
-		b->slen = d;
-	}
-	bBlockCopy (b->data + pos, aux, len);
-	b->data[b->slen] = (unsigned char) '\0';
-	if (aux != (unsigned char*) blk) bstr__free (aux);
-	return BSTR_OK;
-}
-
-/*  int binsert (bstring b1, int pos, const_bstring b2, unsigned char fill)
- *
- *  Inserts the string b2 into b1 at position pos.  If the position pos is
- *  past the end of b1, then the character "fill" is appended as necessary to
- *  make up the gap between the end of b1 and pos.  Unlike bsetstr, binsert
- *  does not allow b2 to be NULL.
- */
-int binsert (bstring b1, int pos, const_bstring b2, unsigned char fill) {
-	if (NULL == b2 || (b2->mlen > 0 && b2->slen > b2->mlen)) return BSTR_ERR;
-	return binsertblk (b1, pos, b2->data, b2->slen, fill);
-}
-
-/*  int breplace (bstring b1, int pos, int len, bstring b2,
- *                unsigned char fill)
- *
- *  Replace a section of a string from pos for a length len with the string
- *  b2. fill is used is pos > b1->slen.
- */
-int breplace (bstring b1, int pos, int len, const_bstring b2,
-              unsigned char fill) {
-int pl, ret;
-ptrdiff_t pd;
-bstring aux = (bstring) b2;
-
-	if (pos < 0 || len < 0) return BSTR_ERR;
-	if (pos > INT_MAX - len) return BSTR_ERR; /* Overflow */
-	pl = pos + len;
-	if (b1 == NULL || b2 == NULL || b1->data == NULL || b2->data == NULL ||
-	    b1->slen < 0 || b2->slen < 0 || b1->mlen < b1->slen ||
-	    b1->mlen <= 0) return BSTR_ERR;
-
-	/* Straddles the end? */
-	if (pl >= b1->slen) {
-		if ((ret = bsetstr (b1, pos, b2, fill)) < 0) return ret;
-		if (pos + b2->slen < b1->slen) {
-			b1->slen = pos + b2->slen;
-			b1->data[b1->slen] = (unsigned char) '\0';
-		}
-		return ret;
-	}
-
-	/* Aliasing case */
-	if ((pd = (ptrdiff_t) (b2->data - b1->data)) >= 0 &&
-	    pd < (ptrdiff_t) b1->slen) {
-		if (NULL == (aux = bstrcpy (b2))) return BSTR_ERR;
-	}
-
-	if (aux->slen > len) {
-		if (balloc (b1, b1->slen + aux->slen - len) != BSTR_OK) {
-			if (aux != b2) bdestroy (aux);
-			return BSTR_ERR;
-		}
-	}
-
-	if (aux->slen != len) bstr__memmove (b1->data + pos + aux->slen,
-	                                     b1->data + pos + len,
-	                                     b1->slen - (pos + len));
-	bstr__memcpy (b1->data + pos, aux->data, aux->slen);
-	b1->slen += aux->slen - len;
-	b1->data[b1->slen] = (unsigned char) '\0';
-	if (aux != b2) bdestroy (aux);
-	return BSTR_OK;
-}
-
-/*
- *  findreplaceengine is used to implement bfindreplace and
- *  bfindreplacecaseless. It works by breaking the three cases of
- *  expansion, reduction and replacement, and solving each of these
- *  in the most efficient way possible.
- */
-
-typedef int (*instr_fnptr) (const_bstring s1, int pos, const_bstring s2);
-
-#define INITIAL_STATIC_FIND_INDEX_COUNT 32
-
-static int findreplaceengine (bstring b, const_bstring find,
-                              const_bstring repl, int pos,
-                              instr_fnptr instr) {
-int i, ret, delta, acc;
-unsigned int mlen, slen;
-int * d;
-int static_d[INITIAL_STATIC_FIND_INDEX_COUNT+1]; /* This +1 is for LINT. */
-ptrdiff_t pd;
-bstring auxf = (bstring) find;
-bstring auxr = (bstring) repl;
-
-	if (b == NULL || b->data == NULL || find == NULL ||
-		find->data == NULL || repl == NULL || repl->data == NULL ||
-		pos < 0 || find->slen <= 0 || b->mlen <= 0 || b->slen > b->mlen ||
-		b->slen < 0 || repl->slen < 0) return BSTR_ERR;
-	if (pos > b->slen - find->slen) return BSTR_OK;
-
-	/* Alias with find string */
-	pd = (ptrdiff_t) (find->data - b->data);
-	if ((ptrdiff_t) (pos - find->slen) < pd && pd < (ptrdiff_t) b->slen) {
-		if (NULL == (auxf = bstrcpy (find))) return BSTR_ERR;
-	}
-
-	/* Alias with repl string */
-	pd = (ptrdiff_t) (repl->data - b->data);
-	if ((ptrdiff_t) (pos - repl->slen) < pd && pd < (ptrdiff_t) b->slen) {
-		if (NULL == (auxr = bstrcpy (repl))) {
-			if (auxf != find) bdestroy (auxf);
-			return BSTR_ERR;
-		}
-	}
-
-	delta = auxf->slen - auxr->slen;
-
-	/* in-place replacement since find and replace strings are of equal
-	   length */
-	if (delta == 0) {
-		while ((pos = instr (b, pos, auxf)) >= 0) {
-			bstr__memcpy (b->data + pos, auxr->data, auxr->slen);
-			pos += auxf->slen;
-		}
-		if (auxf != find) bdestroy (auxf);
-		if (auxr != repl) bdestroy (auxr);
-		return BSTR_OK;
-	}
-
-	/* shrinking replacement since auxf->slen > auxr->slen */
-	if (delta > 0) {
-		acc = 0;
-
-		while ((i = instr (b, pos, auxf)) >= 0) {
-			if (acc && i > pos)
-				bstr__memmove (b->data + pos - acc, b->data + pos, i - pos);
-			if (auxr->slen)
-				bstr__memcpy (b->data + i - acc, auxr->data, auxr->slen);
-			acc += delta;
-			pos = i + auxf->slen;
-		}
-
-		if (acc) {
-			i = b->slen;
-			if (i > pos)
-				bstr__memmove (b->data + pos - acc, b->data + pos, i - pos);
-			b->slen -= acc;
-			b->data[b->slen] = (unsigned char) '\0';
-		}
-
-		if (auxf != find) bdestroy (auxf);
-		if (auxr != repl) bdestroy (auxr);
-		return BSTR_OK;
-	}
-
-	/* expanding replacement since find->slen < repl->slen.  Its a lot
-	   more complicated.  This works by first finding all the matches and
-	   storing them to a growable array, then doing at most one resize of
-	   the destination bstring and then performing the direct memory transfers
-	   of the string segment pieces to form the final result. The growable
-	   array of matches uses a deferred doubling reallocing strategy.  What
-	   this means is that it starts as a reasonably fixed sized auto array in
-	   the hopes that many if not most cases will never need to grow this
-	   array.  But it switches as soon as the bounds of the array will be
-	   exceeded.  An extra find result is always appended to this array that
-	   corresponds to the end of the destination string, so slen is checked
-	   against mlen - 1 rather than mlen before resizing.
-	*/
-
-	mlen = INITIAL_STATIC_FIND_INDEX_COUNT;
-	d = (int *) static_d; /* Avoid malloc for trivial/initial cases */
-	acc = slen = 0;
-
-	while ((pos = instr (b, pos, auxf)) >= 0) {
-		if (slen >= mlen - 1) {
-			int *t;
-			int sl;
-			/* Overflow */
-			if (mlen > (INT_MAX / sizeof(int *)) / 2) {
-				ret = BSTR_ERR;
-				goto done;
-			}
-			mlen += mlen;
-			sl = sizeof (int *) * mlen;
-			if (static_d == d) d = NULL; /* static_d cannot be realloced */
-			if (NULL == (t = (int *) bstr__realloc (d, sl))) {
-				ret = BSTR_ERR;
-				goto done;
-			}
-			if (NULL == d) bstr__memcpy (t, static_d, sizeof (static_d));
-			d = t;
-		}
-		d[slen] = pos;
-		slen++;
-		acc -= delta;
-		pos += auxf->slen;
-		if (pos < 0 || acc < 0) {
-			ret = BSTR_ERR;
-			goto done;
-		}
-	}
-
-	/* slen <= INITIAL_STATIC_INDEX_COUNT-1 or mlen-1 here. */
-	d[slen] = b->slen;
-
-	if (BSTR_OK == (ret = balloc (b, b->slen + acc + 1))) {
-		b->slen += acc;
-		for (i = slen-1; i >= 0; i--) {
-			int s, l;
-			s = d[i] + auxf->slen;
-			l = d[i+1] - s; /* d[slen] may be accessed here. */
-			if (l) {
-				bstr__memmove (b->data + s + acc, b->data + s, l);
-			}
-			if (auxr->slen) {
-				bstr__memmove (b->data + s + acc - auxr->slen,
-				               auxr->data, auxr->slen);
-			}
-			acc += delta;
-		}
-		b->data[b->slen] = (unsigned char) '\0';
-	}
-
-	done:;
-	if (static_d != d) bstr__free (d);
-	if (auxf != find) bdestroy (auxf);
-	if (auxr != repl) bdestroy (auxr);
-	return ret;
-}
-
-/*  int bfindreplace (bstring b, const_bstring find, const_bstring repl,
- *                    int pos)
- *
- *  Replace all occurrences of a find string with a replace string after a
- *  given point in a bstring.
- */
-int bfindreplace (bstring b, const_bstring find, const_bstring repl,
-                  int pos) {
-	return findreplaceengine (b, find, repl, pos, binstr);
-}
-
-/*  int bfindreplacecaseless (bstring b, const_bstring find,
- *                            const_bstring repl, int pos)
- *
- *  Replace all occurrences of a find string, ignoring case, with a replace
- *  string after a given point in a bstring.
- */
-int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl,
-                          int pos) {
-	return findreplaceengine (b, find, repl, pos, binstrcaseless);
-}
-
-/*  int binsertch (bstring b, int pos, int len, unsigned char fill)
- *
- *  Inserts the character fill repeatedly into b at position pos for a
- *  length len.  If the position pos is past the end of b, then the
- *  character "fill" is appended as necessary to make up the gap between the
- *  end of b and the position pos + len.
- */
-int binsertch (bstring b, int pos, int len, unsigned char fill) {
-int d, l, i;
-
-	if (pos < 0 || b == NULL || b->slen < 0 || b->mlen < b->slen ||
-	    b->mlen <= 0 || len < 0) return BSTR_ERR;
-
-	/* Compute the two possible end pointers */
-	d = b->slen + len;
-	l = pos + len;
-	if ((d|l) < 0) return BSTR_ERR;
-
-	if (l > d) {
-		/* Inserting past the end of the string */
-		if (balloc (b, l + 1) != BSTR_OK) return BSTR_ERR;
-		pos = b->slen;
-		b->slen = l;
-	} else {
-		/* Inserting in the middle of the string */
-		if (balloc (b, d + 1) != BSTR_OK) return BSTR_ERR;
-		for (i = d - 1; i >= l; i--) {
-			b->data[i] = b->data[i - len];
-		}
-		b->slen = d;
-	}
-
-	for (i=pos; i < l; i++) b->data[i] = fill;
-	b->data[b->slen] = (unsigned char) '\0';
-	return BSTR_OK;
-}
-
-/*  int bpattern (bstring b, int len)
- *
- *  Replicate the bstring, b in place, end to end repeatedly until it
- *  surpasses len characters, then chop the result to exactly len characters.
- *  This function operates in-place.  The function will return with BSTR_ERR
- *  if b is NULL or of length 0, otherwise BSTR_OK is returned.
- */
-int bpattern (bstring b, int len) {
-int i, d;
-
-	d = blength (b);
-	if (d <= 0 || len < 0 || balloc (b, len + 1) != BSTR_OK) return BSTR_ERR;
-	if (len > 0) {
-		if (d == 1) return bsetstr (b, len, NULL, b->data[0]);
-		for (i = d; i < len; i++) b->data[i] = b->data[i - d];
-	}
-	b->data[len] = (unsigned char) '\0';
-	b->slen = len;
-	return BSTR_OK;
-}
-
-#define BS_BUFF_SZ (1024)
-
-/*  int breada (bstring b, bNread readPtr, void * parm)
- *
- *  Use a finite buffer fread-like function readPtr to concatenate to the
- *  bstring b the entire contents of file-like source data in a roughly
- *  efficient way.
- */
-int breada (bstring b, bNread readPtr, void * parm) {
-int i, l, n;
-
-	if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen ||
-	    readPtr == NULL) return BSTR_ERR;
-
-	i = b->slen;
-	for (n=i+16; ; n += ((n < BS_BUFF_SZ) ? n : BS_BUFF_SZ)) {
-		if (BSTR_OK != balloc (b, n + 1)) return BSTR_ERR;
-		l = (int) readPtr ((void *) (b->data + i), 1, n - i, parm);
-		i += l;
-		b->slen = i;
-		if (i < n) break;
-	}
-
-	b->data[i] = (unsigned char) '\0';
-	return BSTR_OK;
-}
-
-/*  bstring bread (bNread readPtr, void * parm)
- *
- *  Use a finite buffer fread-like function readPtr to create a bstring
- *  filled with the entire contents of file-like source data in a roughly
- *  efficient way.
- */
-bstring bread (bNread readPtr, void * parm) {
-bstring buff;
-
-	if (0 > breada (buff = bfromcstr (""), readPtr, parm)) {
-		bdestroy (buff);
-		return NULL;
-	}
-	return buff;
-}
-
-/*  int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator)
- *
- *  Use an fgetc-like single character stream reading function (getcPtr) to
- *  obtain a sequence of characters which are concatenated to the end of the
- *  bstring b.  The stream read is terminated by the passed in terminator
- *  parameter.
- *
- *  If getcPtr returns with a negative number, or the terminator character
- *  (which is appended) is read, then the stream reading is halted and the
- *  function returns with a partial result in b.  If there is an empty partial
- *  result, 1 is returned.  If no characters are read, or there is some other
- *  detectable error, BSTR_ERR is returned.
- */
-int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator) {
-int c, d, e;
-
-	if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen ||
-	    getcPtr == NULL) return BSTR_ERR;
-	d = 0;
-	e = b->mlen - 2;
-
-	while ((c = getcPtr (parm)) >= 0) {
-		if (d > e) {
-			b->slen = d;
-			if (balloc (b, d + 2) != BSTR_OK) return BSTR_ERR;
-			e = b->mlen - 2;
-		}
-		b->data[d] = (unsigned char) c;
-		d++;
-		if (c == terminator) break;
-	}
-
-	b->data[d] = (unsigned char) '\0';
-	b->slen = d;
-
-	return d == 0 && c < 0;
-}
-
-/*  int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator)
- *
- *  Use an fgetc-like single character stream reading function (getcPtr) to
- *  obtain a sequence of characters which are concatenated to the end of the
- *  bstring b.  The stream read is terminated by the passed in terminator
- *  parameter.
- *
- *  If getcPtr returns with a negative number, or the terminator character
- *  (which is appended) is read, then the stream reading is halted and the
- *  function returns with a partial result concatentated to b.  If there is
- *  an empty partial result, 1 is returned.  If no characters are read, or
- *  there is some other detectable error, BSTR_ERR is returned.
- */
-int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator) {
-int c, d, e;
-
-	if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen ||
-	    getcPtr == NULL) return BSTR_ERR;
-	d = b->slen;
-	e = b->mlen - 2;
-
-	while ((c = getcPtr (parm)) >= 0) {
-		if (d > e) {
-			b->slen = d;
-			if (balloc (b, d + 2) != BSTR_OK) return BSTR_ERR;
-			e = b->mlen - 2;
-		}
-		b->data[d] = (unsigned char) c;
-		d++;
-		if (c == terminator) break;
-	}
-
-	b->data[d] = (unsigned char) '\0';
-	b->slen = d;
-
-	return d == 0 && c < 0;
-}
-
-/*  bstring bgets (bNgetc getcPtr, void * parm, char terminator)
- *
- *  Use an fgetc-like single character stream reading function (getcPtr) to
- *  obtain a sequence of characters which are concatenated into a bstring.
- *  The stream read is terminated by the passed in terminator function.
- *
- *  If getcPtr returns with a negative number, or the terminator character
- *  (which is appended) is read, then the stream reading is halted and the
- *  result obtained thus far is returned.  If no characters are read, or
- *  there is some other detectable error, NULL is returned.
- */
-bstring bgets (bNgetc getcPtr, void * parm, char terminator) {
-bstring buff;
-
-	if (0 > bgetsa (buff = bfromcstr (""), getcPtr, parm, terminator) ||
-	    0 >= buff->slen) {
-		bdestroy (buff);
-		buff = NULL;
-	}
-	return buff;
-}
-
-struct bStream {
-	bstring buff;		/* Buffer for over-reads */
-	void * parm;		/* The stream handle for core stream */
-	bNread readFnPtr;	/* fread compatible fnptr for core stream */
-	int isEOF;			/* track file's EOF state */
-	int maxBuffSz;
-};
-
-/*  struct bStream * bsopen (bNread readPtr, void * parm)
- *
- *  Wrap a given open stream (described by a fread compatible function
- *  pointer and stream handle) into an open bStream suitable for the bstring
- *  library streaming functions.
- */
-struct bStream * bsopen (bNread readPtr, void * parm) {
-struct bStream * s;
-
-	if (readPtr == NULL) return NULL;
-	s = (struct bStream *) bstr__alloc (sizeof (struct bStream));
-	if (s == NULL) return NULL;
-	s->parm = parm;
-	s->buff = bfromcstr ("");
-	s->readFnPtr = readPtr;
-	s->maxBuffSz = BS_BUFF_SZ;
-	s->isEOF = 0;
-	return s;
-}
-
-/*  int bsbufflength (struct bStream * s, int sz)
- *
- *  Set the length of the buffer used by the bStream.  If sz is zero, the
- *  length is not set.  This function returns with the previous length.
- */
-int bsbufflength (struct bStream * s, int sz) {
-int oldSz;
-	if (s == NULL || sz < 0) return BSTR_ERR;
-	oldSz = s->maxBuffSz;
-	if (sz > 0) s->maxBuffSz = sz;
-	return oldSz;
-}
-
-int bseof (const struct bStream * s) {
-	if (s == NULL || s->readFnPtr == NULL) return BSTR_ERR;
-	return s->isEOF && (s->buff->slen == 0);
-}
-
-/*  void * bsclose (struct bStream * s)
- *
- *  Close the bStream, and return the handle to the stream that was originally
- *  used to open the given stream.
- */
-void * bsclose (struct bStream * s) {
-void * parm;
-	if (s == NULL) return NULL;
-	s->readFnPtr = NULL;
-	if (s->buff) bdestroy (s->buff);
-	s->buff = NULL;
-	parm = s->parm;
-	s->parm = NULL;
-	s->isEOF = 1;
-	bstr__free (s);
-	return parm;
-}
-
-/*  int bsreadlna (bstring r, struct bStream * s, char terminator)
- *
- *  Read a bstring terminated by the terminator character or the end of the
- *  stream from the bStream (s) and return it into the parameter r.  This
- *  function may read additional characters from the core stream that are not
- *  returned, but will be retained for subsequent read operations.
- */
-int bsreadlna (bstring r, struct bStream * s, char terminator) {
-int i, l, ret, rlo;
-char * b;
-struct tagbstring x;
-
-	if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0 ||
-	    r->slen < 0 || r->mlen < r->slen) return BSTR_ERR;
-	l = s->buff->slen;
-	if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
-	b = (char *) s->buff->data;
-	x.data = (unsigned char *) b;
-
-	/* First check if the current buffer holds the terminator */
-	b[l] = terminator; /* Set sentinel */
-	for (i=0; b[i] != terminator; i++) ;
-	if (i < l) {
-		x.slen = i + 1;
-		ret = bconcat (r, &x);
-		s->buff->slen = l;
-		if (BSTR_OK == ret) bdelete (s->buff, 0, i + 1);
-		return BSTR_OK;
-	}
-
-	rlo = r->slen;
-
-	/* If not then just concatenate the entire buffer to the output */
-	x.slen = l;
-	if (BSTR_OK != bconcat (r, &x)) return BSTR_ERR;
-
-	/* Perform direct in-place reads into the destination to allow for
-	   the minimum of data-copies */
-	for (;;) {
-		if (BSTR_OK != balloc (r, r->slen + s->maxBuffSz + 1))
-		    return BSTR_ERR;
-		b = (char *) (r->data + r->slen);
-		l = (int) s->readFnPtr (b, 1, s->maxBuffSz, s->parm);
-		if (l <= 0) {
-			r->data[r->slen] = (unsigned char) '\0';
-			s->buff->slen = 0;
-			s->isEOF = 1;
-			/* If nothing was read return with an error message */
-			return BSTR_ERR & -(r->slen == rlo);
-		}
-		b[l] = terminator; /* Set sentinel */
-		for (i=0; b[i] != terminator; i++) ;
-		if (i < l) break;
-		r->slen += l;
-	}
-
-	/* Terminator found, push over-read back to buffer */
-	i++;
-	r->slen += i;
-	s->buff->slen = l - i;
-	bstr__memcpy (s->buff->data, b + i, l - i);
-	r->data[r->slen] = (unsigned char) '\0';
-	return BSTR_OK;
-}
-
-/*  int bsreadlnsa (bstring r, struct bStream * s, bstring term)
- *
- *  Read a bstring terminated by any character in the term string or the end
- *  of the stream from the bStream (s) and return it into the parameter r.
- *  This function may read additional characters from the core stream that
- *  are not returned, but will be retained for subsequent read operations.
- */
-int bsreadlnsa (bstring r, struct bStream * s, const_bstring term) {
-int i, l, ret, rlo;
-unsigned char * b;
-struct tagbstring x;
-struct charField cf;
-
-	if (s == NULL || s->buff == NULL || r == NULL || term == NULL ||
-	    term->data == NULL || r->mlen <= 0 || r->slen < 0 ||
-	    r->mlen < r->slen) return BSTR_ERR;
-	if (term->slen == 1) return bsreadlna (r, s, term->data[0]);
-	if (term->slen < 1 || buildCharField (&cf, term)) return BSTR_ERR;
-
-	l = s->buff->slen;
-	if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
-	b = (unsigned char *) s->buff->data;
-	x.data = b;
-
-	/* First check if the current buffer holds the terminator */
-	b[l] = term->data[0]; /* Set sentinel */
-	for (i=0; !testInCharField (&cf, b[i]); i++) ;
-	if (i < l) {
-		x.slen = i + 1;
-		ret = bconcat (r, &x);
-		s->buff->slen = l;
-		if (BSTR_OK == ret) bdelete (s->buff, 0, i + 1);
-		return BSTR_OK;
-	}
-
-	rlo = r->slen;
-
-	/* If not then just concatenate the entire buffer to the output */
-	x.slen = l;
-	if (BSTR_OK != bconcat (r, &x)) return BSTR_ERR;
-
-	/* Perform direct in-place reads into the destination to allow for
-	   the minimum of data-copies */
-	for (;;) {
-		if (BSTR_OK != balloc (r, r->slen + s->maxBuffSz + 1))
-		    return BSTR_ERR;
-		b = (unsigned char *) (r->data + r->slen);
-		l = (int) s->readFnPtr (b, 1, s->maxBuffSz, s->parm);
-		if (l <= 0) {
-			r->data[r->slen] = (unsigned char) '\0';
-			s->buff->slen = 0;
-			s->isEOF = 1;
-			/* If nothing was read return with an error message */
-			return BSTR_ERR & -(r->slen == rlo);
-		}
-
-		b[l] = term->data[0]; /* Set sentinel */
-		for (i=0; !testInCharField (&cf, b[i]); i++) ;
-		if (i < l) break;
-		r->slen += l;
-	}
-
-	/* Terminator found, push over-read back to buffer */
-	i++;
-	r->slen += i;
-	s->buff->slen = l - i;
-	bstr__memcpy (s->buff->data, b + i, l - i);
-	r->data[r->slen] = (unsigned char) '\0';
-	return BSTR_OK;
-}
-
-/*  int bsreada (bstring r, struct bStream * s, int n)
- *
- *  Read a bstring of length n (or, if it is fewer, as many bytes as is
- *  remaining) from the bStream.  This function may read additional
- *  characters from the core stream that are not returned, but will be
- *  retained for subsequent read operations.  This function will not read
- *  additional characters from the core stream beyond virtual stream pointer.
- */
-int bsreada (bstring r, struct bStream * s, int n) {
-int l, ret, orslen;
-char * b;
-struct tagbstring x;
-
-	if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0
-	 || r->slen < 0 || r->mlen < r->slen || n <= 0) return BSTR_ERR;
-
-	if (n > INT_MAX - r->slen) return BSTR_ERR;
-	n += r->slen;
-
-	l = s->buff->slen;
-
-	orslen = r->slen;
-
-	if (0 == l) {
-		if (s->isEOF) return BSTR_ERR;
-		if (r->mlen > n) {
-			l = (int) s->readFnPtr (r->data + r->slen, 1, n - r->slen,
-			                        s->parm);
-			if (0 >= l || l > n - r->slen) {
-				s->isEOF = 1;
-				return BSTR_ERR;
-			}
-			r->slen += l;
-			r->data[r->slen] = (unsigned char) '\0';
-			return 0;
-		}
-	}
-
-	if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
-	b = (char *) s->buff->data;
-	x.data = (unsigned char *) b;
-
-	do {
-		if (l + r->slen >= n) {
-			x.slen = n - r->slen;
-			ret = bconcat (r, &x);
-			s->buff->slen = l;
-			if (BSTR_OK == ret) bdelete (s->buff, 0, x.slen);
-			return BSTR_ERR & -(r->slen == orslen);
-		}
-
-		x.slen = l;
-		if (BSTR_OK != bconcat (r, &x)) break;
-
-		l = n - r->slen;
-		if (l > s->maxBuffSz) l = s->maxBuffSz;
-
-		l = (int) s->readFnPtr (b, 1, l, s->parm);
-
-	} while (l > 0);
-	if (l < 0) l = 0;
-	if (l == 0) s->isEOF = 1;
-	s->buff->slen = l;
-	return BSTR_ERR & -(r->slen == orslen);
-}
-
-/*  int bsreadln (bstring r, struct bStream * s, char terminator)
- *
- *  Read a bstring terminated by the terminator character or the end of the
- *  stream from the bStream (s) and return it into the parameter r.  This
- *  function may read additional characters from the core stream that are not
- *  returned, but will be retained for subsequent read operations.
- */
-int bsreadln (bstring r, struct bStream * s, char terminator) {
-	if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0)
-		return BSTR_ERR;
-	if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
-	r->slen = 0;
-	return bsreadlna (r, s, terminator);
-}
-
-/*  int bsreadlns (bstring r, struct bStream * s, bstring term)
- *
- *  Read a bstring terminated by any character in the term string or the end
- *  of the stream from the bStream (s) and return it into the parameter r.
- *  This function may read additional characters from the core stream that
- *  are not returned, but will be retained for subsequent read operations.
- */
-int bsreadlns (bstring r, struct bStream * s, const_bstring term) {
-	if (s == NULL || s->buff == NULL || r == NULL || term == NULL
-	 || term->data == NULL || r->mlen <= 0) return BSTR_ERR;
-	if (term->slen == 1) return bsreadln (r, s, term->data[0]);
-	if (term->slen < 1) return BSTR_ERR;
-	if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
-	r->slen = 0;
-	return bsreadlnsa (r, s, term);
-}
-
-/*  int bsread (bstring r, struct bStream * s, int n)
- *
- *  Read a bstring of length n (or, if it is fewer, as many bytes as is
- *  remaining) from the bStream.  This function may read additional
- *  characters from the core stream that are not returned, but will be
- *  retained for subsequent read operations.  This function will not read
- *  additional characters from the core stream beyond virtual stream pointer.
- */
-int bsread (bstring r, struct bStream * s, int n) {
-	if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0
-	 || n <= 0) return BSTR_ERR;
-	if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
-	r->slen = 0;
-	return bsreada (r, s, n);
-}
-
-/*  int bsunread (struct bStream * s, const_bstring b)
- *
- *  Insert a bstring into the bStream at the current position.  These
- *  characters will be read prior to those that actually come from the core
- *  stream.
- */
-int bsunread (struct bStream * s, const_bstring b) {
-	if (s == NULL || s->buff == NULL) return BSTR_ERR;
-	return binsert (s->buff, 0, b, (unsigned char) '?');
-}
-
-/*  int bspeek (bstring r, const struct bStream * s)
- *
- *  Return the currently buffered characters from the bStream that will be
- *  read prior to reads from the core stream.
- */
-int bspeek (bstring r, const struct bStream * s) {
-	if (s == NULL || s->buff == NULL) return BSTR_ERR;
-	return bassign (r, s->buff);
-}
-
-/*  bstring bjoinblk (const struct bstrList * bl, void * blk, int len);
- *
- *  Join the entries of a bstrList into one bstring by sequentially
- *  concatenating them with the content from blk for length len in between.
- *  If there is an error NULL is returned, otherwise a bstring with the
- *  correct result is returned.
- */
-bstring bjoinblk (const struct bstrList * bl, const void * blk, int len) {
-bstring b;
-unsigned char * p;
-int i, c, v;
-
-	if (bl == NULL || bl->qty < 0) return NULL;
-	if (len < 0) return NULL;
-	if (len > 0 && blk == NULL) return NULL;
-	if (bl->qty < 1) return bfromStatic ("");
-
-	for (i = 0, c = 1; i < bl->qty; i++) {
-		v = bl->entry[i]->slen;
-		if (v < 0) return NULL;	/* Invalid input */
-		if (v > INT_MAX - c) return NULL;	/* Overflow */
-		c += v;
-	}
-
-	b = (bstring) bstr__alloc (sizeof (struct tagbstring));
-	if (len == 0) {
-		p = b->data = (unsigned char *) bstr__alloc (c);
-		if (p == NULL) {
-			bstr__free (b);
-			return NULL;
-		}
-		for (i = 0; i < bl->qty; i++) {
-			v = bl->entry[i]->slen;
-			bstr__memcpy (p, bl->entry[i]->data, v);
-			p += v;
-		}
-	} else {
-		v = (bl->qty - 1) * len;
-		if ((bl->qty > 512 || len > 127) &&
-		    v / len != bl->qty - 1) return NULL; /* Overflow */
-		if (v > INT_MAX - c) return NULL;	/* Overflow */
-		c += v;
-		p = b->data = (unsigned char *) bstr__alloc (c);
-		if (p == NULL) {
-			bstr__free (b);
-			return NULL;
-		}
-		v = bl->entry[0]->slen;
-		bstr__memcpy (p, bl->entry[0]->data, v);
-		p += v;
-		for (i = 1; i < bl->qty; i++) {
-			bstr__memcpy (p, blk, len);
-			p += len;
-			v = bl->entry[i]->slen;
-			if (v) {
-				bstr__memcpy (p, bl->entry[i]->data, v);
-				p += v;
-			}
-		}
-	}
-	b->mlen = c;
-	b->slen = c-1;
-	b->data[c-1] = (unsigned char) '\0';
-	return b;
-}
-
-/*  bstring bjoin (const struct bstrList * bl, const_bstring sep);
- *
- *  Join the entries of a bstrList into one bstring by sequentially
- *  concatenating them with the sep string in between.  If there is an error
- *  NULL is returned, otherwise a bstring with the correct result is returned.
- */
-bstring bjoin (const struct bstrList * bl, const_bstring sep) {
-	if (sep != NULL && (sep->slen < 0 || sep->data == NULL)) return NULL;
-	return bjoinblk (bl, sep->data, sep->slen);
-}
-
-#define BSSSC_BUFF_LEN (256)
-
-/*  int bssplitscb (struct bStream * s, const_bstring splitStr,
- *                  int (* cb) (void * parm, int ofs, const_bstring entry),
- *                  void * parm)
- *
- *  Iterate the set of disjoint sequential substrings read from a stream
- *  divided by any of the characters in splitStr.  An empty splitStr causes
- *  the whole stream to be iterated once.
- *
- *  Note: At the point of calling the cb function, the bStream pointer is
- *  pointed exactly at the position right after having read the split
- *  character.  The cb function can act on the stream by causing the bStream
- *  pointer to move, and bssplitscb will continue by starting the next split
- *  at the position of the pointer after the return from cb.
- *
- *  However, if the cb causes the bStream s to be destroyed then the cb must
- *  return with a negative value, otherwise bssplitscb will continue in an
- *  undefined manner.
- */
-int bssplitscb (struct bStream * s, const_bstring splitStr,
-	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm) {
-struct charField chrs;
-bstring buff;
-int i, p, ret;
-
-	if (cb == NULL || s == NULL || s->readFnPtr == NULL ||
-	    splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
-
-	if (NULL == (buff = bfromcstr (""))) return BSTR_ERR;
-
-	if (splitStr->slen == 0) {
-		while (bsreada (buff, s, BSSSC_BUFF_LEN) >= 0) ;
-		if ((ret = cb (parm, 0, buff)) > 0)
-			ret = 0;
-	} else {
-		buildCharField (&chrs, splitStr);
-		ret = p = i = 0;
-		for (;;) {
-			if (i >= buff->slen) {
-				bsreada (buff, s, BSSSC_BUFF_LEN);
-				if (i >= buff->slen) {
-					if (0 < (ret = cb (parm, p, buff))) ret = 0;
-					break;
-				}
-			}
-			if (testInCharField (&chrs, buff->data[i])) {
-				struct tagbstring t;
-				unsigned char c;
-
-				blk2tbstr (t, buff->data + i + 1, buff->slen - (i + 1));
-				if ((ret = bsunread (s, &t)) < 0) break;
-				buff->slen = i;
-				c = buff->data[i];
-				buff->data[i] = (unsigned char) '\0';
-				if ((ret = cb (parm, p, buff)) < 0) break;
-				buff->data[i] = c;
-				buff->slen = 0;
-				p += i + 1;
-				i = -1;
-			}
-			i++;
-		}
-	}
-
-	bdestroy (buff);
-	return ret;
-}
-
-/*  int bssplitstrcb (struct bStream * s, const_bstring splitStr,
- *                    int (* cb) (void * parm, int ofs, const_bstring entry),
- *                    void * parm)
- *
- *  Iterate the set of disjoint sequential substrings read from a stream
- *  divided by the entire substring splitStr.  An empty splitStr causes
- *  each character of the stream to be iterated.
- *
- *  Note: At the point of calling the cb function, the bStream pointer is
- *  pointed exactly at the position right after having read the split
- *  character.  The cb function can act on the stream by causing the bStream
- *  pointer to move, and bssplitscb will continue by starting the next split
- *  at the position of the pointer after the return from cb.
- *
- *  However, if the cb causes the bStream s to be destroyed then the cb must
- *  return with a negative value, otherwise bssplitscb will continue in an
- *  undefined manner.
- */
-int bssplitstrcb (struct bStream * s, const_bstring splitStr,
-	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm) {
-bstring buff;
-int i, p, ret;
-
-	if (cb == NULL || s == NULL || s->readFnPtr == NULL
-	 || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
-
-	if (splitStr->slen == 1) return bssplitscb (s, splitStr, cb, parm);
-
-	if (NULL == (buff = bfromcstr (""))) return BSTR_ERR;
-
-	if (splitStr->slen == 0) {
-		for (i=0; bsreada (buff, s, BSSSC_BUFF_LEN) >= 0; i++) {
-			if ((ret = cb (parm, 0, buff)) < 0) {
-				bdestroy (buff);
-				return ret;
-			}
-			buff->slen = 0;
-		}
-		return BSTR_OK;
-	} else {
-		ret = p = i = 0;
-		for (i=p=0;;) {
-			if ((ret = binstr (buff, 0, splitStr)) >= 0) {
-				struct tagbstring t;
-				blk2tbstr (t, buff->data, ret);
-				i = ret + splitStr->slen;
-				if ((ret = cb (parm, p, &t)) < 0) break;
-				p += i;
-				bdelete (buff, 0, i);
-			} else {
-				bsreada (buff, s, BSSSC_BUFF_LEN);
-				if (bseof (s)) {
-					if ((ret = cb (parm, p, buff)) > 0) ret = 0;
-					break;
-				}
-			}
-		}
-	}
-
-	bdestroy (buff);
-	return ret;
-}
-
-/*  int bstrListCreate (void)
- *
- *  Create a bstrList.
- */
-struct bstrList * bstrListCreate (void) {
-struct bstrList * sl =
-	(struct bstrList *) bstr__alloc (sizeof (struct bstrList));
-	if (sl) {
-		sl->entry = (bstring *) bstr__alloc (1*sizeof (bstring));
-		if (!sl->entry) {
-			bstr__free (sl);
-			sl = NULL;
-		} else {
-			sl->qty = 0;
-			sl->mlen = 1;
-		}
-	}
-	return sl;
-}
-
-/*  int bstrListDestroy (struct bstrList * sl)
- *
- *  Destroy a bstrList that has been created by bsplit, bsplits or
- *  bstrListCreate.
- */
-int bstrListDestroy (struct bstrList * sl) {
-int i;
-	if (sl == NULL || sl->qty < 0) return BSTR_ERR;
-	for (i=0; i < sl->qty; i++) {
-		if (sl->entry[i]) {
-			bdestroy (sl->entry[i]);
-			sl->entry[i] = NULL;
-		}
-	}
-	sl->qty  = -1;
-	sl->mlen = -1;
-	bstr__free (sl->entry);
-	sl->entry = NULL;
-	bstr__free (sl);
-	return BSTR_OK;
-}
-
-/*  int bstrListAlloc (struct bstrList * sl, int msz)
- *
- *  Ensure that there is memory for at least msz number of entries for the
- *  list.
- */
-int bstrListAlloc (struct bstrList * sl, int msz) {
-bstring * l;
-int smsz;
-size_t nsz;
-	if (!sl || msz <= 0 || !sl->entry || sl->qty < 0 || sl->mlen <= 0 ||
-	    sl->qty > sl->mlen) return BSTR_ERR;
-	if (sl->mlen >= msz) return BSTR_OK;
-	smsz = snapUpSize (msz);
-	nsz = ((size_t) smsz) * sizeof (bstring);
-	if (nsz < (size_t) smsz) return BSTR_ERR;
-	l = (bstring *) bstr__realloc (sl->entry, nsz);
-	if (!l) {
-		smsz = msz;
-		nsz = ((size_t) smsz) * sizeof (bstring);
-		l = (bstring *) bstr__realloc (sl->entry, nsz);
-		if (!l) return BSTR_ERR;
-	}
-	sl->mlen = smsz;
-	sl->entry = l;
-	return BSTR_OK;
-}
-
-/*  int bstrListAllocMin (struct bstrList * sl, int msz)
- *
- *  Try to allocate the minimum amount of memory for the list to include at
- *  least msz entries or sl->qty whichever is greater.
- */
-int bstrListAllocMin (struct bstrList * sl, int msz) {
-bstring * l;
-size_t nsz;
-	if (!sl || msz <= 0 || !sl->entry || sl->qty < 0 || sl->mlen <= 0 ||
-	    sl->qty > sl->mlen) return BSTR_ERR;
-	if (msz < sl->qty) msz = sl->qty;
-	if (sl->mlen == msz) return BSTR_OK;
-	nsz = ((size_t) msz) * sizeof (bstring);
-	if (nsz < (size_t) msz) return BSTR_ERR;
-	l = (bstring *) bstr__realloc (sl->entry, nsz);
-	if (!l) return BSTR_ERR;
-	sl->mlen = msz;
-	sl->entry = l;
-	return BSTR_OK;
-}
-
-/*  int bsplitcb (const_bstring str, unsigned char splitChar, int pos,
- *                int (* cb) (void * parm, int ofs, int len), void * parm)
- *
- *  Iterate the set of disjoint sequential substrings over str divided by the
- *  character in splitChar.
- *
- *  Note: Non-destructive modification of str from within the cb function
- *  while performing this split is not undefined.  bsplitcb behaves in
- *  sequential lock step with calls to cb.  I.e., after returning from a cb
- *  that return a non-negative integer, bsplitcb continues from the position
- *  1 character after the last detected split character and it will halt
- *  immediately if the length of str falls below this point.  However, if the
- *  cb function destroys str, then it *must* return with a negative value,
- *  otherwise bsplitcb will continue in an undefined manner.
- */
-int bsplitcb (const_bstring str, unsigned char splitChar, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm) {
-int i, p, ret;
-
-	if (cb == NULL || str == NULL || pos < 0 || pos > str->slen)
-		return BSTR_ERR;
-
-	p = pos;
-	do {
-		for (i=p; i < str->slen; i++) {
-			if (str->data[i] == splitChar) break;
-		}
-		if ((ret = cb (parm, p, i - p)) < 0) return ret;
-		p = i + 1;
-	} while (p <= str->slen);
-	return BSTR_OK;
-}
-
-/*  int bsplitscb (const_bstring str, const_bstring splitStr, int pos,
- *                 int (* cb) (void * parm, int ofs, int len), void * parm)
- *
- *  Iterate the set of disjoint sequential substrings over str divided by any
- *  of the characters in splitStr.  An empty splitStr causes the whole str to
- *  be iterated once.
- *
- *  Note: Non-destructive modification of str from within the cb function
- *  while performing this split is not undefined.  bsplitscb behaves in
- *  sequential lock step with calls to cb.  I.e., after returning from a cb
- *  that return a non-negative integer, bsplitscb continues from the position
- *  1 character after the last detected split character and it will halt
- *  immediately if the length of str falls below this point.  However, if the
- *  cb function destroys str, then it *must* return with a negative value,
- *  otherwise bsplitscb will continue in an undefined manner.
- */
-int bsplitscb (const_bstring str, const_bstring splitStr, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm) {
-struct charField chrs;
-int i, p, ret;
-
-	if (cb == NULL || str == NULL || pos < 0 || pos > str->slen
-	 || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
-	if (splitStr->slen == 0) {
-		if ((ret = cb (parm, 0, str->slen)) > 0) ret = 0;
-		return ret;
-	}
-
-	if (splitStr->slen == 1)
-		return bsplitcb (str, splitStr->data[0], pos, cb, parm);
-
-	buildCharField (&chrs, splitStr);
-
-	p = pos;
-	do {
-		for (i=p; i < str->slen; i++) {
-			if (testInCharField (&chrs, str->data[i])) break;
-		}
-		if ((ret = cb (parm, p, i - p)) < 0) return ret;
-		p = i + 1;
-	} while (p <= str->slen);
-	return BSTR_OK;
-}
-
-/*  int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos,
- *	int (* cb) (void * parm, int ofs, int len), void * parm)
- *
- *  Iterate the set of disjoint sequential substrings over str divided by the
- *  substring splitStr.  An empty splitStr causes the whole str to be
- *  iterated once.
- *
- *  Note: Non-destructive modification of str from within the cb function
- *  while performing this split is not undefined.  bsplitstrcb behaves in
- *  sequential lock step with calls to cb.  I.e., after returning from a cb
- *  that return a non-negative integer, bsplitscb continues from the position
- *  1 character after the last detected split character and it will halt
- *  immediately if the length of str falls below this point.  However, if the
- *  cb function destroys str, then it *must* return with a negative value,
- *  otherwise bsplitscb will continue in an undefined manner.
- */
-int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm) {
-int i, p, ret;
-
-	if (cb == NULL || str == NULL || pos < 0 || pos > str->slen
-	 || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
-
-	if (0 == splitStr->slen) {
-		for (i=pos; i < str->slen; i++) {
-			if ((ret = cb (parm, i, 1)) < 0) return ret;
-		}
-		return BSTR_OK;
-	}
-
-	if (splitStr->slen == 1)
-		return bsplitcb (str, splitStr->data[0], pos, cb, parm);
-
-	for (i=p=pos; i <= str->slen - splitStr->slen; i++) {
-		if (0 == bstr__memcmp (splitStr->data, str->data + i,
-		                       splitStr->slen)) {
-			if ((ret = cb (parm, p, i - p)) < 0) return ret;
-			i += splitStr->slen;
-			p = i;
-		}
-	}
-	if ((ret = cb (parm, p, str->slen - p)) < 0) return ret;
-	return BSTR_OK;
-}
-
-struct genBstrList {
-	bstring b;
-	struct bstrList * bl;
-};
-
-static int bscb (void * parm, int ofs, int len) {
-struct genBstrList * g = (struct genBstrList *) parm;
-	if (g->bl->qty >= g->bl->mlen) {
-		int mlen = g->bl->mlen * 2;
-		bstring * tbl;
-
-		while (g->bl->qty >= mlen) {
-			if (mlen < g->bl->mlen) return BSTR_ERR;
-			mlen += mlen;
-		}
-
-		tbl = (bstring *) bstr__realloc (g->bl->entry,
-		                                 sizeof (bstring) * mlen);
-		if (tbl == NULL) return BSTR_ERR;
-
-		g->bl->entry = tbl;
-		g->bl->mlen = mlen;
-	}
-
-	g->bl->entry[g->bl->qty] = bmidstr (g->b, ofs, len);
-	g->bl->qty++;
-	return BSTR_OK;
-}
-
-/*  struct bstrList * bsplit (const_bstring str, unsigned char splitChar)
- *
- *  Create an array of sequential substrings from str divided by the character
- *  splitChar.
- */
-struct bstrList * bsplit (const_bstring str, unsigned char splitChar) {
-struct genBstrList g;
-
-	if (str == NULL || str->data == NULL || str->slen < 0) return NULL;
-
-	g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList));
-	if (g.bl == NULL) return NULL;
-	g.bl->mlen = 4;
-	g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring));
-	if (NULL == g.bl->entry) {
-		bstr__free (g.bl);
-		return NULL;
-	}
-
-	g.b = (bstring) str;
-	g.bl->qty = 0;
-	if (bsplitcb (str, splitChar, 0, bscb, &g) < 0) {
-		bstrListDestroy (g.bl);
-		return NULL;
-	}
-	return g.bl;
-}
-
-/*  struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr)
- *
- *  Create an array of sequential substrings from str divided by the entire
- *  substring splitStr.
- */
-struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr) {
-struct genBstrList g;
-
-	if (str == NULL || str->data == NULL || str->slen < 0) return NULL;
-
-	g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList));
-	if (g.bl == NULL) return NULL;
-	g.bl->mlen = 4;
-	g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring));
-	if (NULL == g.bl->entry) {
-		bstr__free (g.bl);
-		return NULL;
-	}
-
-	g.b = (bstring) str;
-	g.bl->qty = 0;
-	if (bsplitstrcb (str, splitStr, 0, bscb, &g) < 0) {
-		bstrListDestroy (g.bl);
-		return NULL;
-	}
-	return g.bl;
-}
-
-/*  struct bstrList * bsplits (const_bstring str, bstring splitStr)
- *
- *  Create an array of sequential substrings from str divided by any of the
- *  characters in splitStr.  An empty splitStr causes a single entry bstrList
- *  containing a copy of str to be returned.
- */
-struct bstrList * bsplits (const_bstring str, const_bstring splitStr) {
-struct genBstrList g;
-
-	if (     str == NULL ||      str->slen < 0 ||      str->data == NULL ||
-	    splitStr == NULL || splitStr->slen < 0 || splitStr->data == NULL)
-		return NULL;
-
-	g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList));
-	if (g.bl == NULL) return NULL;
-	g.bl->mlen = 4;
-	g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring));
-	if (NULL == g.bl->entry) {
-		bstr__free (g.bl);
-		return NULL;
-	}
-	g.b = (bstring) str;
-	g.bl->qty = 0;
-
-	if (bsplitscb (str, splitStr, 0, bscb, &g) < 0) {
-		bstrListDestroy (g.bl);
-		return NULL;
-	}
-	return g.bl;
-}
-
-#if defined (__TURBOC__) && !defined (__BORLANDC__)
-# ifndef BSTRLIB_NOVSNP
-#  define BSTRLIB_NOVSNP
-# endif
-#endif
-
-/* Give WATCOM C/C++, MSVC some latitude for their non-support of vsnprintf */
-#if defined(__WATCOMC__) || defined(_MSC_VER)
-#define exvsnprintf(r,b,n,f,a) {r = _vsnprintf (b,n,f,a);}
-#else
-#ifdef BSTRLIB_NOVSNP
-/* This is just a hack.  If you are using a system without a vsnprintf, it is
-   not recommended that bformat be used at all. */
-#define exvsnprintf(r,b,n,f,a) {vsprintf (b,f,a); r = -1;}
-#define START_VSNBUFF (256)
-#else
-
-#if defined(__GNUC__) && !defined(__APPLE__)
-/* Something is making gcc complain about this prototype not being here, so
-   I've just gone ahead and put it in. */
-extern int vsnprintf (char *buf, size_t count, const char *format, va_list arg);
-#endif
-
-#define exvsnprintf(r,b,n,f,a) {r = vsnprintf (b,n,f,a);}
-#endif
-#endif
-
-#if !defined (BSTRLIB_NOVSNP)
-
-#ifndef START_VSNBUFF
-#define START_VSNBUFF (16)
-#endif
-
-/* On IRIX vsnprintf returns n-1 when the operation would overflow the target
-   buffer, WATCOM and MSVC both return -1, while C99 requires that the
-   returned value be exactly what the length would be if the buffer would be
-   large enough.  This leads to the idea that if the return value is larger
-   than n, then changing n to the return value will reduce the number of
-   iterations required. */
-
-/*  int bformata (bstring b, const char * fmt, ...)
- *
- *  After the first parameter, it takes the same parameters as printf (), but
- *  rather than outputting results to stdio, it appends the results to
- *  a bstring which contains what would have been output. Note that if there
- *  is an early generation of a '\0' character, the bstring will be truncated
- *  to this end point.
- */
-int bformata (bstring b, const char * fmt, ...) {
-va_list arglist;
-bstring buff;
-int n, r;
-
-	if (b == NULL || fmt == NULL || b->data == NULL || b->mlen <= 0
-	 || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR;
-
-	/* Since the length is not determinable beforehand, a search is
-	   performed using the truncating "vsnprintf" call (to avoid buffer
-	   overflows) on increasing potential sizes for the output result. */
-
-	if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF;
-	if (NULL == (buff = bfromcstralloc (n + 2, ""))) {
-		n = 1;
-		if (NULL == (buff = bfromcstralloc (n + 2, ""))) return BSTR_ERR;
-	}
-
-	for (;;) {
-		va_start (arglist, fmt);
-		exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist);
-		va_end (arglist);
-
-		buff->data[n] = (unsigned char) '\0';
-		buff->slen = (int) (strlen) ((char *) buff->data);
-
-		if (buff->slen < n) break;
-
-		if (r > n) n = r; else n += n;
-
-		if (BSTR_OK != balloc (buff, n + 2)) {
-			bdestroy (buff);
-			return BSTR_ERR;
-		}
-	}
-
-	r = bconcat (b, buff);
-	bdestroy (buff);
-	return r;
-}
-
-/*  int bassignformat (bstring b, const char * fmt, ...)
- *
- *  After the first parameter, it takes the same parameters as printf (), but
- *  rather than outputting results to stdio, it outputs the results to
- *  the bstring parameter b. Note that if there is an early generation of a
- *  '\0' character, the bstring will be truncated to this end point.
- */
-int bassignformat (bstring b, const char * fmt, ...) {
-va_list arglist;
-bstring buff;
-int n, r;
-
-	if (b == NULL || fmt == NULL || b->data == NULL || b->mlen <= 0
-	 || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR;
-
-	/* Since the length is not determinable beforehand, a search is
-	   performed using the truncating "vsnprintf" call (to avoid buffer
-	   overflows) on increasing potential sizes for the output result. */
-
-	if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF;
-	if (NULL == (buff = bfromcstralloc (n + 2, ""))) {
-		n = 1;
-		if (NULL == (buff = bfromcstralloc (n + 2, ""))) return BSTR_ERR;
-	}
-
-	for (;;) {
-		va_start (arglist, fmt);
-		exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist);
-		va_end (arglist);
-
-		buff->data[n] = (unsigned char) '\0';
-		buff->slen = (int) (strlen) ((char *) buff->data);
-
-		if (buff->slen < n) break;
-
-		if (r > n) n = r; else n += n;
-
-		if (BSTR_OK != balloc (buff, n + 2)) {
-			bdestroy (buff);
-			return BSTR_ERR;
-		}
-	}
-
-	r = bassign (b, buff);
-	bdestroy (buff);
-	return r;
-}
-
-/*  bstring bformat (const char * fmt, ...)
- *
- *  Takes the same parameters as printf (), but rather than outputting results
- *  to stdio, it forms a bstring which contains what would have been output.
- *  Note that if there is an early generation of a '\0' character, the
- *  bstring will be truncated to this end point.
- */
-bstring bformat (const char * fmt, ...) {
-va_list arglist;
-bstring buff;
-int n, r;
-
-	if (fmt == NULL) return NULL;
-
-	/* Since the length is not determinable beforehand, a search is
-	   performed using the truncating "vsnprintf" call (to avoid buffer
-	   overflows) on increasing potential sizes for the output result. */
-
-	if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF;
-	if (NULL == (buff = bfromcstralloc (n + 2, ""))) {
-		n = 1;
-		if (NULL == (buff = bfromcstralloc (n + 2, ""))) return NULL;
-	}
-
-	for (;;) {
-		va_start (arglist, fmt);
-		exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist);
-		va_end (arglist);
-
-		buff->data[n] = (unsigned char) '\0';
-		buff->slen = (int) (strlen) ((char *) buff->data);
-
-		if (buff->slen < n) break;
-
-		if (r > n) n = r; else n += n;
-
-		if (BSTR_OK != balloc (buff, n + 2)) {
-			bdestroy (buff);
-			return NULL;
-		}
-	}
-
-	return buff;
-}
-
-/*  int bvcformata (bstring b, int count, const char * fmt, va_list arglist)
- *
- *  The bvcformata function formats data under control of the format control
- *  string fmt and attempts to append the result to b.  The fmt parameter is
- *  the same as that of the printf function.  The variable argument list is
- *  replaced with arglist, which has been initialized by the va_start macro.
- *  The size of the output is upper bounded by count.  If the required output
- *  exceeds count, the string b is not augmented with any contents and a value
- *  below BSTR_ERR is returned.  If a value below -count is returned then it
- *  is recommended that the negative of this value be used as an update to the
- *  count in a subsequent pass.  On other errors, such as running out of
- *  memory, parameter errors or numeric wrap around BSTR_ERR is returned.
- *  BSTR_OK is returned when the output is successfully generated and
- *  appended to b.
- *
- *  Note: There is no sanity checking of arglist, and this function is
- *  destructive of the contents of b from the b->slen point onward.  If there
- *  is an early generation of a '\0' character, the bstring will be truncated
- *  to this end point.
- */
-int bvcformata (bstring b, int count, const char * fmt, va_list arg) {
-int n, r, l;
-
-	if (b == NULL || fmt == NULL || count <= 0 || b->data == NULL
-	 || b->mlen <= 0 || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR;
-
-	if (count > (n = b->slen + count) + 2) return BSTR_ERR;
-	if (BSTR_OK != balloc (b, n + 2)) return BSTR_ERR;
-
-	exvsnprintf (r, (char *) b->data + b->slen, count + 2, fmt, arg);
-	b->data[b->slen + count + 2] = '\0';
-
-	/* Did the operation complete successfully within bounds? */
-
-	if (n >= (l = b->slen + (int) (strlen) ((char *) b->data + b->slen))) {
-		b->slen = l;
-		return BSTR_OK;
-	}
-
-	/* Abort, since the buffer was not large enough.  The return value
-	   tries to help set what the retry length should be. */
-
-	b->data[b->slen] = '\0';
-	if (r > count+1) {
-		l = r;
-	} else {
-		if (count > INT_MAX / 2)
-			l = INT_MAX;
-		else
-			l = count + count;
-	}
-	n = -l;
-	if (n > BSTR_ERR-1) n = BSTR_ERR-1;
-	return n;
-}
-
-#endif
diff --git a/nserver/src/bstrlib.h b/nserver/src/bstrlib.h
deleted file mode 100644
index 6ad6f4a..0000000
--- a/nserver/src/bstrlib.h
+++ /dev/null
@@ -1,332 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2014 Paul Hsieh
- * Copyright © 2020 rsiddharth
- */
-
-/*
- * This is a slightly modified version of bstrlib.h from the bstrlib
- * library (https://github.com/websnarf/bstrlib/releases/tag/v1.0.0).
- */
-
-/*
- * This source file is part of the bstring string library.  This code was
- * written by Paul Hsieh in 2002-2015, and is covered by the BSD open source
- * license and the GPL. Refer to the accompanying documentation for details
- * on usage and license.
- */
-
-/*
- * bstrlib.h
- *
- * This file is the interface for the core bstring functions.
- */
-
-#ifndef BSTRLIB_INCLUDE
-#define BSTRLIB_INCLUDE
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdarg.h>
-#include <string.h>
-#include <limits.h>
-#include <ctype.h>
-
-#if !defined (BSTRLIB_VSNP_OK) && !defined (BSTRLIB_NOVSNP)
-# if defined (__TURBOC__) && !defined (__BORLANDC__)
-#  define BSTRLIB_NOVSNP
-# endif
-#endif
-
-#define BSTR_ERR (-1)
-#define BSTR_OK (0)
-#define BSTR_BS_BUFF_LENGTH_GET (0)
-
-typedef struct tagbstring * bstring;
-typedef const struct tagbstring * const_bstring;
-
-/* Version */
-#define BSTR_VER_MAJOR  1
-#define BSTR_VER_MINOR  0
-#define BSTR_VER_UPDATE 0
-
-/* Copy functions */
-#define cstr2bstr bfromcstr
-extern bstring bfromcstr (const char * str);
-extern bstring bfromcstralloc (int mlen, const char * str);
-extern bstring bfromcstrrangealloc (int minl, int maxl, const char* str);
-extern bstring blk2bstr (const void * blk, int len);
-extern char * bstr2cstr (const_bstring s, char z);
-extern int bcstrfree (char * s);
-extern bstring bstrcpy (const_bstring b1);
-extern int bassign (bstring a, const_bstring b);
-extern int bassignmidstr (bstring a, const_bstring b, int left, int len);
-extern int bassigncstr (bstring a, const char * str);
-extern int bassignblk (bstring a, const void * s, int len);
-
-/* Destroy function */
-extern int bdestroy (bstring b);
-
-/* Space allocation hinting functions */
-extern int balloc (bstring s, int len);
-extern int ballocmin (bstring b, int len);
-
-/* Substring extraction */
-extern bstring bmidstr (const_bstring b, int left, int len);
-
-/* Various standard manipulations */
-extern int bconcat (bstring b0, const_bstring b1);
-extern int bconchar (bstring b0, char c);
-extern int bcatcstr (bstring b, const char * s);
-extern int bcatblk (bstring b, const void * s, int len);
-extern int binsert (bstring s1, int pos, const_bstring s2, unsigned char fill);
-extern int binsertblk (bstring s1, int pos, const void * s2, int len, unsigned char fill);
-extern int binsertch (bstring s1, int pos, int len, unsigned char fill);
-extern int breplace (bstring b1, int pos, int len, const_bstring b2, unsigned char fill);
-extern int bdelete (bstring s1, int pos, int len);
-extern int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill);
-extern int btrunc (bstring b, int n);
-
-/* Scan/search functions */
-extern int bstricmp (const_bstring b0, const_bstring b1);
-extern int bstrnicmp (const_bstring b0, const_bstring b1, int n);
-extern int biseqcaseless (const_bstring b0, const_bstring b1);
-extern int biseqcaselessblk (const_bstring b, const void * blk, int len);
-extern int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len);
-extern int biseq (const_bstring b0, const_bstring b1);
-extern int biseqblk (const_bstring b, const void * blk, int len);
-extern int bisstemeqblk (const_bstring b0, const void * blk, int len);
-extern int biseqcstr (const_bstring b, const char * s);
-extern int biseqcstrcaseless (const_bstring b, const char * s);
-extern int bstrcmp (const_bstring b0, const_bstring b1);
-extern int bstrncmp (const_bstring b0, const_bstring b1, int n);
-extern int binstr (const_bstring s1, int pos, const_bstring s2);
-extern int binstrr (const_bstring s1, int pos, const_bstring s2);
-extern int binstrcaseless (const_bstring s1, int pos, const_bstring s2);
-extern int binstrrcaseless (const_bstring s1, int pos, const_bstring s2);
-extern int bstrchrp (const_bstring b, int c, int pos);
-extern int bstrrchrp (const_bstring b, int c, int pos);
-#define bstrchr(b,c) bstrchrp ((b), (c), 0)
-#define bstrrchr(b,c) bstrrchrp ((b), (c), blength(b)-1)
-extern int binchr (const_bstring b0, int pos, const_bstring b1);
-extern int binchrr (const_bstring b0, int pos, const_bstring b1);
-extern int bninchr (const_bstring b0, int pos, const_bstring b1);
-extern int bninchrr (const_bstring b0, int pos, const_bstring b1);
-extern int bfindreplace (bstring b, const_bstring find, const_bstring repl, int pos);
-extern int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl, int pos);
-
-/* List of string container functions */
-struct bstrList {
-    int qty, mlen;
-    bstring * entry;
-};
-extern struct bstrList * bstrListCreate (void);
-extern int bstrListDestroy (struct bstrList * sl);
-extern int bstrListAlloc (struct bstrList * sl, int msz);
-extern int bstrListAllocMin (struct bstrList * sl, int msz);
-
-/* String split and join functions */
-extern struct bstrList * bsplit (const_bstring str, unsigned char splitChar);
-extern struct bstrList * bsplits (const_bstring str, const_bstring splitStr);
-extern struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr);
-extern bstring bjoin (const struct bstrList * bl, const_bstring sep);
-extern bstring bjoinblk (const struct bstrList * bl, const void * s, int len);
-extern int bsplitcb (const_bstring str, unsigned char splitChar, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm);
-extern int bsplitscb (const_bstring str, const_bstring splitStr, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm);
-extern int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm);
-
-/* Miscellaneous functions */
-extern int bpattern (bstring b, int len);
-extern int btoupper (bstring b);
-extern int btolower (bstring b);
-extern int bltrimws (bstring b);
-extern int brtrimws (bstring b);
-extern int btrimws (bstring b);
-
-#if !defined (BSTRLIB_NOVSNP)
-extern bstring bformat (const char * fmt, ...);
-extern int bformata (bstring b, const char * fmt, ...);
-extern int bassignformat (bstring b, const char * fmt, ...);
-extern int bvcformata (bstring b, int count, const char * fmt, va_list arglist);
-
-#define bvformata(ret, b, fmt, lastarg) { \
-bstring bstrtmp_b = (b); \
-const char * bstrtmp_fmt = (fmt); \
-int bstrtmp_r = BSTR_ERR, bstrtmp_sz = 16; \
-	for (;;) { \
-		va_list bstrtmp_arglist; \
-		va_start (bstrtmp_arglist, lastarg); \
-		bstrtmp_r = bvcformata (bstrtmp_b, bstrtmp_sz, bstrtmp_fmt, bstrtmp_arglist); \
-		va_end (bstrtmp_arglist); \
-		if (bstrtmp_r >= 0) { /* Everything went ok */ \
-			bstrtmp_r = BSTR_OK; \
-			break; \
-		} else if (-bstrtmp_r <= bstrtmp_sz) { /* A real error? */ \
-			bstrtmp_r = BSTR_ERR; \
-			break; \
-		} \
-		bstrtmp_sz = -bstrtmp_r; /* Doubled or target size */ \
-	} \
-	ret = bstrtmp_r; \
-}
-
-#endif
-
-typedef int (*bNgetc) (void *parm);
-typedef size_t (* bNread) (void *buff, size_t elsize, size_t nelem, void *parm);
-
-/* Input functions */
-extern bstring bgets (bNgetc getcPtr, void * parm, char terminator);
-extern bstring bread (bNread readPtr, void * parm);
-extern int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator);
-extern int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator);
-extern int breada (bstring b, bNread readPtr, void * parm);
-
-/* Stream functions */
-extern struct bStream * bsopen (bNread readPtr, void * parm);
-extern void * bsclose (struct bStream * s);
-extern int bsbufflength (struct bStream * s, int sz);
-extern int bsreadln (bstring b, struct bStream * s, char terminator);
-extern int bsreadlns (bstring r, struct bStream * s, const_bstring term);
-extern int bsread (bstring b, struct bStream * s, int n);
-extern int bsreadlna (bstring b, struct bStream * s, char terminator);
-extern int bsreadlnsa (bstring r, struct bStream * s, const_bstring term);
-extern int bsreada (bstring b, struct bStream * s, int n);
-extern int bsunread (struct bStream * s, const_bstring b);
-extern int bspeek (bstring r, const struct bStream * s);
-extern int bssplitscb (struct bStream * s, const_bstring splitStr, 
-	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
-extern int bssplitstrcb (struct bStream * s, const_bstring splitStr, 
-	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
-extern int bseof (const struct bStream * s);
-
-struct tagbstring {
-	int mlen;
-	int slen;
-	unsigned char * data;
-};
-
-/* Accessor macros */
-#define blengthe(b, e)      (((b) == (void *)0 || (b)->slen < 0) ? (int)(e) : ((b)->slen))
-#define blength(b)          (blengthe ((b), 0))
-#define bdataofse(b, o, e)  (((b) == (void *)0 || (b)->data == (void*)0) ? (char *)(e) : ((char *)(b)->data) + (o))
-#define bdataofs(b, o)      (bdataofse ((b), (o), (void *)0))
-#define bdatae(b, e)        (bdataofse (b, 0, e))
-#define bdata(b)            (bdataofs (b, 0))
-#define bchare(b, p, e)     ((((unsigned)(p)) < (unsigned)blength(b)) ? ((b)->data[(p)]) : (e))
-#define bchar(b, p)         bchare ((b), (p), '\0')
-
-/* Static constant string initialization macro */
-#define bsStaticMlen(q,m)   {(m), (int) sizeof(q)-1, (unsigned char *) ("" q "")}
-#if defined(_MSC_VER)
-# define bsStatic(q)        bsStaticMlen(q,-32)
-#endif
-#ifndef bsStatic
-# define bsStatic(q)        bsStaticMlen(q,-__LINE__)
-#endif
-
-/* Static constant block parameter pair */
-#define bsStaticBlkParms(q) ((void *)("" q "")), ((int) sizeof(q)-1)
-
-#define bcatStatic(b,s)     ((bcatblk)((b), bsStaticBlkParms(s)))
-#define bfromStatic(s)      ((blk2bstr)(bsStaticBlkParms(s)))
-#define bassignStatic(b,s)  ((bassignblk)((b), bsStaticBlkParms(s)))
-#define binsertStatic(b,p,s,f) ((binsertblk)((b), (p), bsStaticBlkParms(s), (f)))
-#define bjoinStatic(b,s)    ((bjoinblk)((b), bsStaticBlkParms(s)))
-#define biseqStatic(b,s)    ((biseqblk)((b), bsStaticBlkParms(s)))
-#define bisstemeqStatic(b,s) ((bisstemeqblk)((b), bsStaticBlkParms(s)))
-#define biseqcaselessStatic(b,s) ((biseqcaselessblk)((b), bsStaticBlkParms(s)))
-#define bisstemeqcaselessStatic(b,s) ((bisstemeqcaselessblk)((b), bsStaticBlkParms(s)))
-
-/* Reference building macros */
-#define cstr2tbstr btfromcstr
-#define btfromcstr(t,s) {                                            \
-    (t).data = (unsigned char *) (s);                                \
-    (t).slen = ((t).data) ? ((int) (strlen) ((char *)(t).data)) : 0; \
-    (t).mlen = -1;                                                   \
-}
-#define blk2tbstr(t,s,l) {            \
-    (t).data = (unsigned char *) (s); \
-    (t).slen = l;                     \
-    (t).mlen = -1;                    \
-}
-#define btfromblk(t,s,l) blk2tbstr(t,s,l)
-#define bmid2tbstr(t,b,p,l) {                                                \
-    const_bstring bstrtmp_s = (b);                                           \
-    if (bstrtmp_s && bstrtmp_s->data && bstrtmp_s->slen >= 0) {              \
-        int bstrtmp_left = (p);                                              \
-        int bstrtmp_len  = (l);                                              \
-        if (bstrtmp_left < 0) {                                              \
-            bstrtmp_len += bstrtmp_left;                                     \
-            bstrtmp_left = 0;                                                \
-        }                                                                    \
-        if (bstrtmp_len > bstrtmp_s->slen - bstrtmp_left)                    \
-            bstrtmp_len = bstrtmp_s->slen - bstrtmp_left;                    \
-        if (bstrtmp_len <= 0) {                                              \
-            (t).data = (unsigned char *)"";                                  \
-            (t).slen = 0;                                                    \
-        } else {                                                             \
-            (t).data = bstrtmp_s->data + bstrtmp_left;                       \
-            (t).slen = bstrtmp_len;                                          \
-        }                                                                    \
-    } else {                                                                 \
-        (t).data = (unsigned char *)"";                                      \
-        (t).slen = 0;                                                        \
-    }                                                                        \
-    (t).mlen = -__LINE__;                                                    \
-}
-#define btfromblkltrimws(t,s,l) {                                            \
-    int bstrtmp_idx = 0, bstrtmp_len = (l);                                  \
-    unsigned char * bstrtmp_s = (s);                                         \
-    if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
-        for (; bstrtmp_idx < bstrtmp_len; bstrtmp_idx++) {                   \
-            if (!isspace (bstrtmp_s[bstrtmp_idx])) break;                    \
-        }                                                                    \
-    }                                                                        \
-    (t).data = bstrtmp_s + bstrtmp_idx;                                      \
-    (t).slen = bstrtmp_len - bstrtmp_idx;                                    \
-    (t).mlen = -__LINE__;                                                    \
-}
-#define btfromblkrtrimws(t,s,l) {                                            \
-    int bstrtmp_len = (l) - 1;                                               \
-    unsigned char * bstrtmp_s = (s);                                         \
-    if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
-        for (; bstrtmp_len >= 0; bstrtmp_len--) {                            \
-            if (!isspace (bstrtmp_s[bstrtmp_len])) break;                    \
-        }                                                                    \
-    }                                                                        \
-    (t).data = bstrtmp_s;                                                    \
-    (t).slen = bstrtmp_len + 1;                                              \
-    (t).mlen = -__LINE__;                                                    \
-}
-#define btfromblktrimws(t,s,l) {                                             \
-    int bstrtmp_idx = 0, bstrtmp_len = (l) - 1;                              \
-    unsigned char * bstrtmp_s = (s);                                         \
-    if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
-        for (; bstrtmp_idx <= bstrtmp_len; bstrtmp_idx++) {                  \
-            if (!isspace (bstrtmp_s[bstrtmp_idx])) break;                    \
-        }                                                                    \
-        for (; bstrtmp_len >= bstrtmp_idx; bstrtmp_len--) {                  \
-            if (!isspace (bstrtmp_s[bstrtmp_len])) break;                    \
-        }                                                                    \
-    }                                                                        \
-    (t).data = bstrtmp_s + bstrtmp_idx;                                      \
-    (t).slen = bstrtmp_len + 1 - bstrtmp_idx;                                \
-    (t).mlen = -__LINE__;                                                    \
-}
-
-/* Write protection macros */
-#define bwriteprotect(t)     { if ((t).mlen >=  0) (t).mlen = -1; }
-#define bwriteallow(t)       { if ((t).mlen == -1) (t).mlen = (t).slen + ((t).slen == 0); }
-#define biswriteprotected(t) ((t).mlen <= 0)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/nserver/src/darray.c b/nserver/src/darray.c
deleted file mode 100644
index 912ccbe..0000000
--- a/nserver/src/darray.c
+++ /dev/null
@@ -1,198 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2010, Zed A. Shaw.
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#include <darray.h>
-#include <darray_algos.h>
-#include <assert.h>
-
-DArray *DArray_create(size_t element_size, size_t initial_max)
-{
-    DArray *array = malloc(sizeof(DArray));
-    check_mem(array);
-    array->max = initial_max;
-    check(array->max > 0, "You must set initial_max > 0.");
-
-    array->contents = calloc(initial_max, sizeof(void *));
-    check_mem(array->contents);
-
-    array->end = 0;
-    array->element_size = element_size;
-    array->expand_rate = DEFAULT_EXPAND_RATE;
-
-    return array;
-
- error:
-    if (array)
-        free(array);
-    return NULL;
-}
-
-void DArray_clear(DArray *array)
-{
-    check(array != NULL, "array cannot be NULL");
-
-    int i = 0;
-    if (array->element_size > 0) {
-        for (i = 0; i < array->max; i++) {
-            if (array->contents[i] != NULL) {
-                free(array->contents[i]);
-            }
-        }
-    }
-
- error:
-    return;
-}
-
-static inline int DArray_resize(DArray *array, size_t newsize)
-{
-    check(array != NULL, "array cannot be NULL");
-    check((int) newsize >= array->end, "newsize must be >= end.");
-
-    array->max = newsize;
-    check(array->max > 0, "The newsize must be > 0.");
-
-    void *contents = realloc(array->contents,
-                             array->max * sizeof(void *));
-    // Check contents and assume realloc doesn't harm the original on error.
-
-    check_mem(contents);
-
-    array->contents = contents;
-
-    return 0;
- error:
-    return -1;
-}
-
-int DArray_expand(DArray *array)
-{
-    size_t old_max = array->max;
-    check(DArray_resize(array, array->max + array->expand_rate) == 0,
-          "Failed to expand array to new size: %d",
-          array->max + (int) array->expand_rate);
-
-    memset(array->contents + old_max, 0, (array->expand_rate) * sizeof(void *));
-
-    return 0;
-
- error:
-    return -1;
-}
-
-int DArray_contract(DArray *array)
-{
-    check(array != NULL, "array cannot be NULL");
-
-    int new_size = array->end < (int) array->expand_rate ?
-        (int) array->expand_rate : array->end;
-
-    return DArray_resize(array, new_size + 1);
- error:
-    return -1;
-}
-
-void DArray_destroy(DArray *array)
-{
-    if (array) {
-        if (array->contents)
-            free(array->contents);
-        free(array);
-    }
-}
-
-void DArray_clear_destroy(DArray *array)
-{
-    DArray_clear(array);
-    DArray_destroy(array);
-}
-
-int DArray_push(DArray *array, void *el)
-{
-    check(array != NULL, "array cannot be NULL");
-
-    array->contents[array->end] = el;
-    array->end++;
-
-    if (DArray_end(array) >= DArray_max(array)) {
-        return DArray_expand(array);
-    } else {
-        return 0;
-    }
-
- error:
-    return -1;
-}
-
-void *DArray_pop(DArray *array)
-{
-    check(array != NULL, "array cannot be NULL");
-    check(array->end - 1 >= 0, "Attempt to pop from empty array.");
-
-    void *el = DArray_remove(array, array->end - 1);
-    array->end--;
-
-    if (DArray_end(array) > (int)array->expand_rate
-        && DArray_end(array) % array->expand_rate) {
-        DArray_contract(array);
-    }
-
-    return el;
- error:
-    return NULL;
-}
-
-int DArray_sort_add(DArray *array, void *el, DArray_compare cmp)
-{
-    int rc;
-    rc = DArray_push(array, el);
-    check(rc == 0, "Error pushing element.");
-
-    // sort the array.
-    rc = DArray_heapsort(array, cmp);
-    check(rc == 0, "Error sorting array.");
-
-    return 0;
- error:
-    return -1;
-}
-
-DArray *DArray_shallow_copy(DArray *array)
-{
-    DArray *copy  = DArray_create(array->element_size, array->max);
-    check(copy != NULL, "Error creating DArray copy.");
-
-    int i = 0;
-    for (i = 0; i < array->max; i++) {
-            copy->contents[i] = array->contents[i];
-    }
-
-    return copy;
- error:
-    return NULL;
-}
-
-int DArray_find(DArray *array, void *el, DArray_compare cmp)
-{
-    int low = 0;
-    int high = DArray_end(array) - 1;
-    void *c = NULL;
-
-    while (low <= high) {
-        int middle =  low + (high - low) / 2;
-        c = DArray_get(array, middle);
-
-        if (cmp(&el, &c) < 0) {
-            high = middle - 1;
-        } else if (cmp(&el, &c) > 0) {
-            low = middle + 1;
-        } else {
-            return middle;
-        }
-    }
-
-    return -1;
-}
diff --git a/nserver/src/darray.h b/nserver/src/darray.h
deleted file mode 100644
index 7e5ae5d..0000000
--- a/nserver/src/darray.h
+++ /dev/null
@@ -1,126 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2010, Zed A. Shaw.
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#ifndef _DArray_h
-#define _DArray_h
-#include <stdlib.h>
-#include <assert.h>
-#include <dbg.h>
-
-typedef struct DArray {
-    int end;
-    int max;
-    size_t element_size;
-    size_t expand_rate;
-    void **contents;
-} DArray;
-
-typedef int (*DArray_compare) (const void *a, const void *b);
-
-DArray *DArray_create(size_t element_size, size_t initial_max);
-
-void DArray_destroy(DArray *array);
-
-void DArray_clear(DArray *array);
-
-int DArray_expand(DArray *array);
-
-int DArray_contract(DArray *array);
-
-int DArray_push(DArray *array, void *el);
-
-void *DArray_pop(DArray *array);
-
-int DArray_sort_add(DArray *array, void *el, DArray_compare cmp);
-
-int DArray_find(DArray *array, void *el, DArray_compare cmp);
-
-void DArray_clear_destroy(DArray *array);
-
-/**
- * Creates a new DArray using `DArray_create` and copies the
- * `contents` from array to the newly created DArray.
- *
- * Returns newly created DArray.
- */
-DArray *DArray_shallow_copy(DArray *array);
-
-#define DArray_last(A) ((A)->contents[(A)->end - 1])
-#define DArray_first(A) ((A)->contents[0])
-#define DArray_end(A) ((A)->end)
-#define DArray_count(A) DArray_end(A)
-#define DArray_max(A) ((A)->max)
-
-#define DEFAULT_EXPAND_RATE 300
-
-static inline int DArray_set(DArray *array, int i, void *el)
-{
-    check(array != NULL, "array cannot be NULL");
-    check(i >= 0, "i cannot be lesser than 0");
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstrict-overflow"
-    check(i < array->max, "darray attempt to set past max");
-#pragma GCC diagnostic pop
-
-    if (i > array->end)
-        array->end = i;
-
-    array->contents[i] = el;
-    return i;
- error:
-    return -1;
-}
-
-static inline void *DArray_get(DArray *array, int i)
-{
-    check(array != NULL, "array cannot be NULL");
-    check(i >= 0, "i cannot be lesser than 0");
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstrict-overflow"
-    check(i < array->max, "darray attempt to get past max");
-#pragma GCC diagnostic pop
-
-    return array->contents[i];
- error:
-    return NULL;
-}
-
-static inline void *DArray_remove(DArray *array, int i)
-{
-    check(array != NULL, "array cannot be NULL");
-    check(i >= 0, "i cannot be lesser than 0");
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstrict-overflow"
-    check(i < array->max, "darray attempt to get past max");
-#pragma GCC diagnostic pop
-
-    void *el = array->contents[i];
-
-    array->contents[i] = NULL;
-
-    return el;
- error:
-    return NULL;
-}
-
-static inline void *DArray_new(DArray *array)
-{
-    check(array != NULL, "array cannot be NULL");
-    check(array->element_size > 0,
-          "Can't use DArray_new on 0 size darrays.");
-
-    return calloc(1, array->element_size);
-
- error:
-    return NULL;
-}
-
-#define DArray_free(E) free((E))
-
-#endif
diff --git a/nserver/src/darray_algos.c b/nserver/src/darray_algos.c
deleted file mode 100644
index 01fd27f..0000000
--- a/nserver/src/darray_algos.c
+++ /dev/null
@@ -1,234 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2010, Zed A. Shaw.
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#include <darray_algos.h>
-
-int DArray_qsort(DArray *array, DArray_compare cmp)
-{
-    qsort(array->contents, DArray_count(array), sizeof(void *), cmp);
-    return 0;
-}
-
-int DArray_heapsort(DArray *array, DArray_compare cmp)
-{
-    return heapsort(array->contents, DArray_count(array),
-                    sizeof(void *), cmp);
-}
-
-int DArray_mergesort(DArray *array, DArray_compare cmp)
-{
-    return mergesort(array->contents, DArray_count(array),
-                     sizeof(void *), cmp);
-}
-
-// Fucked Quick Sort.
-int DArray_fucked_qsort_partition(DArray *array, DArray_compare cmp,
-                                  int low, int high)
-{
-    int i = 0, j = 0, cmp_rc;
-    void *pivot = NULL, *tmp = NULL;
-
-    pivot = array->contents[high];
-    i = low - 1;
-
-    for (j = low; j < high; j++) {
-        cmp_rc = cmp(&array->contents[j], &pivot);
-        if (cmp_rc < 0) {
-            i = i + 1;
-
-            // swap
-            tmp = array->contents[j];
-            array->contents[j] = array->contents[i];
-            array->contents[i] = tmp;
-        }
-    }
-
-    cmp_rc = cmp(&array->contents[high], &array->contents[i + 1]);
-    if (cmp_rc < 0) {
-            tmp = array->contents[high];
-            array->contents[high] = array->contents[i + 1];
-            array->contents[i + 1] = tmp;
-    }
-
-    return i + 1;
-}
-
-int DArray_fucked_qsort_recurse(DArray *array, DArray_compare cmp,
-                        int low, int high)
-{
-    int rc = 0, p = 0;
-    if (low < high) {
-        p = DArray_fucked_qsort_partition(array, cmp, low, high);
-        check(p >= 0, "Failed to partition [%d-%d]", low, high);
-
-        rc = DArray_fucked_qsort_recurse(array, cmp, low, p - 1);
-        check(rc == 0, "Failed to quick sort sub array [%d-%d]", low, p-1);
-
-        rc = DArray_fucked_qsort_recurse(array, cmp, p + 1, high);
-        check(rc == 0, "Failed to quick sort sub array [%d-%d]", p+1, high);
-    }
-
-    return 0;
- error:
-    return -1;
-}
-
-int DArray_fucked_qsort(DArray *array, DArray_compare cmp)
-{
-    int rc;
-    rc = DArray_fucked_qsort_recurse(array, cmp, 0, DArray_end(array) - 1);
-    check(rc == 0, "Error sorting array.");
-
-    return 0;
- error:
-    return -1;
-}
-
-// Fucked Heap Sort.
-#define DArray_fucked_heapsort_iparent(i) ((floor(i - 1) / 2))
-#define DArray_fucked_heapsort_ileft_child(i) ((2*i + 1))
-#define DArray_fucked_heapsort_iright_child(i) ((2*i + 2))
-
-static inline void DArray_fucked_heapsort_swap(DArray *array, int a, int b)
-{
-    void *tmp = array->contents[a];
-    array->contents[a] = array->contents[b];
-    array->contents[b] = tmp;
-}
-
-int DArray_fucked_heapsort_sift_down(DArray *array, DArray_compare cmp,
-                              int start, int end)
-{
-
-    int root = start;
-    int child = 0;
-    int swap = 0;
-
-    while (DArray_fucked_heapsort_ileft_child(root) <= end) {
-        child = DArray_fucked_heapsort_ileft_child(root);
-        swap = root;
-
-        if (cmp(&array->contents[root], &array->contents[child]) < 0) {
-            swap = child;
-        }
-        if (((child + 1) <= end)
-            && (cmp(&array->contents[swap], &array->contents[child + 1]) < 0)) {
-            swap = child + 1;
-        }
-        if (swap == root) {
-            break;
-        }
-
-        DArray_fucked_heapsort_swap(array, root, swap);
-        root = swap;
-    }
-
-    return 0;
-}
-
-int DArray_fucked_heapsort_heapify(DArray *array, DArray_compare cmp)
-{
-    int count = DArray_count(array);
-    int start = (int) DArray_fucked_heapsort_iparent(count - 1);
-    int rc = 0;
-
-
-    while (start >= 0) {
-        rc = DArray_fucked_heapsort_sift_down(array, cmp, start, count - 1);
-        check(rc == 0, "Error sifting down at %d %d", start, count - 1);
-
-        start = start - 1;
-    }
-
-    return 0;
- error:
-    return -1;
-}
-
-int DArray_fucked_heapsort(DArray *array, DArray_compare cmp)
-{
-    int rc = 0, end = 0;
-
-    // First heapify array.
-    rc = DArray_fucked_heapsort_heapify(array, cmp);
-    check(rc == 0, "Error heapifying");
-
-    end = DArray_count(array) - 1;
-    while (end > 0) {
-        DArray_fucked_heapsort_swap(array, end, 0);
-
-        end = end - 1;
-        rc = DArray_fucked_heapsort_sift_down(array, cmp, 0, end);
-        check(rc == 0, "Error sifting down at %d %d", 0, end);
-    }
-
-    return 0;
- error:
-    return -1;
-}
-
-// Fucked Merge Sort.
-void DArray_fucked_topdown_merge(DArray *a, DArray *b,
-                                int begin, int middle,
-                                int end, DArray_compare cmp)
-{
-    int i = 0, j = 0, k = 0;
-
-    i = begin;
-    j = middle;
-
-    for (k = begin; k < end; k++) {
-        if (i < middle &&
-            (j >= end || cmp(&a->contents[i], &a->contents[j]) < 0)) {
-            DArray_set(b, k, DArray_get(a, i));
-            i = i + 1;
-        } else {
-            DArray_set(b, k, DArray_get(a, j));
-            j = j + 1;
-        }
-    }
-
-    return;
-}
-
-void DArray_fucked_topdown_split_merge(DArray *b, DArray *a,
-                                      int begin, int end,
-                                      DArray_compare cmp)
-{
-    if ((end - begin) < 2) {
-        return;
-    }
-    int middle = (end + begin) / 2;
-
-    DArray_fucked_topdown_split_merge(a, b, begin, middle, cmp);
-    DArray_fucked_topdown_split_merge(a, b, middle, end, cmp);
-
-    DArray_fucked_topdown_merge(b, a, begin, middle, end, cmp);
-
-    return;
-}
-
-int DArray_fucked_mergesort(DArray *array, DArray_compare cmp)
-{
-    DArray *copy = DArray_shallow_copy(array);
-    check(copy != NULL, "Error shallow copying array");
-
-    DArray *a = NULL, *b = NULL;
-    int begin = 0, end = 0;
-
-    a = array;
-    b = copy;
-    begin  = 0;
-    end = DArray_end(a);
-    DArray_fucked_topdown_split_merge(b, a, begin, end, cmp);
-
-    // Clean up copy
-    DArray_destroy(copy);
-
-    return 0;
- error:
-    return -1;
-}
diff --git a/nserver/src/darray_algos.h b/nserver/src/darray_algos.h
deleted file mode 100644
index 9be314f..0000000
--- a/nserver/src/darray_algos.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2010, Zed A. Shaw.
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#ifndef darray_algos_h
-#define darray_algos_h
-
-#include <math.h>
-#include <stdlib.h>
-#include <darray.h>
-
-int DArray_qsort(DArray *array, DArray_compare cmp);
-
-int DArray_heapsort(DArray *array, DArray_compare cmp);
-
-int DArray_mergesort(DArray *array, DArray_compare cmp);
-
-int DArray_fucked_qsort(DArray *array, DArray_compare cmp);
-
-int DArray_fucked_heapsort(DArray *array, DArray_compare cmp);
-
-int DArray_fucked_mergesort(DArray *array, DArray_compare cmp);
-
-#endif
diff --git a/nserver/src/db.c b/nserver/src/db.c
deleted file mode 100644
index a0443c9..0000000
--- a/nserver/src/db.c
+++ /dev/null
@@ -1,138 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#include <db.h>
-
-static const char *DB_FILE = "nserver.db";
-
-datum *mk_datum(char *data)
-{
-    datum *d = NULL;
-
-    check(data != NULL, "data invalid");
-
-    d = calloc(1, sizeof(datum));
-    check(d != NULL, "datum mem alloc failed");
-
-    d->dptr = data;
-    d->dsize = strlen(data);
-
-    return d;
- error:
-    if (d) {
-        free(d);
-    }
-    return NULL;
-}
-
-GDBM_FILE db_open(int flags)
-{
-   return gdbm_open(DB_FILE, 0,flags, S_IRUSR|S_IWUSR, NULL);
-}
-
-int db_init()
-{
-    // Create DB if it's not already created.
-    GDBM_FILE  gf = db_open(GDBM_WRCREAT);
-    check(gf != NULL, "unable to init db");
-
-    // Close the DB.
-    int rc = gdbm_close(gf);
-    check(rc == 0,  "error closing db after init");
-
-    return 0;
- error:
-    return -1;
-}
-
-int db_store(char *key, char *value)
-{
-    datum *k_datum = NULL, *v_datum = NULL;
-    GDBM_FILE gf = NULL;
-
-    check(key != NULL && strlen(key) > 0, "key invalid");
-    check(value != NULL && strlen(value) > 0, "data invalid");
-
-    // make key value datum
-    k_datum = mk_datum(key);
-    check(k_datum != NULL, "key datum init failed");
-
-    v_datum = mk_datum(value);
-    check(v_datum != NULL, "value datum init failed");
-
-    // init db.
-    int rc = db_init();
-    check(rc == 0, "db init failed");
-
-    // open the gdbm data in write mode
-    gf = db_open(GDBM_WRITER|GDBM_SYNC);
-    check(gf != NULL, "unable to open db in write  mode");
-
-    // write key -> data to db.
-    rc = gdbm_store(gf, *k_datum, *v_datum, GDBM_REPLACE);
-    check(rc == 0, "gdbm store failed");
-
-    // close db
-    rc = gdbm_close(gf);
-    check(rc == 0, "gdbm close failed");
-
-    // cleanup.
-    free(k_datum);
-    free(v_datum);
-
-    return 0;
- error:
-    if (k_datum) {
-        free(k_datum);
-    }
-    if (v_datum)  {
-        free(v_datum);
-    }
-    if (gf) {
-        gdbm_close(gf);
-    }
-    return -1;
-}
-
-char *db_load(char *key)
-{
-    datum *k_datum = NULL;
-    GDBM_FILE gf = NULL;
-
-    check(key != NULL && strlen(key) > 0, "key invalid");
-
-    // make key datum
-    k_datum = mk_datum(key);
-    check(k_datum != NULL, "key datum init failed");
-
-    // init db.
-    int rc = db_init();
-    check(rc == 0, "db init failed");
-
-    // open the gdbm data in read mode
-    gf = db_open(GDBM_READER|GDBM_SYNC);
-    check(gf != NULL, "unable to open db in read  mode");
-
-    // try to fetch value for key.
-    datum v_datum = gdbm_fetch(gf, *k_datum);
-    check(v_datum.dptr != NULL, "key not found");
-
-    // close db
-    rc = gdbm_close(gf);
-    check(rc == 0, "gdbm close failed");
-
-    // clean up.
-    free(k_datum);
-
-    return v_datum.dptr;
- error:
-    if (k_datum) {
-        free(k_datum);
-    }
-    if (gf) {
-        gdbm_close(gf);
-    }
-    return NULL;
-}
diff --git a/nserver/src/db.h b/nserver/src/db.h
deleted file mode 100644
index 8470e6f..0000000
--- a/nserver/src/db.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#ifndef _db_h
-#define _db_h
-
-#include <gdbm.h>
-#include <dbg.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-
-int db_init();
-int db_store(char *key, char *value);
-char *db_load(char *key);
-
-#endif
-
diff --git a/nserver/src/dbg.h b/nserver/src/dbg.h
deleted file mode 100644
index 1018a4d..0000000
--- a/nserver/src/dbg.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2010, Zed A. Shaw.
- */
-
-#ifndef __dbg_h__
-#define __dbg_h__
-
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-
-#ifdef NDEBUG
-#define debug(M, ...)
-#else
-#define debug(M, ...) fprintf(stderr, "DEBUG %s:%s:%d: " M "\n", \
-                              __FILE__, __FUNCTION__, __LINE__, \
-                              ##__VA_ARGS__)
-#endif
-
-#define clean_errno() (errno == 0 ? "None" : strerror(errno))
-
-#define log_err(M, ...) fprintf(stderr, \
-        "[ERROR] (%s:%s:%d: errno: %s) " M "\n", __FILE__, \
-                                __FUNCTION__, __LINE__, \
-                                clean_errno(), ##__VA_ARGS__)
-
-#define log_warn(M, ...) fprintf(stderr, \
-        "[WARN] (%s:%s:%d: errno: %s) " M "\n", \
-                                 __FILE__, __FUNCTION__, __LINE__, \
-                                 clean_errno(), ##__VA_ARGS__)
-
-#define log_info(M, ...) fprintf(stderr, "[INFO] (%s:%s:%d) " M "\n", \
-                                 __FILE__, __FUNCTION__, __LINE__, \
-                                 ##__VA_ARGS__)
-
-#define check(A, M, ...) if(!(A)) {\
-        log_err(M, ##__VA_ARGS__); errno=0; goto error; }
-
-#define sentinel(M, ...) { log_err(M, ##__VA_ARGS__);\
-        errno=0; goto error; }
-
-#define check_mem(A) check((A), "Out of memory.")
-
-#define check_debug(A, M, ...) if(!(A)) { debug(M, ##__VA_ARGS__);\
-        errno=0; goto error; }
-
-#endif
diff --git a/nserver/src/hashmap.c b/nserver/src/hashmap.c
deleted file mode 100644
index b42c48e..0000000
--- a/nserver/src/hashmap.c
+++ /dev/null
@@ -1,341 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2010, Zed A. Shaw.
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#undef NDEBUG
-#include <stdint.h>
-#include <darray_algos.h>
-#include <hashmap.h>
-#include <dbg.h>
-#include <bstrlib.h>
-
-static int default_compare(void *a, void *b)
-{
-    return bstrcmp((bstring) a, (bstring) b);
-}
-
-/**
- * Simple Bob Jenkin's hash algorithm taken from the wikipedia
- * description.
- */
-static uint32_t default_hash(void *a)
-{
-    size_t len = blength((bstring) a);
-    char *key = bdata((bstring) a);
-    uint32_t hash = 0;
-    uint32_t i = 0;
-
-    for (hash = i = 0; i < len; ++i) {
-        hash += key[i];
-        hash += (hash << 10);
-        hash ^= (hash >> 6);
-    }
-
-    hash += (hash << 3);
-    hash ^= (hash >> 11);
-    hash += (hash << 15);
-
-    return hash;
-}
-
-/**
- * Fucked up version of FNV hash
- */
-uint32_t fnv_hash(void *a)
-{
-    size_t len = blength((bstring) a);
-    char *key = bdata((bstring) a);
-    uint32_t hash =  0;
-    uint32_t i =  0;
-    uint32_t fnv_prime = 16777619;
-    uint32_t fnv_offset_basis = 2166136261;
-
-    hash = fnv_offset_basis;
-    for (i = 0; i < len; ++i) {
-        hash *= fnv_prime;
-        hash ^= key[i];
-    }
-
-    return hash;
-}
-
-Hashmap *Hashmap_create(Hashmap_compare compare, Hashmap_hash hash)
-{
-    Hashmap *map = calloc(1, sizeof(Hashmap));
-    check_mem(map);
-
-    map->compare = compare == NULL ? default_compare : compare;
-    map->hash = hash == NULL ? default_hash : hash;
-    map->salt = rand() >> 16;
-    map->buckets = DArray_create(
-                                 sizeof(DArray *), DEFAULT_NUMBER_OF_BUCKETS);
-    map->buckets->end = map->buckets->max; // fake out expanding it.
-    check_mem(map->buckets);
-
-    return map;
-
- error:
-    if (map) {
-        Hashmap_destroy(map);
-    }
-
-    return NULL;
-}
-
-void Hashmap_destroy(Hashmap *map)
-{
-    int i = 0;
-    int j = 0;
-
-    if (map) {
-        if (map->buckets) {
-            for (i = 0; i < DArray_count(map->buckets); i++) {
-                DArray *bucket = DArray_get(map->buckets, i);
-                if (bucket) {
-                    for (j = 0; j < DArray_count(bucket); j++) {
-                        free(DArray_get(bucket, j));
-                    }
-                    DArray_destroy(bucket);
-                }
-            }
-            DArray_destroy(map->buckets);
-        }
-
-        free(map);
-    }
-}
-
-static inline HashmapNode *Hashmap_node_create(int hash, void *key,
-                                               void *data)
-{
-    HashmapNode *node = calloc(1, sizeof(HashmapNode));
-    check_mem(node);
-
-    node->key = key;
-    node->data = data;
-    node->hash = hash;
-
-    return node;
-
- error:
-    return NULL;
-}
-
-static inline DArray *Hashmap_find_bucket(Hashmap *map, void *key,
-                                          int create,
-                                          uint32_t *hash_out)
-{
-    uint32_t hash = map->hash(key) + map->salt;
-    int bucket_n = hash % DEFAULT_NUMBER_OF_BUCKETS;
-    check(bucket_n >= 0, "Invalid bucket found %d", bucket_n);
-    // store it for the return so the caller can use it
-    *hash_out = hash;
-
-    DArray *bucket = DArray_get(map->buckets, bucket_n);
-
-    if (!bucket && create) {
-        // new bucket, set it up
-        bucket = DArray_create(
-                               sizeof(void *), DEFAULT_NUMBER_OF_BUCKETS);
-        check_mem(bucket);
-        DArray_set(map->buckets, bucket_n, bucket);
-    }
-
-    return bucket;
-
- error:
-    return NULL;
-}
-
-int Hashmap_delete_bucket(Hashmap *map, uint32_t hash)
-{
-    int bucket_n = hash % DEFAULT_NUMBER_OF_BUCKETS;
-    check(bucket_n >= 0, "Invalid bucket found %d", bucket_n);
-
-    // Get bucket.
-    DArray *bucket = DArray_get(map->buckets, bucket_n);
-    if(bucket) {
-        // Remove bucket.
-        DArray_clear_destroy(bucket);
-        DArray_remove(map->buckets, bucket_n);
-    }
-
-    return 0;
- error:
-    return -1;
-}
-
-int Hashmap_set(Hashmap *map, void *key, void *data)
-{
-    uint32_t hash = 0;
-    DArray *bucket = Hashmap_find_bucket(map, key, 1, &hash);
-    check(bucket, "Error can't create bucket");
-
-    HashmapNode *node = Hashmap_node_create(hash, key, data);
-    check_mem(node);
-
-    DArray_push(bucket, node);
-
-    // Sort the bucket.
-    int rc = DArray_heapsort(bucket, (DArray_compare) map->compare);
-    check(rc == 0, "Error sorting bucket");
-
-    return 0;
-
- error:
-    return -1;
-}
-
-static inline int Hashmap_get_node(Hashmap *map, uint32_t hash,
-                                   DArray *bucket, void *key)
-{
-    int i = 0;
-
-    for (i = 0; i < DArray_end(bucket); i++) {
-        debug("TRY: %d", i);
-        HashmapNode *node = DArray_get(bucket, i);
-        if (node->hash == hash && map->compare(node->key, key) == 0) {
-            return i;
-        }
-    }
-
-    return -1;
-}
-
-void *Hashmap_get(Hashmap *map, void *key)
-{
-    uint32_t hash = 0;
-    DArray *bucket = Hashmap_find_bucket(map, key, 0, &hash);
-    if (!bucket) return NULL;
-
-    int i = Hashmap_get_node(map, hash, bucket, key);
-    if (i == -1) return NULL;
-
-    HashmapNode *node = DArray_get(bucket, i);
-    check(node != NULL,
-          "Failed to get node from bucket when it should exist.");
-
-    return node->data;
-
- error:
-    return NULL;
-}
-
-/**
- * Sets key <-> data iff key is not already present in Hashmap.
- */
-int Hashmap_set_fucked(Hashmap *map, void *key, void *data)
-{
-    uint32_t hash = 0;
-    DArray *bucket = Hashmap_find_bucket(map, key, 1, &hash);
-    check(bucket, "Error can't create bucket");
-
-    int i = Hashmap_get_node(map, hash, bucket, key);
-    if (i >= 0) {
-        // Element with `key` already exists. Do nothing.
-        return 0;
-    }
-
-    // Element with `key` does not exist. Add it to Hashmap.
-    HashmapNode *node = Hashmap_node_create(hash, key, data);
-    check_mem(node);
-
-    DArray_push(bucket, node);
-
-    // Sort the bucket.
-    int rc = DArray_heapsort(bucket, (DArray_compare) map->compare);
-    check(rc == 0, "Error sorting bucket");
-
-    return 1;
- error:
-    return -1;
-}
-
-int Hashmap_traverse(Hashmap *map, Hashmap_traverse_cb traverse_cb)
-{
-    int i = 0;
-    int j = 0;
-    int rc = 0;
-
-    for (i = 0; i < DArray_count(map->buckets); i++) {
-        DArray *bucket = DArray_get(map->buckets, i);
-        if (bucket) {
-            for (j = 0; j < DArray_count(bucket); j++) {
-                HashmapNode *node = DArray_get(bucket, j);
-                rc = traverse_cb(node);
-                if (rc != 0)
-                    return rc;
-            }
-        }
-    }
-
-    return 0;
-}
-
-/**
- * Returns all keys of the hashmap as a DArray.
- *
- * Use DArray_destroy on the 'keys' returned by this function after
- * use.
- */
-DArray *Hashmap_keys(Hashmap *map)
-{
-    check(map != NULL, "map is NULL");
-
-    DArray *keys = DArray_create(sizeof(void *),
-                                 DEFAULT_NUMBER_OF_KEYS);
-    check(keys != NULL, "Unable to initialize keys");
-
-    int i = 0;
-    int j = 0;
-
-    for (i = 0; i < DArray_count(map->buckets); i++) {
-        DArray *bucket = DArray_get(map->buckets, i);
-        if (bucket) {
-            for (j = 0; j < DArray_count(bucket); j++) {
-                HashmapNode *node = DArray_get(bucket, j);
-
-                if (node) {
-                    DArray_push(keys, node->key);
-                }
-            }
-        }
-    }
-
-    return keys;
- error:
-    return NULL;
-}
-
-void *Hashmap_delete(Hashmap *map, void *key)
-{
-    uint32_t hash = 0;
-    DArray *bucket = Hashmap_find_bucket(map, key, 0, &hash);
-    if (!bucket)
-        return NULL;
-
-    int i = Hashmap_get_node(map, hash, bucket, key);
-    if (i == -1)
-        return NULL;
-
-    HashmapNode *node = DArray_get(bucket, i);
-    void *data = node->data;
-    free(node);
-
-    HashmapNode *ending = DArray_pop(bucket);
-
-    if (ending != node) {
-        // alright looks like it's not the last one, swap it.
-        DArray_set(bucket, i, ending);
-    } else {
-        // alright looks like it's the last one, destroy bucket.
-        check(Hashmap_delete_bucket(map, hash) == 0,
-              "Error destroy bucket");
-    }
-
-    return data;
- error:
-    return NULL;
-}
diff --git a/nserver/src/hashmap.h b/nserver/src/hashmap.h
deleted file mode 100644
index 1c9cd3e..0000000
--- a/nserver/src/hashmap.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2010, Zed A. Shaw.
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#ifndef _lcthw_Hashmap_h
-#define _lcthw_Hashmap_h
-
-#include <stdint.h>
-#include <darray.h>
-
-#define DEFAULT_NUMBER_OF_BUCKETS 100
-#define DEFAULT_NUMBER_OF_KEYS 50
-
-typedef int (*Hashmap_compare) (void *a, void *b);
-typedef uint32_t(*Hashmap_hash) (void *key);
-
-typedef struct Hashmap {
-    DArray *buckets;
-    Hashmap_compare compare;
-    Hashmap_hash hash;
-    int salt;
-} Hashmap;
-
-
-typedef struct HashmapNode {
-    void *key;
-    void *data;
-    uint32_t hash;
-} HashmapNode;
-
-typedef int (*Hashmap_traverse_cb) (HashmapNode *node);
-
-Hashmap *Hashmap_create(Hashmap_compare, Hashmap_hash);
-void Hashmap_destroy(Hashmap *map);
-
-int Hashmap_set(Hashmap *map, void *key, void *data);
-int Hashmap_set_fucked(Hashmap *map, void *key, void *data);
-void *Hashmap_get(Hashmap *map, void *key);
-
-int Hashmap_traverse(Hashmap *map, Hashmap_traverse_cb travers_cb);
-
-void *Hashmap_delete(Hashmap *map, void *key);
-
-DArray *Hashmap_keys(Hashmap *map);
-
-uint32_t fnv_hash(void *a);
-#endif
diff --git a/nserver/src/ncmd.c b/nserver/src/ncmd.c
deleted file mode 100644
index e1393a3..0000000
--- a/nserver/src/ncmd.c
+++ /dev/null
@@ -1,351 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#include <ncmd.h>
-
-int sanitize(char *cmd)
-{
-    check(cmd != NULL, "cmd is NULL");
-
-    int len = strlen(cmd);
-    check(len > 0, "cmd empty");
-
-    // replace newline character with NUL.
-    for (int i = 0; i < len; i++) {
-        if (cmd[i] == '\n') {
-            cmd[i] = '\0';
-
-            break;
-        }
-    }
-    return 0;
- error:
-    return -1;
-}
-
-int check_cmd(char *cmd, char *err)
-{
-    check_mem(err);
-    check(cmd != NULL, "cmd is NULL");
-
-    int rc = sanitize(cmd);
-    check(rc != -1, "sanitize failed");
-
-    size_t len = strlen(cmd);
-    if (len >= CMD_MIN_SIZE && len <= CMD_MAX_SIZE) {
-        return 0;
-    }
-
-    if (len == 0) {
-        strncpy(err, "closing connection\n", RSP_SIZE);
-        return -1;
-    } else {
-        strncpy(err, "command size invalid\n", RSP_SIZE);
-        return -1;
-    }
-
-    return 0;
- error:
-    strncpy(err, "internal error\n", RSP_SIZE);
-    return -1;
-}
-
-
-struct bstrList *cmd_parts(char *cmd)
-{
-    bstring bcmd = NULL;
-    struct bstrList *parts_tmp = NULL;
-
-    bcmd = bfromcstr(cmd);
-    check(bcmd != NULL, "bstring creation failed");
-
-    parts_tmp = bsplit(bcmd, ' ');
-    check(parts_tmp != NULL, "cmp split failed");
-    check(parts_tmp->qty > 0, "qty check failed");
-
-    struct bstrList *parts = bstrListCreate();
-    check(parts != NULL, "parts create failed");
-
-    int rc = bstrListAlloc(parts, parts_tmp->qty);
-    check(rc == BSTR_OK, "parts alloc failed");
-    check(parts->qty == 0, "qty check failed");
-
-    bstring part = NULL;
-    int index = 0;
-    for (int i = 0; i < parts_tmp->qty; i++) {
-        check(parts->qty <= parts->mlen, "parts capacity check failed");
-
-        part  = parts_tmp->entry[i];
-
-        if (blength(part) == 0) {
-            continue;
-        }
-
-        parts->entry[index++] = bstrcpy(part);
-        parts->qty++;
-    }
-
-    // Clean up.
-    bdestroy(bcmd);
-    bstrListDestroy(parts_tmp);
-
-    return parts;
- error:
-    // Clean up.
-    if (bcmd) {
-        bdestroy(bcmd);
-    }
-    if (parts_tmp) {
-        bstrListDestroy(parts_tmp);
-    }
-
-    return NULL;
-}
-
-int find_function(struct bstrList *cmd_parts)
-{
-    // functions.
-    struct tagbstring fcreate = bsStatic("/create");
-    struct tagbstring fsample = bsStatic("/sample");
-    struct tagbstring fmean = bsStatic("/mean");
-    struct tagbstring fdump = bsStatic("/dump");
-    struct tagbstring fdelete = bsStatic("/delete");
-    struct tagbstring flist = bsStatic("/list");
-    struct tagbstring fstore = bsStatic("/store");
-    struct tagbstring fload = bsStatic("/load");
-
-    check(cmd_parts != NULL, "cmd_parts is NULL");
-    check(cmd_parts->qty > 0, "qty check failed");
-
-    bstring cmd_name = cmd_parts->entry[0];
-    check(blength(cmd_name) > 0, "cmd_name check failed");
-
-    // trim cmd name
-    int rc = btrimws(cmd_name);
-    check(rc == BSTR_OK, "cmd name trim failed");
-
-    // find function for cmd_name
-    if (bstricmp(cmd_name, &fcreate) == 0) {
-        return NS_CREATE;
-    } else if (bstricmp(cmd_name, &fsample) == 0) {
-        return NS_SAMPLE;
-    } else if (bstricmp(cmd_name, &fmean) == 0) {
-        return NS_MEAN;
-    } else if (bstricmp(cmd_name, &fdump) == 0) {
-        return NS_DUMP;
-    } else if (bstricmp(cmd_name, &fdelete) == 0) {
-        return NS_DELETE;
-    } else if (bstricmp(cmd_name, &flist) == 0) {
-        return NS_LIST;
-    } else if (bstricmp(cmd_name, &fstore) == 0) {
-        return NS_STORE;
-    } else if (bstricmp(cmd_name, &fload) == 0) {
-        return NS_LOAD;
-    } else {
-        return NS_NOP;
-    }
-
- error:
-    return NS_NOP;
-}
-
-int check_args(struct bstrList *cmd_parts, int argc)
-{
-    check(cmd_parts != NULL, "cmd_parts is NULL");
-    check(cmd_parts->qty == argc, "qty check failed");
-
-    bstring part = NULL;
-    for (int i = 0; i < argc; i++) {
-        part = cmd_parts->entry[i];
-
-        check(blength(part) > 0, "part %d empty", i);
-    }
-
-    return 0;
- error:
-    return -1;
-}
-
-int call_function(int func, struct bstrList *cmd_parts, char *out)
-{
-    check(out != NULL, "out invalid");
-
-    if (func < 0 || cmd_parts == NULL || cmd_parts->qty < 1) {
-        strncpy(out, "error: args invalid\n", RSP_SIZE);
-
-        return -1;
-    }
-
-    double mean = 0.0;
-    switch (func) {
-    case NS_CREATE:
-        if(check_args(cmd_parts, 2) != 0) {
-            strncpy(out, "error: command invalid\n", RSP_SIZE);
-
-            return -1;
-        }
-        if (sscreate(bdata(cmd_parts->entry[1])) < 0) {
-            strncpy(out, "error: create failed\n", RSP_SIZE);
-
-            return -1;
-        }
-        strncpy(out, "OK\n", RSP_SIZE);
-
-        break;
-    case NS_SAMPLE:
-        if(check_args(cmd_parts, 3) != 0) {
-            strncpy(out, "error: command invalid\n", RSP_SIZE);
-
-            return -1;
-        }
-
-        double sample = strtod(bdata(cmd_parts->entry[2]), NULL);
-        mean = sssample(bdata(cmd_parts->entry[1]), sample);
-        if (mean < 0) {
-            strncpy(out, "error: sample failed\n", RSP_SIZE);
-
-            return -1;
-        }
-        if (sprintf(out, "Mean: %.2f\n", mean) < 0) {
-            strncpy(out, "error: sample failed\n", RSP_SIZE);
-
-            return -1;
-        }
-        break;
-    case NS_MEAN:
-        if(check_args(cmd_parts, 2) != 0) {
-            strncpy(out, "error: command invalid\n", RSP_SIZE);
-
-            return -1;
-        }
-
-        mean = ssmean(bdata(cmd_parts->entry[1]));
-        if (mean < 0) {
-            strncpy(out, "error: mean failed\n", RSP_SIZE);
-
-            return -1;
-        }
-        if (sprintf(out, "Mean: %.2f\n", mean) < 0) {
-            strncpy(out, "error: mean failed\n", RSP_SIZE);
-
-            return -1;
-        }
-        break;
-    case NS_DUMP:
-        if(check_args(cmd_parts, 2) != 0) {
-            strncpy(out, "error: command invalid\n", RSP_SIZE);
-
-            return -1;
-        }
-
-        char *dump = ssdump(bdata(cmd_parts->entry[1]));
-        if (dump == NULL) {
-            strncpy(out, "error: dump failed\n", RSP_SIZE);
-
-            return -1;
-        }
-        strncpy(out, dump, RSP_SIZE);
-
-        // Clean up dump
-        free(dump);
-
-        break;
-    case NS_DELETE:
-        if(check_args(cmd_parts, 2) != 0) {
-            strncpy(out, "error: command invalid\n", RSP_SIZE);
-
-            return -1;
-        }
-
-        if (ssdelete(bdata(cmd_parts->entry[1])) != 0) {
-            strncpy(out, "error: delete failed\n", RSP_SIZE);
-
-            return -1;
-        }
-        strncpy(out, "OK\n", RSP_SIZE);
-
-        break;
-    case NS_LIST:
-        if(check_args(cmd_parts, 1) != 0) {
-            strncpy(out, "error: command invalid\n", RSP_SIZE);
-
-            return -1;
-        }
-
-        char *list = sslist();
-        if (list == NULL) {
-            strncpy(out, "error: list failed\n", RSP_SIZE);
-
-            return -1;
-        }
-        strncpy(out, list, RSP_SIZE);
-
-        // Clean up list.
-        free(list);
-
-        break;
-    case NS_STORE:
-        if(check_args(cmd_parts, 2) != 0) {
-            strncpy(out, "error: command invalid\n", RSP_SIZE);
-
-            return -1;
-        }
-        if (ssstore(bdata(cmd_parts->entry[1])) < 0) {
-            strncpy(out, "error: store failed\n", RSP_SIZE);
-
-            return -1;
-        }
-        strncpy(out, "OK\n", RSP_SIZE);
-        break;
-    case NS_LOAD:
-        if(check_args(cmd_parts, 3) != 0) {
-            strncpy(out, "error: command invalid\n", RSP_SIZE);
-
-            return -1;
-        }
-        if (ssload(bdata(cmd_parts->entry[1]),
-                   bdata(cmd_parts->entry[2])) < 0) {
-            strncpy(out, "error: load failed\n", RSP_SIZE);
-
-            return -1;
-        }
-        strncpy(out, "OK\n", RSP_SIZE);
-        break;
-    default:
-        strncpy(out, "error: function not found\n", RSP_SIZE);
-
-        return -1;
-    }
-
-    return 0;
- error:
-    return -1;
-}
-
-int process(char *cmd, char *out)
-{
-    check(out, "out invalid");
-
-    int rc = check_cmd(cmd, out);
-    check(rc == 0, "cmd check failed");
-
-    // split cmd into parts.
-    struct bstrList *parts = cmd_parts(cmd);
-    check(parts != NULL, "cmd_parts failed");
-    check(parts->qty > 0, "bstrList qty check failed");
-
-    // call find_function.
-    int FUNC = find_function(parts);
-    check(FUNC != -1, "find function failed");
-
-    // call call_function
-    rc = call_function(FUNC, parts, out);
-    check(rc != -1, "call function failed");
-
-    return 0;
- error:
-    return -1;
-}
-
diff --git a/nserver/src/ncmd.h b/nserver/src/ncmd.h
deleted file mode 100644
index 025a06f..0000000
--- a/nserver/src/ncmd.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#ifndef _ncmd_h
-#define _ncmd_h
-
-#include <string.h>
-
-#include <bstrlib.h>
-#include <dbg.h>
-#include <protocol.h>
-
-#define CMD_MIN_SIZE 5
-#define CMD_MAX_SIZE 120
-#define RSP_SIZE 200
-
-enum FUNCTIONS {
-                NS_CREATE,
-                NS_SAMPLE,
-                NS_MEAN,
-                NS_DUMP,
-                NS_DELETE,
-                NS_LIST,
-                NS_STORE,
-                NS_LOAD,
-                NS_NOP = -1
-};
-
-int sanitize(char *cmd);
-int check_cmd(char *cmd, char *err);
-
-struct bstrList *cmd_parts(char *cmd);
-
-int find_function(struct bstrList *cmd_parts);
-int call_function(int func, struct bstrList *cmd_parts, char *out);
-
-int process(char *cmd, char *out);
-
-#endif
diff --git a/nserver/src/nserve.c b/nserver/src/nserve.c
deleted file mode 100644
index 75457af..0000000
--- a/nserver/src/nserve.c
+++ /dev/null
@@ -1,78 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#include <nserve.h>
-
-int slurpsock(char *buf, size_t buf_sz, int sock)
-{
-    ssize_t bytes;
-
-    bytes = recv(sock, buf, buf_sz, 0);
-    check(bytes >= 0, "Failed to read from socket: %d", sock);
-
-    return bytes;
-
- error:
-    return -1;
-}
-
-int barfsock(char *buf, size_t buf_sz, int sock)
-{
-    ssize_t bytes = 0;
-
-    bytes = send(sock, buf, buf_sz, 0);
-    check(bytes >= 0, "barfsock: send failed");
-
-    return bytes;
- error:
-    return -1;
-}
-
-void nserve(int sock)
-{
-    char *out = (char *) calloc(RSP_SIZE + 1, sizeof(char));
-    check_mem(out);
-
-    char *cmd = (char *) calloc(CMD_MAX_SIZE  + 1, sizeof(char));
-    check_mem(cmd);
-
-    int rc = 0, done = 0;
-    do {
-        // clear out, cmd.
-        memset(out, '\0', RSP_SIZE + 1);
-        memset(cmd, '\0', CMD_MAX_SIZE + 1);
-
-        // Read command from socket.
-        ssize_t bytes = slurpsock(cmd, CMD_MAX_SIZE, sock);
-        check(bytes >= 0, "nserve: slurpsock failed");
-
-        rc = process(cmd, out);
-        if (rc < 0) {
-            done = 1;
-        }
-
-        // Write response to socket.
-        rc = barfsock(out, strlen(out), sock);
-        check(rc != -1, "nserve: echo failed");
-    } while(done != 1);
-
-    // Close socket.
-    rc = close(sock);
-    check(rc == 0, "nserve: close failed");
-
-    // Cleanup.
-    free(cmd);
-
-    exit(0);
- error:
-    rc = close(sock);
-    check(rc == 0, "nserve: close failed");
-
-    // Cleanup if needed.
-    if (cmd)
-        free(cmd);
-
-    exit(1);
-}
diff --git a/nserver/src/nserve.h b/nserver/src/nserve.h
deleted file mode 100644
index b0565ef..0000000
--- a/nserver/src/nserve.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#ifndef _nserve_h
-#define _nserve_h
-
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <sys/socket.h>
-
-#include <bstrlib.h>
-#include <ncmd.h>
-#include <dbg.h>
-
-void nserve(int sock);
-
-#endif
diff --git a/nserver/src/nsocket.c b/nserver/src/nsocket.c
deleted file mode 100644
index c4d4525..0000000
--- a/nserver/src/nsocket.c
+++ /dev/null
@@ -1,61 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#include <nsocket.h>
-
-int get_socket()
-{
-    int sockfd = 0;
-    int rc = 0;
-    int y = 1;
-
-    struct addrinfo hints;
-    struct addrinfo *servinfo = NULL;
-    struct addrinfo *addr =  NULL;
-
-    memset(&hints, 0, sizeof(hints));
-    hints.ai_family = AF_UNSPEC;
-    hints.ai_socktype = SOCK_STREAM;
-    hints.ai_flags = AI_PASSIVE;
-
-    rc = getaddrinfo(NULL, PORT, &hints, &servinfo);
-    check(rc == 0, "get_socket: getaddrinfo failed");
-
-    // Loop through the addresses and find one that works.
-    for (addr = servinfo;  addr != NULL; sockfd = 0,
-             addr = addr->ai_next)  {
-        sockfd = socket(addr->ai_family, addr->ai_socktype,
-                          addr->ai_protocol);
-        if (sockfd < 1) {
-            continue;
-        }
-
-        // dodge the "address already in use" error.
-        rc = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
-                        &y, sizeof(int));
-        if (rc != 0) {
-            continue;
-        }
-
-        // assign name to socket.
-        rc = bind(sockfd, addr->ai_addr, addr->ai_addrlen);
-        if (rc != 0) {
-            continue;
-        }
-
-        break;
-    }
-    check(sockfd > 0, "unable to get socket");
-
-    // Cleanup.
-    freeaddrinfo(servinfo);
-
-    return sockfd;
- error:
-    if (servinfo)
-        freeaddrinfo(servinfo);
-
-    return -1;
-}
diff --git a/nserver/src/nsocket.h b/nserver/src/nsocket.h
deleted file mode 100644
index 17cea75..0000000
--- a/nserver/src/nsocket.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#ifndef _nsocket_h
-#define _nsocket_h
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
-
-#include <dbg.h>
-
-#define PORT "7899"
-
-int get_socket();
-
-#endif
diff --git a/nserver/src/protocol.c b/nserver/src/protocol.c
deleted file mode 100644
index 77b806a..0000000
--- a/nserver/src/protocol.c
+++ /dev/null
@@ -1,310 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#include <protocol.h>
-
-static TSTree *tst;
-
-int sscreate(char *key)
-{
-    check(key != NULL || strlen(key) < 1, "key invalid");
-
-    // 1. Check if key is already in the tree.
-    Record *rec = (Record *) TSTree_search(tst, key, strlen(key));
-
-    // If it's already there; there's nothing to do.
-    if (rec != NULL && rec->deleted == 0) {
-        return 1;
-    }
-    // If it's already there and deleted, undelete it.
-    if (rec != NULL && rec->deleted == 1) {
-        rec->deleted = 0;
-
-        // Allocate fresh Stats.
-        rec->st = Stats_create();
-        check(rec->st != NULL, "stats creation failed");
-
-        return 2;
-    }
-
-    // 2. Create bstring from 'key'.
-    bstring k = bfromcstr(key);
-    check(k != NULL, "key creation failed");
-
-    // 3. Allocate fresh Stats.
-    Stats *st = Stats_create();
-    check(st != NULL, "stats creation failed");
-
-    // 4. Create Record.
-    rec = (Record *) calloc(1, sizeof(Record));
-    check_mem(rec);
-
-    // 5. Initialize Record.
-    rec->key = k;
-    rec->st = st;
-    rec->deleted = 0;
-
-    // 6. Add Record to tree.
-    tst = TSTree_insert(tst, key, strlen(key), rec);
-    check(tst != NULL, "tstree insert failed");
-
-    return 0;
- error:
-    return -1;
-}
-
-int ssdelete(char *key)
-{
-   check(key != NULL || strlen(key) < 1, "key invalid");
-   check(tst != NULL, "tstree not initialized");
-
-   Record *rec = (Record *) TSTree_search(tst, key, strlen(key));
-   if (rec == NULL) {
-       // key does not exists.
-       return 0;
-   }
-
-   // Mark as deleted.
-   rec->deleted = 1;
-
-   // Free Stats.
-   free(rec->st);
-
-   return 0;
- error:
-   return -1;
-}
-
-int sssample_parent(char *key, double s)
-{
-    check(key != NULL || strlen(key) < 1, "key invalid");
-    check(tst != NULL, "tstree not initialized");
-
-    // 1. Try to get Record with key prefix.
-    Record *rec = (Record *) TSTree_search_prefix(tst, key, strlen(key));
-
-    if (rec == NULL) {
-        // No record with key prefix.
-        return 0;
-    }
-    check(rec->st != NULL, "record's st invalid");
-
-    if (rec->deleted == 1) {
-        // Record was deleted; nop.
-        return 0;
-    }
-
-    // 2. Sample!
-    Stats_sample(rec->st, s);
-
-    return 1;
- error:
-    return -1;
-}
-
-double sssample(char *key, double s)
-{
-    check(key != NULL || strlen(key) < 1, "key invalid");
-    check(tst != NULL, "tstree not initialized");
-
-    // 1. Try to get Record for key.
-    Record *rec = (Record *) TSTree_search(tst, key, strlen(key));
-
-    check(rec != NULL, "record not found");
-    check(rec->st != NULL, "record's st invalid");
-    check(rec->deleted != 1, "record was deleted");
-
-    // 2. Sample!
-    Stats_sample(rec->st, s);
-
-    // 3. Sample parent!
-    int rc = sssample_parent(key, s);
-    check(rc >= 0, "sampling parent failed");
-
-    // 4. Get mean.
-    double m = Stats_mean(rec->st);
-
-    return m;
- error:
-    return -1;
-}
-
-double ssmean(char *key)
-{
-    check(key != NULL || strlen(key) < 1, "key invalid");
-    check(tst != NULL, "tstree not initialized");
-
-    // 1. Try to get Record for key.
-    Record *rec = (Record *) TSTree_search(tst, key, strlen(key));
-
-    check(rec != NULL, "record not found");
-    check(rec->deleted != 1, "record was deleted");
-    check(rec->st != NULL, "record's st invalid");
-
-    // 2. Get mean.
-    double m = Stats_mean(rec->st);
-
-    return m;
- error:
-    return -1;
-}
-
-char *ssdump(char *key)
-{
-    check(key != NULL && strlen(key) > 0, "key invalid");
-    check(tst != NULL, "tstree not initialized");
-
-    // 1. create bstring from 'key'.
-    Record *rec = (Record *) TSTree_search(tst, key, strlen(key));
-
-    check(rec != NULL, "record not found");
-    check(rec->st != NULL, "stats not found for key");
-    check(rec->deleted != 1, "record was deleted");
-
-    // 2. get dump.
-    char *dstr = Stats_dump(rec->st);
-    check(dstr != NULL, "dump failed for key");
-
-    return dstr;
- error:
-    return NULL;
-}
-
-// meant to be used by sslist.
-void traverse_tree(void *value, void *data)
-{
-    Record *rec  = (Record *) value;
-    bstring bstr = (bstring) data;
-
-    check(rec != NULL, "Record is NULL");
-    check(rec->deleted != 1, "Record was deleted");
-    check(bstr != NULL, "bstr is NULL");
-    check(rec->key != NULL, "Record's key is NULL");
-    check(blength(rec->key) > 0, "Record's key is an empty string");
-
-    int rc = bconcat(bstr, rec->key);
-    check(rc == BSTR_OK, "bstr key concat failed");
-
-    rc = bconchar(bstr, '\n');
-    check(rc == BSTR_OK, "bstr newline concat failed");
-
- error:
-    return;
-}
-
-
-char *sslist()
-{
-    char *list = NULL, *tmp = NULL;
-
-    if (tst == NULL) {
-        list = (char *) calloc(7 + 1, sizeof(char));
-        check_mem(list);
-
-        list = strncpy(list, "EMPTY\n\r", 7);
-
-        return list;
-    }
-
-    // 1. Create "accumulator" string.
-    bstring ks_str = bfromcstr("");
-    check(ks_str != NULL, "error creating keys_str");
-
-    // 2. Accumulate keys into "accumulator" string.
-    TSTree_traverse(tst, traverse_tree, ks_str);
-
-    // 3. Make result.
-    tmp = bstr2cstr(ks_str, ' ');
-
-    list = (char *) calloc(strlen(tmp) + 1, sizeof(char));
-    check_mem(list);
-
-    list = strncpy(list, tmp, strlen(tmp));
-
-    // 4. Clean up.
-    bcstrfree(tmp);
-
-    // 3. Return result.
-    return list;
- error:
-    if (tmp) {
-        bcstrfree(tmp);
-    }
-    return NULL;
-}
-
-int ssstore(char *key)
-{
-    check(key != NULL && strlen(key) > 0, "key invalid");
-    check(tst != NULL, "tstree not initialized");
-
-    // 1. create bstring from 'key'.
-    Record *rec = (Record *) TSTree_search(tst, key, strlen(key));
-
-    check(rec != NULL, "record not found");
-    check(rec->st != NULL, "stats not found for key");
-    check(rec->deleted != 1, "record was deleted");
-
-    // 2. stringify the stats.
-    char *st_str = Stats_stringify(rec->st);
-    check(st_str != NULL, "stats stringify failed");
-
-    // 3. store stats in db.
-    int rc = db_store(key, st_str);
-    check(rc == 0, "db store failed");
-
-    return 0;
- error:
-    return -1;
-}
-
-int ssload(char *from, char *to)
-{
-    check(from != NULL && strlen(from) > 0, "from invalid");
-    check(to != NULL && strlen(to) > 0, "to invalid");
-    check(tst != NULL, "tstree not initialized");
-
-    // 1. Check if 'to' key already exists.
-    Record *rec = (Record *) TSTree_search(tst, to, strlen(to));
-
-    // 2. if 'to' key exists return immediately with -2.
-    if (rec != NULL && rec->deleted == 0) {
-        return -2;
-    }
-
-    // 3. read 'from' key from database.
-    char *st_str = db_load(from);
-    check(st_str != NULL, "db load failed");
-
-    // 4. construct stats from string.
-    Stats *st = Stats_unstringify(st_str);
-    check(st != NULL, "stats unstringify failed");
-
-    // 5. create Record if needed.
-    int rec_created =  0;
-    if (rec == NULL)  {
-        rec = (Record *) calloc(1, sizeof(Record));
-        check_mem(rec);
-        rec_created = 1;
-    }
-
-    // 6. get things ready for insertiion
-    bstring tk = bfromcstr(to);
-    check(tk != NULL, "key creation failed");
-
-    rec->key = tk;
-    rec->st = st;
-    rec->deleted = 0;
-
-    // 7. insert Record into 'to' key in the TSTree if needed.
-    if (rec_created == 1) {
-        tst = TSTree_insert(tst, to, strlen(to), rec);
-        check(tst != NULL, "tstree insert failed");
-    }
-
-    return 0;
- error:
-    return -1;
-}
diff --git a/nserver/src/protocol.h b/nserver/src/protocol.h
deleted file mode 100644
index 4640975..0000000
--- a/nserver/src/protocol.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#ifndef _protocol_h
-#define _protocol_h
-
-
-#include <bstrlib.h>
-#include <darray.h>
-#include <db.h>
-#include <hashmap.h>
-#include <stats.h>
-#include <tstree.h>
-#include <dbg.h>
-
-typedef struct Record {
-    bstring key;
-    Stats *st;
-    int deleted;
-} Record;
-
-int sscreate(char *key);
-int ssdelete(char *key);
-double sssample(char *key, double s);
-double ssmean(char *key);
-char *ssdump(char *key);
-char *sslist();
-int ssstore(char *key);
-int ssload(char *from, char *to);
-
-
-#endif
diff --git a/nserver/src/stats.c b/nserver/src/stats.c
deleted file mode 100644
index 7e51c9e..0000000
--- a/nserver/src/stats.c
+++ /dev/null
@@ -1,128 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2010, Zed A. Shaw.
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#include <math.h>
-#include <stats.h>
-
-Stats *Stats_recreate(double sum, double sumsq, unsigned long n,
-                      double min, double max)
-{
-    Stats *st  = malloc(sizeof(Stats));
-    check_mem(st);
-
-    st->sum =  sum;
-    st->sumsq = sumsq;
-    st->n  = n;
-    st->min = min;
-    st->max = max;
-
-    return st;
-
- error:
-    return NULL;
-}
-
-Stats *Stats_create()
-{
-    return Stats_recreate(0.0, 0.0, 0L, 0.0, 0.0);
-}
-
-void Stats_sample(Stats *st, double s)
-{
-    st->sum  += s;
-    st->sumsq += s * s;
-
-    if (st->n == 0) {
-        st->min = s;
-        st->max = s;
-    } else {
-        if (st->min > s)
-            st->min = s;
-        if (st->max < s)
-            st->max = s;
-    }
-
-    st->n += 1;
-}
-
-char *Stats_dump(Stats *st)
-{
-    size_t char_sz = sizeof(char);
-    size_t dstr_len = 280 * char_sz;
-
-    // allocate space for dump string.
-    char *dstr = calloc(dstr_len, char_sz);
-    check_mem(dstr);
-
-    // dump into dump str.
-    int rc = snprintf(dstr, dstr_len,
-                      "sum: %f, sumsq: %f, n: %ld, "
-                      "min: %f, max: %f, mean: %f, stddev: %f\n",
-                      st->sum, st->sumsq, st->n, st->min, st->max,
-                      Stats_mean(st), Stats_stddev(st));
-    check(rc > 0, "stats dump failed");
-
-    return dstr;
- error:
-    return NULL;
-}
-
-char *Stats_stringify(Stats *st)
-{
-    size_t stats_str_len = 80;
-
-    // allocate space for stringified stats.
-    char *stats_str = calloc(stats_str_len, sizeof(char));
-    check_mem(stats_str);
-
-    // stringify the stats
-    int rc = snprintf(stats_str, stats_str_len,
-                      "%.2f:%.2f:%ld:%.2f:%.2f",
-                      st->sum, st->sumsq, st->n, st->min, st->max);
-    check(rc > 0, "stringify stats failed");
-
-    return stats_str;
- error:
-    if (stats_str) {
-        free(stats_str);
-    }
-    return NULL;
-}
-
-
-Stats *Stats_unstringify(char *st_str)
-{
-    Stats *st = NULL;
-
-    check(st_str != NULL, "st_str invalid");
-
-    bstring st_bstr = bfromcstr(st_str);
-    check(st_bstr != NULL, "st_str bstring convert failed");
-
-    struct bstrList *st_list = bsplit(st_bstr, ':');
-    check(st_list != NULL, "st_bstr split failed");
-    check(st_list->qty == 5, "wrong number of st parts");
-
-    st = Stats_create();
-    check(st != NULL, "stats creation failed");
-
-    st->sum = atof(bdata(st_list->entry[0]));
-    st->sumsq = atof(bdata(st_list->entry[1]));
-    st->n = atoi(bdata(st_list->entry[2]));
-    st->min = atof(bdata(st_list->entry[3]));
-    st->max = atof(bdata(st_list->entry[4]));
-
-    // clean up.
-    int rc = bstrListDestroy(st_list);
-    check(rc == BSTR_OK, "st_list destroy failed");
-
-    return st;
- error:
-    if (st) {
-        free(st);
-    }
-    return NULL;
-}
diff --git a/nserver/src/stats.h b/nserver/src/stats.h
deleted file mode 100644
index f9e5d7a..0000000
--- a/nserver/src/stats.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2010, Zed A. Shaw.
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#ifndef stats_h
-#define stats_h
-
-#include <math.h>
-#include <stdlib.h>
-#include <bstrlib.h>
-#include <dbg.h>
-
-typedef struct Stats {
-    double sum;
-    double sumsq;
-    unsigned long n;
-    double min;
-    double max;
-} Stats;
-
-Stats *Stats_recreate(double sum, double sumsq, unsigned long n,
-                      double min, double max);
-
-Stats *Stats_create();
-
-void Stats_sample(Stats *st, double s);
-
-char *Stats_dump(Stats *st);
-
-char *Stats_stringify(Stats *st);
-
-Stats *Stats_unstringify(char *st_str);
-
-static inline double Stats_mean(Stats *st)
-{
-    return st->sum / st->n;
-}
-
-static inline double Stats_stddev(Stats *st)
-{
-    return sqrt((st->sumsq - (st->sum * st->sum / st->n)) /
-                (st->n - 1));
-}
-
-#endif
diff --git a/nserver/src/tstree.c b/nserver/src/tstree.c
deleted file mode 100644
index 92c7b5e..0000000
--- a/nserver/src/tstree.c
+++ /dev/null
@@ -1,256 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2010, Zed A. Shaw.
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-#include <dbg.h>
-#include <tstree.h>
-
-static inline TSTree *TSTree_insert_base(TSTree *root, TSTree *node,
-                                         const char *key, size_t len,
-                                         void *value)
-{
-    if (node == NULL) {
-        node = (TSTree *) calloc(1, sizeof(TSTree));
-
-        if (root == NULL) {
-            root = node;
-        }
-
-        node->splitchar = *key;
-    }
-
-    if (*key < node->splitchar) {
-        node->low = TSTree_insert_base(root,
-                                       node->low, key, len, value);
-    } else if (*key == node->splitchar) {
-        if (len > 1) {
-            node->equal = TSTree_insert_base(root, node->equal,
-                                             key + 1, len -1 , value);
-        } else {
-            assert(node->value == NULL && "Duplicate insert into tst.");
-            node->value = value;
-        }
-    } else {
-        node->high = TSTree_insert_base(root, node->high,
-                                        key, len, value);
-    }
-
-    return node;
-}
-
-TSTree *TSTree_insert(TSTree *node, const char *key, size_t len,
-                      void *value)
-{
-    return TSTree_insert_base(node, node, key, len, value);
-}
-
-void *TSTree_search(TSTree *root, const char *key, size_t len)
-{
-    TSTree *node = root;
-    size_t i = 0;
-
-    while (i < len && node) {
-        if (key[i] < node->splitchar) {
-            node = node->low;
-        } else if (key[i] == node->splitchar) {
-            i++;
-            if (i < len)
-                node = node->equal;
-        } else {
-            node = node->high;
-        }
-    }
-
-    if (node) {
-        return node->value;
-    } else {
-        return NULL;
-    }
-}
-
-void *TSTree_search_prefix(TSTree *root, const char *key, size_t len)
-{
-    if (len == 0)
-        return NULL;
-
-    TSTree *node = root;
-    TSTree *last = NULL;
-    size_t i = 0;
-
-    while (i < len && node) {
-        if (key[i] < node->splitchar) {
-            node = node->low;
-        } else if (key[i] == node->splitchar) {
-            i++;
-            if (i < len) {
-                if (node->value) {
-                    last = node->value;
-                }
-                node = node->equal;
-            }
-        } else {
-            node = node->high;
-        }
-    }
-
-    return last;
-}
-
-void TSTree_collect_keys(TSTree *node, char *key, size_t key_sz, DArray *array)
-{
-    if (!node) {
-        return;
-    }
-
-    strcat(key, &node->splitchar);
-
-    key_sz += 2;
-    key = (char *) realloc(key, key_sz);
-
-    if (node->value) {
-        char *key_cpy = (char *) calloc(key_sz, sizeof(char));
-        strcpy(key_cpy, key);
-        DArray_push(array, key_cpy);
-    }
-
-    if (node->low) {
-        TSTree_collect_keys(node->low, key, key_sz, array);
-    }
-
-    if (node->equal) {
-        TSTree_collect_keys(node->equal, key, key_sz, array);
-    }
-
-    if (node->high) {
-        TSTree_collect_keys(node->high, key, key_sz, array);
-    }
-}
-
-size_t TSTree_collect_keycat(char *key, size_t key_sz, char *c) {
-    // Expand key.
-    key_sz += 2;
-    key = (char *) realloc(key, key_sz);
-    check(key != NULL, "Unable to expand key");
-
-    // Concat.
-    key = strcat(key, c);
-    check(key != NULL, "key cat failed");
-
-    return key_sz;
- error:
-    if (key) {
-        free(key);
-    }
-    return 0;
-}
-
-DArray *TSTree_collect(TSTree *root, const char *key, size_t len)
-{
-    char *ckey = NULL;
-
-    DArray *array = DArray_create(sizeof(void), 1);
-    check(array != NULL, "Unable to initialize DArray");
-
-    if (len == 0)
-        return array;
-
-    TSTree *node = root;
-    TSTree *last = NULL;
-    size_t i = 0;
-
-    size_t ckey_sz = 4;
-    ckey = (char *) calloc(ckey_sz, sizeof(char));
-    check(ckey != NULL, "Unable to initialize ckey");
-    ckey[0] = '\0';
-
-    while (i < len && node) {
-        if (key[i] < node->splitchar) {
-            node = node->low;
-        } else if (key[i] == node->splitchar) {
-            i++;
-            if (i < len) {
-                ckey_sz = TSTree_collect_keycat(ckey, ckey_sz,
-                                                &node->splitchar);
-                check(ckey_sz > 0, "keycat failed");
-
-                if (node->value) {
-                    last = node;
-                }
-                node = node->equal;
-            }
-        } else {
-            node = node->high;
-        }
-    }
-    node = node ? node : last;
-
-    while (node && !node->value) {
-        ckey_sz = TSTree_collect_keycat(ckey, ckey_sz,
-                                        &node->splitchar);
-        check(ckey_sz > 0, "keycat failed");
-
-        node = node->equal;
-    }
-
-    if (node) {
-        TSTree_collect_keys(node, ckey, ckey_sz, array);
-    }
-
-    // Clean up.
-    free(ckey);
-
-    return array;
-
- error:
-    // Clean up.
-    if (array) {
-        DArray_destroy(array);
-    }
-    if (ckey) {
-        free(ckey);
-    }
-    return NULL;
-}
-
-void TSTree_traverse(TSTree *node, TSTree_traverse_cb cb, void *data)
-{
-    if (!node)
-        return;
-
-    if (node->low)
-        TSTree_traverse(node->low, cb, data);
-
-    if (node->equal) {
-        TSTree_traverse(node->equal, cb, data);
-    }
-
-    if (node->high)
-        TSTree_traverse(node->high, cb, data);
-
-    if (node->value)
-        cb(node->value, data);
-}
-
-void TSTree_destroy(TSTree *node)
-{
-    if (node == NULL)
-        return;
-
-    if (node->low)
-        TSTree_destroy(node->low);
-
-    if (node->equal) {
-        TSTree_destroy(node->equal);
-    }
-
-    if (node->high)
-        TSTree_destroy(node->high);
-
-    free(node);
-}
diff --git a/nserver/src/tstree.h b/nserver/src/tstree.h
deleted file mode 100644
index bd22e0d..0000000
--- a/nserver/src/tstree.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/* SPDX-License-Identifier: BSD-3-Clause */
-/*
- * Copyright © 2010, Zed A. Shaw.
- * Copyright © 2020 rsiddharth <s@ricketyspace.net>
- */
-
-#ifndef _TSTree_h
-#define _TSTree_h
-
-#include <stdlib.h>
-#include <darray.h>
-
-typedef struct TSTree {
-    char splitchar;
-    struct TSTree *low;
-    struct TSTree *equal;
-    struct TSTree *high;
-    void *value;
-} TSTree;
-
-void *TSTree_search(TSTree *root, const char *key, size_t len);
-
-void *TSTree_search_prefix(TSTree *root, const char *key, size_t len);
-
-DArray *TSTree_collect(TSTree *root, const char *key, size_t len);
-
-typedef void (* TSTree_traverse_cb) (void *value, void *data);
-
-TSTree *TSTree_insert(TSTree *node, const char *key, size_t len,
-                      void *value);
-
-void TSTree_traverse(TSTree *node, TSTree_traverse_cb  cb, void *data);
-
-void TSTree_destroy(TSTree *root);
-
-#endif