text: /*
   * 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;
  
  void
  inittraps()
  {
  #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 KSH
  static RETSIGTYPE alarm_catcher ARGS((int sig));
  
  void
  alarm_init()
  {
  	sigtraps[SIGALRM].flags |= TF_SHELL_USES;
  	setsig(&sigtraps[SIGALRM], alarm_catcher,
  		SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP);
  }
  
  static RETSIGTYPE
  alarm_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
   */
  RETSIGTYPE
  trapsig(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.
   */
  void
  intrcheck()
  {
  	if (intrsig)
  		runtraps(TF_DFL_INTR|TF_FATAL);
  }
  
  /* called after EINTR to check if a signal with normally causes process
   * termination has been received.
   */
  int
  fatal_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.
   */
  int
  trap_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.
   */
  void
  runtraps(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);
  }
  
  void
  runtrap(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) */
  void
  cleartraps()
  {
  	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) */
  void
  restoresigs()
  {
  	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);
  }
  
  void
  settrap(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)
   */
  int
  block_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 */
  void
  restore_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.
   */
  int
  setsig(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() */
  void
  setexecsig(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;
  	}
  }
  