[thirdparty/binutils-gdb.git] / readline / signals.c

/* signals.c -- signal handling support for readline. */

/* Copyright (C) 1987-2005 Free Software Foundation, Inc.

   This file is part of the GNU Readline Library, a library for
   reading lines of text with interactive input and history editing.

   The GNU Readline Library is free software; you can redistribute it
   and/or modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2, or
   (at your option) any later version.

   The GNU Readline Library is distributed in the hope that it will be
   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   The GNU General Public License is often shipped with GNU software, and
   is generally kept in a file called COPYING or LICENSE.  If you do not
   have a copy of the license, write to the Free Software Foundation,
   59 Temple Place, Suite 330, Boston, MA 02111 USA. */
#define READLINE_LIBRARY

#if defined (HAVE_CONFIG_H)
#  include <config.h>
#endif

#include <stdio.h>		/* Just for NULL.  Yuck. */
#include <sys/types.h>
#include <signal.h>

#if defined (HAVE_UNISTD_H)
#  include <unistd.h>
#endif /* HAVE_UNISTD_H */

/* System-specific feature definitions and include files. */
#include "rldefs.h"

#if defined (GWINSZ_IN_SYS_IOCTL)
#  include <sys/ioctl.h>
#endif /* GWINSZ_IN_SYS_IOCTL */

#if defined (HANDLE_SIGNALS)
/* Some standard library routines. */
#include "readline.h"
#include "history.h"

#include "rlprivate.h"

#if !defined (RETSIGTYPE)
#  if defined (VOID_SIGHANDLER)
#    define RETSIGTYPE void
#  else
#    define RETSIGTYPE int
#  endif /* !VOID_SIGHANDLER */
#endif /* !RETSIGTYPE */

#if defined (VOID_SIGHANDLER)
#  define SIGHANDLER_RETURN return
#else
#  define SIGHANDLER_RETURN return (0)
#endif

/* This typedef is equivalent to the one for Function; it allows us
   to say SigHandler *foo = signal (SIGKILL, SIG_IGN); */
typedef RETSIGTYPE SigHandler ();

#if defined (HAVE_POSIX_SIGNALS)
typedef struct sigaction sighandler_cxt;
#  define rl_sigaction(s, nh, oh)	sigaction(s, nh, oh)
#else
typedef struct { SigHandler *sa_handler; int sa_mask, sa_flags; } sighandler_cxt;
#  define sigemptyset(m)
#endif /* !HAVE_POSIX_SIGNALS */

#ifndef SA_RESTART
#  define SA_RESTART 0
#endif

static SigHandler *rl_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
static void rl_maybe_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));

/* Exported variables for use by applications. */

/* If non-zero, readline will install its own signal handlers for
   SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
int rl_catch_signals = 1;

/* If non-zero, readline will install a signal handler for SIGWINCH. */
#ifdef SIGWINCH
int rl_catch_sigwinch = 1;
#else
int rl_catch_sigwinch = 0;	/* for the readline state struct in readline.c */
#endif

static int signals_set_flag;
static int sigwinch_set_flag;

/* **************************************************************** */
/*					        		    */
/*			   Signal Handling                          */
/*								    */
/* **************************************************************** */

static sighandler_cxt old_int, old_term, old_alrm, old_quit;
#if defined (SIGTSTP)
static sighandler_cxt old_tstp, old_ttou, old_ttin;
#endif
#if defined (SIGWINCH)
static sighandler_cxt old_winch;
#endif

/* Readline signal handler functions. */

