---

type.c

/* DICElib (DIstributed CAVE Engine library) 
 * Copyright (c) 2001 Bruno Barberi Gnecco <brunobg@lsi.usp.br>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies of the Software, its documentation and marketing & publicity
 * materials, and acknowledgment shall be given in the documentation, materials
 * and software packages that this Software was used.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include "_dicelib.h"
#include "hash.h"
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#ifndef WINDOWS
# ifdef USE_LTDL
#  include <ltdl.h>
# endif
#ifdef HAVE_IEEE754_H
#include <ieee754.h>
#endif /* HAVE_IEEE754_H */
#endif /* WINDOWS */

static HashTable dice_type_table;

struct _dice_type {
        char *          (*pack_func) (void *data, int *n);
        void *          (*unpack_func) (char *data, int *n);
        void            (*free_func) (void *data);
};

int dice_type_is_valid ( char *type ) {
        if ( hash_data(&dice_type_table, type) )
                return 1;
        return 0;
}

#define FUNCTION                "DICE_type_register"

#ifdef USE_LTDL
int DICE_type_register ( char *type ) {
        struct _dice_type       *dt;
        char                    *buffer;
        int                     len;

        _dice_debug(3, dice_printf(FUNCTION, "(%s)\n", type);)

        if ( !type ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL type name\n");)
                return -1;
        }

        dt = (struct _dice_type *)malloc(sizeof(struct _dice_type));
        if ( !dt ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL malloc\n");)
                return -1;
        }

        len = strlen(type)+1+7;
        buffer = (char *)malloc(len*sizeof(char));
        if ( !buffer ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL malloc2\n");)
                return -1;
        }
        strcpy(buffer, type);
        strcat(buffer, "_pack");
        dt->pack_func = lt_dlsym(dice_data.handle, buffer);
        if ( !dt->pack_func ) {
                _dice_debug(1, dice_printf(FUNCTION, "_pack: %s\n", lt_dlerror());)
                return -1;
        }
        strcpy(buffer, type);
        strcat(buffer, "_unpack");
        dt->unpack_func = lt_dlsym(dice_data.handle, buffer);
        if ( !dt->unpack_func ) {
                _dice_debug(1, dice_printf(FUNCTION, "_unpack: %s\n", lt_dlerror());)
                return -1;
        }
        strcpy(buffer, type);
        strcat(buffer, "_free");
        dt->free_func = lt_dlsym(dice_data.handle, buffer);
        if ( !dt->free_func ) {
                _dice_debug(1, dice_printf(FUNCTION, "_free: %s\n", lt_dlerror());)
                return -1;
        }

        if ( hash_insert(&dice_type_table, type, (void *)dt) == -1 ) {
                _dice_debug(1, dice_printf(FUNCTION, "HashInsert returned -1 name\n");)
                return -1;
        }
        free(buffer);
        return 0;
}
#else /* don't USE_LTDL */
int dice_type_register ( DICE_Type *t ) {
        struct _dice_type       *dt;

        _dice_debug(3, dice_printf(FUNCTION, "(%p)\n", t);)

        if ( !t ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL type name\n");)
                return -1;
        }

        if ( !t->name || !t->pack_func || !t->unpack_func || !t->free_func ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL pack, unpack or free function.");)
                return -1;
        }

        dt = (struct _dice_type *)malloc(sizeof(struct _dice_type));
        if ( !dt ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL malloc\n");)
                return -1;
        }
        dt->pack_func = t->pack_func;
        dt->unpack_func = t->unpack_func;
        dt->free_func = t->free_func;
        if ( hash_insert(&dice_type_table, t->name, (void *)dt) == -1 ) {
                _dice_debug(1, dice_printf(FUNCTION, "HashInsert returned -1 name\n");)
                return -1;
        }
        return 0;
}
#endif

#undef FUNCTION
#define FUNCTION                "DICE_type_free"

