---

client.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>
#include <netinet/tcp.h>
#include <sys/time.h>
#include <unistd.h>
#include <signal.h>
# ifdef USE_LTDL
#  include <ltdl.h>
# endif
#else
#include <winsock.h>
#endif

int DICE_is_original ( void ) {
        return (dice_data.id == 0);
}

int DICE_function ( void *data ) {
        if ( dice_data.function )
                return dice_data.function(data);
        return -1;
}
  
#ifdef USE_ASYNC
#define FUNCTION                "dice_client_sigio"

void dice_client_sigio ( int signum ) {
        dice_packet                     packet;
        struct timeval                  tv;
        fd_set                          rfds;
        int                             ret;

        FD_ZERO(&rfds);
        FD_SET(dice_data.controlsock, &rfds);
        tv.tv_sec = 0;
        tv.tv_usec = 0;

        ret = select(dice_data.controlsock+1, &rfds, NULL, NULL, &tv);
        switch ( ret ) {
          case -1:
                _dice_debug(1, dice_printf(FUNCTION, "%s\n", strerror(errno));)
          case 0:
                return;
        }

        /* Ok, there's something there, go get it Rex! */
        packet = dice_packet_get(dice_data.controlsock);
        switch ( packet.packtype ) {
          case INVALID:
                return;
          case SYNC:
                _dice_debug(1, dice_printf(FUNCTION, "got a lonely SYNC!\n");)
                return;
#ifdef USE_ASYNC
          case VARIABLE_ASYNC:
                DICE_async_update(packet.variable.name, packet.variable.value);
                return;
#endif
          case VARIABLE_SYNC:
                _dice_debug(1, dice_printf(FUNCTION, "got a lonely VAR_SYNC!\n");)
                return;
          case READY:
                _dice_debug(1, dice_printf(FUNCTION, "got a lonely READY!\n");)
                return;
          case CONTINUE:
                _dice_debug(1, dice_printf(FUNCTION, "got a lonely CONTINUE!\n");)
                return;
          case GOODBYE:
                _dice_debug(1, dice_printf(FUNCTION, "got a goodbye!\n");)
                exit(0);
                return;
        }
} 
#endif

#undef FUNCTION
#define FUNCTION                "dice_init_client"

int dice_init_client ( void ) {
        int                             flag;
        struct hostent                  *h;
        struct sockaddr_in              addr;
#ifdef USE_ASYNC
        struct sigaction                newaction, oldaction;
#endif
        dice_packet                     packet;

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

        /* Resolve the host */
        if ( (h = gethostbyname(dice_data.controlname)) == NULL ) {
                _dice_debug(1, dice_printf(FUNCTION, "%s\n", strerror(errno));)
                return -1;
        }

        /* Fill out the sockaddr_in structure */
        memset(&addr, 0, sizeof(addr));
        memcpy(&addr.sin_addr, h->h_addr, h->h_length); 
        addr.sin_family = AF_INET;
        addr.sin_port = htons(dice_data.port);

        /* Open the socket. */
        if ( (dice_data.controlsock = socket(AF_INET,SOCK_STREAM,0)) < 0 ) {
                _dice_debug(1, dice_printf(FUNCTION, "%s\n", strerror(errno));)
                return -1;
        }

        /* Attempt to connect */
        if ( connect(dice_data.controlsock, (struct sockaddr *)&addr, sizeof(addr)) < 0 ) {
                _dice_debug(1, dice_printf(FUNCTION, "%s\n", strerror(errno));)
                return -1;
        }

        flag = 1;
        setsockopt(dice_data.controlsock, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(int));

        /* handshaking: get our id. */
        packet = dice_packet_get(dice_data.controlsock);
        if (packet.packtype != HELLO) {
                _dice_debug(1, dice_printf(FUNCTION, "Didn't get a HELLo packet\n");)
                return -1;
        }
        dice_data.id = packet.hello.id;
        if (packet.hello.function) {
#ifdef USE_LTDL
                dice_data.function = lt_dlsym(dice_data.handle, 
                                packet.hello.function);
                if (!dice_data.function)
                        _dice_debug(1, dice_printf(FUNCTION, 
                                        "Error loading function \"%s\": %s\n",
                                        packet.hello.function, lt_dlerror());)
#else
                DICE_Function *f = DICE_MyFunctions;

                while (f->name) {
                        if (!strcmp(f->name, packet.hello.function))
                                break;
                        f++;
                }
  
                if (!f->name) { 
                        _dice_debug(2, dice_printf(FUNCTION,
                                        "Warning: couldn't load function \"%s\"\n",
                                        packet.hello.function);)
                }
                else
                        dice_data.function = f->func;
/*              dice_functions_init(packet.hello.functions); */
#endif
        }
        

#ifdef USE_ASYNC
/* todo: use fcntl(F_SETSIG) to use a signal other than SIGIO */        
        fcntl(dice_data.controlsock, F_SETFL, O_ASYNC);
        newaction.sa_handler = dice_client_sigio;
        sigemptyset(&newaction.sa_mask);
        newaction.sa_flags = SA_RESETHAND | SA_RESTART;

        sigaction(SIGIO, NULL, &oldaction);
        if ( oldaction.sa_handler == SIG_IGN ) {
                _dice_debug(1, dice_printf(FUNCTION, "You cannot use SIGIO.\n");)
                return -1;
        }
        sigaction(SIGIO, &newaction, NULL);
#endif

        return 0;
}

---