static RETSIGTYPE
rl_signal_handler (sig)
     int sig;
{
#if defined (HAVE_POSIX_SIGNALS)
  sigset_t set;
#else /* !HAVE_POSIX_SIGNALS */
#  if defined (HAVE_BSD_SIGNALS)
  long omask;
#  else /* !HAVE_BSD_SIGNALS */
  sighandler_cxt dummy_cxt;	/* needed for rl_set_sighandler call */
#  endif /* !HAVE_BSD_SIGNALS */
#endif /* !HAVE_POSIX_SIGNALS */

  RL_SETSTATE(RL_STATE_SIGHANDLER);

#if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS)
  /* Since the signal will not be blocked while we are in the signal
     handler, ignore it until rl_clear_signals resets the catcher. */
#  if defined (SIGALRM)
  if (sig == SIGINT || sig == SIGALRM)
#  else
  if (sig == SIGINT)
#  endif
    rl_set_sighandler (sig, SIG_IGN, &dummy_cxt);
#endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */

  switch (sig)
    {
    case SIGINT:
      rl_free_line_state ();
      /* FALLTHROUGH */

    case SIGTERM:
#if defined (SIGTSTP)
    case SIGTSTP:
    case SIGTTOU:
    case SIGTTIN:
#endif /* SIGTSTP */
#if defined (SIGALRM)
    case SIGALRM:
#endif
#if defined (SIGQUIT)
    case SIGQUIT:
#endif
      rl_cleanup_after_signal ();

#if defined (HAVE_POSIX_SIGNALS)
      sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set);
      sigdelset (&set, sig);
#else /* !HAVE_POSIX_SIGNALS */
#  if defined (HAVE_BSD_SIGNALS)
      omask = sigblock (0);
#  endif /* HAVE_BSD_SIGNALS */
#endif /* !HAVE_POSIX_SIGNALS */

#if defined (__EMX__)
      signal (sig, SIG_ACK);
#endif

#if defined (HAVE_KILL)
      kill (getpid (), sig);
#else
      raise (sig);		/* assume we have raise */
#endif

      /* Let the signal that we just sent through.  */
#if defined (HAVE_POSIX_SIGNALS)
      sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL);
#else /* !HAVE_POSIX_SIGNALS */
#  if defined (HAVE_BSD_SIGNALS)
      sigsetmask (omask & ~(sigmask (sig)));
#  endif /* HAVE_BSD_SIGNALS */
#endif /* !HAVE_POSIX_SIGNALS */

      rl_reset_after_signal ();
    }

  RL_UNSETSTATE(RL_STATE_SIGHANDLER);
  SIGHANDLER_RETURN;
}

#if defined (SIGWINCH)
static RETSIGTYPE
rl_sigwinch_handler (sig)
     int sig;
{
  SigHandler *oh;

#if defined (MUST_REINSTALL_SIGHANDLERS)
  sighandler_cxt dummy_winch;

  /* We don't want to change old_winch -- it holds the state of SIGWINCH
     disposition set by the calling application.  We need this state
     because we call the application's SIGWINCH handler after updating
     our own idea of the screen size. */
  rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch);
#endif

  RL_SETSTATE(RL_STATE_SIGHANDLER);
  rl_resize_terminal ();

  /* If another sigwinch handler has been installed, call it. */
  oh = (SigHandler *)old_winch.sa_handler;
  if (oh &&  oh != (SigHandler *)SIG_IGN && oh != (SigHandler *)SIG_DFL)
    (*oh) (sig);

  RL_UNSETSTATE(RL_STATE_SIGHANDLER);
  SIGHANDLER_RETURN;
}
#endif  /* SIGWINCH */

/* Functions to manage signal handling. */

#if !defined (HAVE_POSIX_SIGNALS)
static int
rl_sigaction (sig, nh, oh)
     int sig;
     sighandler_cxt *nh, *oh;
{
  oh->sa_handler = signal (sig, nh->sa_handler);
  return 0;
}
#endif /* !HAVE_POSIX_SIGNALS */

/* Set up a readline-specific signal handler, saving the old signal
   information in OHANDLER.  Return the old signal handler, like
   signal(). */
