From 4f92c65203dcb5adeca73bb66e9d887cb201a55f Mon Sep 17 00:00:00 2001 From: FreeArtMan Date: Sun, 4 Jun 2017 00:22:40 +0100 Subject: added netstring like library --- extlibs/netbytes.c | 1150 ++++++++++++++++++++++++++++++++++++++++++++++++++++ extlibs/netbytes.h | 191 +++++++++ 2 files changed, 1341 insertions(+) create mode 100644 extlibs/netbytes.c create mode 100644 extlibs/netbytes.h diff --git a/extlibs/netbytes.c b/extlibs/netbytes.c new file mode 100644 index 0000000..ecbb87e --- /dev/null +++ b/extlibs/netbytes.c @@ -0,0 +1,1150 @@ +#include "netbytes.h" + + +int nb_u8_create( nb_u8 *s, uint8_t val ) +{ + if ( s == NULL ) + return -1; + + s->type = NBT_U8; + s->val = val; + + return 0; +} + + +int nb_u8arr_create( nb_u8arr *s, __NBT_U8ARR_LEN len, uint8_t *val ) +{ + if ( s == NULL ) + return -1; + + s->type = NBT_U8ARRAY; + s->len = len; + s->val = val; + + return 0; +} + +int nb_u16_create( nb_u16 *s, uint16_t val ) +{ + if ( s == NULL ) + return -1; + + s->type = NBT_U16; + s->val = val; + + return 0; +} + + +int nb_u16arr_create( nb_u16arr *s, __NBT_U16ARR_LEN len, uint16_t *val ) +{ + if ( s == NULL ) + return -1; + + s->type = NBT_U16ARRAY; + s->len = len; + s->val = val; + + return 0; +} + + +int nb_u32_create( nb_u32 *s, uint32_t val ) +{ + if ( s == NULL ) + return -1; + + s->type = NBT_U32; + s->val = val; + + return 0; +} + + +int nb_u32arr_create( nb_u32arr *s, __NBT_U32ARR_LEN len, uint32_t *val ) +{ + if ( s == NULL ) + return -1; + + s->type = NBT_U32ARRAY; + s->len = len; + s->val = val; + + return 0; +} + + +int nb_u64_create( nb_u64 *s, uint64_t val ) +{ + if ( s == NULL ) + return -1; + + s->type = NBT_U64; + s->val = val; + + return 0; +} + + +int nb_u64arr_create( nb_u64arr *s, __NBT_U64ARR_LEN len, uint64_t *val ) +{ + if ( s == NULL ) + return -1; + + s->type = NBT_U64ARRAY; + s->len = len; + s->val = val; + + return 0; +} + + +int nb_init( netbyte_store *store ) +{ + if ( store == NULL ) + return -1; + + memset( store, 0, sizeof(netbyte_store) ); + + /* we know that they allready zero, but philosophy more important */ + store->size = 0; + store->count = 0; + + return 0; +} + + +int nb_add_u8( netbyte_store *store, nb_u8 *u8 ) +{ + nb_u8 *new_u8=NULL; + + if ( store->count >= __NBT_MAX_TYPES - 1 ) + { + return -1; + } + + if ( u8->type != NBT_U8 ) + { + return -2; + } + + store->types[store->count].type = NBT_U8; + + new_u8 = malloc(sizeof(nb_u8)); + memcpy(new_u8, u8, sizeof(nb_u8)); + store->types[store->count].nb_val = (uint8_t *)new_u8; + + store->count += 1; + return 0; +} + + +int nb_add_u8arr( netbyte_store *store, nb_u8arr *u8arr ) +{ + nb_u8arr *new_u8arr = NULL; + + if ( store->count >= __NBT_MAX_TYPES - 1 ) + return -1; + + if ( u8arr->type != NBT_U8ARRAY ) + return -2; + + store->types[store->count].type = NBT_U8ARRAY; + + new_u8arr = malloc(sizeof(nb_u8arr)); + memcpy(new_u8arr, u8arr, sizeof(nb_u8arr)); + new_u8arr->val = malloc(sizeof(nb_u8arr)*u8arr->len); + memcpy(new_u8arr->val, u8arr->val, u8arr->len); + store->types[store->count].nb_val = (uint8_t *)new_u8arr; + + store->count += 1; + return 0; +} + + +int nb_add_u16( netbyte_store *store, nb_u16 *u16 ) +{ + if ( store->count >= __NBT_MAX_TYPES - 1 ) + return -1; + + if ( u16->type != NBT_U16 ) + return -2; + + store->types[store->count].type = NBT_U16; + store->types[store->count].nb_val = (uint8_t *)u16; + store->count += 1; + return 0; +} + + +int nb_add_u16arr( netbyte_store *store, nb_u16arr *u16arr ) +{ + if ( store->count >= __NBT_MAX_TYPES - 1 ) + return -1; + + if ( u16arr->type != NBT_U16ARRAY ) + return -2; + + store->types[store->count].type = NBT_U16ARRAY; + store->types[store->count].nb_val = (uint8_t *)u16arr; + store->count += 1; + return 0; +} + + +int nb_add_u32( netbyte_store *store, nb_u32 *u32 ) +{ + if ( store->count >= __NBT_MAX_TYPES - 1 ) + return -1; + + if ( u32->type != NBT_U32 ) + return -2; + + store->types[store->count].type = NBT_U32; + store->types[store->count].nb_val = (uint8_t *)u32; + store->count += 1; + return 0; +} + + +int nb_add_u32arr( netbyte_store *store, nb_u32arr *u32arr ) +{ + if ( store->count >= __NBT_MAX_TYPES - 1 ) + return -1; + + if ( u32arr->type != NBT_U32ARRAY ) + return -2; + + store->types[store->count].type = NBT_U32ARRAY; + store->types[store->count].nb_val = (uint8_t *)u32arr; + store->count += 1; + return 0; +} + + +int nb_add_u64( netbyte_store *store, nb_u64 *u64 ) +{ + if ( store->count >= __NBT_MAX_TYPES - 1 ) + return -1; + + if ( u64->type != NBT_U64 ) + return -2; + + store->types[store->count].type = NBT_U64; + store->types[store->count].nb_val = (uint8_t *)u64; + store->count += 1; + return 0; +} + + +int nb_add_u64arr( netbyte_store *store, nb_u64arr *u64arr ) +{ + if ( store->count >= __NBT_MAX_TYPES - 1 ) + return -1; + + if ( u64arr->type != NBT_U64ARRAY ) + return -2; + + store->types[store->count].type = NBT_U64ARRAY; + store->types[store->count].nb_val = (uint8_t *)u64arr; + store->count += 1; + return 0; +} + + +uint8_t *nb_create( netbyte_store *store ) +{ + uint8_t *ret = NULL; + uint8_t *buf = NULL; + uint8_t *c = NULL; + + int i; + + if ( store == NULL ) + return NULL; + + if ( store->count < 1 ) + return NULL; + + store->size == 0; + + /* precalc needed size starting from zero not metter what */ + store->size += sizeof(__NBT_SIZE); + for (i=0; i < store->count; i++) + { + __nb_type iter = store->types[i]; + switch( iter.type ) + { + case NBT_U8: + store->size += sizeof(__NBT_TYPED) + sizeof(uint8_t); + break; + case NBT_U8ARRAY: + { + nb_u8arr *u8arr = (nb_u8arr *)iter.nb_val; + store->size += sizeof(__NBT_TYPED) + + sizeof(__NBT_U8ARR_LEN) + + u8arr->len; + } + break; + case NBT_U16: + store->size += sizeof(__NBT_TYPED) + sizeof(uint16_t); + break; + case NBT_U16ARRAY: + { + nb_u16arr *u16arr = (nb_u16arr *)iter.nb_val; + store->size += sizeof(__NBT_TYPED) + + sizeof(__NBT_U16ARR_LEN) + + u16arr->len*sizeof(uint16_t); + } + break; + case NBT_U32: + store->size += sizeof(__NBT_TYPED) + sizeof(uint32_t); + break; + case NBT_U32ARRAY: + { + nb_u32arr *u32arr = (nb_u32arr *)iter.nb_val; + store->size += sizeof(__NBT_TYPED) + + sizeof(__NBT_U32ARR_LEN) + + u32arr->len*sizeof(uint32_t); + } + break; + case NBT_U64: + store->size += sizeof(__NBT_TYPED) + sizeof(uint64_t); + break; + case NBT_U64ARRAY: + { + nb_u64arr *u64arr = (nb_u64arr *)iter.nb_val; + store->size += sizeof(__NBT_TYPED) + + sizeof(__NBT_U64ARR_LEN) + + u64arr->len*sizeof(uint64_t); + } + break; + default: + printf("Unknow type be carefull1\n"); + } + } + + /* create netbyte memory chunk */ + buf = malloc( store->size ); + if ( buf == NULL ) + { + return NULL; + } + c = buf; + + /* write size of netbytes */ + memcpy( c, &store->size, sizeof(__NBT_SIZE) ); + c += sizeof(__NBT_SIZE); + + /* per each type copy stuff */ + for ( i = 0; i < store->count; i++ ) + { + __nb_type iter = store->types[i]; + switch ( iter.type ) + { + case NBT_U8: + memcpy( c, &iter.type, sizeof(__NBT_TYPED) ); + c += sizeof(__NBT_TYPED); + memcpy( c, &((nb_u8 *)(iter.nb_val))->val, sizeof(uint8_t) ); + c += sizeof(uint8_t); + break; + case NBT_U8ARRAY: + { + nb_u8arr *u8arr = (nb_u8arr *)iter.nb_val; + memcpy( c, &iter.type, sizeof(__NBT_TYPED) ); + c += sizeof(__NBT_TYPED); + memcpy( c, &u8arr->len, sizeof(__NBT_U8ARR_LEN)); + c += sizeof(__NBT_U8ARR_LEN); + memcpy( c, u8arr->val, u8arr->len ); + c += u8arr->len; + break; + } + case NBT_U16: + memcpy( c, &iter.type, sizeof(__NBT_TYPED) ); + c += sizeof(__NBT_TYPED); + memcpy( c, &((nb_u16 *)(iter.nb_val))->val, sizeof(uint16_t) ); + c += sizeof(uint16_t); + break; + case NBT_U16ARRAY: + { + nb_u16arr *u16arr = (nb_u16arr *)iter.nb_val; + memcpy( c, &iter.type, sizeof(__NBT_TYPED) ); + c += sizeof(__NBT_TYPED); + memcpy( c, &u16arr->len, sizeof(__NBT_U16ARR_LEN)); + c += sizeof(__NBT_U16ARR_LEN); + memcpy( c, u16arr->val, u16arr->len ); + c += u16arr->len*sizeof(uint16_t); + break; + } + case NBT_U32: + memcpy( c, &iter.type, sizeof(__NBT_TYPED) ); + c += sizeof(__NBT_TYPED); + memcpy( c, &((nb_u32 *)(iter.nb_val))->val, sizeof(uint32_t) ); + c += sizeof(uint32_t); + break; + case NBT_U32ARRAY: + { + nb_u32arr *u32arr = (nb_u32arr *)iter.nb_val; + memcpy( c, &iter.type, sizeof(__NBT_TYPED) ); + c += sizeof(__NBT_TYPED); + memcpy( c, &u32arr->len, sizeof(__NBT_U32ARR_LEN)); + c += sizeof(__NBT_U32ARR_LEN); + memcpy( c, u32arr->val, u32arr->len ); + c += u32arr->len*sizeof(uint32_t); + break; + } + case NBT_U64: + memcpy( c, &iter.type, sizeof(__NBT_TYPED) ); + c += sizeof(__NBT_TYPED); + memcpy( c, &((nb_u64 *)(iter.nb_val))->val, sizeof(uint64_t) ); + c += sizeof(uint64_t); + break; + case NBT_U64ARRAY: + { + nb_u64arr *u64arr = (nb_u64arr *)iter.nb_val; + memcpy( c, &iter.type, sizeof(__NBT_TYPED) ); + c += sizeof(__NBT_TYPED); + memcpy( c, &u64arr->len, sizeof(__NBT_U64ARR_LEN)); + c += sizeof(__NBT_U64ARR_LEN); + memcpy( c, u64arr->val, u64arr->len ); + c += u64arr->len*sizeof(uint64_t); + break; + } + default: + printf("Unknow type be carefull2\n"); + } + } + + if ( c-buf-1 > store->size ) + { + printf("Something went wrong while created netbytes\n"); + free(buf); + return NULL; + } + + ret = buf; + + return ret; +} + + +int nb_free(netbyte_store *store) +{ + int i; + + if (!store) + { + return -1; + } + + for (i=0;icount;i++) + { + __NBT_TYPED type = store->types[i].type; + uint8_t *val = store->types[i].nb_val; + + switch(type) + { + case NBT_U8: + { + nb_u8 *u8 = (nb_u8 *)val; + free(u8); + u8=NULL; + store->types[i].nb_val=NULL; + store->types[i].type=0; + break; + } + case NBT_U8ARRAY: + { + nb_u8arr *u8arr = (nb_u8arr *)val; + free(u8arr->val); + free(u8arr); + store->types[i].nb_val=NULL; + store->types[i].type=0; + break; + } + default: + printf("Unknown type\n"); + } + } + free(store); + store = NULL; + + return 0; +} + +int nb_load( netbyte_store *store, uint8_t *data ) +{ + __NBT_TYPED type; + int iter=1; + uint8_t *c = data; + int count; + + if ( store == NULL ) + { + return -1; + } + + if ( data == NULL ) + { + return -2; + } + + __NBT_SIZE size; + memcpy( &size, c, sizeof(__NBT_SIZE) ); + printf("size: %d\n", size); + + size -= sizeof(__NBT_SIZE); + c += sizeof(__NBT_SIZE); + + if (c == data) + { + store->size = size; + return 0; + } + + count = 0; + memset( store, 0, sizeof(netbyte_store) ); + while ( iter ) + { + type = (__NBT_TYPED)c[0]; + switch( type ) + { + case NBT_U8: + { + nb_u8 *u8 = malloc( sizeof(nb_u8) ); + + memcpy( u8, c, sizeof(nb_u8) ); + c += sizeof(nb_u8); + + nb_add_u8( store, u8 ); + + free(u8); + + break; + } + case NBT_U8ARRAY: + { + nb_u8arr *u8arr = malloc( sizeof(nb_u8arr) ); + + memcpy( u8arr, c, sizeof(__NBT_TYPED)); + c += sizeof(__NBT_TYPED); + + memcpy( &u8arr->len, c, sizeof(__NBT_U8ARR_LEN) ); + c += sizeof(__NBT_U8ARR_LEN); + + u8arr->val = c; + //printf("->2 %s\n",c ); + c += u8arr->len; + + nb_add_u8arr( store, u8arr ); + + free(u8arr); + + break; + } + case NBT_U16: + { + nb_u16 *u16 = malloc( sizeof(nb_u16) ); + + memcpy( u16, c, sizeof(nb_u16) ); + c += sizeof(nb_u16); + + nb_add_u16( store, u16 ); + + break; + } + case NBT_U16ARRAY: + { + nb_u16arr *u16arr = malloc( sizeof(nb_u16arr) ); + + memcpy( u16arr, c, sizeof(__NBT_TYPED)); + c += sizeof(__NBT_TYPED); + + memcpy( &u16arr->len, c, sizeof(__NBT_U16ARR_LEN) ); + c += sizeof(__NBT_U16ARR_LEN); + + u16arr->val = (uint16_t *)c; + //printf("->2 %s\n",c ); + c += u16arr->len*sizeof(uint16_t); + + nb_add_u16arr( store, u16arr ); + break; + } + case NBT_U32: + { + nb_u32 *u32 = malloc( sizeof(nb_u32) ); + + memcpy( u32, c, sizeof(nb_u32) ); + c += sizeof(nb_u32); + + nb_add_u32( store, u32 ); + break; + } + case NBT_U32ARRAY: + { + nb_u32arr *u32arr = malloc( sizeof(nb_u32arr) ); + + memcpy( u32arr, c, sizeof(__NBT_TYPED)); + c += sizeof(__NBT_TYPED); + + memcpy( &u32arr->len, c, sizeof(__NBT_U32ARR_LEN) ); + c += sizeof(__NBT_U32ARR_LEN); + + u32arr->val = (uint32_t *)c; + //printf("->2 %s\n",c ); + c += u32arr->len*sizeof(uint32_t); + + nb_add_u32arr( store, u32arr ); + break; + } + case NBT_U64: + { + nb_u64 *u64 = malloc( sizeof(nb_u64) ); + + memcpy( u64, c, sizeof(nb_u64) ); + c += sizeof(nb_u64); + + nb_add_u64( store, u64 ); + break; + } + case NBT_U64ARRAY: + { + nb_u64arr *u64arr = malloc( sizeof(nb_u64arr) ); + + memcpy( u64arr, c, sizeof(__NBT_TYPED)); + c += sizeof(__NBT_TYPED); + + memcpy( &u64arr->len, c, sizeof(__NBT_U64ARR_LEN) ); + c += sizeof(__NBT_U64ARR_LEN); + + u64arr->val = (uint64_t *)c; + //printf("->2 %s\n",c ); + c += u64arr->len; + + nb_add_u64arr( store, u64arr ); + break; + } + default: + printf("Unknown type"); + } + if ( c >= data + size ) + { + iter = 0; + } + } + + return 0; +} + +int nb_count( netbyte_store *store ) +{ + if ( store == NULL ) + { + return -1; + } + + return store->count; +} + + +int nb_type( netbyte_store *store, int count, __NBT_TYPED **type ) +{ + __NBT_TYPED nbt; + if ( store == NULL ) + { + return -1; + } + + if ( store->count < count ) + { + return -2; + } + + //nbt = (__NBT_TYPED)store->types[count].type; //warnign? who cares + //*type = nbt; + *type = store->types[count].type; + return 0; +} + +int nb_val( netbyte_store *store, int count, __nb_type **type ) +{ + if (!store) + { + return -1; + } + + if ((count < 0)||(count > store->count)) + { + return -1; + } + + *type = &store->types[count]; + + return 0; +} + + +int nb_fread( netbyte_store *store, int fd) +{ + __NBT_SIZE size; + ssize_t ret; + off_t old_seek; + uint8_t *nb; + + if ( store == NULL ) + { + return -1; + } + + if ( fd < 1 ) + { + return -2; + } + + nb_init( store ); + + old_seek = lseek( fd, 0, SEEK_CUR); + if ( read( fd, &size, sizeof(__NBT_SIZE) ) != sizeof(__NBT_SIZE) ) + { + printf("Couldn read netbyte size\n"); + return -3; + } + + if ( lseek( fd, old_seek, SEEK_SET ) == -1 ) + { + return -4; + } + + //different endianess can blow this up muahaha + nb = malloc( size ); + + if ( read( fd, nb, size ) != size ) + { + return -5; + } + + if ( nb_load( store, nb ) != 0 ) + { + printf("Cannot read nebyte from file\n"); + return -6; + } + + free(nb); nb=NULL; + + return 0; +} + +int nb_print(netbyte_store *store) +{ + int i; + + if (!store) + { + printf("nb: NULL\n"); + return -1; + } + + printf("nb: size=0x%x count=0x%x\n", store->size, store->count); + + for (i=0;icount;i++) + { + printf("\t[%x] -> ", i); + switch (store->types[i].type) + { + case NBT_U8: + { + nb_u8 *u8 = (nb_u8 *)store->types[i].nb_val; + printf("u8: t=0x%x v=0x%x", + u8->type, u8->val); + break; + } + case NBT_U8ARRAY: + { + nb_u8arr *u8arr = (nb_u8arr *)store->types[i].nb_val; + printf("u8arr: t=0x%x l=0x%x v=0x%x", + u8arr->type, u8arr->len, u8arr->val); + break; + } + default: + printf("Unknown"); + } + printf("\n"); + } + + return 0; +} + +int nb_match(netbyte_store *store, nb_tok_arr *pattern) +{ + int i; + int ret = 0; + + if (store == NULL) + { + return -1; + } + + if (pattern == NULL) + { + return -1; + } + + if (store->count != pattern->len) + { + return 1; + } + + printf("pat->len%d\n",pattern->len); + for (i=0;i < pattern->len;i++) + { + printf("[%d]\n",i); + __NBT_TYPED type = store->types[i].type; + void *val = store->types[i].nb_val; + nb_tok pat_tok = pattern->tok[i]; + int eq = 0; + + switch (type) + { + case NBT_U8: + { + printf("NBT_U8\n"); + nb_u8 *u8 = (nb_u8 *)val; + + if ((pat_tok.type_size == 8)&& + (pat_tok.sign == SIGN_UNSIGNED)&& + (pat_tok.arr == 0)) + { + eq = 1; + } + break; + } + //if array 0 then its same as [] == [0]! + case NBT_U8ARRAY: + { + printf("NBT_U8ARRAY\n"); + nb_u8arr *u8arr = (nb_u8arr *)val; + + if ((pat_tok.type_size == 8)&& + (pat_tok.sign == SIGN_UNSIGNED)&& + (pat_tok.arr == 1)) //&& + //(u8arr->len == pat_tok.len)) //could be bug with []/[0] + { + eq = 1; + } + break; + } + case NBT_I32: + { + printf("NBT_I32\n"); + if ((pat_tok.type_size == 32)&& + (pat_tok.sign == SIGN_SIGNED)) + { + eq = 1; + } + break; + } + default: + printf(">>nb_match ERROR<<\n"); + } + if (eq==0) + { + ret = 1; + break; + } + } + + return ret; +} + +nb_tok_arr *nb_tok_create(int size) +{ + nb_tok_arr *ret=NULL; + + ret = malloc(sizeof(nb_tok_arr)); + memset(ret,0,sizeof(nb_tok_arr)); + + ret->tok = malloc(sizeof(nb_tok)*size); + memset(ret->tok, 0, sizeof(nb_tok)*size); + + ret->size = size; + ret->len = 0; + + return ret; +} + +int nb_tok_add(nb_tok_arr *arr, int sign, int type_size, int len, int farr) +{ + if (arr==NULL) + { + return -1; + } + + if (arr->len >= arr->size-1) + { + return -1; + } + + + arr->tok[arr->len].sign = sign; + arr->tok[arr->len].type_size = type_size; + arr->tok[arr->len].len = len; + arr->tok[arr->len].arr = farr; + arr->len += 1; + + return 0; +} + +void nb_tok_destroy(nb_tok_arr *arr) +{ + if (arr == NULL) + { + return; + } + + if (arr->tok) + { + free(arr->tok); + arr->tok = NULL; + } + + free(arr); + arr = NULL; +} + +#define S_START 1 +#define S_SIGN 2 +#define S_SIZE 3 +#define S_NUMBER 4 +#define S_COMM 5 +#define S_ERR 6 +#define S_LBREAK 7 +#define S_RBREAK 8 +#define S_ARRSIZE 9 +#define S_END 10 +#define S_STARTE 11 + +#define NB_MATCH(CH) ((*c)==(CH)) +#define NB_MATCHDIG() (isdigit(*c)) +#define NB_MOVE() (c++); + +int nb_parse_num(char *s, char *e) +{ + const int num_sz = 17; + int str_sz=-1; + char num[num_sz]; + + memset(num, 0, num_sz); + + str_sz = e-s; + if (str_sz>num_sz-1) + { + printf("ERROR\n"); + return -1; + } + memcpy(num,s,str_sz); + + return atoi(num); +} + +int nb_parse(char *str, nb_tok_arr *arr) +{ + int cnt=0; + nb_tok tok; + int state = S_START; + char *c; + c = str; + char *st=NULL,*en=NULL; + int ret = 0; + + memset(&tok, 0, sizeof(tok)); + printf("\"%s\"\n",str); + while (*c!=0) + { + printf("[%c] ",*c); + switch (state) + { + case S_START: + { + printf("START\n"); + + if (NB_MATCH('u')) + { + printf("!1\n"); + tok.sign = SIGN_UNSIGNED; + state = S_SIGN; + } else if (NB_MATCH('i')) + { + printf("!2\n"); + tok.sign = SIGN_SIGNED; + state = S_SIGN; + } else { + printf("!3\n"); + state = S_ERR; + } + printf("!\n"); + break; + } + case S_STARTE: + { + printf("STARTE\n"); + printf("S:%d TS:%d L:%d A:%d\n", + tok.sign, tok.type_size, tok.len, tok.arr + ); + nb_tok_add(arr, tok.sign, tok.type_size, tok.len, tok.arr); + memset(&tok,0,sizeof(nb_tok)); + state = S_START; + break; + } + case S_SIGN: + { + printf("SIGN\n"); + if (NB_MATCH('i')) + { + state = S_SIZE; + NB_MOVE(); + } else if (NB_MATCH('u')) + { + state = S_SIZE; + NB_MOVE(); + } else + { + state = S_ERR; + } + break; + } + case S_SIZE: + { + printf("SIZE\n"); + if (NB_MATCHDIG()) + { + if (st==NULL) st=c; + NB_MOVE(); + } else if (NB_MATCH(',')) + { + en=c; + tok.type_size = nb_parse_num(st,en); + en=NULL; st=NULL; + + state = S_STARTE; + NB_MOVE(); + } else if (NB_MATCH('[')) + { + en=c; + tok.type_size = nb_parse_num(st,en); + en=NULL; st=NULL; + + state = S_LBREAK; + NB_MOVE(); + } else if (NB_MATCH(' ')) + { + en=c; + tok.type_size = nb_parse_num(st,en); + en=NULL; st=NULL; + + state = S_END; + } else + { + state = S_ERR; + } + break; + } + case S_NUMBER: + { + printf("NUMBER\n"); + if (NB_MATCHDIG()) + { + if(st==NULL) st=c; + + NB_MOVE(); + } else if (NB_MATCH(']')) + { + en=c; + tok.type_size = nb_parse_num(st,en); + tok.arr = 1; + en=NULL; st=NULL; + + state = S_RBREAK; + NB_MOVE(); + } + break; + } + case S_COMM: + { + printf("COMM\n"); + state = S_STARTE; + NB_MOVE(); + break; + } + case S_ERR: + { + printf("ERR\n"); + state = -1; + break; + } + case S_LBREAK: + { + printf("LBREAK\n"); + if (NB_MATCHDIG()) + { + state = S_NUMBER; + } else if (NB_MATCH(']')) + { + state = S_RBREAK; + tok.arr = 1; + NB_MOVE(); + } else + { + state = S_ERR; + } + break; + } + case S_RBREAK: + { + printf("RBREAK\n"); + if (NB_MATCH(',')) + { + state = S_COMM; + } else + { + state = S_END; + } + break; + } + case S_ARRSIZE: + { + printf("ARRSIZE\n"); + break; + } + case S_END: + { + printf("END\n"); + printf("S:%d TS:%d L:%d A:%d\n", + tok.sign, tok.type_size, tok.len, tok.arr + ); + nb_tok_add(arr, tok.sign, tok.type_size, tok.len, tok.arr); + memset(&tok,0,sizeof(nb_tok)); + state = -1; + break; + } + default: + { + printf("Unknown state\n"); + } + + } + cnt++; + if (cnt>32) + { + printf("Loop\n"); + break; + } + if (state == -1) + { + printf("state\n"); + break; + } + } + + return ret; +} \ No newline at end of file diff --git a/extlibs/netbytes.h b/extlibs/netbytes.h new file mode 100644 index 0000000..3960142 --- /dev/null +++ b/extlibs/netbytes.h @@ -0,0 +1,191 @@ +#ifndef __NETBYTES_H +#define __NETBYTES_H + +#include +#include +#include +#include +#include +#include +#include + +/* types that are supported */ +#define NBT_NONE 0x00 /* maybe not yet prepared type */ +#define NBT_U8 0x01 /* single unsigned 8 bits */ +#define NBT_U8ARRAY 0x02 /* u8 array */ +#define NBT_U16 0x03 /* unsigned 16 bit */ +#define NBT_U16ARRAY 0x04 /* u16 array */ +#define NBT_U32 0x05 /* unsigned 32 bit */ +#define NBT_U32ARRAY 0x06 /* u32 array */ +#define NBT_U64 0x07 /* unsigned 64 bit */ +#define NBT_U64ARRAY 0x08 /* u64 array */ +#define NBT_I8 0x09 /* signed 8 bits */ +#define NBT_I8ARRAY 0x0A /* i8 array */ +#define NBT_I16 0x0B /* signed 16bits */ +#define NBT_I16ARRAY 0x0C /* i16 array */ +#define NBT_I32 0x0D /* signed 32 bits */ +#define NBT_I32ARRAY 0x0E /* i32 array */ +#define NBT_I64 0x0F /* signed 64 bits */ +#define NBT_I64ARRAY 0x10 /* i64 array */ +#define NBT_F16 0x11 /**/ +#define NBT_F32 0x12 /**/ +#define NBT_F64 0x13 /**/ +#define NBT_F80 0x14 /**/ +#define NBT_NULL 0x15 /* official empty type */ +#define NBT_LIST 0x16 /* list of data */ + + +/* data typed used */ +#define __NBT_SIZE uint32_t +#define __NBT_TYPED uint8_t +#define __NBT_U8ARR_LEN uint16_t +#define __NBT_U16ARR_LEN uint16_t +#define __NBT_U32ARR_LEN uint16_t +#define __NBT_U64ARR_LEN uint16_t + +#define __NBT_MINIMAL_SIZE (sizeof(__NBT_SIZE)) +#define __NBT_MAX_TYPES (256) + +//creating netbyte structure +typedef struct __nb_type { + __NBT_TYPED type; + uint8_t *nb_val; +} __nb_type; + +typedef struct netbyte_store +{ + __NBT_SIZE size; + int count; + __nb_type types[__NBT_MAX_TYPES]; +} netbyte_store; + +typedef struct nb_u8 +{ + __NBT_TYPED type; + uint8_t val; +} nb_u8; + +typedef struct nb_u8arr +{ + __NBT_TYPED type; + __NBT_U8ARR_LEN len; + uint8_t *val; +} nb_u8arr; + + +/*-----------------*/ +typedef struct nb_u16 +{ + __NBT_TYPED type; + uint16_t val; +} nb_u16; + +typedef struct nb_u16arr +{ + __NBT_TYPED type; + __NBT_U16ARR_LEN len; + uint16_t *val; +} nb_u16arr; + + +/*-----------------*/ +typedef struct nb_u32 +{ + __NBT_TYPED type; + uint32_t val; +} nb_u32; + +typedef struct nb_u32arr +{ + __NBT_TYPED type; + __NBT_U32ARR_LEN len; + uint32_t *val; +} nb_u32arr; + + +/*------------------*/ +typedef struct nb_u64 +{ + __NBT_TYPED type; + uint64_t val; +} nb_u64; + +typedef struct nb_u64arr +{ + __NBT_TYPED type; + __NBT_U64ARR_LEN len; + uint64_t *val; +} nb_u64arr; + +//loading/parsing netbyte structure +typedef struct netbyte_load +{ + __NBT_SIZE size; + uint8_t *buf; +} netbyte_load; + +typedef struct nb_tok +{ + int sign; + int type_size; + int len; + int arr; +} nb_tok; + +typedef struct nb_tok_arr +{ + int size; + int len; + nb_tok *tok; +} nb_tok_arr; + +int nb_u8_create( nb_u8 *s, uint8_t val ); +int nb_u8arr_create( nb_u8arr *s, __NBT_U8ARR_LEN len, uint8_t *val ); +int nb_u16_create( nb_u16 *s, uint16_t val ); +int nb_u16arr_create( nb_u16arr *s, __NBT_U16ARR_LEN len, uint16_t *val ); +int nb_u32_create( nb_u32 *s, uint32_t val ); +int nb_u32arr_create( nb_u32arr *s, __NBT_U32ARR_LEN len, uint32_t *val ); +int nb_u64_create( nb_u64 *s, uint64_t val ); +int nb_u64arr_create( nb_u64arr *s, __NBT_U64ARR_LEN len, uint64_t *val ); + +int nb_init( netbyte_store *store ); +int nb_add_u8( netbyte_store *store, nb_u8 *u8 ); +int nb_add_u8arr( netbyte_store *store, nb_u8arr *u8arr ); +int nb_add_u16( netbyte_store *store, nb_u16 *u16 ); +int nb_add_u16arr( netbyte_store *store, nb_u16arr *u16arr ); +int nb_add_u32( netbyte_store *store, nb_u32 *u32 ); +int nb_add_u32arr( netbyte_store *store, nb_u32arr *u32arr ); +int nb_add_u64( netbyte_store *store, nb_u64 *u64 ); +int nb_add_u64arr( netbyte_store *store, nb_u64arr *u64arr ); + +uint8_t *nb_create( netbyte_store *store ); +int nb_free(netbyte_store *store); + + +int nb_load( netbyte_store *store, uint8_t *data ); +int nb_count( netbyte_store *store ); +int nb_type( netbyte_store *store, int count, __NBT_TYPED **type ); +int nb_val( netbyte_store *store, int count, __nb_type **type ); +int nb_fread( netbyte_store *store, int fd); + +//print all all values in netbyte string +int nb_print(netbyte_store *store); + +/* +check if netbyte matches particular format +-1 err +1 not match +0 match +*/ +int nb_match(netbyte_store *store, nb_tok_arr *pattern); + +#define SIGN_UNSIGNED 1 +#define SIGN_SIGNED 2 + +nb_tok_arr *nb_tok_create(int size); +int nb_tok_add(nb_tok_arr *arr, int sign, int type_size, int len, int farr); +void nb_tok_destroy(nb_tok_arr *arr); + +int nb_parse(char *str, nb_tok_arr *arr); + +#endif \ No newline at end of file -- cgit v1.2.3