[thirdparty/bash.git] / lib / readline / signals.c

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

/* Copyright (C) 1987, 1989, 1992 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 equivalant 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 */

static SigHandler *rl_set_sighandler __P((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;
#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 */

#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 (sig == SIGINT || sig == SIGALRM)
    rl_set_sighandler (sig, SIG_IGN, &dummy_cxt);
#endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */

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

#if defined (SIGTSTP)
    case SIGTSTP:
    case SIGTTOU:
    case SIGTTIN:
#endif /* SIGTSTP */
    case SIGALRM:
    case SIGTERM:
    case SIGQUIT:
      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

      kill (getpid (), sig);

      /* 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 ();
    }

  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_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);

  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 = 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);
      rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);

      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 */

#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);
      rl_sigaction (SIGQUIT, &old_quit, &dummy);
      rl_sigaction (SIGALRM, &old_alrm, &dummy);

#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 ();
  (*rl_deprep_term_function) ();
  rl_clear_signals ();
  rl_pending_input = 0;
}

/* Reset the terminal and readline state after a signal handler returns. */
void
rl_reset_after_signal ()
{
  (*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;

  free_undo_list ();

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

  _rl_kill_kbd_macro ();
  rl_clear_message ();
  _rl_init_argument ();
}

#endif  /* HANDLE_SIGNALS */
Commit	Line	Data
726f6388 JA	1	/* signals.c -- signal handling support for readline. */
	2
	3	/* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.
	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
bb70624e	10	as published by the Free Software Foundation; either version 2, or
726f6388 JA	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,
bb70624e	21	59 Temple Place, Suite 330, Boston, MA 02111 USA. */
726f6388 JA	22	#define READLINE_LIBRARY
726f6388 JA	23
ccc6cda3 JA	24	#if defined (HAVE_CONFIG_H)
	25	# include <config.h>
	26	#endif
	27
	28	#include <stdio.h> /* Just for NULL. Yuck. */
726f6388	29	#include <sys/types.h>
726f6388 JA	30	#include <signal.h>
	31
	32	#if defined (HAVE_UNISTD_H)
	33	# include <unistd.h>
	34	#endif /* HAVE_UNISTD_H */
	35
726f6388 JA	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
ccc6cda3	43	#if defined (HANDLE_SIGNALS)
726f6388 JA	44	/* Some standard library routines. */
	45	#include "readline.h"
	46	#include "history.h"
	47
bb70624e JA	48	#include "rlprivate.h"
bb70624e JA	49
ccc6cda3 JA	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 */
726f6388 JA	57
726f6388 JA	58	#if defined (VOID_SIGHANDLER)
ccc6cda3	59	# define SIGHANDLER_RETURN return
726f6388	60	#else
ccc6cda3 JA	61	# define SIGHANDLER_RETURN return (0)
ccc6cda3 JA	62	#endif
726f6388 JA	63
	64	/* This typedef is equivalant to the one for Function; it allows us
	65	to say SigHandler foo = signal (SIGKILL, SIG_IGN); /
ccc6cda3	66	typedef RETSIGTYPE SigHandler ();
726f6388	67
bb70624e JA	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 */
b72432fd	75
bb70624e	76	static SigHandler rl_set_sighandler __P((int, SigHandler , sighandler_cxt *));
726f6388	77
b72432fd JA	78	/* Exported variables for use by applications. */
	79
	80	/* If non-zero, readline will install its own signal handlers for
	81	SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
	82	int rl_catch_signals = 1;
	83
	84	/* If non-zero, readline will install a signal handler for SIGWINCH. */
	85	#ifdef SIGWINCH
	86	int rl_catch_sigwinch = 1;
	87	#endif
	88
	89	static int signals_set_flag;
	90	static int sigwinch_set_flag;
	91
726f6388 JA	92	/* **************************************************************** */
	93	/* */
	94	/* Signal Handling */
	95	/* */
	96	/* **************************************************************** */
	97
b72432fd JA	98	static sighandler_cxt old_int, old_term, old_alrm, old_quit;
b72432fd JA	99	#if defined (SIGTSTP)
d166f048	100	static sighandler_cxt old_tstp, old_ttou, old_ttin;
d166f048	101	#endif
ccc6cda3 JA	102	#if defined (SIGWINCH)
	103	static sighandler_cxt old_winch;
	104	#endif
	105
	106	/* Readline signal handler functions. */
	107
	108	static RETSIGTYPE
726f6388 JA	109	rl_signal_handler (sig)
	110	int sig;
	111	{
	112	#if defined (HAVE_POSIX_SIGNALS)
	113	sigset_t set;
	114	#else /* !HAVE_POSIX_SIGNALS */
	115	# if defined (HAVE_BSD_SIGNALS)
	116	long omask;
d166f048 JA	117	# else /* !HAVE_BSD_SIGNALS */
	118	sighandler_cxt dummy_cxt; /* needed for rl_set_sighandler call */
	119	# endif /* !HAVE_BSD_SIGNALS */
726f6388 JA	120	#endif /* !HAVE_POSIX_SIGNALS */
	121
	122	#if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS)
	123	/* Since the signal will not be blocked while we are in the signal
	124	handler, ignore it until rl_clear_signals resets the catcher. */
ccc6cda3	125	if (sig == SIGINT \|\| sig == SIGALRM)
d166f048	126	rl_set_sighandler (sig, SIG_IGN, &dummy_cxt);
ccc6cda3	127	#endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */
726f6388 JA	128
	129	switch (sig)
	130	{
	131	case SIGINT:
b72432fd JA	132	rl_free_line_state ();
b72432fd JA	133	/* FALLTHROUGH */
726f6388 JA	134
	135	#if defined (SIGTSTP)
	136	case SIGTSTP:
	137	case SIGTTOU:
	138	case SIGTTIN:
	139	#endif /* SIGTSTP */
	140	case SIGALRM:
ccc6cda3	141	case SIGTERM:
b72432fd JA	142	case SIGQUIT:
b72432fd JA	143	rl_cleanup_after_signal ();
726f6388 JA	144
	145	#if defined (HAVE_POSIX_SIGNALS)
	146	sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set);
	147	sigdelset (&set, sig);
	148	#else /* !HAVE_POSIX_SIGNALS */
	149	# if defined (HAVE_BSD_SIGNALS)
	150	omask = sigblock (0);
	151	# endif /* HAVE_BSD_SIGNALS */
	152	#endif /* !HAVE_POSIX_SIGNALS */
	153
bb70624e JA	154	#if defined (__EMX__)
	155	signal (sig, SIG_ACK);
	156	#endif
	157
726f6388 JA	158	kill (getpid (), sig);
	159
	160	/* Let the signal that we just sent through. */
	161	#if defined (HAVE_POSIX_SIGNALS)
	162	sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL);
	163	#else /* !HAVE_POSIX_SIGNALS */
	164	# if defined (HAVE_BSD_SIGNALS)
	165	sigsetmask (omask & ~(sigmask (sig)));
	166	# endif /* HAVE_BSD_SIGNALS */
	167	#endif /* !HAVE_POSIX_SIGNALS */
	168
b72432fd	169	rl_reset_after_signal ();
726f6388 JA	170	}
726f6388 JA	171
ccc6cda3	172	SIGHANDLER_RETURN;
726f6388 JA	173	}
726f6388 JA	174
ccc6cda3 JA	175	#if defined (SIGWINCH)
ccc6cda3 JA	176	static RETSIGTYPE
b72432fd	177	rl_sigwinch_handler (sig)
ccc6cda3 JA	178	int sig;
	179	{
	180	SigHandler *oh;
	181
d166f048 JA	182	#if defined (MUST_REINSTALL_SIGHANDLERS)
	183	sighandler_cxt dummy_winch;
	184
	185	/* We don't want to change old_winch -- it holds the state of SIGWINCH
	186	disposition set by the calling application. We need this state
	187	because we call the application's SIGWINCH handler after updating
	188	our own idea of the screen size. */
b72432fd	189	rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch);
d166f048 JA	190	#endif
d166f048 JA	191
b72432fd	192	rl_resize_terminal ();
ccc6cda3 JA	193
	194	/* If another sigwinch handler has been installed, call it. */
	195	oh = (SigHandler *)old_winch.sa_handler;
	196	if (oh && oh != (SigHandler )SIG_IGN && oh != (SigHandler )SIG_DFL)
	197	(*oh) (sig);
	198
	199	SIGHANDLER_RETURN;
	200	}
	201	#endif /* SIGWINCH */
	202
	203	/* Functions to manage signal handling. */
	204
	205	#if !defined (HAVE_POSIX_SIGNALS)
	206	static int
	207	rl_sigaction (sig, nh, oh)
	208	int sig;
	209	sighandler_cxt nh, oh;
	210	{
	211	oh->sa_handler = signal (sig, nh->sa_handler);
	212	return 0;
	213	}
	214	#endif /* !HAVE_POSIX_SIGNALS */
	215
	216	/* Set up a readline-specific signal handler, saving the old signal
	217	information in OHANDLER. Return the old signal handler, like
	218	signal(). */
