Home | History | Annotate | Line # | Download | only in ksh
trap.c revision 1.9 
      1 /*	$NetBSD: trap.c,v 1.9 2017/06/22 13:37:16 kamil Exp $	*/
      2 
      3 /*
      4  * signal handling
      5  */
      6 #include <sys/cdefs.h>
      7 
      8 #ifndef lint
      9 __RCSID("$NetBSD: trap.c,v 1.9 2017/06/22 13:37:16 kamil Exp $");
     10 #endif
     11 
     12 #include "sh.h"
     13 
     14 /* Table is indexed by signal number
     15  *
     16  * The script siglist.sh generates siglist.out, which is a sorted, complete
     17  * list of signals
     18  */
     19 Trap sigtraps[SIGNALS+1] = {
     20 	{ .signal = SIGEXIT_, .name = "EXIT", .mess = "Signal 0" },
     21 #include "siglist.out"	/* generated by siglist.sh */
     22 	{ .signal = SIGERR_,  .name = "ERR",  .mess = "Error handler" },
     23     };
     24 
     25 static struct sigaction Sigact_ign, Sigact_trap;
     26 
     27 void
     28 inittraps()
     29 {
     30 #ifdef HAVE_SYS_SIGLIST
     31 # ifndef SYS_SIGLIST_DECLARED
     32 	extern char	*sys_siglist[];
     33 # endif
     34 	int	i;
     35 
     36 	/* Use system description, if available, for unknown signals... */
     37 	for (i = 0; i < NSIG; i++)
     38 		if (!sigtraps[i].name && sys_siglist[i] && sys_siglist[i][0])
     39 			sigtraps[i].mess = sys_siglist[i];
     40 #endif	/* HAVE_SYS_SIGLIST */
     41 
     42 	sigemptyset(&Sigact_ign.sa_mask);
     43 	Sigact_ign.sa_flags = KSH_SA_FLAGS;
     44 	Sigact_ign.sa_handler = SIG_IGN;
     45 	Sigact_trap = Sigact_ign;
     46 	Sigact_trap.sa_handler = trapsig;
     47 
     48 	sigtraps[SIGINT].flags |= TF_DFL_INTR | TF_TTY_INTR;
     49 	sigtraps[SIGQUIT].flags |= TF_DFL_INTR | TF_TTY_INTR;
     50 	sigtraps[SIGTERM].flags |= TF_DFL_INTR;/* not fatal for interactive */
     51 	sigtraps[SIGHUP].flags |= TF_FATAL;
     52 	sigtraps[SIGCHLD].flags |= TF_SHELL_USES;
     53 
     54 	/* these are always caught so we can clean up any temporary files. */
     55 	setsig(&sigtraps[SIGINT], trapsig, SS_RESTORE_ORIG);
     56 	setsig(&sigtraps[SIGQUIT], trapsig, SS_RESTORE_ORIG);
     57 	setsig(&sigtraps[SIGTERM], trapsig, SS_RESTORE_ORIG);
     58 	setsig(&sigtraps[SIGHUP], trapsig, SS_RESTORE_ORIG);
     59 }
     60 
     61 #ifdef KSH
     62 static RETSIGTYPE alarm_catcher ARGS((int sig));
     63 
     64 void
     65 alarm_init()
     66 {
     67 	sigtraps[SIGALRM].flags |= TF_SHELL_USES;
     68 	setsig(&sigtraps[SIGALRM], alarm_catcher,
     69 		SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP);
     70 }
     71 
     72 static RETSIGTYPE
     73 alarm_catcher(sig)
     74 	int sig;
     75 {
     76 	int errno_ = errno;
     77 
     78 	if (ksh_tmout_state == TMOUT_READING) {
     79 		int left = alarm(0);
     80 
     81 		if (left == 0) {
     82 			ksh_tmout_state = TMOUT_LEAVING;
     83 			intrsig = 1;
     84 		} else
     85 			alarm(left);
     86 	}
     87 	errno = errno_;
     88 	return RETSIGVAL;
     89 }
     90 #endif /* KSH */
     91 
     92 Trap *
     93 gettrap(name, igncase)
     94 	const char *name;
     95 	int igncase;
     96 {
     97 	int i;
     98 	register Trap *p;
     99 
    100 	if (digit(*name)) {
    101 		int n;
    102 
    103 		if (getn(name, &n) && 0 <= n && n < SIGNALS)
    104 			return &sigtraps[n];
    105 		return NULL;
    106 	}
    107 	for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++)
    108 		if (p->name) {
    109 			if (igncase) {
    110 				if (p->name && (!strcasecmp(p->name, name) ||
    111 				    (strlen(name) > 3 && !strncasecmp("SIG",
    112 				    p->name, 3) &&
    113 				    !strcasecmp(p->name, name + 3))))
    114 					return p;
    115 			} else {
    116 				if (p->name && (!strcmp(p->name, name) ||
    117 				    (strlen(name) > 3 && !strncmp("SIG",
    118 				    p->name, 3) && !strcmp(p->name, name + 3))))
    119 					return p;
    120 			}
    121 		}
    122 	return NULL;
    123 }
    124 
    125 /*
    126  * trap signal handler
    127  */
    128 RETSIGTYPE
    129 trapsig(i)
    130 	int i;
    131 {
    132 	Trap *p = &sigtraps[i];
    133 	int errno_ = errno;
    134 
    135 	trap = p->set = 1;
    136 	if (p->flags & TF_DFL_INTR)
    137 		intrsig = 1;
    138 	if ((p->flags & TF_FATAL) && !p->trap) {
    139 		fatal_trap = 1;
    140 		intrsig = 1;
    141 	}
    142 	if (p->shtrap)
    143 		(*p->shtrap)(i);
    144 #ifdef V7_SIGNALS
    145 	if (sigtraps[i].cursig == trapsig) /* this for SIGCHLD,SIGALRM */
    146 		sigaction(i, &Sigact_trap, (struct sigaction *) 0);
    147 #endif /* V7_SIGNALS */
    148 	errno = errno_;
    149 	return RETSIGVAL;
    150 }
    151 
    152 /* called when we want to allow the user to ^C out of something - won't
    153  * work if user has trapped SIGINT.
    154  */
    155 void
    156 intrcheck()
    157 {
    158 	if (intrsig)
    159 		runtraps(TF_DFL_INTR|TF_FATAL);
    160 }
    161 
    162 /* called after EINTR to check if a signal with normally causes process
    163  * termination has been received.
    164  */
    165 int
    166 fatal_trap_check()
    167 {
    168 	int i;
    169 	Trap *p;
    170 
    171 	/* todo: should check if signal is fatal, not the TF_DFL_INTR flag */
    172 	for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++)
    173 		if (p->set && (p->flags & (TF_DFL_INTR|TF_FATAL)))
    174 			/* return value is used as an exit code */
    175 			return 128 + p->signal;
    176 	return 0;
    177 }
    178 
    179 /* Returns the signal number of any pending traps: ie, a signal which has
    180  * occurred for which a trap has been set or for which the TF_DFL_INTR flag
    181  * is set.
    182  */
    183 int
    184 trap_pending()
    185 {
    186 	int i;
    187 	Trap *p;
    188 
    189 	for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++)
    190 		if (p->set && ((p->trap && p->trap[0])
    191 			       || ((p->flags & (TF_DFL_INTR|TF_FATAL))
    192 				   && !p->trap)))
    193 			return p->signal;
    194 	return 0;
    195 }
    196 
    197 /*
    198  * run any pending traps.  If intr is set, only run traps that
    199  * can interrupt commands.
    200  */
    201 void
    202 runtraps(flag)
    203 	int flag;
    204 {
    205 	int i;
    206 	register Trap *p;
    207 
    208 #ifdef KSH
    209 	if (ksh_tmout_state == TMOUT_LEAVING) {
    210 		ksh_tmout_state = TMOUT_EXECUTING;
    211 		warningf(FALSE, "timed out waiting for input");
    212 		unwind(LEXIT);
    213 	} else
    214 		/* XXX: this means the alarm will have no effect if a trap
    215 		 * is caught after the alarm() was started...not good.
    216 		 */
    217 		ksh_tmout_state = TMOUT_EXECUTING;
    218 #endif /* KSH */
    219 	if (!flag)
    220 		trap = 0;
    221 	if (flag & TF_DFL_INTR)
    222 		intrsig = 0;
    223 	if (flag & TF_FATAL)
    224 		fatal_trap = 0;
    225 	for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++)
    226 		if (p->set && (!flag
    227 			       || ((p->flags & flag) && p->trap == (char *) 0)))
    228 			runtrap(p);
    229 }
    230 
    231 void
    232 runtrap(p)
    233 	Trap *p;
    234 {
    235 	int	i = p->signal;
    236 	char	*trapstr = p->trap;
    237 	int	oexstat;
    238 	int	UNINITIALIZED(old_changed);
    239 
    240 	p->set = 0;
    241 	if (trapstr == (char *) 0) { /* SIG_DFL */
    242 		if (p->flags & TF_FATAL) {
    243 			/* eg, SIGHUP */
    244 			exstat = 128 + i;
    245 			unwind(LLEAVE);
    246 		}
    247 		if (p->flags & TF_DFL_INTR) {
    248 			/* eg, SIGINT, SIGQUIT, SIGTERM, etc. */
    249 			exstat = 128 + i;
    250 			unwind(LINTR);
    251 		}
    252 		return;
    253 	}
    254 	if (trapstr[0] == '\0') /* SIG_IGN */
    255 		return;
    256 	if (i == SIGEXIT_ || i == SIGERR_) {	/* avoid recursion on these */
    257 		old_changed = p->flags & TF_CHANGED;
    258 		p->flags &= ~TF_CHANGED;
    259 		p->trap = (char *) 0;
    260 	}
    261 	oexstat = exstat;
    262 	/* Note: trapstr is fully parsed before anything is executed, thus
    263 	 * no problem with afree(p->trap) in settrap() while still in use.
    264 	 */
    265 	command(trapstr);
    266 	exstat = oexstat;
    267 	if (i == SIGEXIT_ || i == SIGERR_) {
    268 		if (p->flags & TF_CHANGED)
    269 			/* don't clear TF_CHANGED */
    270 			afree(trapstr, APERM);
    271 		else
    272 			p->trap = trapstr;
    273 		p->flags |= old_changed;
    274 	}
    275 }
    276 
    277 /* clear pending traps and reset user's trap handlers; used after fork(2) */
    278 void
    279 cleartraps()
    280 {
    281 	int i;
    282 	Trap *p;
    283 
    284 	trap = 0;
    285 	intrsig = 0;
    286 	fatal_trap = 0;
    287 	for (i = SIGNALS+1, p = sigtraps; --i >= 0; p++) {
    288 		p->set = 0;
    289 		if ((p->flags & TF_USER_SET) && (p->trap && p->trap[0]))
    290 			settrap(p, (char *) 0);
    291 	}
    292 }
    293 
    294 /* restore signals just before an exec(2) */
    295 void
    296 restoresigs()
    297 {
    298 	int i;
    299 	Trap *p;
    300 
    301 	for (i = SIGNALS+1, p = sigtraps; --i >= 0; p++)
    302 		if (p->flags & (TF_EXEC_IGN|TF_EXEC_DFL))
    303 			setsig(p, (p->flags & TF_EXEC_IGN) ? SIG_IGN : SIG_DFL,
    304 				SS_RESTORE_CURR|SS_FORCE);
    305 }
    306 
    307 void
    308 settrap(p, s)
    309 	Trap *p;
    310 	char *s;
    311 {
    312 	handler_t f;
    313 
    314 	if (p->trap)
    315 		afree(p->trap, APERM);
    316 	p->flags |= TF_CHANGED|TF_USER_SET;
    317 	if (s) {
    318 		p->trap = str_save(s, APERM);
    319 		f = s[0] ? trapsig : SIG_IGN;
    320 	} else {
    321 		p->trap = NULL;
    322 		f = SIG_DFL;
    323 	}
    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