int DICE_type_free ( char *type, void *data ) {
        struct _dice_type       *dt;

        _dice_debug(3, dice_printf(FUNCTION, "(%s,%p)\n", 
                        type, data);)

        if ( !type ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL type name\n");)
                return -1;
        }
        if ( (dt = hash_data(&dice_type_table, type)) == NULL ) {
                _dice_debug(1, dice_printf(FUNCTION, "type %s not found\n");)
                return -1;
        }
        if ( dt->free_func )
                dt->free_func(data);
        return 0;
}

#undef FUNCTION
#define FUNCTION                "DICE_type_pack"

char *DICE_type_pack ( char *type, void *data, int *n ) {
        struct _dice_type       *dt;

        _dice_debug(3, dice_printf(FUNCTION, "(%s,%p)\n", 
                        type, data);)

        if ( !type ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL type name\n");)
                return NULL;
        }
        if ( (dt = hash_data(&dice_type_table, type)) == NULL ) {
                _dice_debug(1, dice_printf(FUNCTION, "type %s not found\n");)
                return NULL;
        }
        return dt->pack_func(data, n);
}


#undef FUNCTION
#define FUNCTION                "DICE_type_unpack"

void *DICE_type_unpack ( char *type, char *packet, int *n ) {
        struct _dice_type       *dt;

        _dice_debug(3, dice_printf(FUNCTION, "(%s,%p)\n", 
                        type, packet);)

        if ( !type ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL type name\n");)
                return NULL;
        }
        if ( (dt = hash_data(&dice_type_table, type)) == NULL ) {
                _dice_debug(1, dice_printf(FUNCTION, "type %s not found\n");)
                return NULL;
        }

        return dt->unpack_func(packet, n);
}

/*
 * The default packers and unpackers.
 */

/* so it won't segfault for nothing */
void dice_free ( void *data ) {
        _dice_debug(4, dice_printf("dice_free", "(%p)\n", data);)
        if ( data )
                free(data);
}

/* unsigned_char */
char *unsigned_char_pack        ( void *data, int *n ) {
        char                    *buf;
        buf = malloc(4);
        if ( !buf || !data ) {
                *n = -1;
                return NULL;
        }
        memset(buf, 0, 4);
        buf[3] = *(unsigned char *)data;
        *n = 4;
        return buf;
}
void *unsigned_char_unpack      ( char *data, int *n ) {
        unsigned char           *c;
        c = (unsigned char *)malloc(1);
        if ( !c )
                return NULL;
        *c = data[3];
        *n = 4;
        return (void *)c;
}
void unsigned_char_free         ( void *data ) {
        dice_free(data);
}

/* signed_char */
char *signed_char_pack  ( void *data, int *n ) {
        return unsigned_char_pack(data, n);
}
void *signed_char_unpack        ( char *data, int *n ) {
        return unsigned_char_unpack(data, n);
}
void signed_char_free           ( void *data ) {
        dice_free(data);
}

/* unsigned_short */
char *unsigned_short_pack       ( void *data, int *n ) {
        char                    *buf;
        unsigned short          *s;
        buf = malloc(4);
        if ( !buf || !data ) {
                *n = -1;
                return NULL;
        }
        memset(buf, 0, 4);
        s = (unsigned short *)data;
        buf[3] = (char) (*s) & 0xFF;
        buf[2] = (char)((*s)>>8) & 0xFF;
        *n = 4;
        return buf;
}
void *unsigned_short_unpack     ( char *data, int *n ) {
        unsigned short          *s;
        s = (unsigned short *)malloc(sizeof(unsigned short));
        if ( !s )
                return NULL;
        *s = (unsigned short)(data[3]&0xFF) + ((data[2] << 8)&0xFF00);
        *n = 4;
        return (void *)s;
}
void unsigned_short_free        ( void *data ) {
        dice_free(data);
}

/* signed_short */
char *signed_short_pack         ( void *data, int *n ) {
        return unsigned_short_pack(data, n);
}
void *signed_short_unpack       ( char *data, int *n ) {
        return unsigned_short_unpack(data, n);
}
void signed_short_free          ( void *data ) {
        dice_free(data);
}