726f6388	219	static SigHandler *
ccc6cda3	220	rl_set_sighandler (sig, handler, ohandler)
726f6388 JA	221	int sig;
726f6388 JA	222	SigHandler *handler;
ccc6cda3	223	sighandler_cxt *ohandler;
726f6388	224	{
bb70624e	225	sighandler_cxt old_handler;
ccc6cda3 JA	226	#if defined (HAVE_POSIX_SIGNALS)
ccc6cda3 JA	227	struct sigaction act;
726f6388 JA	228
	229	act.sa_handler = handler;
	230	act.sa_flags = 0;
	231	sigemptyset (&act.sa_mask);
ccc6cda3	232	sigemptyset (&ohandler->sa_mask);
bb70624e	233	sigaction (sig, &act, &old_handler);
ccc6cda3	234	#else
bb70624e	235	old_handler.sa_handler = (SigHandler *)signal (sig, handler);
726f6388	236	#endif /* !HAVE_POSIX_SIGNALS */
bb70624e JA	237
	238	/* XXX -- assume we have memcpy */
	239	/* If rl_set_signals is called twice in a row, don't set the old handler to
	240	rl_signal_handler, because that would cause infinite recursion. */
	241	if (handler != rl_signal_handler \|\| old_handler.sa_handler != rl_signal_handler)
	242	memcpy (ohandler, &old_handler, sizeof (sighandler_cxt));
	243
ccc6cda3 JA	244	return (ohandler->sa_handler);
ccc6cda3 JA	245	}
726f6388	246
b72432fd JA	247	static void
	248	rl_maybe_set_sighandler (sig, handler, ohandler)
	249	int sig;
	250	SigHandler *handler;
	251	sighandler_cxt *ohandler;
