bin/sh/trap.c

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