[misc] / mtimeout.c

/* -*-c-*-
 *
 * Run a command with a timeout.
 *
 * (c) 2011 Mark Wooding
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the Toys utilties collection.
 *
 * Toys 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 2 of the License, or
 * (at your option) any later version.
 *
 * Toys 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 Toys; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Basic strategy ----------------------------------------------------*
 *
 * There's an obvious and simple way to make a process stop after a certain
 * amount of time: set an alarm.  Alarms are inherited, so this will take
 * down the whole subprocess tree.  Unfortunately, processes use alarms for
 * all sorts of things.  And this relies on the process not fiddling with its
 * @SIGALRM@ handler.
 *
 * The other possibility is to have a separate process which kills our target
 * program when the time's up.  In order to do this effectively, we need to
 * trap the whole thing in a process group.  Then we need to wait until the
 * time is up or the process finished.  We'll assume that the top-level
 * process finishing is sufficient indication that we don't need to hang on
 * any longer.
 *
 * This isn't perfect.  It won't catch stragglers if the target process
 * creates its own sub-process groups -- so, in particular, nested timeouts
 * won't behave in an obvious way.  And, possibly most annoyingly, it
 * interferes with the way terminal I/O works.  I'm sorry: you can't have
 * everything.
 */

/*----- Header files ------------------------------------------------------*/

#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <sys/time.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/wait.h>

#include <mLib/fdflags.h>
#include <mLib/macros.h>
#include <mLib/mdwopt.h>
#include <mLib/quis.h>
#include <mLib/report.h>
#include <mLib/sel.h>
#include <mLib/sig.h>
#include <mLib/tv.h>

/*----- Static variables --------------------------------------------------*/

static sel_state sel;
static int state;

enum {
  ST_WAIT,
  ST_ABORT,
  ST_DONE
};

/*----- Argument conversion functions -------------------------------------*/

/* --- @namesig@ --- *
 *
 * Arguments:	@const char *p@ = pointer to string
 *
 * Returns:	Signal number, or @-1@ for no match.
 *
 * Use:		Converts a signal name into its number.
 */

struct namesig {
  const char *name;
  int sig;
};

int cmp_namesig(const void *k, const void *v)
  { const struct namesig *ns = v; return (strcmp(k, ns->name)); }

