Subversion Repositories DevTools

/*============================================================================

**  COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.

**============================================================================

**

**  Project/Product : 

**  Filename        : timeout_unix.c

**  Author(s)       : DDP

**

**  Description     : Unix program to limit the wall-clock time that an program can run

** 

**                      Create an other process

**                      Kill it after it has run for a specified length of time

**

**                    Used to help JATS to:

**                      Limit compilation times

**                          Handle silly compilers that pop up error messages with an OK

**                      Limit Unit Test run times

**

** Usage            : timeout <options>* command <command args>*

**                    Where options are:

**                      -time:nnn[.nnn][s]  - Timeout in seconds

**                                            Floating point number with suffix

**                                            Suffix - s - seconds

**                                                     m - minutes

**                                                     h - hours

**                                                     d - days

**                    Command           - Users command

**                    command args      - Arguments passed to the command

** 

** Note:            This code MUST be kept in sync with code for all platforms supported

**                  under JATS

** 

** Note:            Large chunks lifted from the Linux command of the same name

**                  See copyright notice below

**

**  Information     :

**   Compiler       : ANSI C

**   Target         : UNIX ONLY

**

**==========================================================================*/

/* timeout -- run a command with bounded time

   Copyright (C) 2008-2015 Free Software Foundation, Inc.

   This program is free software: you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation, either version 3 of the License, or

   (at your option) any later version.

   This program 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 General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <stdio.h>

#include <unistd.h>

#include <fcntl.h>

#include <stdlib.h>

#include <sys/wait.h>

#if ! defined(HOST_SOLARIS)

#include <error.h>

#endif

#include <errno.h>

#include <limits.h>

#include <signal.h>

#include <stdarg.h>

#include "string.h"

#include "strings.h"

/*

** Exit Codes

*/

#define     EXIT_TIMEDOUT      124      /* job timed out*/

#define     EXIT_CANCELED      125      /* internal error*/

#define     EXIT_CANNOT_INVOKE 126      /* error executing job */

#define     EXIT_ENOENT        127      /* couldn't find job to exec */

static unsigned int timeOut = 10;       /* Seconds */

static int monitored_pid;

static int timed_out = 0;

static int term_signal = SIGTERM;       /* same default as kill command.  */

static unsigned int kill_after = 5;

typedef     int bool;

#define     true    1

#define     false   0

/*

**  Prototypes (forward declarations)

*/

/*----------------------------------------------------------------------------

** FUNCTION           : apply_time_suffix

**

** DESCRIPTION        : Helper function to process time suffix

**                      Supports s,h,m,d

**

** INPUTS             : x           - Ref to value to modify

**                      suffix_char - Possible suffix char

**

** RETURNS            : True - suffix was OK

**

----------------------------------------------------------------------------*/

static int apply_time_suffix (double *x, char suffix_char)

{

    int multiplier;

    switch (suffix_char)

    {

    case 0:

    case 's':

        multiplier = 1;

        break;

    case 'm':

        multiplier = 60;

        break;

    case 'h':

        multiplier = 60 * 60;

        break;

    case 'd':

        multiplier = 60 * 60 * 24;

        break;

    default:

        return 0;

    }

    *x *= multiplier;

    return 1;

}

/*----------------------------------------------------------------------------

** FUNCTION           : parseDuration 

**

** DESCRIPTION        : Parse the timeout duration

**                      Allowed - number + 1char suffix

**                          1 Char suffix may be:

**                          'm' - Minutes

**                          'h' - Hours

**                          'd' - Days

**                      The number is an unsigned integer

**

** INPUTS             : ptr     - Input string (Floating point)

**

** RETURNS            : Unsigned integer

**                      May not return. May exit with error message

**

----------------------------------------------------------------------------*/

static unsigned int parseDuration (const char* str)

{

    double duration;

    unsigned int intDuration;

    unsigned int duration_floor;

    char *ep;

    int ok = 1;

    errno = 0;

    duration = strtod(str, &ep);

    if (duration < 0 )

        ok = 0;

    if ( ep == str )

        ok = 0;

    if (errno != 0)

        ok = 0;

    if (*ep && *(ep + 1))

        ok = 0;

    if(ok)

        ok = apply_time_suffix (&duration, *ep);

    if (UINT_MAX <= duration)

        ok = 0;

    if(!ok)

    {

        fprintf(stderr, "Invalid duration");

        exit (EXIT_CANCELED) ;

    }

    /*

    ** Round up - unless exact

    */

    duration_floor = (unsigned int)duration;

    intDuration = duration_floor + (duration_floor < duration);

    /*fprintf(stderr, "parseDuration: %f (%u)\n", duration,  intDuration);*/

  return intDuration;

}

