---

async.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.
 */

/* NOTE TO DEVELOPERS:
   Async variables are currently unused, because no architecture for mixing
   the sync and async comm has been defined yet. Possible solutions include
   signals (which are partly implemented and under #ifdef USE_ASYNC), or
   perhaps threads and two sockets. 
   This file, however, has been kept uptodate with changes that may affect it. */

#include "_dicelib.h"
#include <string.h>
#include "hash.h"

#if 0

static HashTable dice_async_var;

struct dice_async {
        char                    *name;          
        char                    *type;          
        void                    *value;         
        void                    *nextvalue;     
        int                     locked;         
};

void dice_async_free ( void *data ) {
        struct dice_async       *da;

        if ( !data )
                return;

        da = (struct dice_async *)data;
        dice_free(da->name);
        dice_type_free(da->type, da->value);
        dice_type_free(da->type, da->nextvalue);
        dice_free(da->type);
        free(da);
}

int dice_async_init ( void ) {
        if ( hash_init(&dice_async_var, 128, NULL) == -1 )
                return -1;
        
        return 0;
}

void dice_async_end ( void ) {
        hash_free(&dice_async_var, dice_async_free);
}

#undef FUNCTION
#define FUNCTION                "dice_async_new"

int dice_async_new ( char *name, char *type, void *value ) {
        struct dice_async               *da;
        dice_packet                     packet;

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

        if ( !name || !dice_type_is_valid(type) ) {
                _dice_debug(1, dice_printf(FUNCTION, "Invalid type or NULL name.\n");)
                return -1;
        }
        if ( hash_data(&dice_async_var, da->name) ) {
                _dice_debug(1, dice_printf(FUNCTION, "Variable already exists.\n");)
                return -1;
        }

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

        da->name = strdup(name);
        if ( !da->name ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL strdup.\n");)
        }
        da->type = strdup(type);
        if ( !da->type ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL strdup 2.\n");)
        }
        da->value = value;
        da->nextvalue = NULL;
        da->locked = 0;

        return (hash_insert(&dice_async_var, da->name, da) == -1 ? -1 : 0);
}

#undef FUNCTION
#define FUNCTION                "dice_async_delete"

void dice_async_delete ( char *name ) {
        struct dice_async               *da;

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

        if ( !name ) {
                _dice_debug(2, dice_printf(FUNCTION, "NULL name\n");)
                return;
        }
        da = hash_del(&dice_async_var, name);
        if ( !da ) {
                _dice_debug(2, dice_printf(FUNCTION, " variable not found.\n");)
                return;
        }

        dice_async_free((void *)da);
}

#undef FUNCTION
#define FUNCTION                "dice_async_update"

int dice_async_update ( char *name, char *type, void *value ) {
        struct dice_async       *da;

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

        if ( !name ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL name\n");)
                return -1;
        }
        da = hash_data(&dice_async_var, name);
        if ( !da ) {
                return dice_async_new(name, type, value);
        }

        if ( da->locked ) 
                da->nextvalue = value;
        else
                da->value = value;

        return 0;
}

/*
 * Public functions
 */

#undef FUNCTION
#define FUNCTION                "DICE_async_new"

int DICE_async_new ( char *name, char *type, void *value ) {
        struct dice_async       *da;
        DICE_packet             packet;

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

        if ( dice_data.original_only == 1 && dice_data.is_original == 0 )
                return -3;

        /* check arguments */
        if ( !name || !dice_type_is_valid(type) ) {
                _dice_debug(1, dice_printf(FUNCTION, "Invalid type or NULL name\n");)
                return -1;
        }

        /* check if it already exists */
        da = (struct dice_async *)hash_data(&dice_async_var, name);
        if ( da ) {
                _dice_debug(2, dice_printf(FUNCTION, 
                                "variable %s already exists.\n", name);)
                return -2;
        }

        /* ok, post it */
        packet.variable.packtype = VARIABLE_ASYNC;
        packet.variable.name = name;
        packet.variable.type = type;
        packet.variable.value = value;
        return dice_packet_send(&packet, dice_data.controlsock);
}

#undef FUNCTION
#define FUNCTION                "DICE_async_delete"

int DICE_async_delete ( char *name ) {
        DICE_packet             packet;

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

        if ( dice_data.original_only == 1 && dice_data.is_original == 0 )
                return -3;

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

        /* check if it exists */
        da = (struct dice_async *)hash_data(&dice_async_var, name);
        if ( !da ) {
                _dice_debug(2, dice_printf(FUNCTION, 
                                "variable %s doesn't exist.\n", name);)
                return -2;
        }

        /* send it */
        packet.variable_free.packtype = VARIABLE_FREE_ASYNC;
        packet.variable_free.name = name;
        dice_packet_send(&packet, dice_data.controlsock);
        return 0;
}

#undef FUNCTION
#define FUNCTION                "DICE_async_update"

int DICE_async_update ( char *name, void *value ) {
        dice_packet             packet;

        _dice_debug(3, dice_printf(FUNCTION, "(%s,%p)\n", 
                        name, value);)

        if ( dice_data.original_only == 1 && dice_data.is_original == 0 )
                return -3;

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

        /* check if it exists */
        da = (struct dice_async *)hash_data(&dice_async_var, name);
        if ( !da ) {
                _dice_debug(2, dice_printf(FUNCTION, 
                                "variable %s doesn't exist.\n", name);)
                return -2;
        }

        /* ok, post it */
        packet.variable.packtype = VARIABLE_ASYNC;
        packet.variable.name = name;
        packet.variable.type = "";
        packet.variable.value = value;
        return dice_packet_send(&packet, dice_data.controlsock);
}

#undef FUNCTION
#define FUNCTION                "DICE_async_get"

void *DICE_async_get ( char *name ) {
        struct dice_async       *da;

        _dice_debug(3, dice_printf(FUNCTION, "(%s)\n", name);)
        if ( !name ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL name\n");)
                return NULL;
        }
        da = hash_data(&dice_async_var, name);
        
        if ( !da ) {
                _dice_debug(2, dice_printf(FUNCTION, "not found\n");)
                return NULL;
        }
        
        return da->value;
}

#undef FUNCTION
#define FUNCTION                "DICE_async_lock"

int DICE_async_lock ( char *name ) {
        struct dice_async       *da;

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

        da = hash_data(&dice_async_var, name);
        if ( !da ) {
                _dice_debug(2, dice_printf(FUNCTION, "not found\n");)
                return -2;
        }

        da->locked = 1;
        return 0;
}

#undef FUNCTION
#define FUNCTION                "DICE_async_unlock"

int DICE_async_unlock ( char *name ) {
        struct dice_async       *da;
        
        _dice_debug(3, dice_printf(FUNCTION, "(%s)\n", name);)

        if ( !name ) {
                _dice_debug(1, dice_printf(FUNCTION, "NULL name\n");)
                return -1;
        }
        
        da = hash_data(&dice_async_var, name);
        if ( !da ) {
                _dice_debug(2, dice_printf(FUNCTION, "not found\n");)
                return -2;
        }

        if ( da->locked == 1 && da->nextvalue != NULL) {
                da->value = da->nextvalue;
                da->nextvalue = NULL;

        }
        da->locked = 0; 

        return 0;
}

#endif

---