sic_comm.c

Go to the documentation of this file.

/***************************************************************************** 
 *                              Dependencies                                 * 
 *****************************************************************************/

#include "sic_comm.h"

#ifndef WIN32
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <time.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/stat.h>
#endif

#ifdef GAG_SYSV
#include <sys/shm.h>
#include <sys/sem.h>
#elif defined(WIN32)
#else /* GAG_SYSV */
#include <fcntl.h>
#include <sys/mman.h>
#include <semaphore.h>
#endif /* GAG_SYSV */
#ifdef cygwin
#include <limits.h>
#endif /* cygwin */

#include "ctrlc.h"
#include "sic_error.h"
#include "gag_trace.h"

/***************************************************************************** 
 *                          Macros & Definitions                             * 
 *****************************************************************************/

#define SIC_DEBUG_COMM
#if defined(darwin) || defined(cygwin) || defined(linux)
#define SIC_USE_SEM_OPEN
#endif

#ifndef SIGCLD
#define SIGCLD SIGCHLD
#endif /* SIGCLD */

#ifdef SIC_DEBUG_COMM
#define SIC_ASSERT( message, condition) \
    { if (!(condition)) fprintf( stderr, "SIC_ASSERT: %s\n", message); }
#else /* SIC_DEBUG_COMM */
#define SIC_ASSERT( message, condition)
#endif /* SIC_DEBUG_COMM */

#define MAX_ARGC 32
#define MAX_ARGV 256

#define SIC_MAX_WIDGET_ON_BOARD 1000
#define SIC_MAX_SHM_NAME 32
#define SIC_MAX_SEM_NAME_FOR_PORTABILITY 14
#define SIC_MAX_HANDLERS 32

/* Event Ids */
#define SIC_MODIFIED_VARIABLE_EVENT 1
#define SIC_REDRAW_PROMPT_EVENT 2

#if defined(GAG_SYSV)
typedef struct {
    int sem_id;
} sic_sem_t;
#define SIC_SEM_ID(x) ((x)->sem_id)
#elif defined(WIN32)
typedef struct {
    HANDLE sem_id;
} sic_sem_t;
#define SIC_SEM_ID(x) ((x)->sem_id)
#else /* defined(GAG_SYSV) */
typedef struct {
#ifdef SIC_USE_SEM_OPEN
    sem_t *sem_id;
#define SIC_SEM_ID(x) ((x)->sem_id)
#else /* SIC_USE_SEM_OPEN */
    sem_t sem_id;
#define SIC_SEM_ID(x) (&(x)->sem_id)
#endif /* SIC_USE_SEM_OPEN */
    char name[SIC_MAX_SEM_NAME_FOR_PORTABILITY];
} sic_sem_t;

#endif /* defined(GAG_SYSV) */

typedef struct {
    task_t task;
    int event_id;
    void (*listener)();
    int sig_num;
} sic_listener_handler_t;

typedef struct {
    task_t master_task;
    task_t keyboard_task;
    int trace_fd;
    sic_sem_t comm_board_access;
    sic_sem_t draw_prompt;
    sic_sem_t write_command;
    sic_sem_t read_command;
    sic_sem_t listener_acquit;
    sic_sem_t widget_board_access;
    sic_sem_t widget_created;
    int widget_board_id;
    command_line_t command_line;
    char pushed_command_text[MAXBUF];
    sic_command_from_t from;
    int listener_count;
    sic_listener_handler_t listeners[SIC_MAX_HANDLERS];
    int event_id;
} sic_comm_board_t;

typedef struct {
    char window_title[TITLELENGTH];
    char help_filename[HLPFILELNGTH];
    char returned_command[COMMANDLENGTH];
    int returned_code;
    sic_widget_def_t modified_widget;
    int widget_count;
    sic_widget_def_t widgets[SIC_MAX_WIDGET_ON_BOARD];
} sic_widget_board_t;

/* Communication board */
static int s_comm_board_id = -1;
static char s_comm_shm_name[SIC_MAX_SHM_NAME];
static sic_comm_board_t *s_comm_board = NULL;
static sic_comm_board_t *s_sem_comm_board = NULL;

/* Widget board */
static char s_widget_shm_name[SIC_MAX_SHM_NAME];
static sic_widget_board_t *s_widget_board = NULL;

/* Flag for Ctrl+C */
static int s_ctrlc_handled = 0;

/***************************************************************************** 
 *                        Internal function bodies                           * 
 *****************************************************************************/

#ifdef cygwin

int shm_open( const char *name, int oflag, mode_t mode)
{
    static int s_first_call = 1;
    int fd;
    char shm_name[PATH_MAX + 20] = "/dev/shm/";

    if (s_first_call) {
        struct stat tmp;
        if (stat( "/dev", &tmp))
            if (mkdir( "/dev", 0777))
                sic_perror( "mkdir");
        if (stat( shm_name, &tmp))
            if (mkdir( shm_name, 0777))
                sic_perror( "mkdir");
        s_first_call = 0;
    }

    /* skip opening slash */
    if (*name == '/')
        ++name;

    /* create special shared memory file name and leave enough space to
       cause a path/name error if name is too long */
    strlcpy( shm_name + 9, name, PATH_MAX + 10);

    fd = open( shm_name, oflag, mode);

    if (fd != -1) {
        /* once open we must add FD_CLOEXEC flag to file descriptor */
        int flags = fcntl( fd, F_GETFD, 0);

        if (flags >= 0) {
            flags |= FD_CLOEXEC;
            flags = fcntl( fd, F_SETFD, flags);
        }

        /* on failure, just close file and give up */
        if (flags == -1) {
            sic_perror( "fcntl");
            close( fd);
            fd = -1;
        }
    } else
        sic_perror( "open");

    return fd;
}