726f6388	252	{
ccc6cda3 JA	253	sighandler_cxt dummy;
	254	SigHandler *oh;
	255
ccc6cda3	256	sigemptyset (&dummy.sa_mask);
b72432fd	257	oh = rl_set_sighandler (sig, handler, ohandler);
ccc6cda3	258	if (oh == (SigHandler *)SIG_IGN)
b72432fd JA	259	rl_sigaction (sig, ohandler, &dummy);
b72432fd JA	260	}
ccc6cda3	261
b72432fd JA	262	int
	263	rl_set_signals ()
	264	{
	265	sighandler_cxt dummy;
	266	SigHandler *oh;
	267
	268	if (rl_catch_signals && signals_set_flag == 0)
	269	{
	270	rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int);
	271	rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term);
	272	rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);
	273
	274	oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm);
	275	if (oh == (SigHandler *)SIG_IGN)
	276	rl_sigaction (SIGALRM, &old_alrm, &dummy);
ccc6cda3	277	#if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART)
b72432fd JA	278	/* If the application using readline has already installed a signal
	279	handler with SA_RESTART, SIGALRM will cause reads to be restarted
	280	automatically, so readline should just get out of the way. Since
	281	we tested for SIG_IGN above, we can just test for SIG_DFL here. */
	282	if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART))
	283	rl_sigaction (SIGALRM, &old_alrm, &dummy);
