---

_dicelib.h

Go to the documentation of this file.

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

/* internal data */

#ifndef __DICELIB_H
#define __DICELIB_H

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include <stdlib.h>
#include "dicelib.h"

#define _dice_debug(l,c)                if ( l <= dice_data.verbose ) c

struct _dice_data {
        int             verbose;                
        int             port;                   
        int             max_connections;        
        FILE            *error;                 
        void            *handle;                
        char            *color[2];              
        int             original_only;          
        /* server only */
        int             clientnum;              
        struct _clients {
                char            *address;       
                char            *path;          
                char            *function;      
        } *clients;
        enum { NONE, RSH, SSH, BPROC } spawn;   
        /* client only */
        int             id;                     
        char            *controlname;           
        int             controlsock;            
        int             (*function)(void *);    
};
extern struct _dice_data dice_data;

enum _dice_packet_type { 
        INVALID,                                
        SYNC,                                   
        VARIABLE_ASYNC,                         
        VARIABLE_SYNC,                          
        VARIABLE_FREE_ASYNC,                    
        VARIABLE_FREE_SYNC,                     
        READY,                                  
        CONTINUE,                               
        HELLO,                                  
        GOODBYE                                 
};
typedef enum _dice_packet_type dice_packet_type;

union _dice_packet {
        dice_packet_type        packtype;       
        struct {
                dice_packet_type        packtype;       
        } sync;

        struct {
                dice_packet_type        packtype;       
                char                    *name;          
                char                    *type;          
                void                    *value;         
        } variable;
        
        struct {
                dice_packet_type        packtype;       
                char                    *name;          
        } variable_free;

        struct {
                dice_packet_type        packtype;       
        } ready;

        struct {
                dice_packet_type        packtype;       
        } cont;

        struct {
                dice_packet_type        packtype;       
                unsigned long           id;             
                char                    *function;      
        } hello;
        
        struct {
                dice_packet_type        packtype;       
        } goodbye;
};
typedef union _dice_packet dice_packet;

/* initialization */
extern int dice_type_init_defaults ( void );
extern void dice_type_free_all ( void );
extern int dice_sync_init ( void );
extern void dice_sync_end ( void );
extern int dice_async_init ( void );
extern void dice_async_end ( void );
extern int dice_init_client ( void );
extern char *defaultpath;

/*net*/
extern void dice_sync_update_send ( void );
extern int dice_packet_send ( dice_packet *p, int sock );
extern dice_packet dice_packet_get ( int sock );
extern int dice_broadcast ( dice_packet *packet, int except );
extern int dice_control_loop ( int argc, char **argv );

/* utils */
extern int dice_type_register ( DICE_Type *t );
extern int dice_control_hierarchy ( int a, int b );
extern void dice_free ( void *data );
extern char *dice_packet_name ( dice_packet_type t );
extern void dice_printf(char *function, char *format, ...);
extern int dice_type_is_valid ( char *name );

#define dice_is_server()                (dice_data.clientnum != -1)

#ifdef __cplusplus
}
#endif


#endif

---