static SigHandler *
rl_set_sighandler (sig, handler, ohandler)
     int sig;
     SigHandler *handler;
     sighandler_cxt *ohandler;
{
  sighandler_cxt old_handler;
#if defined (HAVE_POSIX_SIGNALS)
  struct sigaction act;

  act.sa_handler = handler;
  act.sa_flags = (sig == SIGWINCH) ? SA_RESTART : 0;
  sigemptyset (&act.sa_mask);
  sigemptyset (&ohandler->sa_mask);
  sigaction (sig, &act, &old_handler);
#else
  old_handler.sa_handler = (SigHandler *)signal (sig, handler);
#endif /* !HAVE_POSIX_SIGNALS */

  /* XXX -- assume we have memcpy */
  /* If rl_set_signals is called twice in a row, don't set the old handler to
     rl_signal_handler, because that would cause infinite recursion. */
  if (handler != rl_signal_handler || old_handler.sa_handler != rl_signal_handler)
    memcpy (ohandler, &old_handler, sizeof (sighandler_cxt));

  return (ohandler->sa_handler);
}

static void
rl_maybe_set_sighandler (sig, handler, ohandler)
     int sig;
     SigHandler *handler;
     sighandler_cxt *ohandler;
{
  sighandler_cxt dummy;
  SigHandler *oh;

  sigemptyset (&dummy.sa_mask);
  oh = rl_set_sighandler (sig, handler, ohandler);
  if (oh == (SigHandler *)SIG_IGN)
    rl_sigaction (sig, ohandler, &dummy);
}

int
rl_set_signals ()
{
  sighandler_cxt dummy;
  SigHandler *oh;

  if (rl_catch_signals && signals_set_flag == 0)
    {
      rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int);
      rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term);
#if defined (SIGQUIT)
      rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);
#endif

#if defined (SIGALRM)
      oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm);
      if (oh == (SigHandler *)SIG_IGN)
	rl_sigaction (SIGALRM, &old_alrm, &dummy);
#if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART)
      /* If the application using readline has already installed a signal
	 handler with SA_RESTART, SIGALRM will cause reads to be restarted
	 automatically, so readline should just get out of the way.  Since
	 we tested for SIG_IGN above, we can just test for SIG_DFL here. */
      if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART))
	rl_sigaction (SIGALRM, &old_alrm, &dummy);
#endif /* HAVE_POSIX_SIGNALS */
#endif /* SIGALRM */

#if defined (SIGTSTP)
      rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp);
#endif /* SIGTSTP */

#if defined (SIGTTOU)
      rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou);
#endif /* SIGTTOU */

#if defined (SIGTTIN)
      rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin);
#endif /* SIGTTIN */

      signals_set_flag = 1;
    }

#if defined (SIGWINCH)
  if (rl_catch_sigwinch && sigwinch_set_flag == 0)
    {
      rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch);
      sigwinch_set_flag = 1;
    }
#endif /* SIGWINCH */

  return 0;
}

int
rl_clear_signals ()
{
  sighandler_cxt dummy;

  if (rl_catch_signals && signals_set_flag == 1)
    {
      sigemptyset (&dummy.sa_mask);

      rl_sigaction (SIGINT, &old_int, &dummy);
      rl_sigaction (SIGTERM, &old_term, &dummy);
#if defined (SIGQUIT)
      rl_sigaction (SIGQUIT, &old_quit, &dummy);
#endif
#if defined (SIGALRM)
      rl_sigaction (SIGALRM, &old_alrm, &dummy);
#endif

#if defined (SIGTSTP)
      rl_sigaction (SIGTSTP, &old_tstp, &dummy);
#endif /* SIGTSTP */

#if defined (SIGTTOU)
      rl_sigaction (SIGTTOU, &old_ttou, &dummy);
#endif /* SIGTTOU */

#if defined (SIGTTIN)
      rl_sigaction (SIGTTIN, &old_ttin, &dummy);
#endif /* SIGTTIN */

      signals_set_flag = 0;
    }

#if defined (SIGWINCH)
  if (rl_catch_sigwinch && sigwinch_set_flag == 1)
    {
      sigemptyset (&dummy.sa_mask);
      rl_sigaction (SIGWINCH, &old_winch, &dummy);
      sigwinch_set_flag = 0;
    }
#endif

  return 0;
}

