[misc] / timeout.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 <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))
      (let ((start (search-forward (concat "/" "* SIGLIST *" "/\n")))
	    (end (search-forward (concat "/" "* END *" "/\n"))))
	(delete-region start end))
      (dolist (sig (sort (copy-list signals) #'string<))
	(insert (format "#ifdef SIG%s\n    { \"%s\", SIG%s },\n#endif\n"
			sig sig sig)))
      (insert (concat "/" "* END *" "/\n"))))
*/

/* 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);
}

/*----- 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[])
{
  char *p;
  double t;
  int signo = SIGTERM;
  pid_t kid;
  struct timeval 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); }

  p = argv[0];
  while (isspace((unsigned char)*p)) p++;
  t = strtod(argv[0], &p);
  while (isspace((unsigned char)*p)) p++;
  if (*p) die(253, "bad time value `%s'", argv[0]);

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