/* unsigned long */
char *unsigned_long_pack        ( void *data, int *n ) {
        char                    *buf;
        unsigned long           *l;
        l = (unsigned long *)data;
        buf = malloc(4);
        if ( !buf || !data ) {
                *n = -1;
                return NULL;
        }
        buf[3] = (char)(*l)&0xFF;
        buf[2] = (char)((*l)>>8)&0xFF;
        buf[1] = (char)((*l)>>16)&0xFF;
        buf[0] = (char)((*l)>>24)&0xFF;
        *n = 4;
        return buf;
}
void *unsigned_long_unpack      ( char *data, int *n ) {
        unsigned long           *l;
        l = (unsigned long *)malloc(sizeof(unsigned long));
        if ( !l )
                return NULL;
        *l = (unsigned long)(data[3]&0xFF) + ((data[2] << 8)&0xFF00) + 
                ((data[1] << 16)&0xFF0000) + ((data[0] << 24)&0xFF000000);
        *n = 4;
        
        return (void *)l;
}
void unsigned_long_free         ( void *data ) {
        dice_free(data);
}

/* signed_long */
char *signed_long_pack          ( void *data, int *n ) {
        return unsigned_long_pack(data, n);
}
void *signed_long_unpack        ( char *data, int *n ) {
        return unsigned_long_unpack(data, n);
}
void signed_long_free           ( void *data ) {
        dice_free(data);
}

static char _digit_encode       ( char c ) {
        if ( c >= '0' && c <= '9' )
                return c - 48;
        else if ( c == '-' )
                return 0xA;
        else if ( c == '+' )
                return 0xB;
        else if ( c == 'e' || c == 'E' )
                return 0xC;
        else if ( c == '.' )
                return 0xD;
        else if ( c == ' ' )
                return 0xE;
        else { /* should NEVER happen */
                return 0xF;
        }
}
static char _digit_decode       ( char d ) {
        if ( d >= 0 && d <= 9 )
                return d + 48;
        else if ( d == 0xA )
                return '-';
        else if ( d == 0xB )
                return '+';
        else if ( d == 0xC )
                return 'e';
        else if ( d == 0xD )
                return '.';
        else if ( d == 0xE )
                return ' ';
        else { /* should NEVER happen */
                return ' ';
        }
}

/* float, transfer using printf */
char *float_pack                ( void *data, int *n ) {
        char                    *buf;
        char                    temp[13];
        float                   f;
        int                     i;

        f = *(float *)data;
        buf = (char *)malloc(6);
        if ( !buf ) {
                *n = -1;
                return NULL;
        }
        snprintf(temp, 13, "%#.5e", f);
        for ( i = 0; i < 6; i++ )
                buf[i] = (_digit_encode(temp[i<<1]))+
                         (_digit_encode(temp[(i<<1)+1])<<4);
        *n = 6;
        return buf;
}
void *float_unpack              ( char *data, int *n ) {
        float                   *g;
        char                    temp[13];
        int                     i;

        g = (float *)malloc(sizeof(float));
        if ( !g )
                return NULL;
        for ( i = 0; i < 6; i++ ) {
                temp[i<<1] = _digit_decode(data[i] & 0xF);
                temp[(i<<1)+1] = _digit_decode((data[i]>>4) & 0xF);
        }
        temp[12] = '\0';
        *n = 6;
        *g = (float)strtod(temp, NULL);
        return g;
}
void float_free         ( void *data ) {
        dice_free(data);
}