/* Clean up the terminal and readline state after catching a signal, before
   resending it to the calling application. */
void
rl_cleanup_after_signal ()
{
  _rl_clean_up_for_exit ();
  if (rl_deprep_term_function)
    (*rl_deprep_term_function) ();
  rl_clear_signals ();
  rl_clear_pending_input ();
}

/* Reset the terminal and readline state after a signal handler returns. */
void
rl_reset_after_signal ()
{
  if (rl_prep_term_function)
    (*rl_prep_term_function) (_rl_meta_flag);
  rl_set_signals ();
}

/* Free up the readline variable line state for the current line (undo list,
   any partial history entry, any keyboard macros in progress, and any
   numeric arguments in process) after catching a signal, before calling
   rl_cleanup_after_signal(). */ 
void
rl_free_line_state ()
{
  register HIST_ENTRY *entry;

  rl_free_undo_list ();

  entry = current_history ();
  if (entry)
    entry->data = (char *)NULL;

  _rl_kill_kbd_macro ();
  rl_clear_message ();
  _rl_reset_argument ();
}

#endif  /* HANDLE_SIGNALS */
Commit	Line	Data
d60d9f65 SS	1	/* signals.c -- signal handling support for readline. */
d60d9f65 SS	2
5bdf8622	3	/* Copyright (C) 1987-2005 Free Software Foundation, Inc.
d60d9f65 SS	4
	5	This file is part of the GNU Readline Library, a library for
	6	reading lines of text with interactive input and history editing.
	7
	8	The GNU Readline Library is free software; you can redistribute it
	9	and/or modify it under the terms of the GNU General Public License
1b17e766	10	as published by the Free Software Foundation; either version 2, or
d60d9f65 SS	11	(at your option) any later version.
	12
	13	The GNU Readline Library is distributed in the hope that it will be
	14	useful, but WITHOUT ANY WARRANTY; without even the implied warranty
	15	of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	The GNU General Public License is often shipped with GNU software, and
	19	is generally kept in a file called COPYING or LICENSE. If you do not
	20	have a copy of the license, write to the Free Software Foundation,
1b17e766	21	59 Temple Place, Suite 330, Boston, MA 02111 USA. */
d60d9f65 SS	22	#define READLINE_LIBRARY
	23
	24	#if defined (HAVE_CONFIG_H)
	25	# include <config.h>
	26	#endif
	27
	28	#include <stdio.h> /* Just for NULL. Yuck. */
	29	#include <sys/types.h>
	30	#include <signal.h>
	31
	32	#if defined (HAVE_UNISTD_H)
	33	# include <unistd.h>
	34	#endif /* HAVE_UNISTD_H */
	35
	36	/* System-specific feature definitions and include files. */
	37	#include "rldefs.h"
	38
	39	#if defined (GWINSZ_IN_SYS_IOCTL)
	40	# include <sys/ioctl.h>
	41	#endif /* GWINSZ_IN_SYS_IOCTL */
	42
d60d9f65 SS	43	#if defined (HANDLE_SIGNALS)
	44	/* Some standard library routines. */
	45	#include "readline.h"
	46	#include "history.h"
	47
1b17e766 EZ	48	#include "rlprivate.h"
1b17e766 EZ	49
d60d9f65 SS	50	#if !defined (RETSIGTYPE)
	51	# if defined (VOID_SIGHANDLER)
	52	# define RETSIGTYPE void
	53	# else
	54	# define RETSIGTYPE int
	55	# endif /* !VOID_SIGHANDLER */
	56	#endif /* !RETSIGTYPE */
	57
	58	#if defined (VOID_SIGHANDLER)
	59	# define SIGHANDLER_RETURN return
	60	#else
	61	# define SIGHANDLER_RETURN return (0)
	62	#endif
	63
