Home | History | Annotate | Line # | Download | only in ksh
trap.c revision 1.6 
      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