nserver/ -> ./

23 files changed, 6042 insertions, 0 deletions

diff --git a/src/bstrlib.c b/src/bstrlib.c
new file mode 100644
index 0000000..8161319
--- /dev/null
+++ b/src/bstrlib.c
@@ -0,0 +1,3149 @@
+/* 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/src/bstrlib.h b/src/bstrlib.h
new file mode 100644
index 0000000..6ad6f4a
--- /dev/null
+++ b/src/bstrlib.h
@@ -0,0 +1,332 @@
+/* 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/src/darray.c b/src/darray.c
new file mode 100644
index 0000000..912ccbe
--- /dev/null
+++ b/src/darray.c
@@ -0,0 +1,198 @@
+/* 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/src/darray.h b/src/darray.h
new file mode 100644
index 0000000..7e5ae5d
--- /dev/null
+++ b/src/darray.h
@@ -0,0 +1,126 @@
+/* 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/src/darray_algos.c b/src/darray_algos.c
new file mode 100644
index 0000000..01fd27f
--- /dev/null
+++ b/src/darray_algos.c
@@ -0,0 +1,234 @@
+/* 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/src/darray_algos.h b/src/darray_algos.h
new file mode 100644
index 0000000..9be314f
--- /dev/null
+++ b/src/darray_algos.h
@@ -0,0 +1,26 @@
+/* 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/src/db.c b/src/db.c
new file mode 100644
index 0000000..a0443c9
--- /dev/null
+++ b/src/db.c
@@ -0,0 +1,138 @@
+/* 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/src/db.h b/src/db.h
new file mode 100644
index 0000000..8470e6f
--- /dev/null
+++ b/src/db.h
@@ -0,0 +1,20 @@
+/* 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/src/dbg.h b/src/dbg.h
new file mode 100644
index 0000000..1018a4d
--- /dev/null
+++ b/src/dbg.h
@@ -0,0 +1,48 @@
+/* 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/src/hashmap.c b/src/hashmap.c
new file mode 100644
index 0000000..b42c48e
--- /dev/null
+++ b/src/hashmap.c
@@ -0,0 +1,341 @@
+/* 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/src/hashmap.h b/src/hashmap.h
new file mode 100644
index 0000000..1c9cd3e
--- /dev/null
+++ b/src/hashmap.h
@@ -0,0 +1,49 @@
+/* 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/src/ncmd.c b/src/ncmd.c
new file mode 100644
index 0000000..e1393a3
--- /dev/null
+++ b/src/ncmd.c
@@ -0,0 +1,351 @@
+/* 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/src/ncmd.h b/src/ncmd.h
new file mode 100644
index 0000000..025a06f
--- /dev/null
+++ b/src/ncmd.h
@@ -0,0 +1,41 @@
+/* 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/src/nserve.c b/src/nserve.c
new file mode 100644
index 0000000..75457af
--- /dev/null
+++ b/src/nserve.c
@@ -0,0 +1,78 @@
+/* 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/src/nserve.h b/src/nserve.h
new file mode 100644
index 0000000..b0565ef
--- /dev/null
+++ b/src/nserve.h
@@ -0,0 +1,20 @@
+/* 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/src/nsocket.c b/src/nsocket.c
new file mode 100644
index 0000000..c4d4525
--- /dev/null
+++ b/src/nsocket.c
@@ -0,0 +1,61 @@
+/* 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/src/nsocket.h b/src/nsocket.h
new file mode 100644
index 0000000..17cea75
--- /dev/null
+++ b/src/nsocket.h
@@ -0,0 +1,19 @@
+/* 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/src/protocol.c b/src/protocol.c
new file mode 100644
index 0000000..77b806a
--- /dev/null
+++ b/src/protocol.c
@@ -0,0 +1,310 @@
+/* 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/src/protocol.h b/src/protocol.h
new file mode 100644
index 0000000..4640975
--- /dev/null
+++ b/src/protocol.h
@@ -0,0 +1,34 @@
+/* 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/src/stats.c b/src/stats.c
new file mode 100644
index 0000000..7e51c9e
--- /dev/null
+++ b/src/stats.c
@@ -0,0 +1,128 @@
+/* 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/src/stats.h b/src/stats.h
new file mode 100644
index 0000000..f9e5d7a
--- /dev/null
+++ b/src/stats.h
@@ -0,0 +1,47 @@
+/* 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/src/tstree.c b/src/tstree.c
new file mode 100644
index 0000000..92c7b5e
--- /dev/null
+++ b/src/tstree.c
@@ -0,0 +1,256 @@
+/* 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/src/tstree.h b/src/tstree.h
new file mode 100644
index 0000000..bd22e0d
--- /dev/null
+++ b/src/tstree.h
@@ -0,0 +1,36 @@
+/* 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