/*  * This file is part of the UCB release of Plan 9. It is subject to the license * terms in the LICENSE file found in the top-level directory of this * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No * part of the UCB release of Plan 9, including this file, may be copied, * modified, propagated, or distributed except according to the terms contained * in the LICENSE file. */ /* * signal handling */ /* Kludge to avoid bogus re-declaration of sigtraps[] error on AIX 3.2.5 */#define FROM_TRAP_C#include "sh.h" /* Table is indexed by signal number * * The script siglist.sh generates siglist.out, which is a sorted, complete * list of signals */Trap sigtraps[SIGNALS+1] = {	{ SIGEXIT_, "EXIT", "Signal 0" },	{ 1 , "HUP", "Hangup" },	{ 2 , "INT", "Interrupt" },	{ 3 , "QUIT", "Quit" },	{ 4 , "ILL", "Illegal instruction" },	{ 5 , "ABRT", "Abort" },	{ 6 , "FPE", "Floating point exception" },	{ 7 , "KILL", "Killed" },	{ 8 , "SEGV", "Memory fault" },	{ 9 , "PIPE", "Broken pipe" },	{ 10 , "ALRM", "Alarm clock" },	{ 11 , "TERM", "Terminated" },	{ 12 , "USR1", "User defined signal 1" },	{ 13 , "USR2", "User defined signal 2" },	{ 14 , "BUS", "Bus error" },	{ 15 , "CHLD", "Child exited" },	{ 16 , "CONT", "Continued" },	{ 17 , "STOP", "Stopped (signal)" },	{ 18 , "TSTP", "Stopped" },	{ 19 , "TTIN", "Stopped (tty input)" },	{ 20 , "TTOU", "Stopped (tty output)" },	{ SIGERR_,  "ERR",  "Error handler" },    }; static struct sigaction Sigact_ign, Sigact_trap; voidinittraps(){#ifdef HAVE_SYS_SIGLIST# ifndef SYS_SIGLIST_DECLARED	extern char	*sys_siglist[];# endif	int	i; 	/* Use system description, if available, for unknown signals... */	for (i = 0; i < NSIG; i++)		if (!sigtraps[i].name && sys_siglist[i] && sys_siglist[i][0])			sigtraps[i].mess = sys_siglist[i];#endif	/* HAVE_SYS_SIGLIST */ 	sigemptyset(&Sigact_ign.sa_mask);	Sigact_ign.sa_flags = KSH_SA_FLAGS;	Sigact_ign.sa_handler = SIG_IGN;	Sigact_trap = Sigact_ign;	Sigact_trap.sa_handler = trapsig; 	sigtraps[SIGINT].flags |= TF_DFL_INTR | TF_TTY_INTR;	sigtraps[SIGQUIT].flags |= TF_DFL_INTR | TF_TTY_INTR;	sigtraps[SIGTERM].flags |= TF_DFL_INTR;/* not fatal for interactive */	sigtraps[SIGHUP].flags |= TF_FATAL;	sigtraps[SIGCHLD].flags |= TF_SHELL_USES; 	/* these are always caught so we can clean up any temproary files. */	setsig(&sigtraps[SIGINT], trapsig, SS_RESTORE_ORIG);	setsig(&sigtraps[SIGQUIT], trapsig, SS_RESTORE_ORIG);	setsig(&sigtraps[SIGTERM], trapsig, SS_RESTORE_ORIG);	setsig(&sigtraps[SIGHUP], trapsig, SS_RESTORE_ORIG);} #ifdef KSHstatic RETSIGTYPE alarm_catcher ARGS((int sig)); voidalarm_init(){	sigtraps[SIGALRM].flags |= TF_SHELL_USES;	setsig(&sigtraps[SIGALRM], alarm_catcher,		SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP);} static RETSIGTYPEalarm_catcher(sig)	int sig;{	if (ksh_tmout_state == TMOUT_READING) {		int left = alarm(0); 		if (left == 0) {			ksh_tmout_state = TMOUT_LEAVING;			intrsig = 1;		} else			alarm(left);	}	return RETSIGVAL;}#endif /* KSH */ Trap *gettrap(name, igncase)	const char *name;	int igncase;{	int i;	register Trap *p; 	if (digit(*name)) {		int n; 		if (getn(name, &n) && 0 <= n && n < SIGNALS)			return &sigtraps[n];		return NULL;	}	if (strncasecmp(name, "sig", 3) == 0)		name += 3;	for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++)		if (p->name && (igncase ? strcasecmp(p->name, name) == 0					: strcmp(p->name, name) == 0))			return p;	return NULL;} /* * trap signal handler */RETSIGTYPEtrapsig(i)	int i;{	Trap *p = &sigtraps[i]; 	trap = p->set = 1;	if (p->flags & TF_DFL_INTR)		intrsig = 1;	if ((p->flags & TF_FATAL) && !p->trap) {		fatal_trap = 1;		intrsig = 1;	}	if (p->shtrap)		(*p->shtrap)(i);#ifdef V7_SIGNALS	if (sigtraps[i].cursig == trapsig) /* this for SIGCHLD,SIGALRM */		sigaction(i, &Sigact_trap, (struct sigaction *) 0);#endif /* V7_SIGNALS */	return RETSIGVAL;} /* called when we want to allow the user to ^C out of something - won't * work if user has trapped SIGINT. */voidintrcheck(){	if (intrsig)		runtraps(TF_DFL_INTR|TF_FATAL);} /* called after EINTR to check if a signal with normally causes process * termination has been received. */intfatal_trap_check(){	int i;	Trap *p; 	/* todo: should check if signal is fatal, not the TF_DFL_INTR flag */	for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++)		if (p->set && (p->flags & (TF_DFL_INTR|TF_FATAL)))			/* return value is used as an exit code */			return 128 + p->signal;	return 0;} /* Returns the signal number of any pending traps: ie, a signal which has * occured for which a trap has been set or for which the TF_DFL_INTR flag * is set. */inttrap_pending(){	int i;	Trap *p; 	for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++)		if (p->set && ((p->trap && p->trap[0])			       || ((p->flags & (TF_DFL_INTR|TF_FATAL))				   && !p->trap)))			return p->signal;	return 0;} /* * run any pending traps.  If intr is set, only run traps that * can interrupt commands. */voidruntraps(flag)	int flag;{	int i;	register Trap *p; #ifdef KSH	if (ksh_tmout_state == TMOUT_LEAVING) {		ksh_tmout_state = TMOUT_EXECUTING;		warningf(FALSE, "timed out waiting for input");		unwind(LEXIT);	} else		/* XXX: this means the alarm will have no effect if a trap		 * is caught after the alarm() was started...not good.		 */		ksh_tmout_state = TMOUT_EXECUTING;#endif /* KSH */	if (!flag)		trap = 0;	if (flag & TF_DFL_INTR)		intrsig = 0;	if (flag & TF_FATAL)		fatal_trap = 0;	for (p = sigtraps, i = SIGNALS+1; --i >= 0; p++)		if (p->set && (!flag			       || ((p->flags & flag) && p->trap == (char *) 0)))			runtrap(p);} voidruntrap(p)	Trap *p;{	int	i = p->signal;	char	*trapstr = p->trap;	int	oexstat;	int	UNINITIALIZED(old_changed); 	p->set = 0;	if (trapstr == (char *) 0) { /* SIG_DFL */		if (p->flags & TF_FATAL) {			/* eg, SIGHUP */			exstat = 128 + i;			unwind(LLEAVE);		}		if (p->flags & TF_DFL_INTR) {			/* eg, SIGINT, SIGQUIT, SIGTERM, etc. */			exstat = 128 + i;			unwind(LINTR);		}		return;	}	if (trapstr[0] == '\0') /* SIG_IGN */		return;	if (i == SIGEXIT_ || i == SIGERR_) {	/* avoid recursion on these */		old_changed = p->flags & TF_CHANGED;		p->flags &= ~TF_CHANGED;		p->trap = (char *) 0;	}	oexstat = exstat;	/* Note: trapstr is fully parsed before anything is executed, thus	 * no problem with afree(p->trap) in settrap() while still in use.	 */	command(trapstr);	exstat = oexstat;	if (i == SIGEXIT_ || i == SIGERR_) {		if (p->flags & TF_CHANGED)			/* don't clear TF_CHANGED */			afree(trapstr, APERM);		else			p->trap = trapstr;		p->flags |= old_changed;	}} /* clear pending traps and reset user's trap handlers; used after fork(2) */voidcleartraps(){	int i;	Trap *p; 	trap = 0;	intrsig = 0;	fatal_trap = 0;	for (i = SIGNALS+1, p = sigtraps; --i >= 0; p++) {		p->set = 0;		if ((p->flags & TF_USER_SET) && (p->trap && p->trap[0]))			settrap(p, (char *) 0);	}} /* restore signals just before an exec(2) */voidrestoresigs(){	int i;	Trap *p; 	for (i = SIGNALS+1, p = sigtraps; --i >= 0; p++)		if (p->flags & (TF_EXEC_IGN|TF_EXEC_DFL))			setsig(p, (p->flags & TF_EXEC_IGN) ? SIG_IGN : SIG_DFL,				SS_RESTORE_CURR|SS_FORCE);} voidsettrap(p, s)	Trap *p;	char *s;{	handler_t f; 	if (p->trap)		afree(p->trap, APERM);	p->trap = str_save(s, APERM); /* handles s == 0 */	p->flags |= TF_CHANGED;	f = !s ? SIG_DFL : s[0] ? trapsig : SIG_IGN; 	p->flags |= TF_USER_SET;	if ((p->flags & (TF_DFL_INTR|TF_FATAL)) && f == SIG_DFL)		f = trapsig;	else if (p->flags & TF_SHELL_USES) {		if (!(p->flags & TF_ORIG_IGN) || Flag(FTALKING)) {			/* do what user wants at exec time */			p->flags &= ~(TF_EXEC_IGN|TF_EXEC_DFL);			if (f == SIG_IGN)				p->flags |= TF_EXEC_IGN;			else				p->flags |= TF_EXEC_DFL;		}		/* assumes handler already set to what shell wants it		 * (normally trapsig, but could be j_sigchld() or SIG_IGN)		 */		return;	} 	/* todo: should we let user know signal is ignored? how? */	setsig(p, f, SS_RESTORE_CURR|SS_USER);} /* Called by c_print() when writing to a co-process to ensure SIGPIPE won't * kill shell (unless user catches it and exits) */intblock_pipe(){	int restore_dfl = 0;	Trap *p = &sigtraps[SIGPIPE]; 	if (!(p->flags & (TF_ORIG_IGN|TF_ORIG_DFL))) {		setsig(p, SIG_IGN, SS_RESTORE_CURR);		if (p->flags & TF_ORIG_DFL)			restore_dfl = 1;	} else if (p->cursig == SIG_DFL) {		setsig(p, SIG_IGN, SS_RESTORE_CURR);		restore_dfl = 1; /* restore to SIG_DFL */	}	return restore_dfl;} /* Called by c_print() to undo whatever block_pipe() did */voidrestore_pipe(restore_dfl)	int restore_dfl;{	if (restore_dfl)		setsig(&sigtraps[SIGPIPE], SIG_DFL, SS_RESTORE_CURR);} /* Set action for a signal.  Action may not be set if original * action was SIG_IGN, depending on the value of flags and * FTALKING. */intsetsig(p, f, flags)	Trap *p;	handler_t f;	int flags;{	struct sigaction sigact; 	if (p->signal == SIGEXIT_ || p->signal == SIGERR_)		return 1; 	/* First time setting this signal?  If so, get and note the current	 * setting.	 */	if (!(p->flags & (TF_ORIG_IGN|TF_ORIG_DFL))) {		sigaction(p->signal, &Sigact_ign, &sigact);		p->flags |= sigact.sa_handler == SIG_IGN ?					TF_ORIG_IGN : TF_ORIG_DFL;		p->cursig = SIG_IGN;	} 	/* Generally, an ignored signal stays ignored, except if	 *	- the user of an interactive shell wants to change it	 *	- the shell wants for force a change	 */	if ((p->flags & TF_ORIG_IGN) && !(flags & SS_FORCE)	    && (!(flags & SS_USER) || !Flag(FTALKING)))		return 0; 	setexecsig(p, flags & SS_RESTORE_MASK); 	/* This is here 'cause there should be a way of clearing shtraps, but	 * don't know if this is a sane way of doing it.  At the moment,	 * all users of shtrap are lifetime users (SIGCHLD, SIGALRM, SIGWINCH).	 */	if (!(flags & SS_USER))		p->shtrap = (handler_t) 0;	if (flags & SS_SHTRAP) {		p->shtrap = f;		f = trapsig;	} 	if (p->cursig != f) {		p->cursig = f;		sigemptyset(&sigact.sa_mask);		sigact.sa_flags = KSH_SA_FLAGS;		sigact.sa_handler = f;		sigaction(p->signal, &sigact, (struct sigaction *) 0);	} 	return 1;} /* control what signal is set to before an exec() */voidsetexecsig(p, restore)	Trap *p;	int restore;{	/* XXX debugging */	if (!(p->flags & (TF_ORIG_IGN|TF_ORIG_DFL)))		internal_errorf(1, "setexecsig: unset signal %d(%s)",			p->signal, p->name); 	/* restore original value for exec'd kids */	p->flags &= ~(TF_EXEC_IGN|TF_EXEC_DFL);	switch (restore & SS_RESTORE_MASK) {	  case SS_RESTORE_CURR: /* leave things as they currently are */		break;	  case SS_RESTORE_ORIG:		p->flags |= p->flags & TF_ORIG_IGN ? TF_EXEC_IGN : TF_EXEC_DFL;		break;	  case SS_RESTORE_DFL:		p->flags |= TF_EXEC_DFL;		break;	  case SS_RESTORE_IGN:		p->flags |= TF_EXEC_IGN;		break;	}}