From b924fc2f66d46ee10aa3b800a6521d3940919f9f Mon Sep 17 00:00:00 2001 From: rsiddharth Date: Fri, 17 Apr 2020 21:02:35 -0400 Subject: nserver/ -> ./ --- src/bstrlib.c | 3149 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/bstrlib.h | 332 ++++++ src/darray.c | 198 ++++ src/darray.h | 126 +++ src/darray_algos.c | 234 ++++ src/darray_algos.h | 26 + src/db.c | 138 +++ src/db.h | 20 + src/dbg.h | 48 + src/hashmap.c | 341 ++++++ src/hashmap.h | 49 + src/ncmd.c | 351 ++++++ src/ncmd.h | 41 + src/nserve.c | 78 ++ src/nserve.h | 20 + src/nsocket.c | 61 + src/nsocket.h | 19 + src/protocol.c | 310 ++++++ src/protocol.h | 34 + src/stats.c | 128 +++ src/stats.h | 47 + src/tstree.c | 256 +++++ src/tstree.h | 36 + 23 files changed, 6042 insertions(+) create mode 100644 src/bstrlib.c create mode 100644 src/bstrlib.h create mode 100644 src/darray.c create mode 100644 src/darray.h create mode 100644 src/darray_algos.c create mode 100644 src/darray_algos.h create mode 100644 src/db.c create mode 100644 src/db.h create mode 100644 src/dbg.h create mode 100644 src/hashmap.c create mode 100644 src/hashmap.h create mode 100644 src/ncmd.c create mode 100644 src/ncmd.h create mode 100644 src/nserve.c create mode 100644 src/nserve.h create mode 100644 src/nsocket.c create mode 100644 src/nsocket.h create mode 100644 src/protocol.c create mode 100644 src/protocol.h create mode 100644 src/stats.c create mode 100644 src/stats.h create mode 100644 src/tstree.c create mode 100644 src/tstree.h (limited to 'src') 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 +#include +#include +#include +#include +#include +#include +#include + +/* 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 +#include +#include +#include + +#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 + */ + +#include +#include +#include + +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 + */ + +#ifndef _DArray_h +#define _DArray_h +#include +#include +#include + +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 + */ + +#include + +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 + */ + +#ifndef darray_algos_h +#define darray_algos_h + +#include +#include +#include + +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 + */ + +#include + +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 + */ + +#ifndef _db_h +#define _db_h + +#include +#include +#include +#include +#include + +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 +#include +#include + +#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 + */ + +#undef NDEBUG +#include +#include +#include +#include +#include + +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 + */ + +#ifndef _lcthw_Hashmap_h +#define _lcthw_Hashmap_h + +#include +#include + +#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 + */ + +#include + +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 + */ + +#ifndef _ncmd_h +#define _ncmd_h + +#include + +#include +#include +#include + +#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 + */ + +#include + +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 + */ + +#ifndef _nserve_h +#define _nserve_h + +#include +#include +#include +#include + +#include +#include +#include + +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 + */ + +#include + +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 + */ + +#ifndef _nsocket_h +#define _nsocket_h + +#include +#include +#include + +#include + +#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 + */ + +#include + +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 + */ + +#ifndef _protocol_h +#define _protocol_h + + +#include +#include +#include +#include +#include +#include +#include + +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 + */ + +#include +#include + +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 + */ + +#ifndef stats_h +#define stats_h + +#include +#include +#include +#include + +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 + */ + +#include +#include +#include +#include +#include +#include + +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 + */ + +#ifndef _TSTree_h +#define _TSTree_h + +#include +#include + +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 -- cgit v1.2.3