int shm_unlink( const char *name)
{
    int rc;
    char shm_name[PATH_MAX + 20] = "/dev/shm/";

    /* skip opening slash */
    if (*name == '/')
        ++name;

    /* create special shared memory file name and leave enough space to
       cause a path/name error if name is too long */
    strlcpy( shm_name + 9, name, PATH_MAX + 10);

    rc = unlink( shm_name);

    return rc;
}

#endif /* cygwin */

static int sic_shm_create( const char* name, int size)
{
#ifndef WIN32
    int shm_id;

#ifdef GAG_SYSV
    shm_id = shmget( IPC_PRIVATE, size, 0600);

    if (shm_id == -1) {
        sic_perror( "shmget");
    }

#else /* GAG_SYSV */
    shm_id = shm_open( name, O_CREAT | O_RDWR, S_IRWXU | S_IRWXG);
    if (shm_id == -1) {
        sic_perror( "shm_open");
    }

#ifndef DONT_SET_CLOSE_ON_EXEC_TO_ZERO
    if (fcntl( shm_id, F_SETFD, 0) == -1) {
        sic_perror( "fcntl");
    }
#endif /* DONT_SET_CLOSE_ON_EXEC_TO_ZERO */

    if (ftruncate( shm_id, size) == -1) {
        sic_perror( "ftruncate");
    }
#endif /* GAG_SYSV */

    return shm_id;
#else /* WIN32 */
    return 0;
#endif /* WIN32 */
}

static void sic_shm_destroy( const char* name, int shm_id)
{
#ifndef WIN32
#ifdef GAG_SYSV
    if (shmctl( shm_id, IPC_RMID, NULL) == -1) {
        sic_perror( "shmctl");
    }

#else /* GAG_SYSV */
    if (close( shm_id) == -1) {
        sic_perror( "close");
    }

    if (shm_unlink( name) == -1) {
        sic_perror( "shm_unlink");
    }
#endif /* GAG_SYSV */
#endif /* WIN32 */
}

static void* sic_shm_attach( int shm_id, int size)
{
    void* addr = NULL;

#ifndef WIN32
#ifdef GAG_SYSV
    addr = shmat( shm_id, (char *)NULL, 0);
    if ((long)addr == -1) {
        sic_perror( "shmat");
    }

#else /* GAG_SYSV */
    addr = mmap( NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, shm_id, 0);
    if (addr == MAP_FAILED) {
        sic_perror( "mmap");
    }
#endif /* GAG_SYSV */
#endif /* WIN32 */

    return addr;
}

static void sic_shm_detach( void *addr, int size)
{
#ifndef WIN32
#ifdef GAG_SYSV
    if (shmdt( addr) == -1) {
        sic_perror( "shmdt");
    }

#else /* GAG_SYSV */
    if (munmap( addr, size) == -1) {
        sic_perror( "munmap");
    }
#endif /* GAG_SYSV */
#endif /* WIN32 */
}

static void sic_sem_open( sic_sem_t *sem)
{
#ifndef WIN32
#ifndef GAG_SYSV
#ifdef SIC_USE_SEM_OPEN
    static char sem_name[SIC_MAX_SEM_NAME_FOR_PORTABILITY];
    static int count = 0;

#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return;
#endif /* SIC_DEBUG_COMM */

    sprintf( sem_name, "/SIC_%d_%d", sic_get_master_task_id( ), ++count);
    sem_t *ret = sem_open( sem_name, 0);
    if (ret == (sem_t *)SEM_FAILED) {
        sic_perror( "sem_open");
    }
    SIC_SEM_ID(sem) = ret;
#endif /* SIC_USE_SEM_OPEN */
#endif /* GAG_SYSV */
#endif /* WIN32 */
}

static void sic_sem_create( sic_sem_t *sem, unsigned int initial_value)
{
#if defined(WIN32)
    SIC_SEM_ID(sem) = CreateSemaphore( NULL, initial_value, 1, NULL);
    if (SIC_SEM_ID(sem) == NULL) {
        sic_perror( "CreateSemaphore");
    }
#elif defined(GAG_SYSV)
    SIC_SEM_ID(sem) = semget( IPC_PRIVATE, 1, S_IRUSR | S_IWUSR);
    if (SIC_SEM_ID(sem) == -1) {
        sic_perror( "semget");
    }

    if (semctl( SIC_SEM_ID(sem), 0, SETVAL, initial_value) == -1) {
        sic_perror( "semctl");
    }

#else /* GAG_SYSV */
#ifdef SIC_USE_SEM_OPEN
    static char sem_name[SIC_MAX_SEM_NAME_FOR_PORTABILITY];
    static int count = 0;

    sprintf( sem_name, "/SIC_%d_%d", sic_get_master_task_id( ), ++count);
    sem_t *ret = sem_open( sem_name, O_CREAT, S_IRUSR | S_IWUSR, initial_value);
    if (ret == (sem_t *)SEM_FAILED) {
        sic_perror( "sem_open");
    }
    SIC_SEM_ID(sem) = ret;
    strncpy( sem->name, sem_name, SIC_MAX_SEM_NAME_FOR_PORTABILITY);
#else /* SIC_USE_SEM_OPEN */
    if (sem_init( SIC_SEM_ID(sem), 1, initial_value) == -1) {
        sic_perror( "sem_init");
    }
#endif /* SIC_USE_SEM_OPEN */
#endif /* GAG_SYSV */
}

