getcar.c

Go to the documentation of this file.

#include "getcar.h"

#include "sic_comm.h"
#include "sic_error.h"
#include "sic_launch.h"
#include "sic_util.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <fcntl.h>
#ifndef WIN32
#include <unistd.h>
#include <sys/time.h>
#else
#include "win32.h"
#endif

#define YES 1
#define NO 0
#define TRANSLATION_MAX_LENGTH 256

static char temporary_file[512];
static char temporary_name[256];

win_struct_t detach_win[NWINDOWS];

static FILE *fd;
static char keychain[64];
static int SHARE=0;

static unsigned long timervalue = 0;

/* Reset timer value to val */
static void set_timer( unsigned long val)
{
#ifndef WIN32
    struct itimerval rttimer;

    rttimer.it_value.tv_sec = val;
    rttimer.it_value.tv_usec = 0;
    rttimer.it_interval.tv_sec = 0;
    rttimer.it_interval.tv_usec = 0;

    setitimer( ITIMER_REAL, &rttimer, NULL);
#endif
}

/* Put a flag to make the task mono or multi user */
void CFC_API xgag_key( CFC_FzString key)
{
    SHARE = YES;
    CFC_fz2c_strcpy( keychain, key);
}

/* set a timer in order to exit after nh hours doing nothing */
void CFC_API xgag_timer( int *nh)
{
    int val;

    printf( "Timer value : %d hours\n", *nh);
    val = ((*nh) * 3600);
    if (val < 0)
        val = 0;
    timervalue = (unsigned long)val;
}

/* Pause the execution of an temporary X-Window detached process
   end inhibate command in permanent X-Menus which beep on user actions */
void CFC_API xgag_wait( )
{
    /* Pause, allowing a sic_xinput panel to set a number of variables
     * while executing a procedure. Unsupported with client server XML.
     */
    static int notDone = 1, doWait = 1;

    if (notDone) {
        if (strcasecmp( sic_s_get_translation( "GAG_WIDGETS"), "XML") == 0) {
            doWait = 0;
            notDone = 0;
        }
    }
    if (doWait) {
        command_line_t command_line;
        sic_command_from_t from;

        printf( "Waiting ...\n");

        /* TODO: look for the good place to call sic_wait_command */
        /* wait for GUI\END */
        do {
            sic_wait_command( &command_line, &from);
        } while (strcmp( command_line.line, "GUI\\END"));
    } else {
        printf( "Warning, GUI\\PAUSE unsupported by XML widgets,\n will give unpredictable results. \n");
    }
}

/* When the main task must be mono-user the command memory
   segment must be shared between all instances */
void CFC_API search_clients( int *code)
{
    *code = (sic_get_comm_id( ) == -1) ? 1 : 0;

#ifndef WIN32
#ifndef darwin
    setpgrp( );
#else
    setpgid( 0, 0);                     /* This should also work on Linux */
#endif
#endif

    /* set error handlers */
    /* signal( SIGINT, SIG_IGN); */ /* done by calling trap_ctrlc */

    if (*code == 1) {              /* First client ... */
        sic_create_comm_board( );
    } else {                       /* remote client ... */
        sic_open_comm_board( sic_get_comm_id( ));
    }
}

void CFC_API sic_c_do_exit( int *status)
{
    sic_do_exit( *status);
}

void CFC_API sic_c_on_exit( )
{
    sic_on_exit( );
}

void CFC_API get_com_params( int *comm_id, int *unused_1, int *unused_2)
{
    *comm_id = sic_get_comm_id( );
    *unused_1 = -1;
    *unused_2 = -1;
}

/***************************************************************************
  If the main task runs in mono-user mode, an instance of SIC_KEYBOARD 
  is created at each call of the task.
  Otherwise, the subsequent instances of the task will call prompt_loop with
  *code set to zero which override the executing task with a REMOTE_CLIENT 
  control task, so that there is always a single instance of the named task 
  currently running.
  ****************************************************************************/
void CFC_API prompt_loop( int *code)
{
    task_t keyboard_task = SIC_TASK_NULL;
    int i, keyfd;
    char buff[16];
    char keyfile[128];

    if (*code) {
        keyboard_task = launch_keyboard( );

        if (keyboard_task == SIC_TASK_NULL) {
            *code = -1;
            return;
        }
#ifdef SIC_RUN_SIC_SPY
        argv = sic_get_static_argv( );
        i = 0;
        sprintf( argv[i++], "sic_spy");
        sprintf( argv[i++], "%d", sic_get_comm_id( ));
        argv[i++] = NULL;

        if (sic_launch( argv) < 0) {
            *code = -1;
            return;
        }
#endif /* SIC_RUN_SIC_SPY */

        if (SHARE) {
            /* Parent process write keyboard_task id for other clients */
            sprintf( keyfile, "%s%s", "/tmp/", keychain);
            if ((keyfd = open( keyfile, O_WRONLY)) == -1) {
                printf( "error open");
                *code = -1;
                return;
            }

            strncpy( buff, "0", 16);
            sprintf( buff, "%d", sic_get_task_id( keyboard_task));
            /* Move file pointer to keyboard_task id position */
            if (lseek( keyfd, 48L, 0L) == -1) {
                printf( "error lseek");
                *code = -1;
                return;
            }

            write( keyfd, buff, 16);

            close( keyfd);
        }

        /* Init tem_win struct */
        for (i = 0; i < NWINDOWS; i++)
            strcpy( detach_win[i].name, "NONE");

    } else {
        run_xremote( );
    }
}

