root/trunk/orca/unix/os.c

/*============================================================================
    ORCA Interpreter
    Copyright (C) 2005-2006  Karl Robillard

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
===========================================================================*/


#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <errno.h>
#include <dirent.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include "os.h"
#include "ovalue.h"


unsigned long randomSeed()
{
    unsigned long seed;
    seed  = time(NULL);
    seed += clock();
    return seed;
}


/**
  Returns -1 if not present.
*/
int orFileSize( const char* path )
{
    struct stat buf;
    if( stat( path, &buf ) == -1 )
        return -1;
    return buf.st_size;
}


/**
  Returns 1 if directory, 0 if file or -1 if error.
*/
int orIsDir( const char* path )
{
    struct stat buf;
    if( stat( path, &buf ) == -1 )
        return -1;
    return S_ISDIR(buf.st_mode) ? 1 : 0;
}


/**
  Returns 0 if result set to file modification time or -1 if error.
*/
int orFileModified( const char* path, OValue* res )
{
    struct stat buf;
    if( stat( path, &buf ) == -1 )
        return -1;

    orSetTF( res, OT_TIME );
    orSeconds(res) = buf.st_mtime;
    return 0;
}


/*
   change-dir
*/
OR_NATIVE_PUB(orChangeDirNative )
{
    int logic = 0;
    OString* str = orSTRING(a1);
    orTermCStr(str);
    if( chdir( str->charArray ) == 0 )
        logic = 1;
    orResult( OT_LOGIC, logic );
}


/*
   what-dir
*/
OR_NATIVE_PUB( orWhatDirNative )
{
    if( getcwd( orTmp, OR_TMP_SIZE ) )
    {
        int len;
        OString* str;
       
        len = strLen( orTmp );
        if( len > 0 )
        {
            str = orMakeString( len + OR_CTERM_LEN );
            str->used = len;
            memCpy( str->charArray, orTmp, len );
            orResultFILE( orStringN(str) );
            return;
        }
    }
    orResultFALSE;
}


/**
  No error if directory exists.
*/
OR_NATIVE_PUB( orMakeDirNative )
{
    int err;
    OString* str = orSTRING(a1);
    orTermCStr(str);
    err = mkdir( str->charArray, 0755 );
    if( err )
    {
        if( (errno != EEXIST) || (orIsDir(str->charArray) != 1) )
        {
            orErrorT( OR_ERROR_ACCESS, strerror/*_r*/(errno) );
        }
    }
}


#define REF_TIME    a1

OR_NATIVE_PUB( orNowNative )
{
    struct timeval tp;

    gettimeofday( &tp, 0 );

    //printf( "sizeof(timeval.tv_sec) %d %d\n",
    //        sizeof(tp.tv_sec), sizeof(tp.tv_usec) );

    if( orRefineSet( REF_TIME ) )
        orSetTF( a1, OT_TIME );
    else
        orSetTF( a1, OT_DATE );

    orSeconds(a1) = tp.tv_sec + (tp.tv_usec * 0.000001);
}


/**
  Sets result.
*/
void orReadDir( OValue* a1, const char* filename )
{
    DIR* dir;
    struct dirent* entry;

    dir = opendir( filename );
    if( dir )
    {
        OIndex hold;
        OIndex blkN;
        OBlock* blk = orMakeBlock( 0 );

        blkN = orBlockN(blk);
        hold = orHold( OT_BLOCK, blkN );

        while( (entry = readdir( dir )) )
        {
            const char* cp = entry->d_name;
            if( cp[0] == '.' && (cp[1] == '.' || cp[1] == '\0') )
                continue;
            orAppendFile( blk, orMakeCString(cp, -1) );
        }

        closedir( dir );

        orRelease( hold );
        orResultBLOCK( blkN );
    }
    else
    {
        orResultFALSE;
    }
}


#ifdef OR_CONFIG_OS_CALL
static void argumentList( OString* str, int sindex, char** argv, int maxArg )
{
    char* cp;
    int prevWhite;
    int argc;

    orTermCStr( str );
    cp = str->charArray + sindex;

    argc = 0;
    prevWhite = 1;
    while( *cp != '\0' )
    {
        if( *cp == ' ' || *cp == '\t' || *cp == '\n' )
        {
            *cp = '\0';
            prevWhite = 1;
        }
        else if( prevWhite )
        {
            prevWhite = 0;
            argv[ argc ] = cp;
            ++argc;
            if( argc == maxArg )
                goto term;
        }
        ++cp;
    }

term:
    argv[ argc ] = 0;
}


#define REF_CALL_OUTPUT     a1+1
#define REF_CALL_OUT        a1+2
#define REF_CALL_WAIT       a1+3