static void sic_sem_close( sic_sem_t *sem)
{
#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return;
#endif /* SIC_DEBUG_COMM */

#if defined(WIN32)
    if (CloseHandle( SIC_SEM_ID(sem)) == FALSE) {
        sic_perror( "CloseHandle");
    }
#elif defined(SIC_USE_SEM_OPEN)
#ifndef cygwin
    if (sem_close( SIC_SEM_ID(sem)) == -1) {
        sic_perror( "sem_close");
    }
#endif /* cygwin */
#endif
}

static void sic_sem_destroy( sic_sem_t *sem)
{
#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return;
#endif /* SIC_DEBUG_COMM */

    sic_sem_close( sem);
#if defined(WIN32)
#elif defined(GAG_SYSV)
    if (semctl( SIC_SEM_ID(sem), 0, IPC_RMID) == -1) {
        sic_perror( "semctl");
    }
#elif defined(SIC_USE_SEM_OPEN)
#ifndef cygwin
    if (sem_unlink( sem->name) == -1) {
        sic_perror( "sem_unlink");
    }
#else /* cygwin */
    if (sem_close( SIC_SEM_ID(sem)) == -1) {
        sic_perror( "sem_close");
    }
#endif /* cygwin */
#else
    if (sem_destroy( SIC_SEM_ID(sem)) == -1) {
        sic_perror( "sem_destroy");
    }
#endif /* GAG_SYSV */
}

static void sic_sem_post( sic_sem_t *sem)
{
#if defined(GAG_SYSV)
    struct sembuf sops;
#endif

#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return;
#endif /* SIC_DEBUG_COMM */

#if defined(WIN32)
    if (!ReleaseSemaphore( SIC_SEM_ID(sem), 1, NULL)) {
        sic_perror( "ReleaseSemaphore");
    }
#elif defined(GAG_SYSV)
    sops.sem_num = 0;
    sops.sem_op = 1;
    sops.sem_flg = 0;

    if (semop( SIC_SEM_ID(sem), &sops, 1) == -1) {
        sic_perror( "semop");
    }

#else /* GAG_SYSV */
    if (sem_post( SIC_SEM_ID(sem)) == -1) {
        sic_perror( "sem_post");
    }
#endif /* GAG_SYSV */
}

static void sic_sem_wait( sic_sem_t *sem)
{
#if defined(GAG_SYSV)
    struct sembuf sops;
#endif

#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return;
#endif /* SIC_DEBUG_COMM */

#if defined(WIN32)
    if (WaitForSingleObject( SIC_SEM_ID(sem), INFINITE) != WAIT_OBJECT_0) {
        sic_perror( "WaitForSingleObject");
    }
#elif defined(GAG_SYSV)
    sops.sem_num = 0;
    sops.sem_op = -1;
    sops.sem_flg = 0;

    while (semop( SIC_SEM_ID(sem), &sops, 1) == -1) {
        if (errno == EINTR)
            errno = 0;
        else
            sic_perror( "semop");
    }
#else /* GAG_SYSV */
    while (sem_wait( SIC_SEM_ID(sem)) == -1) {
        if (errno == EINTR)
            errno = 0;
        else
            sic_perror( "sem_wait");
    }
#endif /* GAG_SYSV */
}

static int sic_sem_timed_wait( sic_sem_t *sem, int timeout)
{
    int ret = 0;

#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return 0;
#endif /* SIC_DEBUG_COMM */

    if (timeout == -1) {
        sic_sem_wait( sem);
        return 0;
    } else {
#if defined(WIN32)
        DWORD wait = WaitForSingleObject( SIC_SEM_ID(sem), timeout);
        if (wait != WAIT_OBJECT_0) {
            if (wait == WAIT_TIMEOUT)
                ret = -1;
            else
                sic_perror( "WaitForSingleObject");
        }
#elif defined(GAG_SYSV) || defined(darwin)
        sic_sem_wait( sem);
#else /* defined(GAG_SYSV) || defined(darwin) */
        struct timespec t;

        clock_gettime( CLOCK_REALTIME, &t);

        /* seconds */
        time_t nb_sec = timeout / 1000;
        /* nano seconds */
        long nb_nsec = (timeout - nb_sec * 1000) * 1000000L;
        if (nb_nsec + t.tv_nsec > 1000000000L) {
            nb_sec++;
            nb_nsec -= 1000000000L;
        }
        t.tv_sec += nb_sec;
        t.tv_nsec += nb_nsec;

        ret = sem_timedwait( SIC_SEM_ID(sem), &t);
        if (ret == -1) {
            if (errno == EINTR || errno == ETIMEDOUT)
                errno = 0;
            else
                sic_perror( "sem_timedwait");
        }
#endif /* defined(GAG_SYSV) || defined(darwin) */
    }
    return ret;
}

static void sic_on_modified_variable( sic_listener_handler_t *h)
{
    gag_trace( "<trace> sic_on_modified_variable");
    /* no need to call sic_open_widget_board because already done by sic_fire_modified_variable_event */
    (*(sic_modified_variable_listener_t)h->listener)( &s_widget_board->modified_widget);
}