ccc6cda3	284	#endif /* HAVE_POSIX_SIGNALS */
726f6388	285
726f6388	286	#if defined (SIGTSTP)
b72432fd	287	rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp);
726f6388	288	#endif /* SIGTSTP */
ccc6cda3	289
726f6388	290	#if defined (SIGTTOU)
b72432fd	291	rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou);
726f6388 JA	292	#endif /* SIGTTOU */
726f6388 JA	293
b72432fd JA	294	#if defined (SIGTTIN)
	295	rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin);
	296	#endif /* SIGTTIN */
d166f048	297
b72432fd JA	298	signals_set_flag = 1;
b72432fd JA	299	}
726f6388 JA	300
726f6388 JA	301	#if defined (SIGWINCH)
b72432fd JA	302	if (rl_catch_sigwinch && sigwinch_set_flag == 0)
	303	{
	304	rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch);
	305	sigwinch_set_flag = 1;
	306	}
726f6388	307	#endif /* SIGWINCH */
ccc6cda3	308
726f6388 JA	309	return 0;
	310	}
	311
ccc6cda3	312	int
726f6388 JA	313	rl_clear_signals ()
726f6388 JA	314	{
ccc6cda3 JA	315	sighandler_cxt dummy;
ccc6cda3 JA	316
b72432fd JA	317	if (rl_catch_signals && signals_set_flag == 1)
	318	{
	319	sigemptyset (&dummy.sa_mask);
726f6388	320
b72432fd JA	321	rl_sigaction (SIGINT, &old_int, &dummy);
	322	rl_sigaction (SIGTERM, &old_term, &dummy);
	323	rl_sigaction (SIGQUIT, &old_quit, &dummy);
	324	rl_sigaction (SIGALRM, &old_alrm, &dummy);
726f6388 JA	325
726f6388 JA	326	#if defined (SIGTSTP)
b72432fd JA	327	rl_sigaction (SIGTSTP, &old_tstp, &dummy);
b72432fd JA	328	#endif /* SIGTSTP */
726f6388 JA	329
726f6388 JA	330	#if defined (SIGTTOU)
b72432fd	331	rl_sigaction (SIGTTOU, &old_ttou, &dummy);
726f6388 JA	332	#endif /* SIGTTOU */
726f6388 JA	333
b72432fd JA	334	#if defined (SIGTTIN)
	335	rl_sigaction (SIGTTIN, &old_ttin, &dummy);
	336	#endif /* SIGTTIN */
ccc6cda3	337
b72432fd JA	338	signals_set_flag = 0;
b72432fd JA	339	}
726f6388 JA	340
726f6388 JA	341	#if defined (SIGWINCH)
b72432fd JA	342	if (rl_catch_sigwinch && sigwinch_set_flag == 1)
	343	{
	344	sigemptyset (&dummy.sa_mask);
	345	rl_sigaction (SIGWINCH, &old_winch, &dummy);
	346	sigwinch_set_flag = 0;
	347	}
726f6388 JA	348	#endif
	349
	350	return 0;
	351	}
b72432fd JA	352
	353	/* Clean up the terminal and readline state after catching a signal, before
	354	resending it to the calling application. */
	355	void
	356	rl_cleanup_after_signal ()
	357	{
	358	_rl_clean_up_for_exit ();
	359	(*rl_deprep_term_function) ();
	360	rl_clear_signals ();
	361	rl_pending_input = 0;
	362	}
	363
	364	/* Reset the terminal and readline state after a signal handler returns. */
	365	void
	366	rl_reset_after_signal ()
	367	{
	368	(*rl_prep_term_function) (_rl_meta_flag);
	369	rl_set_signals ();
	370	}
	371
	372	/* Free up the readline variable line state for the current line (undo list,
	373	any partial history entry, any keyboard macros in progress, and any
	374	numeric arguments in process) after catching a signal, before calling
	375	rl_cleanup_after_signal(). */
	376	void
	377	rl_free_line_state ()
	378	{
	379	register HIST_ENTRY *entry;
	380
	381	free_undo_list ();
	382
	383	entry = current_history ();
	384	if (entry)
	385	entry->data = (char *)NULL;
	386
	387	_rl_kill_kbd_macro ();
	388	rl_clear_message ();
	389	_rl_init_argument ();
	390	}
	391
726f6388	392	#endif /* HANDLE_SIGNALS */