static int namesig(const char *p)
{
  const static struct namesig tab[] = {
  /*
     ;;; The signal name table is very boring to type.  To make life less
     ;;; awful, put the signal names in this list and evaluate the code to
     ;;; get Emacs to regenerate it.  We use @bsearch@ on it, so it's
     ;;; important that it be sorted: Emacs does this for us.

     (let ((signals '(HUP INT QUIT ILL ABRT FPE KILL SEGV PIPE ALRM TERM
		      USR1 USR2 CHLD CONT STOP TSTP TTIN TTOU BUS POLL
		      PROF SYS TRAP URG VTALRM XCPU XFSZ IOT EMT STKFLT
		      IO CLD PWR INFO LOST WINCH)))
       (save-excursion
	 (goto-char (point-min))
	 (search-forward (concat "***" "BEGIN siglist" "***"))
	 (beginning-of-line 2)
	 (delete-region (point)
			(progn
			  (search-forward "***END***")
			  (beginning-of-line)
			  (point)))
	 (dolist (sig (sort (copy-list signals) #'string<))
	   (insert (format "#ifdef SIG%s\n    { \"%s\", SIG%s },\n#endif\n"
			   sig sig sig)))))
  */

    /***BEGIN siglist***/
#ifdef SIGABRT
    { "ABRT", SIGABRT },
#endif
#ifdef SIGALRM
    { "ALRM", SIGALRM },
#endif
#ifdef SIGBUS
    { "BUS", SIGBUS },
#endif
#ifdef SIGCHLD
    { "CHLD", SIGCHLD },
#endif
#ifdef SIGCLD
    { "CLD", SIGCLD },
#endif
#ifdef SIGCONT
    { "CONT", SIGCONT },
#endif
#ifdef SIGEMT
    { "EMT", SIGEMT },
#endif
#ifdef SIGFPE
    { "FPE", SIGFPE },
#endif
#ifdef SIGHUP
    { "HUP", SIGHUP },
#endif
#ifdef SIGILL
    { "ILL", SIGILL },
#endif
#ifdef SIGINFO
    { "INFO", SIGINFO },
#endif
#ifdef SIGINT
    { "INT", SIGINT },
#endif
#ifdef SIGIO
    { "IO", SIGIO },
#endif
#ifdef SIGIOT
    { "IOT", SIGIOT },
#endif
#ifdef SIGKILL
    { "KILL", SIGKILL },
#endif
#ifdef SIGLOST
    { "LOST", SIGLOST },
#endif
#ifdef SIGPIPE
    { "PIPE", SIGPIPE },
#endif
#ifdef SIGPOLL
    { "POLL", SIGPOLL },
#endif
#ifdef SIGPROF
    { "PROF", SIGPROF },
#endif
#ifdef SIGPWR
    { "PWR", SIGPWR },
#endif
#ifdef SIGQUIT
    { "QUIT", SIGQUIT },
#endif
#ifdef SIGSEGV
    { "SEGV", SIGSEGV },
#endif
#ifdef SIGSTKFLT
    { "STKFLT", SIGSTKFLT },
#endif
#ifdef SIGSTOP
    { "STOP", SIGSTOP },
#endif
#ifdef SIGSYS
    { "SYS", SIGSYS },
#endif
#ifdef SIGTERM
    { "TERM", SIGTERM },
#endif
#ifdef SIGTRAP
    { "TRAP", SIGTRAP },
#endif
#ifdef SIGTSTP
    { "TSTP", SIGTSTP },
#endif
#ifdef SIGTTIN
    { "TTIN", SIGTTIN },
#endif
#ifdef SIGTTOU
    { "TTOU", SIGTTOU },
#endif
#ifdef SIGURG
    { "URG", SIGURG },
#endif
#ifdef SIGUSR1
    { "USR1", SIGUSR1 },
#endif
#ifdef SIGUSR2
    { "USR2", SIGUSR2 },
#endif
#ifdef SIGVTALRM
    { "VTALRM", SIGVTALRM },
#endif
#ifdef SIGWINCH
    { "WINCH", SIGWINCH },
#endif
#ifdef SIGXCPU
    { "XCPU", SIGXCPU },
#endif
#ifdef SIGXFSZ
    { "XFSZ", SIGXFSZ },
#endif
    /***END***/
  };

  const struct namesig *ns = bsearch(p, tab, N(tab), sizeof(tab[0]),
				     cmp_namesig);
  if (ns) return (ns->sig);
  else if (isdigit((unsigned char)*p)) return (atoi(p));
  else return (-1);
}

/* --- @strtotime@ --- *
 *
 * Arguments:	@const char *p@ = pointer to string
 *		@struct timeval *tv@ = where to put the result
 *
 * Returns:	---
 *
 * Use:		Converts a string representation of a duration into an
 *		internal version.  Understands various time units.
 */

static void strtotime(const char *p, struct timeval *tv)
{
  char *q = (/*unconst*/ char *)p;
  double t, i, f;

  while (isspace((unsigned char)*q)) q++;
  t = strtod(q, &q);
  while (isspace((unsigned char)*q)) q++;
  switch (*q) {
    case 'd': case 'D': t *= 24;
    case 'h': case 'H': t *= 60;
    case 'm': case 'M': t *= 60;
    case 's': case 'S':
      q++;
      while (isspace((unsigned char)*q)) q++;
  }
  if (*q) die(253, "bad time value `%s'", p);
  f = modf(t, &i);
  tv->tv_sec = i;
  tv->tv_usec = f * 1000000;
}

/*----- Help functions ----------------------------------------------------*/

static void usage(FILE *fp)
  { pquis(fp, "Usage: $ [-s SIG] SECONDS COMMAND [ARGUMENTS ...]\n"); }

static void version(FILE *fp)
  { pquis(fp, "$ (version " VERSION ")\n"); }

static void help(FILE *fp)
{
  version(fp); fputc('\n', stdout);
  usage(fp);
  pquis(fp, "\n\
Run COMMAND, giving it the ARGUMENTS.  If it fails to complete within the\n\
specified number of SECONDS, kill it.  Otherwise exit with the status it\n\
returns.\n								\
\n\
Options:\n\
  -h, --help		Show this help text.\n\
  -v, --version		Show version string.\n\
  -u, --usage		Show a terse usage summary.\n\
\n\
  -s, --signal=SIG	Send signal SIG to the command.\n\
");
}

