From 9514d70e98fa7f8fa26f991586169b9da09e7ea6 Mon Sep 17 00:00:00 2001 From: FreeArtMan <=> Date: Sat, 7 Nov 2015 18:16:23 +0000 Subject: Inititial commit --- netbytes.c | 323 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 323 insertions(+) create mode 100644 netbytes.c (limited to 'netbytes.c') diff --git a/netbytes.c b/netbytes.c new file mode 100644 index 0000000..7250aac --- /dev/null +++ b/netbytes.c @@ -0,0 +1,323 @@ +#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_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 ) +{ + if ( store->count >= __NBT_MAX_TYPES - 1 ) + return -1; + + if ( u8->type != NBT_U8 ) + return -2; + + store->types[store->count].type = NBT_U8; + store->types[store->count].nb_val = (uint8_t *)u8; + store->count += 1; + return 0; +} + + +int nb_add_u8arr( netbyte_store *store, nb_u8arr *u8arr ) +{ + if ( store->count >= __NBT_MAX_TYPES - 1 ) + return -1; + + if ( u8arr->type != NBT_U8ARRAY ) + return -2; + + store->types[store->count].type = NBT_U8ARRAY; + store->types[store->count].nb_val = (uint8_t *)u8arr; + 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) + 1; + break; + case NBT_U8ARRAY: + { + nb_u8arr *u8arr = (nb_u8arr *)iter.nb_val; + store->size += sizeof(__NBT_TYPED) + + sizeof(__NBT_U8ARR_LEN) + + u8arr->len; + } + 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; + } + 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_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 ); + + 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 ); + + 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 ) +{ + if ( store == NULL ) + { + return -1; + } + + if ( store->count < count ) + { + return -2; + } + + *type = store->types[count].type; //warnign? who cares + + return 0; +} + +int nb_val( netbyte_store *store, int count, uint8_t **val ) +{ + if ( store == NULL ) + return -1; + + if ( store->count < count ) + return -2; + + *val = store->types[count].nb_val; + + 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; + } + + return 0; +} -- cgit v1.2.3