9255ee31	64	/* This typedef is equivalent to the one for Function; it allows us
d60d9f65 SS	65	to say SigHandler foo = signal (SIGKILL, SIG_IGN); /
	66	typedef RETSIGTYPE SigHandler ();
	67
1b17e766 EZ	68	#if defined (HAVE_POSIX_SIGNALS)
	69	typedef struct sigaction sighandler_cxt;
	70	# define rl_sigaction(s, nh, oh) sigaction(s, nh, oh)
	71	#else
	72	typedef struct { SigHandler *sa_handler; int sa_mask, sa_flags; } sighandler_cxt;
	73	# define sigemptyset(m)
	74	#endif /* !HAVE_POSIX_SIGNALS */
c862e87b	75
5bdf8622 DJ	76	#ifndef SA_RESTART
	77	# define SA_RESTART 0
	78	#endif
	79
9255ee31 EZ	80	static SigHandler rl_set_sighandler PARAMS((int, SigHandler , sighandler_cxt *));
9255ee31 EZ	81	static void rl_maybe_set_sighandler PARAMS((int, SigHandler , sighandler_cxt ));
d60d9f65	82
c862e87b JM	83	/* Exported variables for use by applications. */
	84
	85	/* If non-zero, readline will install its own signal handlers for
	86	SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
	87	int rl_catch_signals = 1;
	88
	89	/* If non-zero, readline will install a signal handler for SIGWINCH. */
	90	#ifdef SIGWINCH
	91	int rl_catch_sigwinch = 1;
5bdf8622 DJ	92	#else
5bdf8622 DJ	93	int rl_catch_sigwinch = 0; /* for the readline state struct in readline.c */
c862e87b JM	94	#endif
	95
	96	static int signals_set_flag;
	97	static int sigwinch_set_flag;
	98
d60d9f65 SS	99	/* **************************************************************** */
	100	/* */
	101	/* Signal Handling */
	102	/* */
	103	/* **************************************************************** */
	104
c862e87b JM	105	static sighandler_cxt old_int, old_term, old_alrm, old_quit;
c862e87b JM	106	#if defined (SIGTSTP)
d60d9f65	107	static sighandler_cxt old_tstp, old_ttou, old_ttin;
d60d9f65	108	#endif
d60d9f65 SS	109	#if defined (SIGWINCH)
	110	static sighandler_cxt old_winch;
	111	#endif
	112
	113	/* Readline signal handler functions. */
	114
	115	static RETSIGTYPE
	116	rl_signal_handler (sig)
	117	int sig;
	118	{
	119	#if defined (HAVE_POSIX_SIGNALS)
	120	sigset_t set;
	121	#else /* !HAVE_POSIX_SIGNALS */
	122	# if defined (HAVE_BSD_SIGNALS)
	123	long omask;
	124	# else /* !HAVE_BSD_SIGNALS */
	125	sighandler_cxt dummy_cxt; /* needed for rl_set_sighandler call */
	126	# endif /* !HAVE_BSD_SIGNALS */
	127	#endif /* !HAVE_POSIX_SIGNALS */
	128
9255ee31 EZ	129	RL_SETSTATE(RL_STATE_SIGHANDLER);
9255ee31 EZ	130
d60d9f65 SS	131	#if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS)
	132	/* Since the signal will not be blocked while we are in the signal
	133	handler, ignore it until rl_clear_signals resets the catcher. */
5bdf8622 DJ	134	# if defined (SIGALRM)
	135	if (sig == SIGINT \|\| sig == SIGALRM)
	136	# else
	137	if (sig == SIGINT)
	138	# endif
d60d9f65 SS	139	rl_set_sighandler (sig, SIG_IGN, &dummy_cxt);
	140	#endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */
	141
	142	switch (sig)
	143	{
	144	case SIGINT:
c862e87b JM	145	rl_free_line_state ();
c862e87b JM	146	/* FALLTHROUGH */
d60d9f65	147
5bdf8622	148	case SIGTERM:
d60d9f65 SS	149	#if defined (SIGTSTP)
	150	case SIGTSTP:
	151	case SIGTTOU:
	152	case SIGTTIN:
	153	#endif /* SIGTSTP */
5bdf8622	154	#if defined (SIGALRM)
d60d9f65	155	case SIGALRM:
430b7832	156	#endif
5bdf8622	157	#if defined (SIGQUIT)
c862e87b	158	case SIGQUIT:
430b7832	159	#endif
c862e87b	160	rl_cleanup_after_signal ();
d60d9f65 SS	161
	162	#if defined (HAVE_POSIX_SIGNALS)
	163	sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set);
	164	sigdelset (&set, sig);
	165	#else /* !HAVE_POSIX_SIGNALS */
	166	# if defined (HAVE_BSD_SIGNALS)
	167	omask = sigblock (0);
	168	# endif /* HAVE_BSD_SIGNALS */
	169	#endif /* !HAVE_POSIX_SIGNALS */
	170
1b17e766 EZ	171	#if defined (__EMX__)
	172	signal (sig, SIG_ACK);
	173	#endif
	174
5bdf8622	175	#if defined (HAVE_KILL)
d60d9f65	176	kill (getpid (), sig);
430b7832	177	#else
5bdf8622	178	raise (sig); /* assume we have raise */
430b7832	179	#endif
d60d9f65 SS	180
	181	/* Let the signal that we just sent through. */
	182	#if defined (HAVE_POSIX_SIGNALS)
	183	sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL);
	184	#else /* !HAVE_POSIX_SIGNALS */
	185	# if defined (HAVE_BSD_SIGNALS)
	186	sigsetmask (omask & ~(sigmask (sig)));
	187	# endif /* HAVE_BSD_SIGNALS */
	188	#endif /* !HAVE_POSIX_SIGNALS */
	189