/*----- Timeout handling --------------------------------------------------*/

/* --- @timeout@ --- *
 *
 * The first time, we send the signal requested by the caller.  Then we wait
 * five seconds for the child to die, and send @SIGKILL@.  If that still
 * doesn't help, then we just give up.  It's not like there's anything else
 * we can do which is likely to help.  And it's not like the process is going
 * to be doing anything else in user mode ever again.
 */

struct timeout {
  sel_timer t;
  int panic;
  int sig;
  pid_t kid;
};

static void timeout(struct timeval *now, void *p)
{
  struct timeout *t = p;
  struct timeval tv;

  switch (t->panic) {
    case 0:
      moan("timed out: killing child process");
      kill(-t->kid, t->sig);
      break;
    case 1:
      moan("child hasn't responded: killing harder");
      kill(-t->kid, SIGKILL);
      break;
    case 2:
      moan("child still undead: giving up");
      state = ST_ABORT;
      break;
  }
  TV_ADDL(&tv, now, 5, 0);
  sel_addtimer(&sel, &t->t, &tv, timeout, t);
  t->panic++;
}

/*----- Signal handling ---------------------------------------------------*/

/* --- @sigchld@ --- *
 *
 * If it's our child that died, fetch its exit status and stop.
 */

struct sigchld {
  pid_t kid;
  int rc;
};

static void sigchld(int sig, void *p)
{
  struct sigchld *s = p;
  int rc;
  pid_t pid;

  if ((pid = waitpid(s->kid, &rc, WNOHANG)) < 0)
    die(254, "waitpid failed: %s", strerror(errno));
  if (pid == s->kid) {
    s->rc = rc;
    state = ST_DONE;
  }
}

/* --- @sigpropagate@ --- *
 *
 * Propagate various signals to the child process group and then maybe act on
 * them.
 */

static void sigpropagate(int sig, void *p)
{
  struct sigchld *s = p;

  kill(-s->kid, sig);
  switch (sig) {
    case SIGTSTP: raise(SIGSTOP); break;
  }
}

#define PROPAGATE_SIGNALS(_)						\
  _(TSTP) _(CONT) _(INT) _(HUP) _(QUIT)

/*----- Main program ------------------------------------------------------*/

/* --- @main@ --- */

int main(int argc, char *const argv[])
{
  int signo = SIGTERM;
  pid_t kid;
  struct timeval now, tv;
  struct timeout to;
  struct sigchld sc;
  sig sig_CHLD;
#define DEFSIG(tag) sig sig_##tag;
  PROPAGATE_SIGNALS(DEFSIG)
#undef DEFSIG
  unsigned f = 0;
#define F_BOGUS 1u

  /* --- Option parsing --- */

  ego(argv[0]);

  for (;;) {
    static const struct option opts[] = {
      { "help",			0,		0,	'h' },
      { "version",		0,		0,	'v' },
      { "usage",		0,		0,	'u' },
      { "signal",		OPTF_ARGREQ,	0,	's' },
      { 0,			0,		0,	0 }
    };

    int i = mdwopt(argc, argv, "+hvus:", opts, 0, 0, 0);
    if (i < 0) break;
    switch (i) {
      case 'h': help(stdout); exit(0);
      case 'v': version(stdout); exit(0);
      case 'u': usage(stdout); exit(0);
      case 's':
	if ((signo = namesig(optarg)) < 0)
	  die(253, "bad signal spec `%s'", optarg);
	break;
      default: f |= F_BOGUS; break;
    }
  }
  argc -= optind; argv += optind;
  if ((f & F_BOGUS) || argc < 2) { usage(stderr); exit(253); }
  strtotime(argv[0], &tv);

  /* --- Get things set up --- */

  state = ST_WAIT;
  sel_init(&sel);

  /* --- Set up signal handling --- *
   *
   * Doing anything with asynchronous signals is a mug's game, so we bring
   * them in-band.  Do this before starting the child process, because
   * otherwise we might miss an immediate @SIGCHLD@.
   */

  sig_init(&sel);
  sc.rc = 0;
  sig_add(&sig_CHLD, SIGCHLD, sigchld, &sc);
#define ADDSIG(tag) sig_add(&sig_##tag, SIG##tag, sigpropagate, &sc);
  PROPAGATE_SIGNALS(ADDSIG)
#undef ADDSIG

  /* --- Now start the child process --- */

  if ((kid = fork()) < 0) die(2, "fork failed: %s", strerror(errno));
  if (!kid) {
    setpgid(0, 0);
    execvp(argv[1], argv + 1);
    die(252, "exec(%s) failed: %s", argv[1], strerror(errno));
  }
  sc.kid = kid;

  /* --- Set up the timer --- */

  to.kid = kid;
  to.sig = signo;
  to.panic = 0;
  gettimeofday(&now, 0);
  TV_ADD(&tv, &now, &tv);
  sel_addtimer(&sel, &to.t, &tv, timeout, &to);

  /* --- Main @select@ loop */

  while (state == ST_WAIT) {
    if (sel_select(&sel)) {
      if (errno == EINTR) continue;
      die(254, "select failed: %s", strerror(errno));
    }
  }

  /* --- Check and translate the exit code --- */

  switch (state) {
    case ST_ABORT:
      exit(251);
    case ST_DONE:
      if (WIFEXITED(sc.rc))
	exit(WEXITSTATUS(sc.rc));
      else if (WIFSIGNALED(sc.rc))
	exit(128 | WTERMSIG(sc.rc));
      else
	exit(128);
    default:
      moan("FATAL: unexpected state %d", state);
      abort();
  }
}

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
e825e5a9 MW	1	/* --c--
	2	*
	3	* Run a command with a timeout.
	4	*
	5	* (c) 2011 Mark Wooding
	6	*/
	7
	8	/----- Licensing notice --------------------------------------------------
	9	*
	10	* This file is part of the Toys utilties collection.
	11	*
	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.
	16	*
	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.
	21	*
	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.
	25	*/
	26
	27	/----- Basic strategy ----------------------------------------------------
	28	*
	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
	33	* @SIGALRM@ handler.
	34	*
	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
	40	* any longer.
	41	*
	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
	46	* everything.
	47	*/
	48
	49	/----- Header files ------------------------------------------------------/
	50
	51	#include <ctype.h>
	52	#include <errno.h>
