#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;
}