#if defined(HOST_SOLARIS)

/*----------------------------------------------------------------------------

** FUNCTION           : error

**

** DESCRIPTION        : Poor mans emulation of the Linux function 'error'

**

**

** INPUTS             : status - not used

**                      errnum - Error number

**                      format - Format string

**                      ...    - Arguments for format

**

** RETURNS            : Nothing

**

----------------------------------------------------------------------------*/

static void error(int status, int errnum, const char *format, ...)

{

    va_list params;

    va_start(params, format);

    vfprintf (stderr, format, params);

    errno = errnum;

    perror (" ");

    va_end(params);

}

#endif

/* Try to disable core dumps for this process.

   Return TRUE if successful, FALSE otherwise.  */

static bool disable_core_dumps (void)

{

#if HAVE_PRCTL && defined PR_SET_DUMPABLE

  if (prctl (PR_SET_DUMPABLE, 0) == 0)

    return true;

  error (0, errno, "warning: disabling core dumps failed");

  return false;

#elif HAVE_SETRLIMIT && defined RLIMIT_CORE

  /* Note this doesn't disable processing by a filter in

     /proc/sys/kernel/core_pattern on Linux.  */

  if (setrlimit (RLIMIT_CORE, &(struct rlimit) {0,0}) == 0)

    return true;

  error (0, errno, "warning: disabling core dumps failed");

  return false;

#else

  return false;

#endif

}

static void unblock_signal (int sig)

{

  sigset_t unblock_set;

  sigemptyset (&unblock_set);

  sigaddset (&unblock_set, sig);

  if (sigprocmask (SIG_UNBLOCK, &unblock_set, NULL) != 0)

    error (0, errno, "warning: sigprocmask");

}

/* Start the timeout after which we'll receive a SIGALRM.

   Round DURATION up to the next representable value.

   Treat out-of-range values as if they were maximal,

   as that's more useful in practice than reporting an error.

   '0' means don't timeout.  */

static void settimeout (unsigned int duration, bool warn)

{

  /* We configure timers below so that SIGALRM is sent on expiry.

     Therefore ensure we don't inherit a mask blocking SIGALRM.  */

    unblock_signal (SIGALRM);

    alarm (duration);

}

/* send SIG avoiding the current process.  */

static int send_sig (int where, int sig)

{

  /* If sending to the group, then ignore the signal,

     so we don't go into a signal loop.  Note that this will ignore any of the

     signals registered in install_signal_handlers(), that are sent after we

     propagate the first one, which hopefully won't be an issue.  Note this

     process can be implicitly multithreaded due to some timer_settime()

     implementations, therefore a signal sent to the group, can be sent

     multiple times to this process.  */

  if (where == 0)

    signal (sig, SIG_IGN);

  return kill (where, sig);

}

static void cleanup (int sig)

{

  if (sig == SIGALRM)

    {

      timed_out = 1;

      sig = term_signal;

    }

  if (monitored_pid)

    {

      if (kill_after)

        {

          int saved_errno = errno; /* settimeout may reset.  */

          /* Start a new timeout after which we'll send SIGKILL.  */

          term_signal = SIGKILL;

          settimeout (kill_after, false);

          kill_after = 0; /* Don't let later signals reset kill alarm.  */

          errno = saved_errno;

        }

      /* Send the signal directly to the monitored child,

         in case it has itself become group leader,

         or is not running in a separate group.  */

      send_sig (monitored_pid, sig);

      /* The normal case is the job has remained in our

         newly created process group, so send to all processes in that.  */

      send_sig (0, sig);

      if (sig != SIGKILL && sig != SIGCONT)

        {

          send_sig (monitored_pid, SIGCONT);

          send_sig (0, SIGCONT);

        }

    }

  else /* we're the child or the child is not exec'd yet.  */

    _exit (128 + sig);

}

static void install_signal_handlers (int sigterm)

{

  struct sigaction sa;

  sigemptyset (&sa.sa_mask);  /* Allow concurrent calls to handler */

  sa.sa_handler = cleanup;

  sa.sa_flags = SA_RESTART;   /* Restart syscalls if possible, as that's

                                 more likely to work cleanly.  */

  sigaction (SIGALRM, &sa, NULL); /* our timeout.  */

  sigaction (SIGINT, &sa, NULL);  /* Ctrl-C at terminal for example.  */

  sigaction (SIGQUIT, &sa, NULL); /* Ctrl-\ at terminal for example.  */

  sigaction (SIGHUP, &sa, NULL);  /* terminal closed for example.  */

  sigaction (SIGTERM, &sa, NULL); /* if we're killed, stop monitored proc.  */

  sigaction (sigterm, &sa, NULL); /* user specified termination signal.  */

}