753f86de	53	#include <math.h>
e825e5a9 MW	54	#include <signal.h>
	55	#include <stdio.h>
	56	#include <stdlib.h>
	57	#include <string.h>
	58
	59	#include <sys/types.h>
	60	#include <sys/time.h>
	61	#include <fcntl.h>
	62	#include <unistd.h>
	63	#include <sys/select.h>
	64	#include <sys/wait.h>
	65
	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>
	71	#include <mLib/sel.h>
	72	#include <mLib/sig.h>
	73	#include <mLib/tv.h>
	74
	75	/----- Static variables --------------------------------------------------/
	76
	77	static sel_state sel;
	78	static int state;
	79
	80	enum {
	81	ST_WAIT,
	82	ST_ABORT,
	83	ST_DONE
	84	};
	85
	86	/----- Argument conversion functions -------------------------------------/
	87
	88	/* --- @namesig@ --- *
	89	*
	90	* Arguments: @const char *p@ = pointer to string
	91	*
	92	* Returns: Signal number, or @-1@ for no match.
	93	*
	94	* Use: Converts a signal name into its number.
	95	*/
	96
	97	struct namesig {
	98	const char *name;
	99	int sig;
	100	};
	101
	102	int cmp_namesig(const void k, const void v)
	103	{ const struct namesig *ns = v; return (strcmp(k, ns->name)); }
	104
	105	static int namesig(const char *p)
	106	{
	107	const static struct namesig tab[] = {
e33fa755 MW	108	/*
	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.
e825e5a9	113
e33fa755 MW	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)))
	118	(save-excursion
	119	(goto-char (point-min))
	120	(search-forward (concat "*" "BEGIN siglist" "*"))
	121	(beginning-of-line 2)
	122	(delete-region (point)
	123	(progn
	124	(search-forward "*END*")
	125	(beginning-of-line)
	126	(point)))
	127	(dolist (sig (sort (copy-list signals) #'string<))
	128	(insert (format "#ifdef SIG%s\n { \"%s\", SIG%s },\n#endif\n"
	129	sig sig sig)))))
	130	*/
	131
	132	/*BEGIN siglist*/
e825e5a9 MW	133	#ifdef SIGABRT
	134	{ "ABRT", SIGABRT },
	135	#endif
	136	#ifdef SIGALRM
	137	{ "ALRM", SIGALRM },
	138	#endif
	139	#ifdef SIGBUS
	140	{ "BUS", SIGBUS },
	141	#endif
	142	#ifdef SIGCHLD
	143	{ "CHLD", SIGCHLD },
	144	#endif
	145	#ifdef SIGCLD
	146	{ "CLD", SIGCLD },
	147	#endif
	148	#ifdef SIGCONT
	149	{ "CONT", SIGCONT },
	150	#endif
	151	#ifdef SIGEMT
	152	{ "EMT", SIGEMT },
	153	#endif
	154	#ifdef SIGFPE
	155	{ "FPE", SIGFPE },
	156	#endif
	157	#ifdef SIGHUP
	158	{ "HUP", SIGHUP },
	159	#endif
	160	#ifdef SIGILL
	161	{ "ILL", SIGILL },
	162	#endif
	163	#ifdef SIGINFO
	164	{ "INFO", SIGINFO },
	165	#endif
	166	#ifdef SIGINT
	167	{ "INT", SIGINT },
	168	#endif
	169	#ifdef SIGIO
	170	{ "IO", SIGIO },
	171	#endif
	172	#ifdef SIGIOT
	173	{ "IOT", SIGIOT },
	174	#endif
	175	#ifdef SIGKILL
	176	{ "KILL", SIGKILL },
	177	#endif
	178	#ifdef SIGLOST
	179	{ "LOST", SIGLOST },
	180	#endif
	181	#ifdef SIGPIPE
	182	{ "PIPE", SIGPIPE },
	183	#endif
	184	#ifdef SIGPOLL
	185	{ "POLL", SIGPOLL },
	186	#endif
	187	#ifdef SIGPROF
	188	{ "PROF", SIGPROF },
	189	#endif
	190	#ifdef SIGPWR
	191	{ "PWR", SIGPWR },
	192	#endif
	193	#ifdef SIGQUIT
	194	{ "QUIT", SIGQUIT },
	195	#endif
	196	#ifdef SIGSEGV
197	{ "SEGV", SIGSEGV },
198	#endif
199	#ifdef SIGSTKFLT
200	{ "STKFLT", SIGSTKFLT },
201	#endif
202	#ifdef SIGSTOP
203	{ "STOP", SIGSTOP },
204	#endif
205	#ifdef SIGSYS
206	{ "SYS", SIGSYS },
207	#endif
208	#ifdef SIGTERM
209	{ "TERM", SIGTERM },
210	#endif
211	#ifdef SIGTRAP
212	{ "TRAP", SIGTRAP },
213	#endif
214	#ifdef SIGTSTP
215	{ "TSTP", SIGTSTP },
216	#endif
217	#ifdef SIGTTIN
218	{ "TTIN", SIGTTIN },
219	#endif
220	#ifdef SIGTTOU
221	{ "TTOU", SIGTTOU },
222	#endif
223	#ifdef SIGURG
224	{ "URG", SIGURG },
225	#endif
226	#ifdef SIGUSR1
227	{ "USR1", SIGUSR1 },
228	#endif
229	#ifdef SIGUSR2
230	{ "USR2", SIGUSR2 },
231	#endif
232	#ifdef SIGVTALRM
233	{ "VTALRM", SIGVTALRM },
234	#endif
235	#ifdef SIGWINCH
236	{ "WINCH", SIGWINCH },
237	#endif
238	#ifdef SIGXCPU
239	{ "XCPU", SIGXCPU },
240	#endif
241	#ifdef SIGXFSZ
242	{ "XFSZ", SIGXFSZ },
243	#endif
e33fa755	244	/*END*/
e825e5a9 MW	245	};
	246
	247	const struct namesig *ns = bsearch(p, tab, N(tab), sizeof(tab[0]),
	248	cmp_namesig);
	249	if (ns) return (ns->sig);
	250	else if (isdigit((unsigned char)*p)) return (atoi(p));
	251	else return (-1);
	252	}
	253
