---

net.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 <string.h>
#include <errno.h>
#include <fcntl.h>
#ifndef WINDOWS
#include <netdb.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#else
#include <winsock.h>
#endif

#define PACK_MAX_LENGTH         16384

#define FUNCTION        "DICE_packet_send"

int dice_packet_send ( dice_packet *p, int socket ) {
        static char                     packet[PACK_MAX_LENGTH];
        char                            *buffer;
        int                             size = 256, sent = 0, i;
        unsigned short                  length = 4;

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

        memset(packet, 0, size);
        packet[0] = (char)p->packtype;
        packet[1] = '\0';

        switch ( p->packtype ) {
          case INVALID:
                return -1;
          case SYNC:
                length = 4;
                break;
          case VARIABLE_ASYNC:
          case VARIABLE_SYNC:
                buffer = DICE_type_pack("string", (void *)p->variable.name, &i);
                memcpy(&packet[length], buffer, i);
                length += i;
                free(buffer);
                buffer = DICE_type_pack("string", (void *)p->variable.type, &i);
                memcpy(&packet[length], buffer, i);
                length += i;
                free(buffer);
                buffer = DICE_type_pack(p->variable.type, (void *)p->variable.value, &i);
                if (length + i >= PACK_MAX_LENGTH) {
                        _dice_debug(1, dice_printf(FUNCTION, "Packet %s is too big: %d bytes\n", 
                                        p->variable.name, length+i);)
                        return -1;
                }
                memcpy(&packet[length], buffer, i);
                length += i;
                free(buffer);
                break;
          case VARIABLE_FREE_ASYNC:
          case VARIABLE_FREE_SYNC:
                buffer = DICE_type_pack("string", (void *)p->variable.name, &i);
                memcpy(&packet[length], buffer, i);
                length += i;
                free(buffer);
                break;
          case READY:
                length = 4;
                break;
          case CONTINUE:
                length = 4;
                break;
          case HELLO:
                buffer = DICE_type_pack("unsigned_long", (void *)&p->hello.id, &i);
                memcpy(&packet[length], buffer, i);
                length += i;
                free(buffer);   
                buffer = DICE_type_pack("string", (void *)p->hello.function, &i);
                memcpy(&packet[length], buffer, i);
                length += i;
                free(buffer);
                break;
          case GOODBYE:
                length = 4;
                break;
          default:
                return -1;
                break;
        }

        packet[2] = (length>>8) & 0xFF;
        packet[3] = length & 0xFF;

        _dice_debug(3, dice_printf(FUNCTION, "type %s, length %d, sending.\n", 
                        dice_packet_name(p->packtype), length);)
        while ( sent < length ) {
                i = send(socket, packet+sent, length-sent, 0);
                if ( i == -1 ) {
                        /* etc */
                        _dice_debug(1, dice_printf(FUNCTION, "%s\n",
                                        strerror(errno));)
                        return -1;
                }
                sent += i;
        }
        return 0;
}

#undef FUNCTION
#define FUNCTION        "DICE_packet_get"

dice_packet dice_packet_get ( int socket ) {
        static unsigned char            queue[16384];
        dice_packet                     pack;
        int                             i;
        unsigned short                  length;
        char                            *p;
        
        _dice_debug(3, dice_printf(FUNCTION, "(%d)\n", socket);)

        pack.packtype = INVALID;

        i = read(socket, queue, 4);
        if ( i < 0 ) {
                _dice_debug(1, dice_printf(FUNCTION, "%s\n",
                                strerror(errno));)
                return pack;
        }
        if ( i == 0 ) {
                /*todo: closed connection... gotta do something here. */
                return pack;
        }
        while ( i != 4 ) { 
                i += read(socket, queue+i, 4-i);
        };

        pack.packtype = (dice_packet_type)queue[0];
        if ( queue[1] != '\0' ) {
                _dice_debug(1, dice_printf(FUNCTION, "Packet has problems.\n");)
                return pack;
        }
        length = (((unsigned int)queue[2])<<8) + (unsigned int)queue[3];

        _dice_debug(3, dice_printf(FUNCTION, "type %s, length %d.\n", 
                        dice_packet_name(pack.packtype), length);)
        /* read the rest of it */
        i = 4;
        while ( i < length )
                i += read(socket, queue+i, length-i);
        p = queue+4;

        /* fill the structure */
        switch ( pack.packtype ) {
          case SYNC:
                return pack;
          case VARIABLE_SYNC:
          case VARIABLE_ASYNC:
                pack.variable.name = (char *)DICE_type_unpack("string", p, &i);
                p += i;
                pack.variable.type = (char *)DICE_type_unpack("string", p, &i);
                p += i;
                if ( !dice_type_is_valid(pack.variable.type) && !dice_is_server() ) {
                        _dice_debug(1, dice_printf(FUNCTION, 
                                        "register %s!", pack.variable.type);)
                        return pack;
#if 0
                        if ( DICE_type_register(pack.variable.type) == -1 ) {
                                /* todo something! */
                        }
#endif
                }
                pack.variable.value = DICE_type_unpack(pack.variable.type, p, &i);
                p += i;
                if ( p - (char *)queue != length )
                        _dice_debug(2, dice_printf(FUNCTION, 
                                        "Packet has problems: size[%d] nominal:[%d].\n",
                                        p - (char *)queue, length);)
                return pack;
          case VARIABLE_FREE_SYNC:
          case VARIABLE_FREE_ASYNC:
                pack.variable.name = (char *)DICE_type_unpack("string", p, &i);
                p += i;
                if ( p - (char *)queue != length )
                        _dice_debug(2, dice_printf(FUNCTION, "Packet has problems.\n");)
                return pack;
          case READY:
                return pack;
          case CONTINUE:
                return pack;
          case HELLO:
                pack.hello.id = *(unsigned long *)DICE_type_unpack("unsigned_long", p, &i);
                p += i;
                pack.hello.function = (char *)DICE_type_unpack("string", p, &i);
                p += i;
                if ( p - (char *)queue != length )
                        _dice_debug(2, dice_printf(FUNCTION, 
                                        "Packet has problems: size[%d] nominal:[%d]; (%ld %s)\n",
                                        p - (char *)queue, length, pack.hello.id, pack.hello.function);)
                return pack;
          case GOODBYE:
                return pack;
          default:
                pack.packtype = INVALID;
                return pack;
        }
}

char *dice_packet_name ( dice_packet_type t ) {
        switch ( t ) {
                case    INVALID:
                        return "INVALID";
                case    SYNC:           
                        return "SYNC";
                case    VARIABLE_ASYNC: 
                        return "VARIABLE_ASYNC";
                case    VARIABLE_SYNC:  
                        return "VARIABLE_SYNC";
                case    VARIABLE_FREE_ASYNC:
                        return "VARIABLE_FREE_ASYNC";
                case    VARIABLE_FREE_SYNC:
                        return "VARIABLE_FREE_SYNC";
                case    READY:          
                        return "READY";
                case    CONTINUE:       
                        return "CONTINUE";
                case    HELLO:
                        return "HELLO";
                case    GOODBYE:
                        return "GOODBYE";
        }
        return NULL;
};

---