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) | |
c6b2f544 MW |
290 | { |
291 | pquis(fp, | |
292 | "Usage: $ [-K] [-b TIME] [-k TIME] [-s SIG] " | |
293 | "TIME COMMAND [ARGUMENTS ...]\n"); | |
294 | } | |
e825e5a9 MW |
295 | |
296 | static void version(FILE *fp) | |
297 | { pquis(fp, "$ (version " VERSION ")\n"); } | |
298 | ||
299 | static void help(FILE *fp) | |
300 | { | |
301 | version(fp); fputc('\n', stdout); | |
302 | usage(fp); | |
303 | pquis(fp, "\n\ | |
304 | Run COMMAND, giving it the ARGUMENTS. If it fails to complete within the\n\ | |
c6b2f544 | 305 | specified number of TIME, kill it. Otherwise exit with the status it\n\ |
2b201ce9 | 306 | returns.\n\ |
e825e5a9 | 307 | \n\ |
c6b2f544 MW |
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\ | |
311 | \n\ | |
e825e5a9 MW |
312 | Options:\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\ | |
316 | \n\ | |
c6b2f544 MW |
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\ | |
e825e5a9 MW |
320 | -s, --signal=SIG Send signal SIG to the command.\n\ |
321 | "); | |
322 | } | |
323 | ||
324 | /*----- Timeout handling --------------------------------------------------*/ | |
325 | ||
326 | /* --- @timeout@ --- * | |
327 | * | |
f42ff973 MW |
328 | * The timeout sequencing stuff is complicated, so here's a simple machine to |
329 | * make it work. | |
e825e5a9 MW |
330 | */ |
331 | ||
f42ff973 MW |
332 | enum { |
333 | TA_MOAN, /* Report message to user */ | |
334 | #define TAARG_MOAN s | |
335 | ||
336 | TA_KILL, /* Send a signal */ | |
337 | #define TAARG_KILL i | |
338 | ||
339 | TA_GOTO, /* Goto different state */ | |
340 | #define TAARG_GOTO i | |
341 | ||
342 | TA_WAIT, /* Wait for more time */ | |
343 | #define TAARG_WAIT tv | |
344 | ||
345 | TA_STATE, /* Alter the internal state */ | |
346 | #define TAARG_STATE i | |
347 | }; | |
348 | ||
349 | struct tmact { | |
350 | unsigned act; | |
351 | union { | |
352 | const char *s; /* String parameter */ | |
353 | int i; /* Integer parameter */ | |
354 | struct timeval tv; /* Time parameter */ | |
355 | } u; | |
356 | }; | |
357 | ||
e825e5a9 | 358 | struct timeout { |
f42ff973 MW |
359 | sel_timer t; /* Timer intrusion */ |
360 | struct tmact *ta; /* Instruction vector */ | |
361 | int ip; /* Instruction pointer */ | |
e825e5a9 MW |
362 | pid_t kid; |
363 | }; | |
364 | ||
365 | static void timeout(struct timeval *now, void *p) | |
366 | { | |
367 | struct timeout *t = p; | |
f42ff973 | 368 | struct tmact *ta; |
e825e5a9 MW |
369 | struct timeval tv; |
370 | ||
f42ff973 MW |
371 | for (;;) { |
372 | ta = &t->ta[t->ip++]; | |
373 | switch (ta->act) { | |
374 | case TA_MOAN: | |
03dc6e6e | 375 | moan("%s", ta->u.s); |
f42ff973 MW |
376 | break; |
377 | case TA_KILL: | |
378 | kill(-t->kid, ta->u.i); | |
379 | break; | |
380 | case TA_GOTO: | |
381 | t->ip = ta->u.i; | |
382 | break; | |
383 | case TA_STATE: | |
384 | state = ta->u.i; | |
385 | return; | |
386 | case TA_WAIT: | |
387 | TV_ADD(&tv, now, &ta->u.tv); | |
388 | sel_addtimer(&sel, &t->t, &tv, timeout, t); | |
389 | return; | |
390 | default: | |
391 | moan("unexpected tmact %u", ta->act); | |
392 | abort(); | |
393 | } | |
e825e5a9 | 394 | } |
e825e5a9 MW |
395 | } |
396 | ||
397 | /*----- Signal handling ---------------------------------------------------*/ | |
398 | ||
399 | /* --- @sigchld@ --- * | |
400 | * | |
401 | * If it's our child that died, fetch its exit status and stop. | |
402 | */ | |
403 | ||
404 | struct sigchld { | |
405 | pid_t kid; | |
406 | int rc; | |
407 | }; | |
408 | ||
409 | static void sigchld(int sig, void *p) | |
410 | { | |
411 | struct sigchld *s = p; | |
412 | int rc; | |
413 | pid_t pid; | |
414 | ||
415 | if ((pid = waitpid(s->kid, &rc, WNOHANG)) < 0) | |
416 | die(254, "waitpid failed: %s", strerror(errno)); | |
417 | if (pid == s->kid) { | |
418 | s->rc = rc; | |
419 | state = ST_DONE; | |
420 | } | |
421 | } | |
422 | ||
423 | /* --- @sigpropagate@ --- * | |
424 | * | |
425 | * Propagate various signals to the child process group and then maybe act on | |
426 | * them. | |
427 | */ | |
428 | ||
429 | static void sigpropagate(int sig, void *p) | |
430 | { | |
431 | struct sigchld *s = p; | |
432 | ||
433 | kill(-s->kid, sig); | |
434 | switch (sig) { | |
435 | case SIGTSTP: raise(SIGSTOP); break; | |
436 | } | |
437 | } | |
438 | ||
439 | #define PROPAGATE_SIGNALS(_) \ | |
440 | _(TSTP) _(CONT) _(INT) _(HUP) _(QUIT) | |
441 | ||
442 | /*----- Main program ------------------------------------------------------*/ | |
443 | ||
444 | /* --- @main@ --- */ | |
445 | ||
446 | int main(int argc, char *const argv[]) | |
447 | { | |
e825e5a9 | 448 | pid_t kid; |
e825e5a9 | 449 | struct timeout to; |
f42ff973 MW |
450 | struct timeval now; |
451 | ||
452 | #define PAIR(x, y) { x, y } | |
453 | #define TACODE(I) \ | |
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) | |
463 | ||
464 | enum { | |
465 | #define TALBL(label, op, arg) taoff_##label, | |
466 | TACODE(TALBL) | |
467 | #undef TALBL | |
468 | taoff_end | |
469 | }; | |
470 | ||
471 | static struct tmact ta[] = { | |
472 | #define TAASM(label, op, arg) { TA_##op, { .TAARG_##op = arg } }, | |
473 | TACODE(TAASM) | |
474 | #undef TAASM | |
475 | }; | |
476 | ||
e825e5a9 MW |
477 | struct sigchld sc; |
478 | sig sig_CHLD; | |
479 | #define DEFSIG(tag) sig sig_##tag; | |
480 | PROPAGATE_SIGNALS(DEFSIG) | |
481 | #undef DEFSIG | |
482 | unsigned f = 0; | |
483 | #define F_BOGUS 1u | |
484 | ||
485 | /* --- Option parsing --- */ | |
486 | ||
487 | ego(argv[0]); | |
488 | ||
489 | for (;;) { | |
490 | static const struct option opts[] = { | |
491 | { "help", 0, 0, 'h' }, | |
492 | { "version", 0, 0, 'v' }, | |
493 | { "usage", 0, 0, 'u' }, | |
0db9a123 MW |
494 | { "no-kill", 0, 0, 'K' }, |
495 | { "kill-after", OPTF_ARGREQ, 0, 'k' }, | |
496 | { "bored-after", OPTF_ARGREQ, 0, 'b' }, | |
e825e5a9 MW |
497 | { "signal", OPTF_ARGREQ, 0, 's' }, |
498 | { 0, 0, 0, 0 } | |
499 | }; | |
500 | ||
0db9a123 | 501 | int i = mdwopt(argc, argv, "+hvuKb:k:s:", opts, 0, 0, 0); |
e825e5a9 MW |
502 | if (i < 0) break; |
503 | switch (i) { | |
504 | case 'h': help(stdout); exit(0); | |
505 | case 'v': version(stdout); exit(0); | |
506 | case 'u': usage(stdout); exit(0); | |
0db9a123 MW |
507 | case 'b': |
508 | ta[taoff_boredwait].act = TA_WAIT; | |
509 | strtotime(optarg, &ta[taoff_boredwait].u.tv); | |
510 | break; | |
511 | case 'k': | |
512 | ta[taoff_killwait].act = TA_WAIT; | |
513 | strtotime(optarg, &ta[taoff_killwait].u.tv); | |
514 | break; | |
515 | case 'K': | |
516 | ta[taoff_killwait].act = TA_GOTO; | |
517 | ta[taoff_killwait].u.i = taoff_boredwait; | |
518 | break; | |
e825e5a9 | 519 | case 's': |
f42ff973 | 520 | if ((ta[taoff_sig].u.i = namesig(optarg)) < 0) |
e825e5a9 MW |
521 | die(253, "bad signal spec `%s'", optarg); |
522 | break; | |
523 | default: f |= F_BOGUS; break; | |
524 | } | |
525 | } | |
526 | argc -= optind; argv += optind; | |
527 | if ((f & F_BOGUS) || argc < 2) { usage(stderr); exit(253); } | |
f42ff973 | 528 | strtotime(argv[0], &ta[taoff_sigwait].u.tv); |
e825e5a9 MW |
529 | |
530 | /* --- Get things set up --- */ | |
531 | ||
532 | state = ST_WAIT; | |
533 | sel_init(&sel); | |
534 | ||
535 | /* --- Set up signal handling --- * | |
536 | * | |
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@. | |
540 | */ | |
541 | ||
542 | sig_init(&sel); | |
543 | sc.rc = 0; | |
544 | sig_add(&sig_CHLD, SIGCHLD, sigchld, &sc); | |
545 | #define ADDSIG(tag) sig_add(&sig_##tag, SIG##tag, sigpropagate, &sc); | |
546 | PROPAGATE_SIGNALS(ADDSIG) | |
547 | #undef ADDSIG | |
548 | ||
549 | /* --- Now start the child process --- */ | |
550 | ||
551 | if ((kid = fork()) < 0) die(2, "fork failed: %s", strerror(errno)); | |
552 | if (!kid) { | |
553 | setpgid(0, 0); | |
554 | execvp(argv[1], argv + 1); | |
3ece3fc9 | 555 | die(252, "exec(%s) failed: %s", argv[1], strerror(errno)); |
e825e5a9 MW |
556 | } |
557 | sc.kid = kid; | |
558 | ||
559 | /* --- Set up the timer --- */ | |
560 | ||
753f86de | 561 | gettimeofday(&now, 0); |
f42ff973 MW |
562 | to.kid = kid; |
563 | to.ta = ta; | |
564 | to.ip = 0; | |
565 | timeout(&now, &to); | |
e825e5a9 MW |
566 | |
567 | /* --- Main @select@ loop */ | |
568 | ||
569 | while (state == ST_WAIT) { | |
570 | if (sel_select(&sel)) { | |
571 | if (errno == EINTR) continue; | |
572 | die(254, "select failed: %s", strerror(errno)); | |
573 | } | |
574 | } | |
575 | ||
576 | /* --- Check and translate the exit code --- */ | |
577 | ||
578 | switch (state) { | |
579 | case ST_ABORT: | |
580 | exit(251); | |
581 | case ST_DONE: | |
582 | if (WIFEXITED(sc.rc)) | |
583 | exit(WEXITSTATUS(sc.rc)); | |
584 | else if (WIFSIGNALED(sc.rc)) | |
585 | exit(128 | WTERMSIG(sc.rc)); | |
586 | else | |
587 | exit(128); | |
588 | default: | |
589 | moan("FATAL: unexpected state %d", state); | |
590 | abort(); | |
591 | } | |
592 | } | |
593 | ||
594 | /*----- That's all, folks -------------------------------------------------*/ |