c862e87b	190	rl_reset_after_signal ();
d60d9f65 SS	191	}
d60d9f65 SS	192
9255ee31	193	RL_UNSETSTATE(RL_STATE_SIGHANDLER);
d60d9f65 SS	194	SIGHANDLER_RETURN;
	195	}
	196
	197	#if defined (SIGWINCH)
	198	static RETSIGTYPE
c862e87b	199	rl_sigwinch_handler (sig)
d60d9f65 SS	200	int sig;
	201	{
	202	SigHandler *oh;
	203
	204	#if defined (MUST_REINSTALL_SIGHANDLERS)
	205	sighandler_cxt dummy_winch;
	206
	207	/* We don't want to change old_winch -- it holds the state of SIGWINCH
	208	disposition set by the calling application. We need this state
	209	because we call the application's SIGWINCH handler after updating
	210	our own idea of the screen size. */
c862e87b	211	rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch);
d60d9f65 SS	212	#endif
d60d9f65 SS	213
9255ee31	214	RL_SETSTATE(RL_STATE_SIGHANDLER);
c862e87b	215	rl_resize_terminal ();
d60d9f65 SS	216
	217	/* If another sigwinch handler has been installed, call it. */
	218	oh = (SigHandler *)old_winch.sa_handler;
	219	if (oh && oh != (SigHandler )SIG_IGN && oh != (SigHandler )SIG_DFL)
	220	(*oh) (sig);
	221