static void sic_on_redraw_prompt( sic_listener_handler_t *h)
{
    gag_trace( "<trace> sic_on_redraw_prompt");
    (*(sic_redraw_prompt_listener_t)h->listener)( &s_comm_board->command_line);
}

static void sic_on_event( sic_listener_handler_t *h)
{
    switch (h->event_id) {
    case SIC_MODIFIED_VARIABLE_EVENT:
        sic_on_modified_variable( h);
        break;
    case SIC_REDRAW_PROMPT_EVENT:
        sic_on_redraw_prompt( h);
        break;
    }
#ifndef WIN32
    sic_sem_post( &s_sem_comm_board->listener_acquit);
#endif
}

static void sic_event_handler( int sig_num)
{
    int i;
    int event_id = s_comm_board->event_id;

#ifndef WIN32
    signal( sig_num, sic_event_handler);
#endif /* WIN32 */
    for (i = 0; i < s_comm_board->listener_count; i++) {
        sic_listener_handler_t *h = &s_comm_board->listeners[i];
        if (h->event_id == event_id) {
            sic_on_event( h);
        }
    }
}

static void sic_record_listener( sic_listener_handler_t *widget_handler)
{
#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return;
#endif /* SIC_DEBUG_COMM */

    sic_sem_wait( &s_sem_comm_board->comm_board_access);

    s_comm_board->listeners[s_comm_board->listener_count++] = *widget_handler;
#ifndef WIN32
    signal( widget_handler->sig_num, sic_event_handler);
#endif /* WIN32 */

    sic_sem_post( &s_sem_comm_board->comm_board_access);
}

static void sic_trigger_listener( sic_listener_handler_t *h)
{
#ifndef WIN32
    if (kill( h->task, h->sig_num) == 0)
        sic_sem_timed_wait( &s_sem_comm_board->listener_acquit, 1000);
#else /* WIN32 */
    sic_on_event( h);
#endif /* WIN32 */
}

static void sic_trigger_listeners( int event_id)
{
    int i;

    sic_sem_wait( &s_sem_comm_board->comm_board_access);

    s_comm_board->event_id = event_id;

    for (i = 0; i < s_comm_board->listener_count; i++) {
        sic_listener_handler_t *h = &s_comm_board->listeners[i];
        if (h->event_id == event_id)
            sic_trigger_listener( h);
    }

    sic_sem_post( &s_sem_comm_board->comm_board_access);
}

static void sic_purge_listeners( task_t task)
{
    int i;
    int j;

    sic_sem_wait( &s_sem_comm_board->comm_board_access);

    j = 0;
    for (i = 0; i < s_comm_board->listener_count; i++) {
        sic_listener_handler_t *h = &s_comm_board->listeners[i];
        if (h->task != task) {
            if (j != i)
                s_comm_board->listeners[j] = *h;
            j++;
        }
    }
    s_comm_board->listener_count = j;

    sic_sem_post( &s_sem_comm_board->comm_board_access);
}

static int sic_is_master( )
{
    return s_comm_board_id != -1;
}

static void sic_kill_all_child_processes( )
{
#ifndef WIN32
    signal( SIGCLD, SIG_IGN);           /* Avoid zombies */
    signal( SIGTERM, SIG_IGN);          /* don't kill itself */
    kill( 0, SIGTERM);
    wait( 0);
#endif /* WIN32 */
}

static void sic_signal_handler( int sig_num)
{
    gag_trace( "<trace: signal> sic_signal_handler on %d", sig_num);
    sic_do_exit( 1);
}

static void sic_init_handlers( )
{
    atexit( sic_on_exit);
#ifndef WIN32
    if (!s_ctrlc_handled)
        signal( SIGINT, SIG_IGN);
    signal( SIGTTOU, SIG_IGN);

    signal( SIGHUP, sic_signal_handler);
    signal( SIGQUIT, sic_signal_handler);
    signal( SIGILL, sic_signal_handler);
    signal( SIGABRT, sic_signal_handler);
    signal( SIGBUS, sic_signal_handler);
    signal( SIGFPE, sic_signal_handler);
    signal( SIGSEGV, sic_signal_handler);
    signal( SIGPIPE, sic_signal_handler);
    signal( SIGTERM, sic_signal_handler);
    signal( SIGSTOP, sic_signal_handler);
    signal( SIGSYS, sic_signal_handler);
#if defined(SIGIO)
    signal( SIGIO, sic_signal_handler);
#elif defined(SIGPOLL)
    signal( SIGPOLL, sic_signal_handler);
#endif
#endif /* WIN32 */
}

static int sic_raw_post_command_from( const command_line_t *command_line, int timeout, sic_command_from_t from)
{
    int ret;

#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return 0;
#endif /* SIC_DEBUG_COMM */

    gag_trace( "<trace: enter> sic_post_command");
    ret = sic_sem_timed_wait( &s_sem_comm_board->write_command, timeout);
    if (ret == 0) {
        /* keep current prompt */
        strncpy( (char*)command_line->prompt, s_comm_board->command_line.prompt, PROMPT);
        s_comm_board->command_line = *command_line;
        s_comm_board->from = from;
        gag_trace( "<command: send> \"%s%s\"", command_line->prompt, command_line->line);
        sic_sem_post( &s_sem_comm_board->read_command);
    }
    gag_trace( "<trace: leave> sic_post_command");
    return ret;
}