/* double, transfer using printf */
char *double_pack               ( void *data, int *n ) {
        char                    *buf;
        char                    temp[23];
        double                  f;
        int                     i;

        f = *(double *)data;
        buf = (char *)malloc(12);
        if ( !buf ) {
                *n = -1;
                return NULL;
        }
        snprintf(buf, 23, "%#.15e", f);
        for ( i = 0; i < 12; i++ )
                buf[i] = (_digit_encode(temp[i<<1]))+
                         (_digit_encode(temp[(i<<1)+1])<<4);
        *n = 12;
        return buf;
}
void *double_unpack             ( char *data, int *n ) {
        double                  *g;
        char                    temp[23];
        int                     i;

        g = (double *)malloc(sizeof(double));
        if ( !g )
                return NULL;
        for ( i = 0; i < 6; i++ ) {
                temp[i<<1] = _digit_decode(data[i] & 0xF);
                temp[(i<<1)+1] = _digit_decode((data[i]>>4) & 0xF);
        }
        temp[22] = '\0';
        *n = 12;
        *g = (double)strtod(data, NULL);
        return g;
}
void double_free                ( void *data ) {
        dice_free(data);
}

#ifdef HAVE_IEEE754_H
/* float as defined in ieee754. Needs ieee754.h. */
char *float754_pack             ( void *data, int *n ) {
        char                    *buf;
        union ieee754_float     f;

        f.f = *(float *)data;
        buf = (char *)malloc(4);
        if ( !buf ) {
                *n = -1;
                return NULL;
        }
        buf[0] = (f.ieee.negative<<7) | ((f.ieee.exponent>>1)&0x7F);
        buf[1] = ((f.ieee.exponent&0x01)<<7) | ((f.ieee.mantissa>>16)&0x7F);
        buf[2] = (f.ieee.mantissa>>8) & 0xFF;
        buf[3] = (f.ieee.mantissa)&0xFF;
        *n = 4;
        return buf;
}
void *float754_unpack           ( char *data, int *n ) {
        union ieee754_float     f;
        float                   *g;
        g = (float *)malloc(sizeof(float));
        if ( !g )
                return NULL;
        f.ieee.negative = data[0]>>7;
        f.ieee.exponent = ((data[0]<<1)&0xFE) + ((data[1]>>7)&0x01);
        f.ieee.mantissa = (data[3]&0xFF) + ((data[2]<<8)&0xFF00) + 
                        (((data[1]&0x7F)<<16)&0xFF0000);
        *n = 4;
        *g = f.f;
        return g;
}
void float754_free              ( void *data ) {
        dice_free(data);
}

/* double as defined in ieee754. Needs ieee754.h. */
char *double754_pack    ( void *data, int *n ) {
        char                    *buf;
        union ieee754_double    d;

        d.d = *(double *)data;
        buf = (char *)malloc(8);
        if ( !buf ) {
                *n = -1;
                return NULL;
        }
        buf[0] = (d.ieee.negative<<7) + ((d.ieee.exponent>>4)&0x7F);
        buf[1] = (((d.ieee.exponent)<<4)&0xF0) + ((d.ieee.mantissa0>>16)&0x0F);
        buf[2] = (d.ieee.mantissa0>>8) & 0xFF;
        buf[3] = (d.ieee.mantissa0)&0xFF;
        buf[4] = (d.ieee.mantissa1>>24) & 0xFF;
        buf[5] = (d.ieee.mantissa1>>16) & 0xFF;
        buf[6] = (d.ieee.mantissa1>>8) & 0xFF;
        buf[7] = (d.ieee.mantissa1) & 0xFF;
        *n = 8;
        return buf;
}
void *double754_unpack          ( char *data, int *n ) {
        union ieee754_double    d;
        double                  *e;
        e = (double *)malloc(sizeof(double));
        if ( !e ) {
                return NULL;
        }
        d.ieee.negative = data[0]>>7;
        d.ieee.exponent = ((data[0]<<4)&0x7F0) + ((data[1]>>4)&0x0F);
        d.ieee.mantissa0 = (data[3]&0xFF) + ((data[2]<<8)&0xFF00) 
                        + (((data[1]&0x0F)<<16)&0xFF0000);
        d.ieee.mantissa1 = (data[7]&0xFF) + ((data[6]<<8)&0xFF00)
                        + ((data[5]<<16)&0xFF0000) + ((data[4]<<24)&0xFF000000);
        *n = 8;
        *e = d.d;
        return e;
}
void double754_free             ( void *data ) {
        dice_free(data);
}
#endif

