2331100b0e5d8f4231136f9a45e1e3ddb39b2ef7
[dragonfly.git] / bin / sh / trap.c
1 /*-
2  * Copyright (c) 1991, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Kenneth Almquist.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  * @(#)trap.c   8.5 (Berkeley) 6/5/95
37  * $FreeBSD: src/bin/sh/trap.c,v 1.45 2011/02/04 22:47:55 jilles Exp $
38  */
39
40 #include <signal.h>
41 #include <unistd.h>
42 #include <stdlib.h>
43
44 #include "shell.h"
45 #include "main.h"
46 #include "nodes.h"      /* for other headers */
47 #include "eval.h"
48 #include "jobs.h"
49 #include "show.h"
50 #include "options.h"
51 #include "syntax.h"
52 #include "output.h"
53 #include "memalloc.h"
54 #include "error.h"
55 #include "trap.h"
56 #include "mystring.h"
57 #include "myhistedit.h"
58
59
60 /*
61  * Sigmode records the current value of the signal handlers for the various
62  * modes.  A value of zero means that the current handler is not known.
63  * S_HARD_IGN indicates that the signal was ignored on entry to the shell,
64  */
65
66 #define S_DFL 1                 /* default signal handling (SIG_DFL) */
67 #define S_CATCH 2               /* signal is caught */
68 #define S_IGN 3                 /* signal is ignored (SIG_IGN) */
69 #define S_HARD_IGN 4            /* signal is ignored permanently */
70 #define S_RESET 5               /* temporary - to reset a hard ignored sig */
71
72
73 MKINIT char sigmode[NSIG];      /* current value of signal */
74 int pendingsigs;                /* indicates some signal received */
75 int in_dotrap;                  /* do we execute in a trap handler? */
76 static char *volatile trap[NSIG];       /* trap handler commands */
77 static volatile sig_atomic_t gotsig[NSIG];
78                                 /* indicates specified signal received */
79 static int ignore_sigchld;      /* Used while handling SIGCHLD traps. */
80 volatile sig_atomic_t gotwinch;
81 static int last_trapsig;
82
83 static int exiting;             /* exitshell() has been called */
84 static int exiting_exitstatus;  /* value passed to exitshell() */
85
86 static int getsigaction(int, sig_t *);
87
88
89 /*
90  * Map a string to a signal number.
91  *
92  * Note: the signal number may exceed NSIG.
93  */
94 static int
95 sigstring_to_signum(char *sig)
96 {
97
98         if (is_number(sig)) {
99                 int signo;
100
101                 signo = atoi(sig);
102                 return ((signo >= 0 && signo < NSIG) ? signo : (-1));
103         } else if (strcasecmp(sig, "EXIT") == 0) {
104                 return (0);
105         } else {
106                 int n;
107
108                 if (strncasecmp(sig, "SIG", 3) == 0)
109                         sig += 3;
110                 for (n = 1; n < sys_nsig; n++)
111                         if (sys_signame[n] &&
112                             strcasecmp(sys_signame[n], sig) == 0)
113                                 return (n);
114         }
115         return (-1);
116 }
117
118
119 /*
120  * Print a list of valid signal names.
121  */
122 static void
123 printsignals(void)
124 {
125         int n, outlen;
126
127         outlen = 0;
128         for (n = 1; n < sys_nsig; n++) {
129                 if (sys_signame[n]) {
130                         out1fmt("%s", sys_signame[n]);
131                         outlen += strlen(sys_signame[n]);
132                 } else {
133                         out1fmt("%d", n);
134                         outlen += 3;    /* good enough */
135                 }
136                 ++outlen;
137                 if (outlen > 71 || n == sys_nsig - 1) {
138                         out1str("\n");
139                         outlen = 0;
140                 } else {
141                         out1c(' ');
142                 }
143         }
144 }
145
146
147 /*
148  * The trap builtin.
149  */
150 int
151 trapcmd(int argc __unused, char **argv)
152 {
153         char *action;
154         int signo;
155         int errors = 0;
156         int i;
157
158         while ((i = nextopt("l")) != '\0') {
159                 switch (i) {
160                 case 'l':
161                         printsignals();
162                         return (0);
163                 }
164         }
165         argv = argptr;
166
167         if (*argv == NULL) {
168                 for (signo = 0 ; signo < sys_nsig ; signo++) {
169                         if (signo < NSIG && trap[signo] != NULL) {
170                                 out1str("trap -- ");
171                                 out1qstr(trap[signo]);
172                                 if (signo == 0) {
173                                         out1str(" EXIT\n");
174                                 } else if (sys_signame[signo]) {
175                                         out1fmt(" %s\n", sys_signame[signo]);
176                                 } else {
177                                         out1fmt(" %d\n", signo);
178                                 }
179                         }
180                 }
181                 return 0;
182         }
183         action = NULL;
184         if (*argv && sigstring_to_signum(*argv) == -1) {
185                 if (strcmp(*argv, "-") == 0)
186                         argv++;
187                 else {
188                         action = *argv;
189                         argv++;
190                 }
191         }
192         while (*argv) {
193                 if ((signo = sigstring_to_signum(*argv)) == -1) {
194                         warning("bad signal %s", *argv);
195                         errors = 1;
196                 }
197                 INTOFF;
198                 if (action)
199                         action = savestr(action);
200                 if (trap[signo])
201                         ckfree(trap[signo]);
202                 trap[signo] = action;
203                 if (signo != 0)
204                         setsignal(signo);
205                 INTON;
206                 argv++;
207         }
208         return errors;
209 }
210
211
212 /*
213  * Clear traps on a fork.
214  */
215 void
216 clear_traps(void)
217 {
218         char *volatile *tp;
219
220         for (tp = trap ; tp <= &trap[NSIG - 1] ; tp++) {
221                 if (*tp && **tp) {      /* trap not NULL or SIG_IGN */
222                         INTOFF;
223                         ckfree(*tp);
224                         *tp = NULL;
225                         if (tp != &trap[0])
226                                 setsignal(tp - trap);
227                         INTON;
228                 }
229         }
230 }
231
232
233 /*
234  * Check if we have any traps enabled.
235  */
236 int
237 have_traps(void)
238 {
239         char *volatile *tp;
240
241         for (tp = trap ; tp <= &trap[NSIG - 1] ; tp++) {
242                 if (*tp && **tp)        /* trap not NULL or SIG_IGN */
243                         return 1;
244         }
245         return 0;
246 }
247
248 /*
249  * Set the signal handler for the specified signal.  The routine figures
250  * out what it should be set to.
251  */
252 void
253 setsignal(int signo)
254 {
255         int action;
256         sig_t sigact = SIG_DFL;
257         struct sigaction sa;
258         char *t;
259
260         if ((t = trap[signo]) == NULL)
261                 action = S_DFL;
262         else if (*t != '\0')
263                 action = S_CATCH;
264         else
265                 action = S_IGN;
266         if (action == S_DFL) {
267                 switch (signo) {
268                 case SIGINT:
269                         action = S_CATCH;
270                         break;
271                 case SIGQUIT:
272 #ifdef DEBUG
273                         {
274                         extern int debug;
275
276                         if (debug)
277                                 break;
278                         }
279 #endif
280                         action = S_CATCH;
281                         break;
282                 case SIGTERM:
283                         if (rootshell && iflag)
284                                 action = S_IGN;
285                         break;
286 #if JOBS
287                 case SIGTSTP:
288                 case SIGTTOU:
289                         if (rootshell && mflag)
290                                 action = S_IGN;
291                         break;
292 #endif
293 #ifndef NO_HISTORY
294                 case SIGWINCH:
295                         if (rootshell && iflag)
296                                 action = S_CATCH;
297                         break;
298 #endif
299                 }
300         }
301
302         t = &sigmode[signo];
303         if (*t == 0) {
304                 /*
305                  * current setting unknown
306                  */
307                 if (!getsigaction(signo, &sigact)) {
308                         /*
309                          * Pretend it worked; maybe we should give a warning
310                          * here, but other shells don't. We don't alter
311                          * sigmode, so that we retry every time.
312                          */
313                         return;
314                 }
315                 if (sigact == SIG_IGN) {
316                         if (mflag && (signo == SIGTSTP ||
317                              signo == SIGTTIN || signo == SIGTTOU)) {
318                                 *t = S_IGN;     /* don't hard ignore these */
319                         } else
320                                 *t = S_HARD_IGN;
321                 } else {
322                         *t = S_RESET;   /* force to be set */
323                 }
324         }
325         if (*t == S_HARD_IGN || *t == action)
326                 return;
327         switch (action) {
328                 case S_DFL:     sigact = SIG_DFL;       break;
329                 case S_CATCH:   sigact = onsig;         break;
330                 case S_IGN:     sigact = SIG_IGN;       break;
331         }
332         *t = action;
333         sa.sa_handler = sigact;
334         sa.sa_flags = 0;
335         sigemptyset(&sa.sa_mask);
336         sigaction(signo, &sa, NULL);
337 }
338
339
340 /*
341  * Return the current setting for sig w/o changing it.
342  */
343 static int
344 getsigaction(int signo, sig_t *sigact)
345 {
346         struct sigaction sa;
347
348         if (sigaction(signo, NULL, &sa) == -1)
349                 return 0;
350         *sigact = (sig_t) sa.sa_handler;
351         return 1;
352 }
353
354
355 /*
356  * Ignore a signal.
357  */
358 void
359 ignoresig(int signo)
360 {
361
362         if (sigmode[signo] != S_IGN && sigmode[signo] != S_HARD_IGN) {
363                 signal(signo, SIG_IGN);
364         }
365         sigmode[signo] = S_HARD_IGN;
366 }
367
368
369 /*
370  * Signal handler.
371  */
372 void
373 onsig(int signo)
374 {
375
376         if (signo == SIGINT && trap[SIGINT] == NULL) {
377                 onint();
378                 return;
379         }
380
381         if (signo != SIGCHLD || !ignore_sigchld)
382                 gotsig[signo] = 1;
383         pendingsigs++;
384
385         /* If we are currently in a wait builtin, prepare to break it */
386         if ((signo == SIGINT || signo == SIGQUIT) && in_waitcmd != 0)
387                 breakwaitcmd = 1;
388         /*
389          * If a trap is set, not ignored and not the null command, we need
390          * to make sure traps are executed even when a child blocks signals.
391          */
392         if (Tflag &&
393             trap[signo] != NULL &&
394             ! (trap[signo][0] == '\0') &&
395             ! (trap[signo][0] == ':' && trap[signo][1] == '\0'))
396                 breakwaitcmd = 1;
397
398 #ifndef NO_HISTORY
399         if (signo == SIGWINCH)
400                 gotwinch = 1;
401 #endif
402 }
403
404
405 /*
406  * Called to execute a trap.  Perhaps we should avoid entering new trap
407  * handlers while we are executing a trap handler.
408  */
409 void
410 dotrap(void)
411 {
412         int i;
413         int savestatus;
414
415         in_dotrap++;
416         for (;;) {
417                 for (i = 1; i < NSIG; i++) {
418                         if (gotsig[i]) {
419                                 gotsig[i] = 0;
420                                 if (trap[i]) {
421                                         /*
422                                          * Ignore SIGCHLD to avoid infinite
423                                          * recursion if the trap action does
424                                          * a fork.
425                                          */
426                                         if (i == SIGCHLD)
427                                                 ignore_sigchld++;
428                                         last_trapsig = i;
429                                         savestatus = exitstatus;
430                                         evalstring(trap[i], 0);
431                                         exitstatus = savestatus;
432                                         if (i == SIGCHLD)
433                                                 ignore_sigchld--;
434                                 }
435                                 break;
436                         }
437                 }
438                 if (i >= NSIG)
439                         break;
440         }
441         in_dotrap--;
442         pendingsigs = 0;
443 }
444
445
446 /*
447  * Controls whether the shell is interactive or not.
448  */
449 void
450 setinteractive(int on)
451 {
452         static int is_interactive = -1;
453
454         if (on == is_interactive)
455                 return;
456         setsignal(SIGINT);
457         setsignal(SIGQUIT);
458         setsignal(SIGTERM);
459 #ifndef NO_HISTORY
460         setsignal(SIGWINCH);
461 #endif
462         is_interactive = on;
463 }
464
465
466 /*
467  * Called to exit the shell.
468  */
469 void
470 exitshell(int status)
471 {
472         TRACE(("exitshell(%d) pid=%d\n", status, getpid()));
473         exiting = 1;
474         exiting_exitstatus = status;
475         exitshell_savedstatus();
476 }
477
478 void
479 exitshell_savedstatus(void)
480 {
481         struct jmploc loc1, loc2;
482         char *p;
483         volatile int sig = 0;
484         sigset_t sigs;
485
486         if (!exiting) {
487                 if (in_dotrap && last_trapsig) {
488                         sig = last_trapsig;
489                         exiting_exitstatus = sig + 128;
490                 } else
491                         exiting_exitstatus = oexitstatus;
492         }
493         exitstatus = oexitstatus = exiting_exitstatus;
494         if (setjmp(loc1.loc)) {
495                 goto l1;
496         }
497         if (setjmp(loc2.loc)) {
498                 goto l2;
499         }
500         handler = &loc1;
501         if ((p = trap[0]) != NULL && *p != '\0') {
502                 trap[0] = NULL;
503                 evalstring(p, 0);
504         }
505 l1:   handler = &loc2;                  /* probably unnecessary */
506         flushall();
507 #if JOBS
508         setjobctl(0);
509 #endif
510 l2:
511         if (sig != 0 && sig != SIGSTOP && sig != SIGTSTP && sig != SIGTTIN &&
512             sig != SIGTTOU) {
513                 signal(sig, SIG_DFL);
514                 sigemptyset(&sigs);
515                 sigaddset(&sigs, sig);
516                 sigprocmask(SIG_UNBLOCK, &sigs, NULL);
517                 kill(getpid(), sig);
518                 /* If the default action is to ignore, fall back to _exit(). */
519         }
520         _exit(exiting_exitstatus);
521 }