From b2dff1c04f6aada1e339f664964f633be1a2e4f9 Mon Sep 17 00:00:00 2001 From: Alexander Vdolainen Date: Wed, 8 Jun 2016 04:27:07 +0300 Subject: [PATCH] sxt: raw data buffer ops; --- include/sxt/errno.h | 1 + include/sxt/rdb.h | 12 ++ sxt/core.c | 17 ++ sxt/rdb.c | 511 +++++++++++++++++++++++++++++++++++++++++--- 4 files changed, 509 insertions(+), 32 deletions(-) diff --git a/include/sxt/errno.h b/include/sxt/errno.h index 87051c6..21cd610 100644 --- a/include/sxt/errno.h +++ b/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) diff --git a/include/sxt/rdb.h b/include/sxt/rdb.h index 3ea035b..0c15912 100644 --- a/include/sxt/rdb.h +++ b/include/sxt/rdb.h @@ -29,6 +29,8 @@ #include +#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 *); diff --git a/sxt/core.c b/sxt/core.c index d14cfe2..dac82ef 100644 --- a/sxt/core.c +++ b/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 */ +} diff --git a/sxt/rdb.c b/sxt/rdb.c index e456b51..5e6bbc5 100644 --- a/sxt/rdb.c +++ b/sxt/rdb.c @@ -28,38 +28,67 @@ #include #include #include +#include #include #include -#if 0 -#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 +extern uint64_t ntohll(uint64_t n); /* 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