9255ee31	222	RL_UNSETSTATE(RL_STATE_SIGHANDLER);
d60d9f65 SS	223	SIGHANDLER_RETURN;
	224	}
	225	#endif /* SIGWINCH */
	226
	227	/* Functions to manage signal handling. */
	228
	229	#if !defined (HAVE_POSIX_SIGNALS)
	230	static int
	231	rl_sigaction (sig, nh, oh)
	232	int sig;
	233	sighandler_cxt nh, oh;
	234	{
	235	oh->sa_handler = signal (sig, nh->sa_handler);
	236	return 0;
	237	}
	238	#endif /* !HAVE_POSIX_SIGNALS */
	239
	240	/* Set up a readline-specific signal handler, saving the old signal
	241	information in OHANDLER. Return the old signal handler, like
	242	signal(). */
	243	static SigHandler *
	244	rl_set_sighandler (sig, handler, ohandler)
	245	int sig;
	246	SigHandler *handler;
	247	sighandler_cxt *ohandler;
	248	{
1b17e766	249	sighandler_cxt old_handler;
d60d9f65 SS	250	#if defined (HAVE_POSIX_SIGNALS)
	251	struct sigaction act;
	252
	253	act.sa_handler = handler;
5bdf8622	254	act.sa_flags = (sig == SIGWINCH) ? SA_RESTART : 0;
d60d9f65 SS	255	sigemptyset (&act.sa_mask);
d60d9f65 SS	256	sigemptyset (&ohandler->sa_mask);
1b17e766	257	sigaction (sig, &act, &old_handler);
d60d9f65	258	#else
1b17e766	259	old_handler.sa_handler = (SigHandler *)signal (sig, handler);
d60d9f65	260	#endif /* !HAVE_POSIX_SIGNALS */
1b17e766 EZ	261
	262	/* XXX -- assume we have memcpy */
	263	/* If rl_set_signals is called twice in a row, don't set the old handler to
	264	rl_signal_handler, because that would cause infinite recursion. */
	265	if (handler != rl_signal_handler \|\| old_handler.sa_handler != rl_signal_handler)
	266	memcpy (ohandler, &old_handler, sizeof (sighandler_cxt));
	267
d60d9f65 SS	268	return (ohandler->sa_handler);
	269	}
	270
c862e87b JM	271	static void
	272	rl_maybe_set_sighandler (sig, handler, ohandler)
	273	int sig;
	274	SigHandler *handler;
	275	sighandler_cxt *ohandler;
d60d9f65 SS	276	{
	277	sighandler_cxt dummy;
	278	SigHandler *oh;
	279
d60d9f65	280	sigemptyset (&dummy.sa_mask);
c862e87b	281	oh = rl_set_sighandler (sig, handler, ohandler);
d60d9f65	282	if (oh == (SigHandler *)SIG_IGN)
c862e87b JM	283	rl_sigaction (sig, ohandler, &dummy);
c862e87b JM	284	}
d60d9f65	285
c862e87b JM	286	int
	287	rl_set_signals ()
	288	{
	289	sighandler_cxt dummy;
	290	SigHandler *oh;
	291
	292	if (rl_catch_signals && signals_set_flag == 0)
	293	{
	294	rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int);
	295	rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term);
5bdf8622	296	#if defined (SIGQUIT)
c862e87b	297	rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);
430b7832	298	#endif
c862e87b	299
5bdf8622	300	#if defined (SIGALRM)
c862e87b JM	301	oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm);
	302	if (oh == (SigHandler *)SIG_IGN)
	303	rl_sigaction (SIGALRM, &old_alrm, &dummy);
d60d9f65	304	#if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART)
c862e87b JM	305	/* If the application using readline has already installed a signal
	306	handler with SA_RESTART, SIGALRM will cause reads to be restarted
	307	automatically, so readline should just get out of the way. Since
	308	we tested for SIG_IGN above, we can just test for SIG_DFL here. */
	309	if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART))
	310	rl_sigaction (SIGALRM, &old_alrm, &dummy);
d60d9f65	311	#endif /* HAVE_POSIX_SIGNALS */
430b7832	312	#endif /* SIGALRM */
d60d9f65	313
d60d9f65	314	#if defined (SIGTSTP)
c862e87b	315	rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp);
d60d9f65 SS	316	#endif /* SIGTSTP */
	317
	318	#if defined (SIGTTOU)
c862e87b	319	rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou);
d60d9f65 SS	320	#endif /* SIGTTOU */
d60d9f65 SS	321
c862e87b JM	322	#if defined (SIGTTIN)
	323	rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin);
	324	#endif /* SIGTTIN */
d60d9f65	325
c862e87b JM	326	signals_set_flag = 1;
c862e87b JM	327	}
d60d9f65 SS	328
d60d9f65 SS	329	#if defined (SIGWINCH)
c862e87b JM	330	if (rl_catch_sigwinch && sigwinch_set_flag == 0)
	331	{
	332	rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch);
	333	sigwinch_set_flag = 1;
	334	}