753f86de MW	254	/* --- @strtotime@ --- *
	255	*
	256	* Arguments: @const char *p@ = pointer to string
	257	* @struct timeval *tv@ = where to put the result
	258	*
	259	* Returns: ---
	260	*
	261	* Use: Converts a string representation of a duration into an
	262	* internal version. Understands various time units.
	263	*/
	264
	265	static void strtotime(const char p, struct timeval tv)
	266	{
	267	char q = (/unconst/ char )p;
	268	double t, i, f;
	269
	270	while (isspace((unsigned char)*q)) q++;
	271	t = strtod(q, &q);
	272	while (isspace((unsigned char)*q)) q++;
	273	switch (*q) {
	274	case 'd': case 'D': t *= 24;
	275	case 'h': case 'H': t *= 60;
	276	case 'm': case 'M': t *= 60;
	277	case 's': case 'S':
	278	q++;
	279	while (isspace((unsigned char)*q)) q++;
	280	}
	281	if (*q) die(253, "bad time value `%s'", p);
	282	f = modf(t, &i);
	283	tv->tv_sec = i;
	284	tv->tv_usec = f * 1000000;
	285	}
	286
e825e5a9 MW	287	/----- Help functions ----------------------------------------------------/
	288
	289	static void usage(FILE *fp)
	290	{ pquis(fp, "Usage: $ [-s SIG] SECONDS COMMAND [ARGUMENTS ...]\n"); }
	291
	292	static void version(FILE *fp)
	293	{ pquis(fp, "$ (version " VERSION ")\n"); }
	294
	295	static void help(FILE *fp)
	296	{
	297	version(fp); fputc('\n', stdout);
	298	usage(fp);
	299	pquis(fp, "\n\
	300	Run COMMAND, giving it the ARGUMENTS. If it fails to complete within the\n\
	301	specified number of SECONDS, kill it. Otherwise exit with the status it\n\
	302	returns.\n \
	303	\n\
	304	Options:\n\
	305	-h, --help Show this help text.\n\
	306	-v, --version Show version string.\n\
	307	-u, --usage Show a terse usage summary.\n\
	308	\n\
	309	-s, --signal=SIG Send signal SIG to the command.\n\
	310	");
	311	}
	312
	313	/----- Timeout handling --------------------------------------------------/
	314
	315	/* --- @timeout@ --- *
	316	*
	317	* The first time, we send the signal requested by the caller. Then we wait
	318	* five seconds for the child to die, and send @SIGKILL@. If that still
	319	* doesn't help, then we just give up. It's not like there's anything else
	320	* we can do which is likely to help. And it's not like the process is going
	321	* to be doing anything else in user mode ever again.
	322	*/
	323
	324	struct timeout {
	325	sel_timer t;
	326	int panic;
	327	int sig;
	328	pid_t kid;
	329	};
	330
	331	static void timeout(struct timeval now, void p)
	332	{
	333	struct timeout *t = p;
	334	struct timeval tv;
	335
	336	switch (t->panic) {
	337	case 0:
	338	moan("timed out: killing child process");
	339	kill(-t->kid, t->sig);
	340	break;
	341	case 1:
	342	moan("child hasn't responded: killing harder");
	343	kill(-t->kid, SIGKILL);
	344	break;
	345	case 2:
	346	moan("child still undead: giving up");
	347	state = ST_ABORT;
	348	break;
	349	}
	350	TV_ADDL(&tv, now, 5, 0);
351	sel_addtimer(&sel, &t->t, &tv, timeout, t);
352	t->panic++;
353	}
354
355	/----- Signal handling ---------------------------------------------------/
356
357	/* --- @sigchld@ --- *
358	*
359	* If it's our child that died, fetch its exit status and stop.
360	*/
361
362	struct sigchld {
363	pid_t kid;
364	int rc;
365	};
366
367	static void sigchld(int sig, void *p)
368	{
369	struct sigchld *s = p;
370	int rc;
371	pid_t pid;
372
373	if ((pid = waitpid(s->kid, &rc, WNOHANG)) < 0)
374	die(254, "waitpid failed: %s", strerror(errno));
375	if (pid == s->kid) {
376	s->rc = rc;
377	state = ST_DONE;
378	}
379	}
380
381	/* --- @sigpropagate@ --- *
382	*
383	* Propagate various signals to the child process group and then maybe act on
384	* them.
385	*/
386
387	static void sigpropagate(int sig, void *p)
388	{
389	struct sigchld *s = p;
390
391	kill(-s->kid, sig);
392	switch (sig) {
393	case SIGTSTP: raise(SIGSTOP); break;
394	}
395	}
396
397	#define PROPAGATE_SIGNALS(_) \
398	_(TSTP) _(CONT) _(INT) _(HUP) _(QUIT)
399
400	/----- Main program ------------------------------------------------------/
401
402	/* --- @main@ --- */
403
404	int main(int argc, char *const argv[])
405	{
e825e5a9 MW	406	int signo = SIGTERM;
e825e5a9 MW	407	pid_t kid;
753f86de	408	struct timeval now, tv;
e825e5a9 MW	409	struct timeout to;
	410	struct sigchld sc;
	411	sig sig_CHLD;
	412	#define DEFSIG(tag) sig sig_##tag;
	413	PROPAGATE_SIGNALS(DEFSIG)
	414	#undef DEFSIG
	415	unsigned f = 0;
	416	#define F_BOGUS 1u
	417
	418	/* --- Option parsing --- */
	419
	420	ego(argv[0]);
	421
	422	for (;;) {
	423	static const struct option opts[] = {
	424	{ "help", 0, 0, 'h' },
	425	{ "version", 0, 0, 'v' },
	426	{ "usage", 0, 0, 'u' },
	427	{ "signal", OPTF_ARGREQ, 0, 's' },
	428	{ 0, 0, 0, 0 }
	429	};
	430
	431	int i = mdwopt(argc, argv, "+hvus:", opts, 0, 0, 0);
	432	if (i < 0) break;
	433	switch (i) {
	434	case 'h': help(stdout); exit(0);
	435	case 'v': version(stdout); exit(0);
	436	case 'u': usage(stdout); exit(0);
	437	case 's':
	438	if ((signo = namesig(optarg)) < 0)
	439	die(253, "bad signal spec `%s'", optarg);
	440	break;
	441	default: f \|= F_BOGUS; break;
	442	}
	443	}
	444	argc -= optind; argv += optind;
	445	if ((f & F_BOGUS) \|\| argc < 2) { usage(stderr); exit(253); }
753f86de	446	strtotime(argv[0], &tv);
e825e5a9 MW	447
	448	/* --- Get things set up --- */
	449
	450	state = ST_WAIT;
	451	sel_init(&sel);
	452
	453	/* --- Set up signal handling --- *
	454	*
	455	* Doing anything with asynchronous signals is a mug's game, so we bring
	456	* them in-band. Do this before starting the child process, because
	457	* otherwise we might miss an immediate @SIGCHLD@.
	458	*/
	459
	460	sig_init(&sel);
	461	sc.rc = 0;
	462	sig_add(&sig_CHLD, SIGCHLD, sigchld, &sc);
	463	#define ADDSIG(tag) sig_add(&sig_##tag, SIG##tag, sigpropagate, &sc);
	464	PROPAGATE_SIGNALS(ADDSIG)
	465	#undef ADDSIG
	466
	467	/* --- Now start the child process --- */
	468
	469	if ((kid = fork()) < 0) die(2, "fork failed: %s", strerror(errno));
	470	if (!kid) {
	471	setpgid(0, 0);
	472	execvp(argv[1], argv + 1);
3ece3fc9	473	die(252, "exec(%s) failed: %s", argv[1], strerror(errno));
e825e5a9 MW	474	}
	475	sc.kid = kid;
	476
	477	/* --- Set up the timer --- */
	478
	479	to.kid = kid;
	480	to.sig = signo;
	481	to.panic = 0;
753f86de MW	482	gettimeofday(&now, 0);
753f86de MW	483	TV_ADD(&tv, &now, &tv);
e825e5a9 MW	484	sel_addtimer(&sel, &to.t, &tv, timeout, &to);
	485
	486	/* --- Main @select@ loop */
	487
	488	while (state == ST_WAIT) {
	489	if (sel_select(&sel)) {
	490	if (errno == EINTR) continue;
	491	die(254, "select failed: %s", strerror(errno));
	492	}
	493	}
	494
	495	/* --- Check and translate the exit code --- */
	496
	497	switch (state) {
	498	case ST_ABORT:
	499	exit(251);
	500	case ST_DONE:
	501	if (WIFEXITED(sc.rc))
	502	exit(WEXITSTATUS(sc.rc));
	503	else if (WIFSIGNALED(sc.rc))
	504	exit(128 \| WTERMSIG(sc.rc));
	505	else
	506	exit(128);
	507	default:
	508	moan("FATAL: unexpected state %d", state);
	509	abort();
	510	}
	511	}
	512
	513	/----- That's all, folks -------------------------------------------------/