static void callOutput( OValue* a1 )
{
#define BUFSIZE     256
    int pid;
    int pfd[2];

    if( pipe(pfd) == -1 )
    {
        orError( "pipe failed" );
        return;
    }

    pid = fork();
    if( pid == 0 )
    {
        // In child process; invoke command.

        // What is the overhead of creating the arg list between fork/exec?
        char* argv[10];
        argumentList( orSTRING(a1), a1->series.it, argv, 9 );

        close( pfd[0] );
        dup2( pfd[1], 1 );
        close( pfd[1] );

        if( execvp( argv[0], argv ) == -1 )
        {
            perror( "orCallNative" );
            _exit( 255 );
        }
    }
    else if( pid > 0 )
    {
        // In parent process.

        int n;
        int status;
        OString* str;

        str = orSTRING(REF_CALL_OUT);
        str->used = 0;
        orArrayReserve( str, 1, BUFSIZE ); 

        close( pfd[1] );
        while( (n = read( pfd[0], str->charArray + str->used, BUFSIZE )) > 0 )
        {
            str->used += n;
            orArrayReserve( str, 1, str->used + BUFSIZE ); 
        }
        close( pfd[0] );

        waitpid( pid, &status, 0 );
        if( WIFEXITED(status) )
        {
            orResult( OT_INTEGER, WEXITSTATUS(status) );
            return;
        }
        orResultNONE;
    }
    else
    {
        // fork failed.
        close( pfd[0] );
        close( pfd[1] );
        orError( "fork failed" );
    }
}


static int _asyncProcCount = 0;

static void callSimple( OValue* a1 )
{
    int pid;
    int status;
    int waitRef;

    waitRef = orRefineSet(REF_CALL_WAIT);
    if( ! waitRef )
    {
        // Need to call wait() when SIGCHLD is received to avoid zombies.
        /*
         FIXME: Using _asyncProcCount may cause the signal handler to get
         the status if call/wait is called while an asynchronous process is
         still running.
        */
        _asyncProcCount++;
    }

    pid = fork();
    if( pid == 0 )
    {
        // In child process; invoke command.

        // What is the overhead of creating the arg list between fork/exec?
        char* argv[10];
        argumentList( orSTRING(a1), a1->series.it, argv, 9 );

        if( execvp( argv[0], argv ) == -1 )
        {
            perror( "orCallNative" );
            _exit( 255 );
        }
    }
    else if( pid > 0 )
    {
        // In parent process.

        if( waitRef )
        {
            waitpid( pid, &status, 0 );
            if( WIFEXITED(status) )
            {
                orResult( OT_INTEGER, WEXITSTATUS(status) );
                return;
            }
        }
        orResultNONE;
    }
    else
    {
        // fork failed.
        orError( "fork failed" );
        if( ! waitRef )
            --_asyncProcCount;
    }
}


/*
  command /output out /wait
*/
OR_NATIVE_PUB( orCallNative )
{
    if( a1->type != OT_STRING )
    {
        orResultFALSE;
        return;
    }

    if( orRefineSet( REF_CALL_OUTPUT ) )
    {
        callOutput( a1 );
    }
    else
    {
        callSimple( a1 );
    }
}
#endif


#ifdef OR_CONFIG_OS_CALL
/* Cleans up after callSimple() */
static void child_handler( int sig )
{
    (void) sig;

    if( _asyncProcCount )
    {
        int status;
        wait( &status );
        --_asyncProcCount;
    }
}
#endif

#if 0
void kill_handler( int sig )
{
    (void) sig;
    printf( "User Abort\n" );
}

void fpe_handler( int sig )
{
    (void) sig;
    printf( "Math Error\n" );
    exit(-1);
}
#endif


void orInstallExceptionHandlers()
{
#ifdef OR_CONFIG_OS_CALL
    /* NOTE: Cannot use this if using Qt's QProcess (it uses SIGCHLD) */
    struct sigaction childSA;

    childSA.sa_handler = child_handler;
    childSA.sa_flags   = SA_NOCLDSTOP;
    sigemptyset( &childSA.sa_mask );

    sigaction( SIGCHLD, &childSA, NULL );
#endif

#if 0
    struct sigaction action;
    struct sigaction faction;

    action.sa_handler = kill_handler;
    action.sa_flags   = 0;
    sigemptyset( &action.sa_mask );

    sigaction( SIGTERM, &action, NULL );    // kill
    sigaction( SIGINT,  &action, NULL );    // Ctrl-C

    faction.sa_handler = fpe_handler;
    faction.sa_flags   = 0;
    sigemptyset( &faction.sa_mask );

    sigaction( SIGFPE,  &faction, NULL );
#endif

#if 0
    //double f = 0.0;
    //printf( "%g\n", 2.0 / f );
    int n = 0;
    printf( "%d\n", 2 / n );
#endif
}


/*EOF*/