Core: SXT: using libndbuf, added external dependencies;
parent
e628f4a2fb
commit
a01dd93bb8
@ -1,161 +0,0 @@
|
||||
/*
|
||||
* Secure eXtended Message Passing framework
|
||||
* Secure eXtended Transport layer implementation: (libsxt)
|
||||
* - very similar to SSH2/TLS
|
||||
* - using already proven and tested crypto algos
|
||||
* - better than TLS for message passing
|
||||
*
|
||||
* raw data buffer implementation used within library
|
||||
*
|
||||
* (c) Alexander Vdolainen 2016 <avdolainen@zoho.com>
|
||||
*
|
||||
* libsxmp is free software: you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation, either version 2.1 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* libsxmp is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
* See the GNU Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.";
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __SXT_RDB_H__
|
||||
#define __SXT_RDB_H__
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#define SXTRDB_TERMINAT 0xdeadbeef
|
||||
|
||||
#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;
|
||||
|
||||
/* variadic macro workaround */
|
||||
#define VA_APPLY_VARIADIC_MACRO(macro, tuple) macro tuple
|
||||
|
||||
#define __VA_NARG__(...) \
|
||||
(__VA_NARG_(_0, ## __VA_ARGS__, __RSEQ_N()) - 1)
|
||||
#define __VA_NARG_(...) \
|
||||
VA_APPLY_VARIADIC_MACRO(__VA_ARG_N, (__VA_ARGS__))
|
||||
#define __VA_ARG_N( \
|
||||
_1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
|
||||
_11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
|
||||
_21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
|
||||
_31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
|
||||
_41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
|
||||
_51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
|
||||
_61,_62,_63,N,...) N
|
||||
#define __RSEQ_N() \
|
||||
63, 62, 61, 60, \
|
||||
59, 58, 57, 56, 55, 54, 53, 52, 51, 50, \
|
||||
49, 48, 47, 46, 45, 44, 43, 42, 41, 40, \
|
||||
39, 38, 37, 36, 35, 34, 33, 32, 31, 30, \
|
||||
29, 28, 27, 26, 25, 24, 23, 22, 21, 20, \
|
||||
19, 18, 17, 16, 15, 14, 13, 12, 11, 10, \
|
||||
9, 8, 7, 6, 5, 4, 3, 2, 1, 0
|
||||
|
||||
/* allocation, freeing */
|
||||
/* allocate raw buffer with defaults preallocation */
|
||||
sxtrdb_t *sxtrdb_new(void);
|
||||
|
||||
/* will do the same as sxtrdb_new but will allocate given length */
|
||||
sxtrdb_t *sxtrdb_new_palloc(uint32_t);
|
||||
|
||||
/* free all allocated space and buffer itself */
|
||||
void sxtrdb_free(sxtrdb_t *);
|
||||
|
||||
/* read/write */
|
||||
/* read different types, should return the size of the
|
||||
* ridden data, otherwise error occurs */
|
||||
uint32_t sxtrdb_read_u8(sxtrdb_t *, uint8_t *);
|
||||
uint32_t sxtrdb_read_u16(sxtrdb_t *, uint16_t *);
|
||||
uint32_t sxtrdb_read_u32(sxtrdb_t *, uint32_t *);
|
||||
uint32_t sxtrdb_read_u64(sxtrdb_t *, uint64_t *);
|
||||
|
||||
/* get raw data, pointer must be allocated with at least required length,
|
||||
* will return size of ridden data
|
||||
*/
|
||||
uint32_t sxtrdb_read_raw(sxtrdb_t *, void *, uint32_t);
|
||||
|
||||
/* write different types, should return the size of the
|
||||
* written data, otherwise error occurs */
|
||||
uint32_t sxtrdb_write_u8(sxtrdb_t *, uint8_t);
|
||||
uint32_t sxtrdb_write_u16(sxtrdb_t *, uint16_t);
|
||||
uint32_t sxtrdb_write_u32(sxtrdb_t *, uint32_t);
|
||||
uint32_t sxtrdb_write_u64(sxtrdb_t *, uint64_t);
|
||||
|
||||
/* write raw data with the given length */
|
||||
uint32_t sxtrdb_write_raw(sxtrdb_t *, void *, uint32_t);
|
||||
|
||||
/* write raw data *before* existing data */
|
||||
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 *);
|
||||
|
||||
/* set used length */
|
||||
int sxtrdb_setlength(sxtrdb_t *, uint32_t);
|
||||
|
||||
/* returns length of allocated space in the buffer */
|
||||
uint32_t sxtrdb_alength(sxtrdb_t *);
|
||||
|
||||
/* returns length of the left data to read */
|
||||
uint32_t sxtrdb_leftlength(sxtrdb_t *);
|
||||
|
||||
/* reaturn a pointer to the raw data */
|
||||
void *sxtrdb_rdata(sxtrdb_t *);
|
||||
|
||||
/* return pointer to the data currently being read/write */
|
||||
void *sxtrdb_rdatacur(sxtrdb_t *);
|
||||
|
||||
/* set flags to the raw buffer */
|
||||
void sxtrdb_setflags(sxtrdb_t *, int);
|
||||
|
||||
/* exchange flags for raw buff */
|
||||
void sxtrdb_exflags(sxtrdb_t *, int);
|
||||
|
||||
/* reset current pointer */
|
||||
void sxtrdb_resetcur(sxtrdb_t *);
|
||||
|
||||
/* reset all the flags */
|
||||
#define sxtrdb_flagsreset(a) sxtrdb_exflags((a), 0)
|
||||
|
||||
/* compare buffers, returns 0 if equal */
|
||||
int sxtrdb_cmp(sxtrdb_t *, sxtrdb_t *);
|
||||
|
||||
/* let the buffer to use actually used bytes, not all allocated space
|
||||
* will return SXT_SUCCESS on success (or in case if it doesn't required),
|
||||
* SXT_ENOMEM or other error if fails
|
||||
*/
|
||||
int sxtrdb_memopt(sxtrdb_t *);
|
||||
|
||||
|
||||
#endif /* __SXT_RDB_H__ */
|
||||
@ -1,49 +0,0 @@
|
||||
/*
|
||||
* Secure eXtended Message Passing framework
|
||||
* Secure eXtended Transport layer implementation: (libsxt)
|
||||
* - very similar to SSH2/TLS
|
||||
* - using already proven and tested crypto algos
|
||||
* - better than TLS for message passing
|
||||
*
|
||||
* (c) Alexander Vdolainen 2016 <avdolainen@zoho.com>
|
||||
*
|
||||
* libsxmp is free software: you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation, either version 2.1 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* libsxmp is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
* See the GNU Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.";
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/time.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
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 */
|
||||
}
|
||||
|
||||
@ -1,748 +0,0 @@
|
||||
/*
|
||||
* Secure eXtended Message Passing framework
|
||||
* Secure eXtended Transport layer implementation: (libsxt)
|
||||
* - very similar to SSH2/TLS
|
||||
* - using already proven and tested crypto algos
|
||||
* - better than TLS for message passing
|
||||
*
|
||||
* raw data buffer implementation used within library
|
||||
*
|
||||
* (c) Alexander Vdolainen 2016 <avdolainen@zoho.com>
|
||||
*
|
||||
* libsxmp is free software: you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation, either version 2.1 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* libsxmp is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
* See the GNU Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.";
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdarg.h>
|
||||
#include <arpa/inet.h>
|
||||
|
||||
#include <sxt/errno.h>
|
||||
#include <sxt/rdb.h>
|
||||
|
||||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
/* read/write */
|
||||
/* read different types, should return the size of the
|
||||
* ridden data, otherwise error occurs */
|
||||
uint32_t sxtrdb_read_u8(sxtrdb_t *b, uint8_t *o)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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 = ntohll(u);
|
||||
|
||||
return sizeof(uint64_t);
|
||||
}
|
||||
|
||||
/* get raw data, pointer must be allocated with at least required length,
|
||||
* will return size of ridden data
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
/* write different types, should return the size of the
|
||||
* written data, otherwise error occurs */
|
||||
uint32_t sxtrdb_write_u8(sxtrdb_t *b, uint8_t u)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
if(!b || !b->raw) return 0;
|
||||
if(b->ulength + sizeof(uint64_t) >= b->rlength) {
|
||||
if(__rdb_grow(b, sizeof(uint64_t))) return 0;
|
||||
}
|
||||
|
||||
*(uint64_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)
|
||||
{
|
||||
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 len;
|
||||
}
|
||||
|
||||
/* write raw data *before* existing data */
|
||||
uint32_t sxtrdb_write_raw_head(sxtrdb_t *b, void *wi, uint32_t len)
|
||||
{
|
||||
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)
|
||||
{
|
||||
va_list ap_copy;
|
||||
union {
|
||||
uint8_t *_u8;
|
||||
uint16_t *_u16;
|
||||
uint32_t *_u32;
|
||||
uint64_t *_u64;
|
||||
void **_dp;
|
||||
char **_cstr;
|
||||
sxtrdb_t **_rdb;
|
||||
} 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;
|
||||
case 'P':
|
||||
d._dp = va_arg(ap, void **);
|
||||
*d._dp = NULL;
|
||||
|
||||
len = sxtrdb_read_u32(b, &clen);
|
||||
if(len != sizeof(uint32_t)) {
|
||||
r = SXT_ERDBRD;
|
||||
break;
|
||||
}
|
||||
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;
|
||||
case 'R':
|
||||
d._rdb = va_arg(ap, sxtrdb_t **);
|
||||
*d._rdb = NULL;
|
||||
|
||||
len = sxtrdb_read_u32(b, &clen);
|
||||
if(len != sizeof(uint32_t)) {
|
||||
r = SXT_ERDBRD;
|
||||
break;
|
||||
}
|
||||
/* allocate rdb and write to it */
|
||||
if((*d._rdb = sxtrdb_new_palloc(clen)) == NULL) {
|
||||
r = SXT_ENOMEM;
|
||||
break;
|
||||
} else sxtrdb_setflags(*d._rdb, SXTRDB_BURN);
|
||||
len = sxtrdb_read_raw(b, sxtrdb_rdata(*d._rdb), clen);
|
||||
if(len != clen) {
|
||||
sxtrdb_free(*d._dp);
|
||||
goto __errrbread;
|
||||
} else sxtrdb_setlength(*d._rdb, clen);
|
||||
|
||||
d._rdb = 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 'R':
|
||||
d._rdb = va_arg(ap_copy, sxtrdb_t **);
|
||||
if(*d._rdb) sxtrdb_free(*d._rdb);
|
||||
break;
|
||||
case 'p':
|
||||
(void)va_arg(ap_copy, size_t);
|
||||
case 'P':
|
||||
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 FIXME: TODO: add errno setting upon failure */
|
||||
uint32_t sxtrdb_print_va(sxtrdb_t *b, const char *fmt, int argc, va_list ap)
|
||||
{
|
||||
const char *t;
|
||||
char *cstr;
|
||||
sxtrdb_t *rdb;
|
||||
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, (uint32_t)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 'R':
|
||||
rdb = (sxtrdb_t *)va_arg(ap, sxtrdb_t *);
|
||||
clen = sxtrdb_length(rdb);
|
||||
r = sxtrdb_write_u32(b, (uint32_t)clen);
|
||||
if(r != sizeof(uint32_t)) return 0;
|
||||
else len += r;
|
||||
r = sxtrdb_write_raw(b, sxtrdb_rdata(rdb), (uint32_t)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_u32(b, (uint32_t)clen);
|
||||
if(r != sizeof(uint32_t)) return 0;
|
||||
else len += r;
|
||||
r = sxtrdb_write_raw(b, d._dp, (uint32_t)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, (uint32_t)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)
|
||||
{
|
||||
if(!b || !b->raw) return 0;
|
||||
|
||||
return b->ulength;
|
||||
}
|
||||
|
||||
/* returns length of allocated space in the buffer */
|
||||
uint32_t sxtrdb_alength(sxtrdb_t *b)
|
||||
{
|
||||
if(!b || !b->raw) return 0;
|
||||
|
||||
return b->rlength;
|
||||
}
|
||||
|
||||
/* returns length of the left data to read */
|
||||
uint32_t sxtrdb_leftlength(sxtrdb_t *b)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
if(!b || !b->raw) return NULL;
|
||||
|
||||
if(b->curr >= b->ulength) return NULL;
|
||||
|
||||
return (void *)(b->raw + b->curr);
|
||||
}
|
||||
|
||||
/* reset current pointer */
|
||||
void sxtrdb_resetcur(sxtrdb_t *b)
|
||||
{
|
||||
if(!b || b->raw) return;
|
||||
else b->curr = 0;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/* 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;
|
||||
}
|
||||
|
||||
int sxtrdb_setlength(sxtrdb_t *b, uint32_t s)
|
||||
{
|
||||
if(!b) return SXT_EINVAL;
|
||||
|
||||
if(s > b->rlength) return SXT_EINVAL;
|
||||
else b->ulength = s;
|
||||
|
||||
return SXT_SUCCESS;
|
||||
}
|
||||
|
||||
/* compare buffers, returns 0 if equal */
|
||||
int sxtrdb_cmp(sxtrdb_t *b1, sxtrdb_t *b2)
|
||||
{
|
||||
int c = 0;
|
||||
|
||||
if(!b1 | !b2) return -1;
|
||||
|
||||
if((c = sxtrdb_length(b1) - sxtrdb_length(b2)) != 0) return c;
|
||||
else c = memcmp((const void *)sxtrdb_rdata(b1),
|
||||
(const void *)sxtrdb_rdata(b2),
|
||||
sxtrdb_length(b1));
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
/* let the buffer to use actually used bytes, not all allocated space
|
||||
* will return SXT_SUCCESS on success (or in case if it doesn't required),
|
||||
* SXT_ENOMEM or other error if fails
|
||||
*/
|
||||
int sxtrdb_memopt(sxtrdb_t *b)
|
||||
{
|
||||
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
|
||||
Loading…
Reference in New Issue