/*----------------------------------------------------------------------------

** FUNCTION           : main

**

** DESCRIPTION        : Main entry point

**

**

** INPUTS             : argc            - Number of args

**                      argv            - Address of args

**

** RETURNS            :

**

----------------------------------------------------------------------------*/

int main (int argc, char **argv)

{

    int     argp;

    /*

    **  Process command line arguments

    **  Options for this program will be located first

    */

    for ( argp = 1; argp < argc ; argp++ )

    {

        /*

        **  Scan until first non option argument

        */

        if ( *argv[argp] != '-' )

            break;

        if ( strncasecmp( argv[argp], "-TIME:", 6 ) == 0)

        {

            timeOut = parseDuration(argv[argp] + 6);

/* fprintf(stderr, "Timeout: %d\n", timeOut); */

        }

        else

        {

            fprintf(stderr, "Error: Unknown option: %s\n", argv[argp] );

            exit(EXIT_CANCELED);

        }

    }

    /*

    **  Need at least one more argument - the program to run

    */

    if ( argp >= argc || argc <= 1 )

    {

      fputs("Error: Insufficient number of arguments given\n", stderr);

      fputs("       Need at least the name of the program\n", stderr);

      exit(EXIT_CANCELED);

    }

    /* Ensure we're in our own group so all subprocesses can be killed.

       Note we don't just put the child in a separate group as

       then we would need to worry about foreground and background groups

       and propagating signals between them.  */

    setpgid (0, 0);

    /* Setup handlers before fork() so that we

       handle any signals caused by child, without races.  */

    install_signal_handlers (term_signal);

    signal (SIGTTIN, SIG_IGN);   /* Don't stop if background child needs tty.  */

    signal (SIGTTOU, SIG_IGN);   /* Don't stop if background child needs tty.  */

    signal (SIGCHLD, SIG_DFL);   /* Don't inherit CHLD handling from parent.   */

    monitored_pid = fork ();

    if (monitored_pid == -1)

    {

        error (0, errno, "fork system call failed");

        return EXIT_CANCELED;

    }

    else if (monitored_pid == 0)

    {

        /* Child */

        int exit_status;

        char lBuf[30];

        /* Expose the Timeout as an EnvVar */

        snprintf(lBuf, sizeof(lBuf), "GBE_JOBLIMIT=%u", timeOut);

        if (putenv( lBuf ))

        {

            error (0, errno, "putenv call failed");

            return EXIT_CANCELED;

        }

        /* exec doesn't reset SIG_IGN -> SIG_DFL.  */

        signal (SIGTTIN, SIG_IGN);

        signal (SIGTTOU, SIG_IGN);

        execvp (argv[argp], &argv[argp]); 

        /* exit like sh, env, nohup, ...  */

        exit_status = errno == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE;

        error (0, errno, "failed to run command \"%s\"", argv[argp]);

        return exit_status;

    }

    else

    {

        /* Parent */

        pid_t wait_result;

        int status;

        settimeout (timeOut, true);

        while ((wait_result = waitpid (monitored_pid, &status, 0)) < 0

               && errno == EINTR)

          continue;

        if (wait_result < 0)

          {

            /* shouldn't happen.  */

            error (0, errno, "error waiting for command");

            status = EXIT_CANCELED;

          }

        else

          {

            if (WIFEXITED (status))

              status = WEXITSTATUS (status);

            else if (WIFSIGNALED (status))

              {

                int sig = WTERMSIG (status);

                if (WCOREDUMP (status))

                  error (0, 0, "the monitored command dumped core");

                if (!timed_out && disable_core_dumps ())

                  {

                    /* exit with the signal flag set.  */

                    signal (sig, SIG_DFL);

                    raise (sig);

                  }

                status = sig + 128; /* what sh returns for signaled processes.  */

              }

            else

              {

                /* shouldn't happen.  */

                error (0, 0, "unknown status from command (%d)", status);

                status = EXIT_FAILURE;

              }

          }

        if (timed_out)

        {

          fprintf(stderr, "Process exceeded time limit (%d Secs)\n", timeOut);

          status = EXIT_TIMEDOUT;

        }

        return status;

    }

}