trap.c

   1 /*
   2  * signal handling
   3  */
   4
   5 #include <ctype.h>
   6
   7 /* Kludge to avoid bogus re-declaration of sigtraps[] error on AIX 3.2.5 */
   8 #define FROM_TRAP_C
   9 #include "sh.h"
  10
  11 /* Table is indexed by signal number
  12  *
  13  * The script siglist.sh generates siglist.out, which is a sorted, complete
  14  * list of signals
  15  */
  16 Trap sigtraps[SIGNALS+1] = {
  17         { SIGEXIT_, "EXIT", "Signal 0", 0, 0, 0, 0, 0 },
  18 #include "siglist.out"  /* generated by siglist.sh */
  19     };
  20
  21 static struct sigaction Sigact_ign, Sigact_trap;
  22
  23 void
  24 inittraps()
  25 {
  26 #ifdef HAVE_SYS_SIGLIST
  27 # ifndef SYS_SIGLIST_DECLARED
  28         extern char     *sys_siglist[];
  29 # endif
  30         int     i;
  31
  32         /* Use system description, if available, for unknown signals... */
  33         for (i = 0; i < NSIG; i++)
  34                 if (!sigtraps[i].name && sys_siglist[i] && sys_siglist[i][0])
  35                         sigtraps[i].mess = sys_siglist[i];
  36 #endif  /* HAVE_SYS_SIGLIST */
  37
  38         sigemptyset(&Sigact_ign.sa_mask);
  39         Sigact_ign.sa_flags = KSH_SA_FLAGS;
  40         Sigact_ign.sa_handler = SIG_IGN;
  41         Sigact_trap = Sigact_ign;
  42         Sigact_trap.sa_handler = trapsig;
  43
  44         sigtraps[SIGINT].flags |= TF_DFL_INTR | TF_TTY_INTR;
  45         sigtraps[SIGQUIT].flags |= TF_DFL_INTR | TF_TTY_INTR;
  46         sigtraps[SIGTERM].flags |= TF_DFL_INTR;/* not fatal for interactive */
  47         sigtraps[SIGHUP].flags |= TF_FATAL;
  48         sigtraps[SIGCHLD].flags |= TF_SHELL_USES;
  49
  50         /* these are always caught so we can clean up any temproary files. */
  51         setsig(&sigtraps[SIGINT], trapsig, SS_RESTORE_ORIG);
  52         setsig(&sigtraps[SIGQUIT], trapsig, SS_RESTORE_ORIG);
  53         setsig(&sigtraps[SIGTERM], trapsig, SS_RESTORE_ORIG);
  54         setsig(&sigtraps[SIGHUP], trapsig, SS_RESTORE_ORIG);
  55 }
  56
  57 #ifdef KSH
  58 static RETSIGTYPE alarm_catcher ARGS((int sig));
  59
  60 void
  61 alarm_init()
  62 {
  63         sigtraps[SIGALRM].flags |= TF_SHELL_USES;
  64         setsig(&sigtraps[SIGALRM], alarm_catcher,
  65                 SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP);
  66 }
  67
  68 static RETSIGTYPE
  69 alarm_catcher(sig)
  70         int sig;
  71 {
  72         if (ksh_tmout_state == TMOUT_READING) {
  73                 int left = alarm(0);
  74
  75                 if (left == 0) {
  76                         ksh_tmout_state = TMOUT_LEAVING;
  77                         intrsig = 1;
  78                 } else
  79                         alarm(left);
  80         }
  81         return RETSIGVAL;
  82 }
  83 #endif /* KSH */
  84
  85 Trap *
  86 gettrap(const char *name)
  87 {
  88         int i;
  89         Trap *p;
  90
  91         if (isdigit(*name)) {
  92                 int n;
  93
  94                 if (getn(name, &n) && ((0 == n) || (1 == n) || (2 == n) || (3 == n) || (6 == n) || (9 == n) || (13 == n) || (14 == n) || (15 == n) ))
  95                         return &sigtraps[n];
  96                 return NULL;
  97         }
  98         for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++)
  99                 if (p->name && strcmp(p->name, name) == 0)
 100                         return p;
 101         return NULL;
 102 }
 103
 104 /*
 105  * trap signal handler
 106  */
 107 RETSIGTYPE
 108 trapsig(i)
 109         int i;
 110 {
 111         Trap *p = &sigtraps[i];
 112
 113         trap = p->set = 1;
 114         if (p->flags & TF_DFL_INTR)
 115                 intrsig = 1;
 116         if ((p->flags & TF_FATAL) && !p->trap) {
 117                 fatal_trap = 1;
 118                 intrsig = 1;
 119         }
 120         if (p->shtrap)
 121                 (*p->shtrap)(i);
 122 #ifdef V7_SIGNALS
 123         if (sigtraps[i].cursig == trapsig) /* this for SIGCHLD,SIGALRM */
 124                 sigaction(i, &Sigact_trap, (struct sigaction *) 0);
 125 #endif /* V7_SIGNALS */
 126         return RETSIGVAL;
 127 }
 128
 129 /* called when we want to allow the user to ^C out of something - won't
 130  * work if user has trapped SIGINT.
 131  */
 132 void
 133 intrcheck()
 134 {
 135         if (intrsig)
 136                 runtraps(TF_DFL_INTR|TF_FATAL);
 137 }
 138
 139 /* called after EINTR to check if a signal with normally causes process
 140  * termination has been received.
 141  */
 142 int
 143 fatal_trap_check()
 144 {
 145         int i;
 146         Trap *p;
 147
 148         /* todo: should check if signal is fatal, not the TF_DFL_INTR flag */
 149         for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++)
 150                 if (p->set && (p->flags & (TF_DFL_INTR|TF_FATAL)))
 151                         /* return value is used as an exit code */
 152                         return 128 + p->signal;
 153         return 0;
 154 }
 155
 156 /* Returns the signal number of any pending traps: ie, a signal which has
 157  * occured for which a trap has been set or for which the TF_DFL_INTR flag
 158  * is set.
 159  */
 160 int
 161 trap_pending()
 162 {
 163         int i;
 164         Trap *p;
 165
 166         for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++)
 167                 if (p->set && ((p->trap && p->trap[0])
 168                                || ((p->flags & (TF_DFL_INTR|TF_FATAL))
 169                                    && !p->trap)))
 170                         return p->signal;
 171         return 0;
 172 }
 173
 174 /*
 175  * run any pending traps.  If intr is set, only run traps that
 176  * can interrupt commands.
 177  */
 178 void
 179 runtraps(flag)
 180         int flag;
 181 {
 182         int i;
 183         register Trap *p;
 184
 185 #ifdef KSH
 186         if (ksh_tmout_state == TMOUT_LEAVING) {
 187                 ksh_tmout_state = TMOUT_EXECUTING;
 188                 warningf(FALSE, "timed out waiting for input");
 189                 unwind(LEXIT);
 190         } else
 191                 /* XXX: this means the alarm will have no effect if a trap
 192                  * is caught after the alarm() was started...not good.
 193                  */
 194                 ksh_tmout_state = TMOUT_EXECUTING;
 195 #endif /* KSH */
 196         if (!flag)
 197                 trap = 0;
 198         if (flag & TF_DFL_INTR)
 199                 intrsig = 0;
 200         if (flag & TF_FATAL)
 201                 fatal_trap = 0;
 202         for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++)
 203                 if (p->set && (!flag
 204                                || ((p->flags & flag) && p->trap == (char *) 0)))
 205                         runtrap(p);
 206 }
 207
 208 void
 209 runtrap(p)
 210         Trap *p;
 211 {
 212         int     i = p->signal;
 213         char    *trapstr = p->trap;
 214         int     oexstat;
 215         int     UNINITIALIZED(old_changed);
 216
 217         p->set = 0;
 218         if (trapstr == (char *) 0) { /* SIG_DFL */
 219                 if (p->flags & TF_FATAL) {
 220                         /* eg, SIGHUP */
 221                         exstat = 128 + i;
 222                         unwind(LLEAVE);
 223                 }
 224                 if (p->flags & TF_DFL_INTR) {
 225                         /* eg, SIGINT, SIGQUIT, SIGTERM, etc. */
 226                         exstat = 128 + i;
 227                         unwind(LINTR);
 228                 }
 229                 return;
 230         }
 231         if (trapstr[0] == '\0') /* SIG_IGN */
 232                 return;
 233         if (i == SIGEXIT_ ) {   /* avoid recursion on these */
 234                 old_changed = p->flags & TF_CHANGED;
 235                 p->flags &= ~TF_CHANGED;
 236                 p->trap = (char *) 0;
 237         }
 238         oexstat = exstat;
 239         /* Note: trapstr is fully parsed before anything is executed, thus
 240          * no problem with afree(p->trap) in settrap() while still in use.
 241          */
 242         command(trapstr);
 243         exstat = oexstat;
 244         if (i == SIGEXIT_ ) {
 245                 if (p->flags & TF_CHANGED)
 246                         /* don't clear TF_CHANGED */
 247                         afree(trapstr, APERM);
 248                 else
 249                         p->trap = trapstr;
 250                 p->flags |= old_changed;
 251         }
 252 }
 253
 254 /* clear pending traps and reset user's trap handlers; used after fork(2) */
 255 void
 256 cleartraps()
 257 {
 258         int i;
 259         Trap *p;
 260
 261         trap = 0;
 262         intrsig = 0;
 263         fatal_trap = 0;
 264         for (i = SIGNALS+1, p = sigtraps; --i >= 0; p++) {
 265                 p->set = 0;
 266                 if ((p->flags & TF_USER_SET) && (p->trap && p->trap[0]))
 267                         settrap(p, (char *) 0);
 268         }
 269 }
 270
 271 /* restore signals just before an exec(2) */
 272 void
 273 restoresigs()
 274 {
 275         int i;
 276         Trap *p;
 277
 278         for (i = SIGNALS+1, p = sigtraps; --i >= 0; p++)
 279                 if (p->flags & (TF_EXEC_IGN|TF_EXEC_DFL))
 280                         setsig(p, (p->flags & TF_EXEC_IGN) ? SIG_IGN : SIG_DFL,
 281                                 SS_RESTORE_CURR|SS_FORCE);
 282 }
 283
 284 void
 285 settrap(p, s)
 286         Trap *p;
 287         char *s;
 288 {
 289         handler_t f;
 290
 291         if (p->trap)
 292                 afree(p->trap, APERM);
 293         p->trap = str_save(s, APERM); /* handles s == 0 */
 294         p->flags |= TF_CHANGED;
 295         f = !s ? SIG_DFL : s[0] ? trapsig : SIG_IGN;
 296
 297         p->flags |= TF_USER_SET;
 298         if ((p->flags & (TF_DFL_INTR|TF_FATAL)) && f == SIG_DFL)
 299                 f = trapsig;
 300         else if (p->flags & TF_SHELL_USES) {
 301                 if (!(p->flags & TF_ORIG_IGN) || Flag(FTALKING)) {
 302                         /* do what user wants at exec time */
 303                         p->flags &= ~(TF_EXEC_IGN|TF_EXEC_DFL);
 304                         if (f == SIG_IGN)
 305                                 p->flags |= TF_EXEC_IGN;
 306                         else
 307                                 p->flags |= TF_EXEC_DFL;
 308                 }
 309                 /* assumes handler already set to what shell wants it
 310                  * (normally trapsig, but could be j_sigchld() or SIG_IGN)
 311                  */
 312                 return;
 313         }
 314
 315         /* todo: should we let user know signal is ignored? how? */
 316         setsig(p, f, SS_RESTORE_CURR|SS_USER);
 317 }
 318
 319 /* Called by c_print() when writing to a co-process to ensure SIGPIPE won't
 320  * kill shell (unless user catches it and exits)
 321  */
 322 int
 323 block_pipe()
 324 {
 325         int restore_dfl = 0;
 326         Trap *p = &sigtraps[SIGPIPE];
 327
 328         if (!(p->flags & (TF_ORIG_IGN|TF_ORIG_DFL))) {
 329                 setsig(p, SIG_IGN, SS_RESTORE_CURR);
 330                 if (p->flags & TF_ORIG_DFL)
 331                         restore_dfl = 1;
 332         } else if (p->cursig == SIG_DFL) {
 333                 setsig(p, SIG_IGN, SS_RESTORE_CURR);
 334                 restore_dfl = 1; /* restore to SIG_DFL */
 335         }
 336         return restore_dfl;
 337 }
 338
 339 /* Called by c_print() to undo whatever block_pipe() did */
 340 void
 341 restore_pipe(restore_dfl)
 342         int restore_dfl;
 343 {
 344         if (restore_dfl)
 345                 setsig(&sigtraps[SIGPIPE], SIG_DFL, SS_RESTORE_CURR);
 346 }
 347
 348 /* Set action for a signal.  Action may not be set if original
 349  * action was SIG_IGN, depending on the value of flags and
 350  * FTALKING.
 351  */
 352 int
 353 setsig(p, f, flags)
 354         Trap *p;
 355         handler_t f;
 356         int flags;
 357 {
 358         struct sigaction sigact;
 359
 360         if (p->signal == SIGEXIT_ )
 361                 return 1;
 362
 363         /* First time setting this signal?  If so, get and note the current
 364          * setting.
 365          */
 366         if (!(p->flags & (TF_ORIG_IGN|TF_ORIG_DFL))) {
 367                 sigaction(p->signal, &Sigact_ign, &sigact);
 368                 p->flags |= sigact.sa_handler == SIG_IGN ?
 369                                         TF_ORIG_IGN : TF_ORIG_DFL;
 370                 p->cursig = SIG_IGN;
 371         }
 372
 373         /* Generally, an ignored signal stays ignored, except if
 374          *      - the user of an interactive shell wants to change it
 375          *      - the shell wants for force a change
 376          */
 377         if ((p->flags & TF_ORIG_IGN) && !(flags & SS_FORCE)
 378             && (!(flags & SS_USER) || !Flag(FTALKING)))
 379                 return 0;
 380
 381         setexecsig(p, flags & SS_RESTORE_MASK);
 382
 383         /* This is here 'cause there should be a way of clearing shtraps, but
 384          * don't know if this is a sane way of doing it.  At the moment,
 385          * all users of shtrap are lifetime users (SIGCHLD, SIGALRM, SIGWINCH).
 386          */
 387         if (!(flags & SS_USER))
 388                 p->shtrap = (handler_t) 0;
 389         if (flags & SS_SHTRAP) {
 390                 p->shtrap = f;
 391                 f = trapsig;
 392         }
 393
 394         if (p->cursig != f) {
 395                 p->cursig = f;
 396                 sigemptyset(&sigact.sa_mask);
 397                 sigact.sa_flags = KSH_SA_FLAGS;
 398                 sigact.sa_handler = f;
 399                 sigaction(p->signal, &sigact, (struct sigaction *) 0);
 400         }
 401
 402         return 1;
 403 }
 404
 405 /* control what signal is set to before an exec() */
 406 void
 407 setexecsig(p, restore)
 408         Trap *p;
 409         int restore;
 410 {
 411         /* XXX debugging */
 412         if (!(p->flags & (TF_ORIG_IGN|TF_ORIG_DFL)))
 413                 internal_errorf(1, "setexecsig: unset signal %d(%s)",
 414                         p->signal, p->name);
 415
 416         /* restore original value for exec'd kids */
 417         p->flags &= ~(TF_EXEC_IGN|TF_EXEC_DFL);
 418         switch (restore & SS_RESTORE_MASK) {
 419           case SS_RESTORE_CURR: /* leave things as they currently are */
 420                 break;
 421           case SS_RESTORE_ORIG:
 422                 p->flags |= p->flags & TF_ORIG_IGN ? TF_EXEC_IGN : TF_EXEC_DFL;
 423                 break;
 424           case SS_RESTORE_DFL:
 425                 p->flags |= TF_EXEC_DFL;
 426                 break;
 427           case SS_RESTORE_IGN:
 428                 p->flags |= TF_EXEC_IGN;
 429                 break;
 430         }
 431 }