static void sic_build_command_line( const char* text, command_line_t *command_line)
{
    strncpy( command_line->line, text, MAXBUF);
    command_line->nc = (int)strlen( text);
    command_line->prompt[0] = '\0';
    command_line->code = 0;
}

/***************************************************************************** 
 *                             Function bodies                               * 
 *****************************************************************************/

void sic_create_comm_board( )
{
    char *trace = getenv( "SIC_COMM_TRACE");
    if (trace != NULL) {
        gag_trace_open( trace);
    }

    gag_trace( "<trace: enter> sic_create_comm_board");
    if (s_comm_board_id == -1) {
        sprintf( s_comm_shm_name, "/SIC_%d_C", sic_get_current_task_id( ));
        s_comm_board_id = sic_shm_create( s_comm_shm_name, sizeof( sic_comm_board_t));
        sic_open_comm_board( s_comm_board_id);
        s_comm_board->master_task = sic_get_current_task( );
        s_comm_board->keyboard_task = SIC_TASK_NULL;
        if (gag_trace_get_file_pointer( ) != NULL)
            s_comm_board->trace_fd = fileno( gag_trace_get_file_pointer( ));
        else
            s_comm_board->trace_fd = -1;
        sic_sem_create( &s_sem_comm_board->comm_board_access, 1);
        sic_sem_create( &s_sem_comm_board->draw_prompt, 0);
        sic_sem_create( &s_sem_comm_board->write_command, 0);
        sic_sem_create( &s_sem_comm_board->read_command, 0);
        sic_sem_create( &s_sem_comm_board->widget_board_access, 1);
        sic_sem_create( &s_sem_comm_board->widget_created, 0);
        sic_sem_create( &s_sem_comm_board->listener_acquit, 0);
        s_comm_board->widget_board_id = -1;
        sic_build_command_line( "", &s_comm_board->command_line);
        s_comm_board->pushed_command_text[0] = '\0';
        s_comm_board->from = -1;
        s_comm_board->listener_count = 0;
        s_comm_board->event_id = -1;
    }
    gag_trace( "<trace: leave> sic_create_comm_board");
}

void sic_destroy_comm_board( )
{
    gag_trace( "<trace: enter> sic_destroy_comm_board");

    SIC_ASSERT( "sic_destroy_comm_board called from child process", sic_is_master( ));

    sic_kill_all_child_processes( );
    if (s_sem_comm_board != NULL) {
        sic_sem_destroy( &s_sem_comm_board->comm_board_access);
        sic_sem_destroy( &s_sem_comm_board->draw_prompt);
        sic_sem_destroy( &s_sem_comm_board->write_command);
        sic_sem_destroy( &s_sem_comm_board->read_command);
        sic_sem_destroy( &s_sem_comm_board->widget_board_access);
        sic_sem_destroy( &s_sem_comm_board->widget_created);
        sic_sem_destroy( &s_sem_comm_board->listener_acquit);
        s_sem_comm_board = NULL;
    }

    sic_close_comm_board( );

    if (s_comm_board_id >= 0) {
        sic_shm_destroy( s_comm_shm_name, s_comm_board_id);
        /* do it last for sic_is_master to work */
        s_comm_board_id = -1;
    }

    gag_trace( "<trace: leave> sic_destroy_comm_board");
}

#ifndef WIN32
/*
 * Fork a process.
 */
static pid_t sic_fork( )
{
    pid_t pid;

    gag_trace( "<trace: fork>");

    /* flush the associated standard I/O streams
       to prevent duplicated outputs */
    fflush( NULL);

    pid = fork( );
    if (pid < 0) {
        sic_perror( "fork");
    } else if (pid) {
        gag_trace( "<trace: fork> process %d created", pid);
    } else {
        gag_trace( "<trace: fork> child starting");
    }
    return pid;
}
#endif /* WIN32 */

char **sic_get_static_argv( )
{
    static char *s_argv[MAX_ARGC];
    static char s_argv_buf[MAX_ARGC][MAX_ARGV];
    int i;

    /* make argv pointing on allocated buffers */
    for (i = 0; i < MAX_ARGC; i++)
        s_argv[i] = s_argv_buf[i];

    return s_argv;
}

