sxt: raw data buffer ops;

include/sxt/errno.h

@@ -44,6 +44,7 @@
 #define SXT_EAUTH           (SXT_EBASESHIFT + 13)
 #define SXT_EKEY            (SXT_EBASESHIFT + 14)
 #define SXT_EHASH           (SXT_EBASESHIFT + 15)
+#define SXT_ERDBRD          (SXT_EBASESHIFT + 16)
 #define SXT_EINVAL          (SXT_EBASESHIFT + 22)
 #define SXT_ENOMEM          (SXT_EBASESHIFT + 42)
 

include/sxt/rdb.h

@@ -29,6 +29,8 @@
 
 #include <stdarg.h>
 
+#define SXTRDB_TERMINAT  0xdeadbeef
+
 #define SXTRDB_BURN  (1 << 1)
 
 typedef struct __sxtrawdatabuffer_type {
@@ -78,9 +80,19 @@ uint32_t sxtrdb_write_raw_head(sxtrdb_t *, void *, uint32_t);
 /* parse */
 int sxtrdb_escan_va(sxtrdb_t *b, const char *fmt, int argc, va_list ap);
 
+int sxtrdb_escan_wot(sxtrdb_t *b, const char *fmt, int argc, ...);
+
+#define sxtrdb_escan(b, fmt, ...) \
+  sxtrdb_escan_wot((b), (fmt), __VA_NARG__(__VA_ARGS__), __VA_ARGS__, SXTRDB_TERMINAT)
+
 /* print */
 uint32_t sxtrdb_print_va(sxtrdb_t *b, const char *fmt, int argc, va_list ap);
 
+uint32_t sxtrdb_print_wot(sxtrdb_t *b, const char *fmt, int argc, ...);
+
+#define sxtrdb_print(b, fmt, ...) \
+  sxtrdb_print_wot((b), (fmt), __VA_NARG__(__VA_ARGS__), __VA_ARGS__, SXTRDB_TERMINAT)
+
 /* misc */
 /* returns length of used space in the buffer */
 uint32_t sxtrdb_length(sxtrdb_t *);

sxt/core.c

@@ -97,3 +97,20 @@ void sha512_final(unsigned char *md, SHA512CTX c) {
   SHA512_Final(md, c);
   if(c) free(c);
 }
+
+
+uint64_t ntohll(uint64_t n)
+{
+#ifdef WORDS_BIGENDIAN
+  return n;
+#else /* WORDS_BIGENDIAN */
+  return (((uint64_t)(n) << 56) | \
+         (((uint64_t)(n) << 40) & 0xff000000000000ULL) | \
+         (((uint64_t)(n) << 24) & 0xff0000000000ULL) | \
+         (((uint64_t)(n) << 8)  & 0xff00000000ULL) | \
+         (((uint64_t)(n) >> 8)  & 0xff000000ULL) | \
+         (((uint64_t)(n) >> 24) & 0xff0000ULL) | \
+         (((uint64_t)(n) >> 40) & 0xff00ULL) | \
+         ((uint64_t)(n)  >> 56));
+#endif /* WORDS_BIGENDIAN */
+}

sxt/rdb.c

@@ -28,38 +28,67 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
+#include <arpa/inet.h>
 
 #include <sxt/errno.h>
 #include <sxt/rdb.h>
 
-#if 0
+extern uint64_t ntohll(uint64_t n);
-#define SXTRDB_BURN  (1 << 1)
-
-typedef struct __sxtrawdatabuffer_type {
-  char *raw;
-  uint32_t rlength; /* raw buffer allocated length */
-  uint32_t ulength; /* length of used allocated space */
-  uint32_t curr; /* cursor for read/write operations */
-  int flags;
-} sxtrdb_t;
-#endif
 
 /* allocation, freeing */
+#define DEFAULT_PREALLOC_SIZE  256
+#define SXTBUF_MAXLENGTH  6*(1024*1024)
+
 /* allocate raw buffer with defaults preallocation */
 sxtrdb_t *sxtrdb_new(void)
 {
-  return NULL;
+  sxtrdb_t *b = malloc(sizeof(sxtrdb_t));
+
+  if(!b) return NULL;
+
+  if(!(b->raw = malloc(DEFAULT_PREALLOC_SIZE))) {
+    free(b);
+    b = NULL;
+  } else {
+    b->rlength = DEFAULT_PREALLOC_SIZE;
+    b->ulength = b->curr = 0;
+    b->flags = 0;
+  }
+
+  return b;
 }
 
 /* will do the same as sxtrdb_new but will allocate given length */
 sxtrdb_t *sxtrdb_new_palloc(uint32_t alen)
 {
-  return NULL;
+  sxtrdb_t *b = NULL;
+
+  if(alen > SXTBUF_MAXLENGTH) return NULL;
+
+  if(!(b = malloc(sizeof(sxtrdb_t)))) return NULL;
+  else memset(b, 0, sizeof(sxtrdb_t));
+
+  if(!(b->raw = malloc(alen))) {
+    free(b);
+    b = NULL;
+  } else b->rlength = alen;
+
+  return b;
 }
 
 /* free all allocated space and buffer itself */
 void sxtrdb_free(sxtrdb_t *b)
 {
+  if(!b) return;
+
+  if(b->flags & SXTRDB_BURN) {
+    if(b->raw) memset(b->raw, 0, b->rlength);
+    memset(b, 0, sizeof(sxtrdb_t));
+  }
+
+  if(b->raw) free(b->raw);
+  free(b);
+
   return;
 }
 
@@ -68,22 +97,68 @@ void sxtrdb_free(sxtrdb_t *b)
  * ridden data, otherwise error occurs */
 uint32_t sxtrdb_read_u8(sxtrdb_t *b, uint8_t *o)
 {
-  return 0;
+  uint8_t u;
+
+  if(!b || !o) return 0;
+  if(!b->raw) return 0;
+
+  if(b->curr >= b->ulength) return 0;
+  u = *((uint8_t*)(b->raw + b->curr));
+  b->curr += sizeof(uint8_t);
+  *o = u;
+
+  return sizeof(uint8_t);
 }
 
 uint32_t sxtrdb_read_u16(sxtrdb_t *b, uint16_t *o)
 {
-  return 0;
+  uint16_t u;
+
+  if(!b || !o) return 0;
+  if(!b->raw) return 0;
+
+  if(b->curr >= b->ulength) return 0;
+  if(b->curr + sizeof(uint16_t) > b->ulength) return 0;
+
+  u = *((uint16_t *)(b->raw + b->curr));
+  b->curr += sizeof(uint16_t);
+  *o = ntohs(u);
+
+  return sizeof(uint16_t);
 }
 
 uint32_t sxtrdb_read_u32(sxtrdb_t *b, uint32_t *o)
 {
-  return 0;
+  uint32_t u;
+
+  if(!b || !o) return 0;
+  if(!b->raw) return 0;
+
+  if(b->curr >= b->ulength) return 0;
+  if(b->curr + sizeof(uint32_t) > b->ulength) return 0;
+
+  u = *((uint32_t *)(b->raw + b->curr));
+  b->curr += sizeof(uint32_t);
+  *o = ntohl(u);
+
+  return sizeof(uint32_t);
 }
 
 uint32_t sxtrdb_read_u64(sxtrdb_t *b, uint64_t *o)
 {
-  return 0;
+  uint64_t u;
+
+  if(!b || !o) return 0;
+  if(!b->raw) return 0;
+
+  if(b->curr >= b->ulength) return 0;
+  if(b->curr + sizeof(uint64_t) > b->ulength) return 0;
+
+  u = *((uint64_t *)(b->raw + b->curr));
+  b->curr += sizeof(uint64_t);
+  *o = ntohl(u);
+
+  return sizeof(uint64_t);
 }
 
 /* get raw data, pointer must be allocated with at least required length,
@@ -91,6 +166,41 @@ uint32_t sxtrdb_read_u64(sxtrdb_t *b, uint64_t *o)
  */
 uint32_t sxtrdb_read_raw(sxtrdb_t *b, void *o, uint32_t rlen)
 {
+  if(!b || !o) return 0;
+  if(!rlen || !b->raw) return 0;
+  if(b->curr >= b->ulength) return 0;
+  if(b->curr + rlen > b->ulength) return 0;
+
+  memcpy(o, (const void*)b->raw + b->curr, rlen);
+  b->curr += rlen;
+
+  return rlen;
+}
+
+static int __rdb_grow(sxtrdb_t *b, uint32_t len)
+{
+  uint32_t rlen;
+  char *ne = NULL;
+
+  if(!len) return -1;
+  if(b->rlength + len > SXTBUF_MAXLENGTH) return -1;
+
+  rlen = len +
+    (len%DEFAULT_PREALLOC_SIZE != 0 ? (DEFAULT_PREALLOC_SIZE - len%DEFAULT_PREALLOC_SIZE) : 0);
+  if(b->rlength + rlen > SXTBUF_MAXLENGTH) rlen = len;
+
+  rlen += b->rlength;
+  if(!(ne = malloc(rlen))) return -1;
+
+  if(b->flags & SXTRDB_BURN) memset(ne, 0, rlen);
+
+  memcpy(ne, b->raw, b->ulength);
+
+  if(b->flags & SXTRDB_BURN) memset(b->raw, 0, b->rlength);
+  free(b->raw);
+  b->raw = ne;
+  b->rlength = rlen;
+
   return 0;
 }
 
@@ -98,88 +208,405 @@ uint32_t sxtrdb_read_raw(sxtrdb_t *b, void *o, uint32_t rlen)
  * written data, otherwise error occurs */
 uint32_t sxtrdb_write_u8(sxtrdb_t *b, uint8_t u)
 {
-  return 0;
+  if(!b || !b->raw) return 0;
+  if(b->ulength == b->rlength) {
+    if(__rdb_grow(b, sizeof(uint8_t))) return 0;
+  }
+
+  *(uint8_t *)(b->raw + b->ulength) = u;
+  b->ulength += sizeof(uint8_t);
+
+  return sizeof(uint8_t);
 }
 
 uint32_t sxtrdb_write_u16(sxtrdb_t *b, uint16_t uu)
 {
-  return 0;
+  if(!b || !b->raw) return 0;
+  if(b->ulength + sizeof(uint16_t) >= b->rlength) {
+    if(__rdb_grow(b, sizeof(uint16_t))) return 0;
+  }
+
+  *(uint16_t *)(b->raw + b->ulength) = htons(uu);
+  b->ulength += sizeof(uint16_t);
+
+  return sizeof(uint16_t);
 }
 
 uint32_t sxtrdb_write_u32(sxtrdb_t *b, uint32_t uu)
 {
-  return 0;
+  if(!b || !b->raw) return 0;
+  if(b->ulength + sizeof(uint32_t) >= b->rlength) {
+    if(__rdb_grow(b, sizeof(uint32_t))) return 0;
+  }
+
+  *(uint32_t *)(b->raw + b->ulength) = htonl(uu);
+  b->ulength += sizeof(uint32_t);
+
+  return sizeof(uint32_t);
 }
 
 uint32_t sxtrdb_write_u64(sxtrdb_t *b, uint64_t uu)
 {
-  return 0;
+  if(!b || !b->raw) return 0;
+  if(b->ulength + sizeof(uint64_t) >= b->rlength) {
+    if(__rdb_grow(b, sizeof(uint64_t))) return 0;
+  }
+
+  *(uint32_t *)(b->raw + b->ulength) = ntohll(uu);
+  b->ulength += sizeof(uint64_t);
+
+  return sizeof(uint64_t);
 }
 
 /* write raw data with the given length */
 uint32_t sxtrdb_write_raw(sxtrdb_t *b, void *wi, uint32_t len)
 {
-  return 0;
+  if(!b || !b->raw) return 0;
+  if(!wi || !len) return 0;
+  if(b->ulength + len >= b->rlength) {
+    if(__rdb_grow(b, len)) return 0;
+  }
+
+  memcpy((void *)b->raw + b->ulength, (const void *)wi, len);
+  b->ulength += len;
+
+  return sizeof(uint64_t);
 }
 
 /* write raw data *before* existing data */
 uint32_t sxtrdb_write_raw_head(sxtrdb_t *b, void *wi, uint32_t len)
 {
-  return 0;
+  char *ne;
+  uint32_t rlen;
+
+  if(!b || !b->raw) return 0;
+  if(!wi || !len) return 0;
+  if(b->ulength + len > b->rlength) {
+    /* allocate a new one and copy it right */
+    if(b->rlength + len > SXTBUF_MAXLENGTH) return -1;
+
+    rlen = len +
+      (len%DEFAULT_PREALLOC_SIZE != 0 ? (DEFAULT_PREALLOC_SIZE - len%DEFAULT_PREALLOC_SIZE) : 0);
+    if(b->rlength + rlen > SXTBUF_MAXLENGTH) rlen = len;
+
+    rlen += b->rlength;
+    if(!(ne = malloc(rlen))) return -1;
+
+    if(b->flags & SXTRDB_BURN) memset(ne, 0, rlen);
+
+    memcpy((void *)ne + len, b->raw, b->ulength);
+
+    if(b->flags & SXTRDB_BURN) memset(b->raw, 0, b->rlength);
+    free(b->raw);
+    b->raw = ne;
+    b->rlength = rlen;
+  } else {
+    memmove((void *)b->raw + b->ulength, b->raw, b->ulength);
+  }
+  memcpy(b->raw, wi, len);
+  b->ulength += len;
+
+  return len;
 }
 
 /* parse */
 int sxtrdb_escan_va(sxtrdb_t *b, const char *fmt, int argc, va_list ap)
 {
-  return 0;
+  va_list ap_copy;
+  union {
+    uint8_t *_u8;
+    uint16_t *_u16;
+    uint32_t *_u32;
+    uint64_t *_u64;
+    void **_dp;
+    char **_cstr;
+  } d;
+  const char *t, *last;
+  uint32_t len, clen;
+  int r, count;
+
+  va_copy(ap_copy, ap);
+
+  for(t = fmt, count = 0; *t != '\0'; t++, count++) {
+    if(count > argc && argc != -1) {
+      va_end(ap_copy);
+      return SXT_EINVAL;
+    }
+
+    switch(*t) {
+    case 'b':
+      d._u8 = va_arg(ap, uint8_t *);
+      len = sxtrdb_read_u8(b, d._u8);
+      r = (len == sizeof(uint8_t)) ? SXT_SUCCESS : SXT_ERDBRD;
+      break;
+    case 'w':
+      d._u16 = va_arg(ap, uint16_t *);
+      len = sxtrdb_read_u16(b, d._u16);
+      r = (len == sizeof(uint16_t)) ? SXT_SUCCESS : SXT_ERDBRD;
+      break;
+    case 'd':
+      d._u32 = va_arg(ap, uint32_t *);
+      len = sxtrdb_read_u32(b, d._u32);
+      r = (len == sizeof(uint32_t)) ? SXT_SUCCESS : SXT_ERDBRD;
+      break;
+    case 'q':
+      d._u64 = va_arg(ap, uint64_t *);
+      len = sxtrdb_read_u64(b, d._u64);
+      r = (len == sizeof(uint64_t)) ? SXT_SUCCESS : SXT_ERDBRD;
+      break;
+    case 's':
+      d._cstr = va_arg(ap, char **);
+      *d._cstr = NULL;
+      len = sxtrdb_read_u32(b, &clen);
+      if(len != sizeof(uint32_t)) {
+      __errrbread:
+        r = SXT_ERDBRD;
+        break;
+      }
+      if(clen > SXTBUF_MAXLENGTH) goto __errrbread;
+      if((*d._cstr = malloc(clen + sizeof(char))) == NULL) {
+        r = SXT_ENOMEM;
+        break;
+      }
+      len = sxtrdb_read_raw(b, *d._cstr, clen);
+      if(len != clen) {
+        free(*d._cstr);
+        goto __errrbread;
+      }
+      (*d._cstr)[len] = '\0';
+      d._cstr = NULL;
+      r = SXT_SUCCESS;
+      break;
+    case 'p':
+      clen = va_arg(ap, size_t);
+
+      d._dp = va_arg(ap, void **);
+      *d._dp = NULL;
+      count++;
+
+      if((*d._dp = malloc(clen)) == NULL) {
+        r = SXT_ENOMEM;
+        break;
+      }
+      len = sxtrdb_read_raw(b, *d._dp, clen);
+      if(len != clen) {
+        free(*d._dp);
+        goto __errrbread;
+      }
+      d._dp = NULL;
+      r = SXT_SUCCESS;
+      break;
+    }
+
+    if(r != SXT_SUCCESS) break;
+  }
+
+  if(argc != -1 && argc != count) r = SXT_EINVAL;
+
+  if(r == SXT_SUCCESS) {
+    clen = va_arg(ap, uint32_t);
+    if(clen != SXTRDB_TERMINAT) {
+      if(argc == -1) r = SXT_EINVAL;
+      else abort();
+    }
+  }
+
+  /* clean up all the stuff on error */
+  if(r != SXT_SUCCESS) {
+    last = t;
+    for(t = fmt; t < last; ++t) {
+      switch(*t) {
+      case 'b':
+      case 'w':
+      case 'd':
+      case 'q':
+        (void)va_arg(ap_copy, void *);
+        break;
+      case 's':
+        d._cstr = va_arg(ap_copy, char **);
+        if(*d._cstr) {
+          memset(*d._cstr, 0, strlen(*d._cstr));
+          free(*d._cstr);
+        }
+        break;
+      case 'p':
+        (void)va_arg(ap_copy, size_t);
+        d._dp = va_arg(ap_copy, void **);
+        if(*d._dp) free(*d._dp);
+        break;
+      default:
+        (void)va_arg(ap_copy, void *);
+        break;
+      }
+    }
+  }
+  va_end(ap_copy);
+
+  return r;
+}
+
+int sxtrdb_escan_wot(sxtrdb_t *b, const char *fmt, int argc, ...)
+{
+  va_list ap;
+  int r;
+
+  va_start(ap, argc);
+  r = sxtrdb_escan_va(b, fmt, argc, ap);
+  va_end(ap);
+
+  return r;
 }
 
-/* print */
+/* print FIXME: TODO: add errno setting upon failure */
 uint32_t sxtrdb_print_va(sxtrdb_t *b, const char *fmt, int argc, va_list ap)
 {
-  return 0;
+  const char *t;
+  char *cstr;
+  union {
+    uint8_t _u8;
+    uint16_t _u16;
+    uint32_t _u32;
+    uint64_t _u64;
+    void *_dp;
+  } d;
+  uint32_t len = 0, clen;
+  int r, count;
+
+  for(t = fmt, count = 0; *t != '\0'; t++, count++) {
+    if(count > argc && argc != -1) return 0;
+    switch(*t) {
+    case 'b':
+      d._u8 = (uint8_t)va_arg(ap, unsigned int);
+      r = sxtrdb_write_u8(b, d._u8);
+      if(r != sizeof(uint8_t)) return 0;
+      else len += r;
+      break;
+    case 'w':
+      d._u16 = (uint16_t)va_arg(ap, unsigned int);
+      r = sxtrdb_write_u16(b, d._u16);
+      if(r != sizeof(uint16_t)) return 0;
+      else len += r;
+      break;
+    case 'd':
+      d._u32 = (uint32_t)va_arg(ap, uint32_t);
+      r = sxtrdb_write_u32(b, d._u32);
+      if(r != sizeof(uint32_t)) return 0;
+      else len += r;
+      break;
+    case 'q':
+      d._u64 = (uint64_t)va_arg(ap, uint64_t);
+      r = sxtrdb_write_u64(b, d._u64);
+      if(r != sizeof(uint64_t)) return 0;
+      else len += r;
+      break;
+    case 's':
+      cstr = (char *)va_arg(ap, char *);
+      clen = strlen(cstr);
+      r = sxtrdb_write_u32(b, clen);
+      if(r != sizeof(uint32_t)) return 0;
+      else len += r;
+      r = sxtrdb_write_raw(b, cstr, clen);
+      if(r != clen) return 0;
+      else len += clen;
+      break;
+    case 'p':
+      clen = va_arg(ap, size_t);
+      d._dp = va_arg(ap, void *);
+      count++;
+      r = sxtrdb_write_raw(b, d._dp, clen);
+      if(r != clen) return 0;
+      else len += clen;
+      break;
+    default:
+      return 0;
+      break;
+    }
+  }
+
+  if(argc != count && argc != -1) return 0;
+
+  clen = va_arg(ap, uint32_t);
+  if(clen != SXTRDB_TERMINAT) {
+    if(argc == -1) return 0;
+    else abort(); /* corruption */
+  }
+
+  return len;
+}
+
+uint32_t sxtrdb_print_wot(sxtrdb_t *b, const char *fmt, int argc, ...)
+{
+  va_list ap;
+  uint32_t wrl;
+
+  va_start(ap, argc);
+  wrl = sxtrdb_print_va(b, fmt, argc, ap);
+  va_end(ap);
+
+  return wrl;
 }
 
 /* misc */
 /* returns length of used space in the buffer */
 uint32_t sxtrdb_length(sxtrdb_t *b)
 {
-  return 0;
+  if(!b || !b->raw) return 0;
+
+  return b->ulength;
 }
 
 /* returns length of allocated space in the buffer */
 uint32_t sxtrdb_alength(sxtrdb_t *b)
 {
-  return 0;
+  if(!b || !b->raw) return 0;
+
+  return b->rlength;
 }
 
 /* returns length of the left data to read */
 uint32_t sxtrdb_leftlength(sxtrdb_t *b)
 {
-  return 0;
+  if(!b || !b->raw) return 0;
+  if(b->curr > b->ulength) return 0;
+
+  return b->ulength - b->curr;
 }
 
 /* reaturn a pointer to the raw data */
 void *sxtrdb_rdata(sxtrdb_t *b)
 {
-  return NULL;
+  if(!b || !b->raw) return NULL;
+
+  return (void *)b->raw;
 }
 
 /* return pointer to the data currently being read/write */
 void *sxtrdb_rdatacur(sxtrdb_t *b)
 {
-  return NULL;
+  if(!b || !b->raw) return NULL;
+
+  if(b->curr >= b->ulength) return NULL;
+
+  return (void *)(b->raw + b->curr);
 }
 
 /* set flags to the raw buffer */
 void sxtrdb_setflags(sxtrdb_t *b, int af)
 {
+  if(!b) return;
+
+  b->flags |= af;
+
   return;
 }
 
 /* exchange flags for raw buff */
 void sxtrdb_exflags(sxtrdb_t *b, int nf)
 {
+  if(!b) return;
+
+  b->flags = nf;
+
   return;
 }
 
@@ -189,6 +616,26 @@ void sxtrdb_exflags(sxtrdb_t *b, int nf)
  */
 int sxtrdb_memopt(sxtrdb_t *b)
 {
-  return SXT_ERROR;
+  uint32_t len;
+  char *ne;
+
+  if(!b || !b->raw) return SXT_EINVAL;
+
+  if((b->rlength - b->ulength) > DEFAULT_PREALLOC_SIZE) {
+    len = b->ulength +
+      (b->ulength%DEFAULT_PREALLOC_SIZE != 0 ?
+       (DEFAULT_PREALLOC_SIZE - b->ulength%DEFAULT_PREALLOC_SIZE) : 0);
+    if(!(ne = malloc(len))) return SXT_ENOMEM;
+
+    if(b->flags & SXTRDB_BURN) memset(ne, 0, len);
+    memcpy(ne, b->raw, b->ulength);
+    if(b->flags & SXTRDB_BURN) memset(b->raw, 0, b->ulength);
+    free(b->raw);
+    b->raw = ne;
+    b->rlength = len;
+  }
+
+  return SXT_SUCCESS;
 }
 
+#undef DEFAULT_PREALLOC_SIZE