3 * Run a command with a timeout.
5 * (c) 2011 Mark Wooding
8 /*----- Licensing notice --------------------------------------------------*
10 * This file is part of the Toys utilties collection.
12 * Toys is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * Toys is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with Toys; if not, write to the Free Software Foundation,
24 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27 /*----- Basic strategy ----------------------------------------------------*
29 * There's an obvious and simple way to make a process stop after a certain
30 * amount of time: set an alarm. Alarms are inherited, so this will take
31 * down the whole subprocess tree. Unfortunately, processes use alarms for
32 * all sorts of things. And this relies on the process not fiddling with its
35 * The other possibility is to have a separate process which kills our target
36 * program when the time's up. In order to do this effectively, we need to
37 * trap the whole thing in a process group. Then we need to wait until the
38 * time is up or the process finished. We'll assume that the top-level
39 * process finishing is sufficient indication that we don't need to hang on
42 * This isn't perfect. It won't catch stragglers if the target process
43 * creates its own sub-process groups -- so, in particular, nested timeouts
44 * won't behave in an obvious way. And, possibly most annoyingly, it
45 * interferes with the way terminal I/O works. I'm sorry: you can't have
49 /*----- Header files ------------------------------------------------------*/
59 #include <sys/types.h>
63 #include <sys/select.h>
66 #include <mLib/fdflags.h>
67 #include <mLib/macros.h>
68 #include <mLib/mdwopt.h>
69 #include <mLib/quis.h>
70 #include <mLib/report.h>
75 /*----- Static variables --------------------------------------------------*/
86 /*----- Argument conversion functions -------------------------------------*/
88 /* --- @namesig@ --- *
90 * Arguments: @const char *p@ = pointer to string
92 * Returns: Signal number, or @-1@ for no match.
94 * Use: Converts a signal name into its number.
102 int cmp_namesig(const void *k, const void *v)
103 { const struct namesig *ns = v; return (strcmp(k, ns->name)); }
105 static int namesig(const char *p)
107 const static struct namesig tab[] = {
109 ;;; The signal name table is very boring to type. To make life less
110 ;;; awful, put the signal names in this list and evaluate the code to
111 ;;; get Emacs to regenerate it. We use @bsearch@ on it, so it's
112 ;;; important that it be sorted: Emacs does this for us.
114 (let ((signals '(HUP INT QUIT ILL ABRT FPE KILL SEGV PIPE ALRM TERM
115 USR1 USR2 CHLD CONT STOP TSTP TTIN TTOU BUS POLL
116 PROF SYS TRAP URG VTALRM XCPU XFSZ IOT EMT STKFLT
117 IO CLD PWR INFO LOST WINCH)))
119 (goto-char (point-min))
120 (search-forward (concat "***" "BEGIN siglist" "***"))
121 (beginning-of-line 2)
122 (delete-region (point)
124 (search-forward "***END***")
127 (dolist (sig (sort (copy-list signals) #'string<))
128 (insert (format "#ifdef SIG%s\n { \"%s\", SIG%s },\n#endif\n"
132 /***BEGIN siglist***/
200 { "STKFLT", SIGSTKFLT },
233 { "VTALRM", SIGVTALRM },
236 { "WINCH", SIGWINCH },
247 const struct namesig *ns = bsearch(p, tab, N(tab), sizeof(tab[0]),
249 if (ns) return (ns->sig);
250 else if (isdigit((unsigned char)*p)) return (atoi(p));
254 /* --- @strtotime@ --- *
256 * Arguments: @const char *p@ = pointer to string
257 * @struct timeval *tv@ = where to put the result
261 * Use: Converts a string representation of a duration into an
262 * internal version. Understands various time units.
265 static void strtotime(const char *p, struct timeval *tv)
267 char *q = (/*unconst*/ char *)p;
270 while (isspace((unsigned char)*q)) q++;
272 while (isspace((unsigned char)*q)) q++;
274 case 'd': case 'D': t *= 24;
275 case 'h': case 'H': t *= 60;
276 case 'm': case 'M': t *= 60;
279 while (isspace((unsigned char)*q)) q++;
281 if (*q) die(253, "bad time value `%s'", p);
284 tv->tv_usec = f * 1000000;
287 /*----- Help functions ----------------------------------------------------*/
289 static void usage(FILE *fp)
292 "Usage: $ [-K] [-b TIME] [-k TIME] [-s SIG] "
293 "TIME COMMAND [ARGUMENTS ...]\n");
296 static void version(FILE *fp)
297 { pquis(fp, "$ (version " VERSION ")\n"); }
299 static void help(FILE *fp)
301 version(fp); fputc('\n', stdout);
304 Run COMMAND, giving it the ARGUMENTS. If it fails to complete within the\n\
305 specified number of TIME, kill it. Otherwise exit with the status it\n\
308 A TIME is a possibly fractional number followed by an optional unit\n\
309 designator, which may be `s', `m', `h', or `d', for seconds, minutes,\n\
310 hours, or days, respectively. The default units are seconds.\n\
313 -h, --help Show this help text.\n\
314 -v, --version Show version string.\n\
315 -u, --usage Show a terse usage summary.\n\
317 -b, --bored-after=TIME Wait for TIME after sending SIGKILL.\n\
318 -k, --kill-after=TIME Wait for TIME after signal before sending SIGKILL.\n\
319 -K, --no-kill Don't send SIGKILL; just give up when bored.\n\
320 -s, --signal=SIG Send signal SIG to the command.\n\
324 /*----- Timeout handling --------------------------------------------------*/
326 /* --- @timeout@ --- *
328 * The timeout sequencing stuff is complicated, so here's a simple machine to
333 TA_MOAN, /* Report message to user */
336 TA_KILL, /* Send a signal */
339 TA_GOTO, /* Goto different state */
342 TA_WAIT, /* Wait for more time */
343 #define TAARG_WAIT tv
345 TA_STATE, /* Alter the internal state */
346 #define TAARG_STATE i
352 const char *s; /* String parameter */
353 int i; /* Integer parameter */
354 struct timeval tv; /* Time parameter */
359 sel_timer t; /* Timer intrusion */
360 struct tmact *ta; /* Instruction vector */
361 int ip; /* Instruction pointer */
365 static void timeout(struct timeval *now, void *p)
367 struct timeout *t = p;
372 ta = &t->ta[t->ip++];
378 kill(-t->kid, ta->u.i);
387 TV_ADD(&tv, now, &ta->u.tv);
388 sel_addtimer(&sel, &t->t, &tv, timeout, t);
391 moan("unexpected tmact %u", ta->act);
397 /*----- Signal handling ---------------------------------------------------*/
399 /* --- @sigchld@ --- *
401 * If it's our child that died, fetch its exit status and stop.
409 static void sigchld(int sig, void *p)
411 struct sigchld *s = p;
415 if ((pid = waitpid(s->kid, &rc, WNOHANG)) < 0)
416 die(254, "waitpid failed: %s", strerror(errno));
423 /* --- @sigpropagate@ --- *
425 * Propagate various signals to the child process group and then maybe act on
429 static void sigpropagate(int sig, void *p)
431 struct sigchld *s = p;
435 case SIGTSTP: raise(SIGSTOP); break;
439 #define PROPAGATE_SIGNALS(_) \
440 _(TSTP) _(CONT) _(INT) _(HUP) _(QUIT)
442 /*----- Main program ------------------------------------------------------*/
446 int main(int argc, char *const argv[])
452 #define PAIR(x, y) { x, y }
454 I(sigwait, WAIT, PAIR(0, 0)) \
455 I(_a, MOAN, "timed out: killing child process") \
456 I(sig, KILL, SIGTERM) \
457 I(killwait, WAIT, PAIR(5, 0)) \
458 I(_b, MOAN, "child hasn't responded: killing harder") \
459 I(_c, KILL, SIGKILL) \
460 I(boredwait, WAIT, PAIR(5, 0)) \
461 I(_d, MOAN, "child still undead: giving up") \
462 I(_e, STATE, ST_ABORT)
465 #define TALBL(label, op, arg) taoff_##label,
471 static struct tmact ta[] = {
472 #define TAASM(label, op, arg) { TA_##op, { .TAARG_##op = arg } },
479 #define DEFSIG(tag) sig sig_##tag;
480 PROPAGATE_SIGNALS(DEFSIG)
485 /* --- Option parsing --- */
490 static const struct option opts[] = {
491 { "help", 0, 0, 'h' },
492 { "version", 0, 0, 'v' },
493 { "usage", 0, 0, 'u' },
494 { "no-kill", 0, 0, 'K' },
495 { "kill-after", OPTF_ARGREQ, 0, 'k' },
496 { "bored-after", OPTF_ARGREQ, 0, 'b' },
497 { "signal", OPTF_ARGREQ, 0, 's' },
501 int i = mdwopt(argc, argv, "+hvuKb:k:s:", opts, 0, 0, 0);
504 case 'h': help(stdout); exit(0);
505 case 'v': version(stdout); exit(0);
506 case 'u': usage(stdout); exit(0);
508 ta[taoff_boredwait].act = TA_WAIT;
509 strtotime(optarg, &ta[taoff_boredwait].u.tv);
512 ta[taoff_killwait].act = TA_WAIT;
513 strtotime(optarg, &ta[taoff_killwait].u.tv);
516 ta[taoff_killwait].act = TA_GOTO;
517 ta[taoff_killwait].u.i = taoff_boredwait;
520 if ((ta[taoff_sig].u.i = namesig(optarg)) < 0)
521 die(253, "bad signal spec `%s'", optarg);
523 default: f |= F_BOGUS; break;
526 argc -= optind; argv += optind;
527 if ((f & F_BOGUS) || argc < 2) { usage(stderr); exit(253); }
528 strtotime(argv[0], &ta[taoff_sigwait].u.tv);
530 /* --- Get things set up --- */
535 /* --- Set up signal handling --- *
537 * Doing anything with asynchronous signals is a mug's game, so we bring
538 * them in-band. Do this before starting the child process, because
539 * otherwise we might miss an immediate @SIGCHLD@.
544 sig_add(&sig_CHLD, SIGCHLD, sigchld, &sc);
545 #define ADDSIG(tag) sig_add(&sig_##tag, SIG##tag, sigpropagate, &sc);
546 PROPAGATE_SIGNALS(ADDSIG)
549 /* --- Now start the child process --- */
551 if ((kid = fork()) < 0) die(2, "fork failed: %s", strerror(errno));
554 execvp(argv[1], argv + 1);
555 die(252, "exec(%s) failed: %s", argv[1], strerror(errno));
559 /* --- Set up the timer --- */
561 gettimeofday(&now, 0);
567 /* --- Main @select@ loop */
569 while (state == ST_WAIT) {
570 if (sel_select(&sel)) {
571 if (errno == EINTR) continue;
572 die(254, "select failed: %s", strerror(errno));
576 /* --- Check and translate the exit code --- */
582 if (WIFEXITED(sc.rc))
583 exit(WEXITSTATUS(sc.rc));
584 else if (WIFSIGNALED(sc.rc))
585 exit(128 | WTERMSIG(sc.rc));
589 moan("FATAL: unexpected state %d", state);
594 /*----- That's all, folks -------------------------------------------------*/