int sic_execvp( char *argv[])
{
#ifndef WIN32
#ifdef SIC_DEBUG_COMM
    char gdb_cmd_file[MAX_ARGV];
    FILE *fp;
    int i;
    static char *exec_argv[MAX_ARGC];
    static char exec_argv_buf[MAX_ARGC][MAX_ARGV];
#endif /* SIC_DEBUG_COMM */
    char *app_name = argv[0];

    gag_trace( "<trace: exec> %s", app_name);

#ifdef SIC_DEBUG_COMM
    if (getenv( "SIC_DEBUG_GDB") == NULL)
#endif /* SIC_DEBUG_COMM */

        return execvp( argv[0], argv);

#ifdef SIC_DEBUG_COMM
    /* don't use sic_get_static_argv( ) because it can be use by the caller */
    /* make argv pointing on allocated buffers */
    for (i = 0; i < MAX_ARGC; i++)
        exec_argv[i] = exec_argv_buf[i];

    /* create gdb command file */
    sprintf( gdb_cmd_file, ".gdb_%s", app_name);
    fp = fopen( gdb_cmd_file, "w");
    fprintf( fp, "set args");
    for (i = 1; argv[i] != NULL; i++) {
        fprintf( fp, " \"%s\"", argv[i]);
    }
    fprintf( fp, "\n");
    fclose( fp);

    /* create command line with call to gdb */
    i = 0;
    sprintf( exec_argv[i++], "xterm");
    sprintf( exec_argv[i++], "-T");
    sprintf( exec_argv[i++], app_name);
    sprintf( exec_argv[i++], "-e");
    sprintf( exec_argv[i++], "gdb");
    sprintf( exec_argv[i++], "-x");
    sprintf( exec_argv[i++], gdb_cmd_file);
    sprintf( exec_argv[i++], app_name);
    exec_argv[i++] = NULL;
    if (i >= MAX_ARGC) {
        fprintf( stderr, "E-SIC, too much arguments, exiting\n");
        sic_do_exit( 1);
    }

    /* show original command line */
    printf( "I-SIC, Launching:");
    for (i = 0; argv[i] != NULL; i++)
        printf( " %s", argv[i]);
    printf( "\n");

    return execvp( exec_argv[0], exec_argv);
#endif /* SIC_DEBUG_COMM */
#else /* WIN32 */
    return 0;
#endif /* WIN32 */
}

task_t sic_launch( int (*start_entry)( void *), void *data)
{
#ifndef WIN32
    pid_t pid = sic_fork( );

    if (pid == 0) {
        /* child process */
        if ((*start_entry)( data) == -1)
            pid = - 1;
    }

    return pid;
#else /* WIN32 */
    DWORD dwThreadId; 
    HANDLE hthrd;

    hthrd = CreateThread( 
        NULL,                        // no security attributes 
        0,                           // use default stack size  
        (LPTHREAD_START_ROUTINE) start_entry, // thread function 
        data,                        // argument to thread function 
        0,                           // use default creation flags 
        &dwThreadId);                // returns the thread identifier 

    // Check the return value for success. 

    if (hthrd == NULL) 
        sic_perror( "CreateThread");

    return hthrd;
#endif /* WIN32 */
}

int sic_terminate( task_t task)
{
#ifndef WIN32
    if (kill( task, SIGTERM))
        return -1;
    if (waitpid( task, NULL, 0) == -1)
        return -1;
#else /* WIN32 */
    if (!TerminateThread( task, 0)) {
        sic_pwarning( "TerminateThread");
        return -1;
    }
#endif /* WIN32 */
    return 0;
}

void sic_on_exit( )
{
    static int recur_level = 0;

    gag_trace( "<trace: sic_on_exit>");
    if (!recur_level) {
        recur_level++;
        if (sic_is_master( ))
            sic_destroy_comm_board( );
        else
            sic_close_comm_board( );
    }

    gag_trace( "<trace: exit>");
    gag_trace_close( );
}

void sic_do_exit( int status)
{
    gag_trace( "<trace: sic_do_exit>");

    exit( status);
}

int sic_get_comm_id( )
{
    return s_comm_board_id;
}

int sic_open_comm_board( int comm_board_id)
{
    if (comm_board_id == -1) {
        SIC_ASSERT( "sic_open_comm_board with bad id", 0);
        return -1;
    }

    sic_init_handlers( );
    
    /* negative comm_board_id can be used for debugging purpose */
    if (s_comm_board == NULL
#ifdef SIC_DEBUG_COMM
        && comm_board_id >= 0
#endif /* SIC_DEBUG_COMM */
        ) {
#ifndef WIN32
        s_comm_board = sic_shm_attach( comm_board_id, sizeof( sic_comm_board_t));
#else /* WIN32 */
        static sic_comm_board_t single_process_comm_board;

        s_comm_board = &single_process_comm_board;
#endif/* WIN32 */
        s_sem_comm_board = s_comm_board;

        if (!sic_is_master( )) {
            if (s_comm_board->trace_fd >= 0)
                gag_trace_set_file_pointer( fdopen( s_comm_board->trace_fd, "w"));

#ifdef SIC_USE_SEM_OPEN
            static sic_comm_board_t process_local_sem_comm_board;
            s_sem_comm_board = &process_local_sem_comm_board;
#endif /* SIC_USE_SEM_OPEN */

            sic_sem_open( &s_sem_comm_board->comm_board_access);
            sic_sem_open( &s_sem_comm_board->draw_prompt);
            sic_sem_open( &s_sem_comm_board->write_command);
            sic_sem_open( &s_sem_comm_board->read_command);
            sic_sem_open( &s_sem_comm_board->widget_board_access);
            sic_sem_open( &s_sem_comm_board->widget_created);
            sic_sem_open( &s_sem_comm_board->listener_acquit);
        }
    }
    gag_trace( "<trace> sic_open_comm_board");
    return 0;
}

void sic_close_comm_board( )
{
    gag_trace( "<trace> sic_close_comm_board");
    if (s_comm_board != NULL) {
#ifndef WIN32
        sync( ); /* flush disks */
#endif /* WIN32 */
        sic_destroy_widget_board( );
        if (s_sem_comm_board != NULL) {
            sic_purge_listeners( sic_get_current_task( ));
            sic_sem_close( &s_sem_comm_board->comm_board_access);
            sic_sem_close( &s_sem_comm_board->draw_prompt);
            sic_sem_close( &s_sem_comm_board->write_command);
            sic_sem_close( &s_sem_comm_board->read_command);
            sic_sem_close( &s_sem_comm_board->widget_board_access);
            sic_sem_close( &s_sem_comm_board->widget_created);
            sic_sem_close( &s_sem_comm_board->listener_acquit);
            s_sem_comm_board = NULL;
        }
        sic_shm_detach( s_comm_board, sizeof( sic_comm_board_t));
        s_comm_board = NULL;
    }
}

