src/timeout.c

   1 /* timeout -- run a command with bounded time
   2    Copyright (C) 2008-2010 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  16
  17
  18 /* timeout - Start a command, and kill it if the specified timeout expires
  19
  20    We try to behave like a shell starting a single (foreground) job,
  21    and will kill the job if we receive the alarm signal we setup.
  22    The exit status of the job is returned, or one of these errors:
  23      EXIT_TIMEDOUT      124      job timed out
  24      EXIT_CANCELED      125      internal error
  25      EXIT_CANNOT_INVOKE 126      error executing job
  26      EXIT_ENOENT        127      couldn't find job to exec
  27
  28    Caveats:
  29      If user specifies the KILL (9) signal is to be sent on timeout,
  30      the monitor is killed and so exits with 128+9 rather than 124.
  31
  32      If you start a command in the background, which reads from the tty
  33      and so is immediately sent SIGTTIN to stop, then the timeout
  34      process will ignore this so it can timeout the command as expected.
  35      This can be seen with `timeout 10 dd&` for example.
  36      However if one brings this group to the foreground with the `fg`
  37      command before the timer expires, the command will remain
  38      in the sTop state as the shell doesn't send a SIGCONT
  39      because the timeout process (group leader) is already running.
  40      To get the command running again one can Ctrl-Z, and do fg again.
  41      Note one can Ctrl-C the whole job when in this state.
  42      I think this could be fixed but I'm not sure the extra
  43      complication is justified for this scenario.
  44
  45    Written by Pádraig Brady.  */
  46
  47 #include <config.h>
  48 #include <getopt.h>
  49 #include <stdio.h>
  50 #include <sys/types.h>
  51 #include <signal.h>
  52
  53 #if HAVE_SYS_WAIT_H
  54 # include <sys/wait.h>
  55 #endif
  56 #ifndef WIFSIGNALED
  57 # define WIFSIGNALED(s) (((s) & 0xFFFF) - 1 < (unsigned int) 0xFF)
  58 #endif
  59 #ifndef WTERMSIG
  60 # define WTERMSIG(s) ((s) & 0x7F)
  61 #endif
  62
  63 #include "system.h"
  64 #include "xstrtol.h"
  65 #include "sig2str.h"
  66 #include "operand2sig.h"
  67 #include "cloexec.h"
  68 #include "error.h"
  69 #include "quote.h"
  70
  71 #define PROGRAM_NAME "timeout"
  72
  73 #define AUTHORS proper_name_utf8 ("Padraig Brady", "P\303\241draig Brady")
  74
  75 static int timed_out;
  76 static int term_signal = SIGTERM;  /* same default as kill command.  */
  77 static int monitored_pid;
  78 static int sigs_to_ignore[NSIG];   /* so monitor can ignore sigs it resends.  */
  79 static unsigned long kill_after;
  80
  81 static struct option const long_options[] =
  82 {
  83   {"kill-after", required_argument, NULL, 'k'},
  84   {"signal", required_argument, NULL, 's'},
  85   {GETOPT_HELP_OPTION_DECL},
  86   {GETOPT_VERSION_OPTION_DECL},
  87   {NULL, 0, NULL, 0}
  88 };
  89
  90 /* send sig to group but not ourselves.
  91  * FIXME: Is there a better way to achieve this?  */
  92 static int
  93 send_sig (int where, int sig)
  94 {
  95   sigs_to_ignore[sig] = 1;
  96   return kill (where, sig);
  97 }
  98
  99 static void
 100 cleanup (int sig)
 101 {
 102   if (sig == SIGALRM)
 103     {
 104       timed_out = 1;
 105       sig = term_signal;
 106     }
 107   if (monitored_pid)
 108     {
 109       if (sigs_to_ignore[sig])
 110         {
 111           sigs_to_ignore[sig] = 0;
 112           return;
 113         }
 114       if (kill_after)
 115         {
 116           /* Start a new timeout after which we'll send SIGKILL.  */
 117           term_signal = SIGKILL;
 118           alarm (kill_after);
 119           kill_after = 0; /* Don't let later signals reset kill alarm.  */
 120         }
 121       send_sig (0, sig);
 122       if (sig != SIGKILL && sig != SIGCONT)
 123         send_sig (0, SIGCONT);
 124     }
 125   else /* we're the child or the child is not exec'd yet.  */
 126     _exit (128 + sig);
 127 }
 128
 129 void
 130 usage (int status)
 131 {
 132   if (status != EXIT_SUCCESS)
 133     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 134              program_name);
 135   else
 136     {
 137       printf (_("\
 138 Usage: %s [OPTION] DURATION COMMAND [ARG]...\n\
 139   or:  %s [OPTION]\n"), program_name, program_name);
 140
 141       fputs (_("\
 142 Start COMMAND, and kill it if still running after DURATION.\n\
 143 \n\
 144 Mandatory arguments to long options are mandatory for short options too.\n\
 145 "), stdout);
 146       fputs (_("\
 147   -k, --kill-after=DURATION\n\
 148                    also send a KILL signal if COMMAND is still running\n\
 149                    this long after the initial signal was sent.\n\
 150   -s, --signal=SIGNAL\n\
 151                    specify the signal to be sent on timeout.\n\
 152                    SIGNAL may be a name like `HUP' or a number.\n\
 153                    See `kill -l` for a list of signals\n"), stdout);
 154
 155       fputs (HELP_OPTION_DESCRIPTION, stdout);
 156       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 157
 158       fputs (_("\n\
 159 DURATION is an integer with an optional suffix:\n\
 160 `s' for seconds(the default), `m' for minutes, `h' for hours or `d' for days.\n\
 161 "), stdout);
 162
 163       fputs (_("\n\
 164 If the command times out, then exit with status 124.  Otherwise, exit\n\
 165 with the status of COMMAND.  If no signal is specified, send the TERM\n\
 166 signal upon timeout.  The TERM signal kills any process that does not\n\
 167 block or catch that signal.  For other processes, it may be necessary to\n\
 168 use the KILL (9) signal, since this signal cannot be caught.\n"), stdout);
 169       emit_ancillary_info ();
 170     }
 171   exit (status);
 172 }
 173
 174 /* Given a long integer value *X, and a suffix character, SUFFIX_CHAR,
 175    scale *X by the multiplier implied by SUFFIX_CHAR.  SUFFIX_CHAR may
 176    be the NUL byte or `s' to denote seconds, `m' for minutes, `h' for
 177    hours, or `d' for days.  If SUFFIX_CHAR is invalid, don't modify *X
 178    and return false.  If *X would overflow an integer, don't modify *X
 179    and return false. Otherwise return true.  */
 180
 181 static bool
 182 apply_time_suffix (unsigned long *x, char suffix_char)
 183 {
 184   unsigned int multiplier = 1;
 185
 186   switch (suffix_char)
 187     {
 188     case 0:
 189     case 's':
 190       return true;
 191     case 'd':
 192       multiplier *= 24;
 193     case 'h':
 194       multiplier *= 60;
 195     case 'm':
 196       if (multiplier > UINT_MAX / 60) /* 16 bit overflow */
 197         return false;
 198       multiplier *= 60;
 199       break;
 200     default:
 201       return false;
 202     }
 203
 204   if (*x > UINT_MAX / multiplier)
 205     return false;
 206
 207   *x *= multiplier;
 208
 209   return true;
 210 }
 211
 212 static unsigned long
 213 parse_duration (const char* str)
 214 {
 215   unsigned long duration;
 216   char *ep;
 217
 218   if (xstrtoul (str, &ep, 10, &duration, NULL)
 219       /* Invalid interval. Note 0 disables timeout  */
 220       || (duration > UINT_MAX)
 221       /* Extra chars after the number and an optional s,m,h,d char.  */
 222       || (*ep && *(ep + 1))
 223       /* Check any suffix char and update timeout based on the suffix.  */
 224       || !apply_time_suffix (&duration, *ep))
 225     {
 226       error (0, 0, _("invalid time interval %s"), quote (str));
 227       usage (EXIT_CANCELED);
 228     }
 229
 230   return duration;
 231 }
 232
 233 static void
 234 install_signal_handlers (int sigterm)
 235 {
 236   struct sigaction sa;
 237   sigemptyset (&sa.sa_mask);  /* Allow concurrent calls to handler */
 238   sa.sa_handler = cleanup;
 239   sa.sa_flags = SA_RESTART;  /* restart syscalls (like wait() below) */
 240
 241   sigaction (SIGALRM, &sa, NULL); /* our timeout.  */
 242   sigaction (SIGINT, &sa, NULL);  /* Ctrl-C at terminal for example.  */
 243   sigaction (SIGQUIT, &sa, NULL); /* Ctrl-\ at terminal for example.  */
 244   sigaction (SIGHUP, &sa, NULL);  /* terminal closed for example.  */
 245   sigaction (SIGTERM, &sa, NULL); /* if we're killed, stop monitored proc.  */
 246   sigaction (sigterm, &sa, NULL); /* user specified termination signal.  */
 247 }
 248
 249 int
 250 main (int argc, char **argv)
 251 {
 252   unsigned long timeout;
 253   char signame[SIG2STR_MAX];
 254   int c;
 255
 256   initialize_main (&argc, &argv);
 257   set_program_name (argv[0]);
 258   setlocale (LC_ALL, "");
 259   bindtextdomain (PACKAGE, LOCALEDIR);
 260   textdomain (PACKAGE);
 261
 262   initialize_exit_failure (EXIT_CANCELED);
 263   atexit (close_stdout);
 264
 265   while ((c = getopt_long (argc, argv, "+k:s:", long_options, NULL)) != -1)
 266     {
 267       switch (c)
 268         {
 269         case 'k':
 270           kill_after = parse_duration (optarg);
 271           break;
 272
 273         case 's':
 274           term_signal = operand2sig (optarg, signame);
 275           if (term_signal == -1)
 276             usage (EXIT_CANCELED);
 277           break;
 278
 279         case_GETOPT_HELP_CHAR;
 280
 281         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 282
 283         default:
 284           usage (EXIT_CANCELED);
 285           break;
 286         }
 287     }
 288
 289   if (argc - optind < 2)
 290     usage (EXIT_CANCELED);
 291
 292   timeout = parse_duration (argv[optind++]);
 293
 294   argv += optind;
 295
 296   /* Ensure we're in our own group so all subprocesses can be killed.
 297      Note we don't just put the child in a separate group as
 298      then we would need to worry about foreground and background groups
 299      and propagating signals between them.  */
 300   setpgid (0, 0);
 301
 302   /* Setup handlers before fork() so that we
 303      handle any signals caused by child, without races.  */
 304   install_signal_handlers (term_signal);
 305   signal (SIGTTIN, SIG_IGN);    /* don't sTop if background child needs tty.  */
 306   signal (SIGTTOU, SIG_IGN);    /* don't sTop if background child needs tty.  */
 307   signal (SIGCHLD, SIG_DFL);    /* Don't inherit CHLD handling from parent.   */
 308
 309   monitored_pid = fork ();
 310   if (monitored_pid == -1)
 311     {
 312       error (0, errno, _("fork system call failed"));
 313       return EXIT_CANCELED;
 314     }
 315   else if (monitored_pid == 0)
 316     {                           /* child */
 317       int exit_status;
 318
 319       /* exec doesn't reset SIG_IGN -> SIG_DFL.  */
 320       signal (SIGTTIN, SIG_DFL);
 321       signal (SIGTTOU, SIG_DFL);
 322
 323       execvp (argv[0], argv);   /* FIXME: should we use "sh -c" ... here?  */
 324
 325       /* exit like sh, env, nohup, ...  */
 326       exit_status = (errno == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE);
 327       error (0, errno, _("failed to run command %s"), quote (argv[0]));
 328       return exit_status;
 329     }
 330   else
 331     {
 332       int status;
 333
 334       alarm (timeout);
 335
 336       /* We're just waiting for a single process here, so wait() suffices.
 337          Note the signal() calls above on GNU/Linux and BSD at least,
 338          essentially call the lower level sigaction() with the SA_RESTART flag
 339          set, which ensures the following wait call will only return if the
 340          child exits, not on this process receiving a signal. Also we're not
 341          passing WUNTRACED | WCONTINUED to a waitpid() call and so will not get
 342          indication that the child has stopped or continued.  */
 343       if (wait (&status) == -1)
 344         {
 345           /* shouldn't happen.  */
 346           error (0, errno, _("error waiting for command"));
 347           status = EXIT_CANCELED;
 348         }
 349       else
 350         {
 351           if (WIFEXITED (status))
 352             status = WEXITSTATUS (status);
 353           else if (WIFSIGNALED (status))
 354             status = WTERMSIG (status) + 128; /* what sh does at least.  */
 355           else
 356             {
 357               /* shouldn't happen.  */
 358               error (0, 0, _("unknown status from command (0x%X)"), status);
 359               status = EXIT_FAILURE;
 360             }
 361         }
 362
 363       if (timed_out)
 364         return EXIT_TIMEDOUT;
 365       else
 366         return status;
 367     }
 368 }