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