static void redraw_prompt( CFC_FzString prompt, CFC_FzString line, int code, sic_command_from_t from)
{
    command_line_t command_line;

    CFC_fz2c_strcpy( command_line.prompt, prompt);
    if (code)
        CFC_fz2c_strcpy( command_line.line, line);
    else
        command_line.line[0] = '\0';
    command_line.nc = 0;
    command_line.code = code;
    if (from == SIC_KEYBOARD)
        sic_post_prompt( &command_line);
    else if (from != SIC_SILENT_MODE)
        sic_fire_redraw_prompt_event( &command_line);
}

/*********************************************************************
  First send the result of last executed command to the keyboard 
  manager program. 
  Then block on semaphore and read the command to be executed in shared memory
  at the reception of a signal form X-Window Application or at semaphore
  released by the keyboard manager program.
  ********************************************************************/
int CFC_API read_linec( CFC_FzString prompt, CFC_FzString line, int *code, int *wait_command)
{
    static sic_command_from_t from = SIC_KEYBOARD;
    command_line_t command_line;

    redraw_prompt( prompt, line, *code, from);

    if (timervalue != 0)
        set_timer( timervalue);

    do {
        sic_wait_command( &command_line, &from);
    } while (!*wait_command && from != SIC_KEYBOARD);

    if (from != SIC_KEYBOARD && from != SIC_SILENT_MODE)
        sic_suspend_prompt( );

    if (timervalue != 0)
        set_timer( 1000000);

    /* TODO: see if still needed */
    /*
       if (strncmp( command_line.line, "GTVL\\FLUSH", 11) == 0)
       return_prompt = NO;
       else
       return_prompt = YES;
     */

    CFC_c2fz_strcpy( prompt, command_line.prompt);
    CFC_c2fz_strcpy( line, command_line.line);
    *code = command_line.code;
    return (int)command_line.nc;
}

/* Prepare a temporary file to create a detached X-Window process */
void CFC_API xgag_detach( CFC_FzString title, CFC_FzString name)
{
#ifndef WIN32
    struct timeval tp;
    struct timezone tzp;

    if (gettimeofday( &tp, &tzp) != 0)
        sic_perror( "gettimeofday");

    sprintf( temporary_file, "%s%s%ld.%ld", sic_s_get_translation( "GAG_TMP:"), "gag_tmp", tp.tv_sec, tp.tv_usec);
#else
    char temp_path[MAX_PATH];

    GetTempPath( MAX_PATH, temp_path);
    GetTempFileName( temp_path, "tmp", 0, temporary_file);
#endif
    sprintf( temporary_name, "%s", CFC_fz2c_string( name));
    fd = fopen( temporary_file, "w");
        if (fd == NULL) {
                fprintf( stderr, "E-DIALOGS,  Cannot create %s\n", temporary_file);
                sic_do_exit( 1);
        }
    fprintf( fd, "%s\n", CFC_fz2c_string( title));
    fprintf( fd, "%s\n", CFC_fz2c_string( name));
}

/* Start a command menu */
void CFC_API xgag_menu( CFC_FzString label)
{
    fprintf( fd, "%s\n", "MENU");
    fprintf( fd, "%s\n", CFC_fz2c_string( label));
}

/* End a command menu */
void CFC_API xgag_endmenu( )
{
    fprintf( fd, "%s\n", "ENDMENU");
}

/* Add a command in a menu */
void CFC_API xgag_command( CFC_FzString label, CFC_FzString command)
{
    fprintf( fd, "%s\n", CFC_fz2c_string( label));
    fprintf( fd, "%s\n", CFC_fz2c_string( command));
}

/* Create the detached X-Window process */
void CFC_API xgag_launch( )
{
    int i;
    task_t launch_task;

    fclose( fd);

    launch_task = launch_xmenu( temporary_file);
    for (i = 0; i < NWINDOWS; i++) {
        if (strcmp( detach_win[i].name, "NONE") == 0) {
            strcpy( detach_win[i].name, temporary_name);
            detach_win[i].task = launch_task;
            break;
        }
    }
}

void CFC_API xgag_end_detach( CFC_FzString name)
{
    int i;

    for (i = 0; i < NWINDOWS; i++) {
        if (strcmp( detach_win[i].name, CFC_fz2c_string( name)) == 0) {
            if (!sic_terminate( detach_win[i].task)) {
                strcpy( detach_win[i].name, "NONE");
            }
            break;
        }
    }
}

---