d60d9f65 SS	335	#endif /* SIGWINCH */
	336
	337	return 0;
	338	}
	339
	340	int
	341	rl_clear_signals ()
	342	{
	343	sighandler_cxt dummy;
	344
c862e87b JM	345	if (rl_catch_signals && signals_set_flag == 1)
	346	{
	347	sigemptyset (&dummy.sa_mask);
d60d9f65	348
c862e87b JM	349	rl_sigaction (SIGINT, &old_int, &dummy);
c862e87b JM	350	rl_sigaction (SIGTERM, &old_term, &dummy);
5bdf8622	351	#if defined (SIGQUIT)
c862e87b	352	rl_sigaction (SIGQUIT, &old_quit, &dummy);
430b7832	353	#endif
5bdf8622	354	#if defined (SIGALRM)
c862e87b	355	rl_sigaction (SIGALRM, &old_alrm, &dummy);
430b7832	356	#endif
d60d9f65 SS	357
d60d9f65 SS	358	#if defined (SIGTSTP)
c862e87b JM	359	rl_sigaction (SIGTSTP, &old_tstp, &dummy);
c862e87b JM	360	#endif /* SIGTSTP */
d60d9f65 SS	361
d60d9f65 SS	362	#if defined (SIGTTOU)
c862e87b	363	rl_sigaction (SIGTTOU, &old_ttou, &dummy);
d60d9f65 SS	364	#endif /* SIGTTOU */
d60d9f65 SS	365
c862e87b JM	366	#if defined (SIGTTIN)
	367	rl_sigaction (SIGTTIN, &old_ttin, &dummy);
	368	#endif /* SIGTTIN */
d60d9f65	369
c862e87b JM	370	signals_set_flag = 0;
c862e87b JM	371	}
d60d9f65 SS	372
d60d9f65 SS	373	#if defined (SIGWINCH)
c862e87b JM	374	if (rl_catch_sigwinch && sigwinch_set_flag == 1)
	375	{
	376	sigemptyset (&dummy.sa_mask);
	377	rl_sigaction (SIGWINCH, &old_winch, &dummy);
	378	sigwinch_set_flag = 0;
	379	}
d60d9f65 SS	380	#endif
	381
	382	return 0;
	383	}
c862e87b JM	384
	385	/* Clean up the terminal and readline state after catching a signal, before
	386	resending it to the calling application. */
	387	void
	388	rl_cleanup_after_signal ()
	389	{
	390	_rl_clean_up_for_exit ();
5bdf8622 DJ	391	if (rl_deprep_term_function)
5bdf8622 DJ	392	(*rl_deprep_term_function) ();
c862e87b	393	rl_clear_signals ();
9255ee31	394	rl_clear_pending_input ();
c862e87b JM	395	}
	396
	397	/* Reset the terminal and readline state after a signal handler returns. */
	398	void
	399	rl_reset_after_signal ()
	400	{
5bdf8622 DJ	401	if (rl_prep_term_function)
5bdf8622 DJ	402	(*rl_prep_term_function) (_rl_meta_flag);
c862e87b JM	403	rl_set_signals ();
	404	}
	405
	406	/* Free up the readline variable line state for the current line (undo list,
	407	any partial history entry, any keyboard macros in progress, and any
	408	numeric arguments in process) after catching a signal, before calling
	409	rl_cleanup_after_signal(). */
	410	void
	411	rl_free_line_state ()
	412	{
	413	register HIST_ENTRY *entry;
	414
9255ee31	415	rl_free_undo_list ();
c862e87b JM	416
	417	entry = current_history ();
	418	if (entry)
	419	entry->data = (char *)NULL;
	420
	421	_rl_kill_kbd_macro ();
	422	rl_clear_message ();
5bdf8622	423	_rl_reset_argument ();
c862e87b JM	424	}
c862e87b JM	425
d60d9f65	426	#endif /* HANDLE_SIGNALS */