task_id_t sic_get_task_id( task_t task)
{
#ifndef WIN32
    return (task_id_t)task;
#else
    return (task_id_t)(long long)task;
#endif
}

task_t sic_get_master_task( )
{
#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return (task_t)0;
#endif /* SIC_DEBUG_COMM */

    return s_comm_board->master_task;
}

task_id_t sic_get_master_task_id( )
{
    return sic_get_task_id( sic_get_master_task( ));
}

task_t sic_get_current_task( )
{
#ifndef WIN32
    return getpid( );
#else
    return GetCurrentThread( );
#endif
}

task_id_t sic_get_current_task_id( )
{
    return sic_get_task_id( sic_get_current_task( ));
}

void sic_set_ctrlc_handled( int handled)
{
    s_ctrlc_handled = handled;
}

void sic_send_ctrlc( )
{
#ifndef WIN32
    kill( sic_get_master_task( ), SIGINT);
#else /* WIN32 */
    sic_do_exit( 0);
#endif /* WIN32 */
}

void sic_post_prompt( const command_line_t *command_line)
{
    gag_trace( "<trace> sic_post_prompt");
    s_comm_board->command_line = *command_line;
    sic_sem_post( &s_sem_comm_board->draw_prompt);
}

int sic_wait_prompt( command_line_t *command_line, int timeout)
{
    int ret;

#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return 0;
#endif /* SIC_DEBUG_COMM */

    gag_trace( "<trace: enter> sic_wait_prompt");
    ret = sic_sem_timed_wait( &s_sem_comm_board->draw_prompt, timeout);
    if (ret == 0) {
        *command_line = s_comm_board->command_line;
    }
    gag_trace( "<trace: leave> sic_wait_prompt");
    return ret;
}

void sic_get_current_prompt( char prompt[])
{
    strncpy( prompt, s_comm_board->command_line.prompt, PROMPT);
}

int sic_push_command_text( const char *text)
{
    gag_trace( "<trace: enter> sic_push_command_text");

    if (s_comm_board->pushed_command_text[0]) {
        gag_trace( "<trace: leave> sic_push_command_text return error");
        return -1;
    }

    strncpy( s_comm_board->pushed_command_text, text, MAXBUF);
    gag_trace( "<command: push> \"%s\"", text);
    sic_sem_post( &s_sem_comm_board->read_command);

    gag_trace( "<trace: leave> sic_push_command_text");
    return 0;
}

int sic_post_command_from( const command_line_t *command_line, sic_command_from_t from)
{
    return sic_raw_post_command_from( command_line, 2000, from);
}

int sic_post_command( const command_line_t *command_line)
{
    return sic_post_command_from( command_line, SIC_DEFAULT);
}

void sic_post_command_from_prompt( const command_line_t *command_line)
{
    sic_raw_post_command_from( command_line, -1, SIC_KEYBOARD);
}

int sic_post_command_text_from( const char *text, sic_command_from_t from)
{
    command_line_t command_line;
    
    sic_build_command_line( text, &command_line);

    return sic_post_command_from( &command_line, from);
}

int sic_post_command_text( const char *text)
{
    return sic_post_command_text_from( text, SIC_DEFAULT);
}

int sic_post_command_va( const char *args, va_list l)
{
    char command[MAXBUF];
    vsprintf( command, args, l);

    return sic_post_command_text( command);
}

int sic_post_command_args( const char *args, ...)
{
    int ret;
    va_list l;

    va_start( l, args);
    ret = sic_post_command_va( args, l);
    va_end( l);

    return ret;
}

void sic_wait_command( command_line_t *command_line, sic_command_from_t *from)
{
    gag_trace( "<trace: enter> sic_wait_command");
    if (!s_comm_board->pushed_command_text[0])
        sic_sem_post( &s_sem_comm_board->write_command);
    sic_sem_wait( &s_sem_comm_board->read_command);
    if (!s_comm_board->pushed_command_text[0]) {
        *command_line = s_comm_board->command_line;
        *from = s_comm_board->from;
    } else {
        sic_build_command_line( s_comm_board->pushed_command_text, command_line);
        *from = SIC_DEFAULT;
        s_comm_board->pushed_command_text[0] = '\0';
    }
    gag_trace( "<command: receive> \"%s%s\"", command_line->prompt, command_line->line);

    gag_trace( "<trace: leave> sic_wait_command");
}

void sic_create_widget_board( )
{
    gag_trace( "<trace> sic_create_widget_board");
    if (s_comm_board->widget_board_id < 0) {
        sprintf( s_widget_shm_name, "/SIC_%d_W", sic_get_current_task_id( ));
        s_comm_board->widget_board_id = sic_shm_create( s_widget_shm_name, sizeof( sic_widget_board_t));
    }
    sic_open_widget_board( );
    s_widget_board->widget_count = 0;
}