/* string */
char *string_pack               ( void *data, int *n ) {
        char                    *buf;
        int                     length, total;

        length = strlen((char *)data);
        total = length + 4-(length%4 == 0 ? 4 : length %4) + 4; /* make it mod4=0 to conform with RFC1014 */
        buf = (char *)malloc(total);
        if ( !buf )
                dice_printf(NULL, "error");
        memset(buf, 0, total);
        buf[3] = (char)(length)&0xFF;   
        buf[2] = (char)((length)>>8)&0xFF;
        buf[1] = (char)((length)>>16)&0xFF;
        buf[0] = (char)((length)>>24)&0xFF;
        memcpy(buf+4, data, length);
        *n = total;
        return buf;
}
void *string_unpack             ( char *data, int *n ) {
        char                    *buf;
        int                     length;
        length = (int)(data[3]&0xFF) + (((int)data[2] << 8)&0xFF00) + 
                (((int)data[1] << 16)&0xFF0000) + (((int)data[0] << 24)&0xFF000000);

        buf = malloc(length+1);
        if ( !buf ) {
                dice_printf("awer", "%s", strerror(errno));
        }
        memcpy(buf, data+4, length);
        buf[length] = '\0';
        *n = length + 4-(length%4 == 0 ? 4 : length %4) + 4;
        return (void *)buf;
}
void string_free                ( void *data ) {
        dice_free(data);
}

#undef FUNCTION
#define FUNCTION                "dice_default_types"
int dice_type_init_defaults ( void ) {
#ifdef USE_LTDL
        char *default_names[] = {
                "unsigned_char",
                "signed_char",
                "unsigned_short",
                "signed_short",
                "unsigned_long",
                "signed_long",
                "float", 
                "double",
#ifdef HAVE_IEEE754_H
                "float754", 
                "double754",
#endif
                "string"
        };
#else /* do not USE_LTDL */
        DICE_Type default_types[] = {
                { "unsigned_char", unsigned_char_pack, unsigned_char_unpack, unsigned_char_free },
                { "signed_char", signed_char_pack, signed_char_unpack, signed_char_free },
                { "unsigned_short", unsigned_short_pack, unsigned_short_unpack, unsigned_short_free },
                { "signed_short", signed_short_pack, signed_short_unpack, signed_short_free },
                { "unsigned_long", unsigned_long_pack, unsigned_long_unpack, unsigned_long_free },
                { "signed_long", signed_long_pack, signed_long_unpack, signed_long_free },
                { "float", float_pack, float_unpack, float_free },
                { "double", double_pack, double_unpack, double_free },
#ifdef HAVE_IEEE754_H
                { "float754", float754_pack, float754_unpack, float754_free },
                { "double754", double754_pack, double754_unpack, double754_free },
#endif
                { "string", string_pack, string_unpack, string_free } };
        DICE_Type *t;
#endif
        int i;

        _dice_debug(3, dice_printf(FUNCTION, "\n");)

        hash_init(&dice_type_table, 64, NULL);
        for ( i = 0; i < sizeof(default_types)/sizeof(DICE_Type); i++ ) {
#ifdef USE_LTDL 
                if ( DICE_type_register(default_names[i]) == -1 ) {
                        _dice_debug(1, dice_printf(FUNCTION, "Could not register %s\n", default_names[i]);)
#else
                if ( dice_type_register(&default_types[i]) == -1 ) {
                        _dice_debug(1, dice_printf(FUNCTION, "Could not register %s\n", default_types->name);)
#endif
                        return -1;
                }
        }
#ifndef USE_LTDL
        t = DICE_MyTypes;
        while (t->name) {
                if ( dice_type_register(t) == -1 ) {
                        _dice_debug(1, dice_printf(FUNCTION, "Could not register %s\n", t->name);)
                        return -1;
                }
                t++;
        }
#endif
        return 0;  
}

void dice_type_free_all ( void ) {
        hash_free(&dice_type_table, dice_free);
}

---