void sic_set_widget_global_infos( const char window_title[], const char help_filename[], const char returned_command[])
{
    strcpy( s_widget_board->window_title, window_title);
    strcpy( s_widget_board->help_filename, help_filename);
    strcpy( s_widget_board->returned_command, returned_command);
}

void sic_set_widget_returned_command( const char returned_command[])
{
#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return;
#endif /* SIC_DEBUG_COMM */

    strcpy( s_widget_board->returned_command, returned_command);
}

void sic_get_widget_returned_command( char returned_command[])
{
    strcpy( returned_command, s_widget_board->returned_command);
}

void sic_set_widget_returned_code( int code)
{
#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return;
#endif /* SIC_DEBUG_COMM */

    s_widget_board->returned_code = code;
}

int sic_get_widget_returned_code( )
{
    return s_widget_board->returned_code;
}

void sic_add_modified_variable_listener( sic_modified_variable_listener_t l)
{
    sic_listener_handler_t h = {
        (task_t)NULL,
        SIC_MODIFIED_VARIABLE_EVENT,
        NULL,
#ifndef WIN32
        SIGUSR2
#else /* WIN32 */
        0
#endif /* WIN32 */
    };
    h.task = sic_get_current_task( );
    h.listener = l;
    sic_record_listener( &h);
}

void sic_fire_modified_variable_event( const sic_widget_def_t *widget)
{
    gag_trace( "<trace: enter> sic_fire_modified_variable_event");
    sic_open_widget_board( );
    s_widget_board->modified_widget = *widget;
    sic_trigger_listeners( SIC_MODIFIED_VARIABLE_EVENT);
    sic_close_widget_board( );
    gag_trace( "<trace: leave> sic_fire_modified_variable_event");
}

void sic_add_redraw_prompt_listener( sic_redraw_prompt_listener_t l)
{
    sic_listener_handler_t h = {
        (task_t)NULL,
        SIC_REDRAW_PROMPT_EVENT,
        NULL,
#ifndef WIN32
        SIGUSR2
#else /* WIN32 */
        0
#endif /* WIN32 */
    };
    h.task = sic_get_current_task( );
    h.listener = l;
    sic_record_listener( &h);
}

void sic_fire_redraw_prompt_event( const command_line_t *command_line)
{
    gag_trace( "<trace: enter> sic_fire_redraw_prompt_event");
    s_comm_board->command_line = *command_line;
    sic_trigger_listeners( SIC_REDRAW_PROMPT_EVENT);
    gag_trace( "<trace: leave> sic_fire_redraw_prompt_event");
}

void sic_suspend_prompt( )
{
    fprintf( stderr, "%s\n", s_comm_board->command_line.line);
}

int sic_add_widget_def( sic_widget_def_t *def)
{
    if (s_widget_board->widget_count >= SIC_MAX_WIDGET_ON_BOARD)
        return -1;

    s_widget_board->widgets[s_widget_board->widget_count++] = *def;

    return 0;
}

void sic_set_widget_def( int index, const sic_widget_def_t *widget)
{
    s_widget_board->widgets[index] = *widget;
}

void sic_destroy_widget_board( )
{
    gag_trace( "<trace> sic_destroy_widget_board");
    if (s_widget_board != NULL) {
        sic_shm_detach( s_widget_board, sizeof( sic_widget_board_t));
        s_widget_board = NULL;
    }
    /* destroy share memory from master */
    if (sic_is_master( ) && s_comm_board->widget_board_id >= 0) {
        sic_shm_destroy( s_widget_shm_name, s_comm_board->widget_board_id);
        s_comm_board->widget_board_id = -1;
    }
}

int sic_open_widget_board( )
{
#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return 0;
#endif /* SIC_DEBUG_COMM */

    gag_trace( "<trace: enter> sic_open_widget_board");
    sic_sem_wait( &s_sem_comm_board->widget_board_access);
    if (s_widget_board == NULL) {
#ifndef WIN32
        s_widget_board = sic_shm_attach( s_comm_board->widget_board_id, sizeof( sic_widget_board_t));
#else /* WIN32 */
        static sic_widget_board_t single_process_widget_board;

        s_widget_board = &single_process_widget_board;
#endif/* WIN32 */
    }
    gag_trace( "<trace: leave> sic_open_widget_board");
    return s_widget_board->widget_count;
}

void sic_get_widget_global_infos( char window_title[], char help_filename[], char returned_command[])
{
#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return;
#endif /* SIC_DEBUG_COMM */

    strcpy( window_title, s_widget_board->window_title);
    strcpy( help_filename, s_widget_board->help_filename);
    strcpy( returned_command, s_widget_board->returned_command);
}

void sic_get_widget_def( int index, sic_widget_def_t *widget)
{
    *widget = s_widget_board->widgets[index];
}

void sic_close_widget_board( )
{
#ifdef SIC_DEBUG_COMM
    if (s_comm_board == NULL)
        return;
#endif /* SIC_DEBUG_COMM */

    gag_trace( "<trace> sic_close_widget_board");
    sic_sem_post( &s_sem_comm_board->widget_board_access);
}

void sic_post_widget_created( )
{
    gag_trace( "<trace> sic_post_widget_created");
    sic_sem_post( &s_sem_comm_board->widget_created);
}

void sic_wait_widget_created( )
{
    gag_trace( "<trace: enter> sic_wait_widget_created");
    sic_sem_wait( &s_sem_comm_board->widget_created);
    gag_trace( "<trace: leave> sic_wait_widget_created");
}

---