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

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

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

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

   Readline 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 3 of the License, or
   (at your option) any later version.

   Readline 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.

   You should have received a copy of the GNU General Public License
   along with Readline.  If not, see <http://www.gnu.org/licenses/>.
*/

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

/* Some standard library routines. */
#include "readline.h"
#include "history.h"

#include "rlprivate.h"

#if defined (HANDLE_SIGNALS)

#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 *));

static RETSIGTYPE rl_signal_handler PARAMS((int));
static RETSIGTYPE _rl_handle_signal PARAMS((int));
     
/* 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

/* Private variables. */
int _rl_interrupt_immediately = 0;
int volatile _rl_caught_signal = 0;	/* should be sig_atomic_t, but that requires including <signal.h> everywhere */

/* If non-zero, print characters corresponding to received signals as long as
   the user has indicated his desire to do so (_rl_echo_control_chars). */
int _rl_echoctl = 0;

int _rl_intr_char = 0;
int _rl_quit_char = 0;
int _rl_susp_char = 0;

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

/* Called from RL_CHECK_SIGNALS() macro */
RETSIGTYPE
_rl_signal_handler (sig)
{
  _rl_caught_signal = 0;	/* XXX */

  _rl_handle_signal (sig);
  SIGHANDLER_RETURN;
}

static RETSIGTYPE
rl_signal_handler (sig)
     int sig;
{
  if (_rl_interrupt_immediately || RL_ISSTATE(RL_STATE_CALLBACK))
    {
      _rl_interrupt_immediately = 0;
      _rl_handle_signal (sig);
    }
  else
    _rl_caught_signal = sig;

  SIGHANDLER_RETURN;
}

static RETSIGTYPE
_rl_handle_signal (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_reset_completion_state ();
      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_echo_signal_char (sig);
      rl_cleanup_after_signal ();

#if defined (HAVE_POSIX_SIGNALS)
      sigemptyset (&set);
      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;
#  if defined (SIGWINCH)
  act.sa_flags = (sig == SIGWINCH) ? SA_RESTART : 0;
#  else
  act.sa_flags = 0;
#  endif /* SIGWINCH */
  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 defined (HAVE_POSIX_SIGNALS)
  static int sigmask_set = 0;
  static sigset_t bset, oset;
#endif

#if defined (HAVE_POSIX_SIGNALS)
  if (rl_catch_signals && sigmask_set == 0)
    {
      sigemptyset (&bset);

      sigaddset (&bset, SIGINT);
      sigaddset (&bset, SIGTERM);
#if defined (SIGQUIT)
      sigaddset (&bset, SIGQUIT);
#endif
#if defined (SIGALRM)
      sigaddset (&bset, SIGALRM);
#endif
#if defined (SIGTSTP)
      sigaddset (&bset, SIGTSTP);
#endif
#if defined (SIGTTIN)
      sigaddset (&bset, SIGTTIN);
#endif
#if defined (SIGTTOU)
      sigaddset (&bset, SIGTTOU);
#endif
      sigmask_set = 1;
    }      
#endif /* HAVE_POSIX_SIGNALS */

  if (rl_catch_signals && signals_set_flag == 0)
    {
#if defined (HAVE_POSIX_SIGNALS)
      sigemptyset (&oset);
      sigprocmask (SIG_BLOCK, &bset, &oset);
#endif

      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 (HAVE_POSIX_SIGNALS)
      sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
#endif
    }

#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_pending_input ();
  rl_clear_signals ();
}

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

/* **************************************************************** */
/*								    */
/*			   SIGINT Management			    */
/*								    */
/* **************************************************************** */

#if defined (HAVE_POSIX_SIGNALS)
static sigset_t sigint_set, sigint_oset;
static sigset_t sigwinch_set, sigwinch_oset;
#else /* !HAVE_POSIX_SIGNALS */
#  if defined (HAVE_BSD_SIGNALS)
static int sigint_oldmask;
static int sigwinch_oldmask;
#  endif /* HAVE_BSD_SIGNALS */
#endif /* !HAVE_POSIX_SIGNALS */

static int sigint_blocked;
static int sigwinch_blocked;

/* Cause SIGINT to not be delivered until the corresponding call to
   release_sigint(). */
void
_rl_block_sigint ()
{
  if (sigint_blocked)
    return;

#if defined (HAVE_POSIX_SIGNALS)
  sigemptyset (&sigint_set);
  sigemptyset (&sigint_oset);
  sigaddset (&sigint_set, SIGINT);
  sigprocmask (SIG_BLOCK, &sigint_set, &sigint_oset);
#else /* !HAVE_POSIX_SIGNALS */
#  if defined (HAVE_BSD_SIGNALS)
  sigint_oldmask = sigblock (sigmask (SIGINT));
#  else /* !HAVE_BSD_SIGNALS */
#    if defined (HAVE_USG_SIGHOLD)
  sighold (SIGINT);
#    endif /* HAVE_USG_SIGHOLD */
#  endif /* !HAVE_BSD_SIGNALS */
#endif /* !HAVE_POSIX_SIGNALS */

  sigint_blocked = 1;
}

/* Allow SIGINT to be delivered. */
void
_rl_release_sigint ()
{
  if (sigint_blocked == 0)
    return;

#if defined (HAVE_POSIX_SIGNALS)
  sigprocmask (SIG_SETMASK, &sigint_oset, (sigset_t *)NULL);
#else
#  if defined (HAVE_BSD_SIGNALS)
  sigsetmask (sigint_oldmask);
#  else /* !HAVE_BSD_SIGNALS */
#    if defined (HAVE_USG_SIGHOLD)
  sigrelse (SIGINT);
#    endif /* HAVE_USG_SIGHOLD */
#  endif /* !HAVE_BSD_SIGNALS */
#endif /* !HAVE_POSIX_SIGNALS */

  sigint_blocked = 0;
}

/* Cause SIGWINCH to not be delivered until the corresponding call to
   release_sigwinch(). */
void
_rl_block_sigwinch ()
{
  if (sigwinch_blocked)
    return;

#if defined (HAVE_POSIX_SIGNALS)
  sigemptyset (&sigwinch_set);
  sigemptyset (&sigwinch_oset);
  sigaddset (&sigwinch_set, SIGWINCH);
  sigprocmask (SIG_BLOCK, &sigwinch_set, &sigwinch_oset);
#else /* !HAVE_POSIX_SIGNALS */
#  if defined (HAVE_BSD_SIGNALS)
  sigwinch_oldmask = sigblock (sigmask (SIGWINCH));
#  else /* !HAVE_BSD_SIGNALS */
#    if defined (HAVE_USG_SIGHOLD)
  sighold (SIGWINCH);
#    endif /* HAVE_USG_SIGHOLD */
#  endif /* !HAVE_BSD_SIGNALS */
#endif /* !HAVE_POSIX_SIGNALS */

  sigwinch_blocked = 1;
}

/* Allow SIGWINCH to be delivered. */
void
_rl_release_sigwinch ()
{
  if (sigwinch_blocked == 0)
    return;

#if defined (HAVE_POSIX_SIGNALS)
  sigprocmask (SIG_SETMASK, &sigwinch_oset, (sigset_t *)NULL);
#else
#  if defined (HAVE_BSD_SIGNALS)
  sigsetmask (sigwinch_oldmask);
#  else /* !HAVE_BSD_SIGNALS */
#    if defined (HAVE_USG_SIGHOLD)
  sigrelse (SIGWINCH);
#    endif /* HAVE_USG_SIGHOLD */
#  endif /* !HAVE_BSD_SIGNALS */
#endif /* !HAVE_POSIX_SIGNALS */

  sigwinch_blocked = 0;
}

/* **************************************************************** */
/*								    */
/*		Echoing special control characters		    */
/*								    */
/* **************************************************************** */
void
rl_echo_signal_char (sig)
     int sig;
{
  char cstr[3];
  int cslen, c;

  if (_rl_echoctl == 0 || _rl_echo_control_chars == 0)
    return;

  switch (sig)
    {
    case SIGINT:  c = _rl_intr_char; break;
#if defined (SIGQUIT)
    case SIGQUIT: c = _rl_quit_char; break;
#endif
#if defined (SIGTSTP)
    case SIGTSTP: c = _rl_susp_char; break;
#endif
    default: return;
    }

  if (CTRL_CHAR (c) || c == RUBOUT)
    {
      cstr[0] = '^';
      cstr[1] = CTRL_CHAR (c) ? UNCTRL (c) : '?';
      cstr[cslen = 2] = '\0';
    }
  else
    {
      cstr[0] = c;
      cstr[cslen = 1] = '\0';
    }

  _rl_output_some_chars (cstr, cslen);
}
Commit	Line	Data
726f6388 JA	1	/* signals.c -- signal handling support for readline. */
726f6388 JA	2
3185942a	3	/* Copyright (C) 1987-2009 Free Software Foundation, Inc.
726f6388	4
3185942a JA	5	This file is part of the GNU Readline Library (Readline), a library
3185942a JA	6	for reading lines of text with interactive input and history editing.
726f6388	7
3185942a JA	8	Readline is free software: you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation, either version 3 of the License, or
726f6388 JA	11	(at your option) any later version.
726f6388 JA	12
3185942a JA	13	Readline is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
726f6388 JA	16	GNU General Public License for more details.
726f6388 JA	17
3185942a JA	18	You should have received a copy of the GNU General Public License
	19	along with Readline. If not, see <http://www.gnu.org/licenses/>.
	20	*/
	21
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
	43	/* Some standard library routines. */
	44	#include "readline.h"
	45	#include "history.h"
	46
bb70624e JA	47	#include "rlprivate.h"
bb70624e JA	48
3185942a JA	49	#if defined (HANDLE_SIGNALS)
3185942a JA	50
ccc6cda3 JA	51	#if !defined (RETSIGTYPE)
	52	# if defined (VOID_SIGHANDLER)
	53	# define RETSIGTYPE void
	54	# else
	55	# define RETSIGTYPE int
	56	# endif /* !VOID_SIGHANDLER */
	57	#endif /* !RETSIGTYPE */
726f6388 JA	58
726f6388 JA	59	#if defined (VOID_SIGHANDLER)
ccc6cda3	60	# define SIGHANDLER_RETURN return
726f6388	61	#else
ccc6cda3 JA	62	# define SIGHANDLER_RETURN return (0)
ccc6cda3 JA	63	#endif
726f6388	64
28ef6c31	65	/* This typedef is equivalent to the one for Function; it allows us
726f6388	66	to say SigHandler foo = signal (SIGKILL, SIG_IGN); /
ccc6cda3	67	typedef RETSIGTYPE SigHandler ();
726f6388	68
bb70624e JA	69	#if defined (HAVE_POSIX_SIGNALS)
	70	typedef struct sigaction sighandler_cxt;
	71	# define rl_sigaction(s, nh, oh) sigaction(s, nh, oh)
	72	#else
	73	typedef struct { SigHandler *sa_handler; int sa_mask, sa_flags; } sighandler_cxt;
	74	# define sigemptyset(m)
	75	#endif /* !HAVE_POSIX_SIGNALS */
b72432fd	76
b80f6443 JA	77	#ifndef SA_RESTART
	78	# define SA_RESTART 0
	79	#endif
	80
f73dda09	81	static SigHandler rl_set_sighandler PARAMS((int, SigHandler , sighandler_cxt *));
7117c2d2	82	static void rl_maybe_set_sighandler PARAMS((int, SigHandler , sighandler_cxt ));
726f6388	83
17345e5a JA	84	static RETSIGTYPE rl_signal_handler PARAMS((int));
	85	static RETSIGTYPE _rl_handle_signal PARAMS((int));
	86
b72432fd JA	87	/* Exported variables for use by applications. */
	88
	89	/* If non-zero, readline will install its own signal handlers for
	90	SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
	91	int rl_catch_signals = 1;
	92
	93	/* If non-zero, readline will install a signal handler for SIGWINCH. */
	94	#ifdef SIGWINCH
	95	int rl_catch_sigwinch = 1;
b80f6443 JA	96	#else
b80f6443 JA	97	int rl_catch_sigwinch = 0; /* for the readline state struct in readline.c */
b72432fd JA	98	#endif
b72432fd JA	99
3185942a	100	/* Private variables. */
17345e5a JA	101	int _rl_interrupt_immediately = 0;
	102	int volatile _rl_caught_signal = 0; /* should be sig_atomic_t, but that requires including <signal.h> everywhere */
	103
0001803f CR	104	/* If non-zero, print characters corresponding to received signals as long as
0001803f CR	105	the user has indicated his desire to do so (_rl_echo_control_chars). */
3185942a JA	106	int _rl_echoctl = 0;
	107
	108	int _rl_intr_char = 0;
	109	int _rl_quit_char = 0;
	110	int _rl_susp_char = 0;
	111
b72432fd JA	112	static int signals_set_flag;
	113	static int sigwinch_set_flag;
	114
726f6388 JA	115	/* **************************************************************** */
	116	/* */
	117	/* Signal Handling */
	118	/* */
	119	/* **************************************************************** */
	120
b72432fd JA	121	static sighandler_cxt old_int, old_term, old_alrm, old_quit;
b72432fd JA	122	#if defined (SIGTSTP)
d166f048	123	static sighandler_cxt old_tstp, old_ttou, old_ttin;
d166f048	124	#endif
ccc6cda3 JA	125	#if defined (SIGWINCH)
	126	static sighandler_cxt old_winch;
	127	#endif
	128
	129	/* Readline signal handler functions. */
	130
17345e5a JA	131	/* Called from RL_CHECK_SIGNALS() macro */
	132	RETSIGTYPE
	133	_rl_signal_handler (sig)
	134	{
	135	_rl_caught_signal = 0; /* XXX */
	136
	137	_rl_handle_signal (sig);
	138	SIGHANDLER_RETURN;
	139	}
	140
ccc6cda3	141	static RETSIGTYPE
726f6388 JA	142	rl_signal_handler (sig)
726f6388 JA	143	int sig;
17345e5a	144	{
0001803f	145	if (_rl_interrupt_immediately \|\| RL_ISSTATE(RL_STATE_CALLBACK))
17345e5a JA	146	{
	147	_rl_interrupt_immediately = 0;
	148	_rl_handle_signal (sig);
	149	}
0001803f CR	150	else
0001803f CR	151	_rl_caught_signal = sig;
17345e5a	152
17345e5a JA	153	SIGHANDLER_RETURN;
	154	}
	155
	156	static RETSIGTYPE
	157	_rl_handle_signal (sig)
	158	int sig;
726f6388 JA	159	{
	160	#if defined (HAVE_POSIX_SIGNALS)
	161	sigset_t set;
	162	#else /* !HAVE_POSIX_SIGNALS */
	163	# if defined (HAVE_BSD_SIGNALS)
	164	long omask;
d166f048 JA	165	# else /* !HAVE_BSD_SIGNALS */
	166	sighandler_cxt dummy_cxt; /* needed for rl_set_sighandler call */
	167	# endif /* !HAVE_BSD_SIGNALS */
726f6388 JA	168	#endif /* !HAVE_POSIX_SIGNALS */
726f6388 JA	169
28ef6c31 JA	170	RL_SETSTATE(RL_STATE_SIGHANDLER);
28ef6c31 JA	171
726f6388 JA	172	#if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS)
	173	/* Since the signal will not be blocked while we are in the signal
	174	handler, ignore it until rl_clear_signals resets the catcher. */
95732b49	175	# if defined (SIGALRM)
ccc6cda3	176	if (sig == SIGINT \|\| sig == SIGALRM)
95732b49 JA	177	# else
	178	if (sig == SIGINT)
	179	# endif
d166f048	180	rl_set_sighandler (sig, SIG_IGN, &dummy_cxt);
ccc6cda3	181	#endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */
726f6388 JA	182
	183	switch (sig)
	184	{
	185	case SIGINT:
3185942a	186	_rl_reset_completion_state ();
b72432fd JA	187	rl_free_line_state ();
b72432fd JA	188	/* FALLTHROUGH */
726f6388	189
95732b49	190	case SIGTERM:
726f6388 JA	191	#if defined (SIGTSTP)
	192	case SIGTSTP:
	193	case SIGTTOU:
	194	case SIGTTIN:
	195	#endif /* SIGTSTP */
95732b49	196	#if defined (SIGALRM)
726f6388	197	case SIGALRM:
95732b49 JA	198	#endif
95732b49 JA	199	#if defined (SIGQUIT)
b72432fd	200	case SIGQUIT:
95732b49	201	#endif
3185942a	202	rl_echo_signal_char (sig);
b72432fd	203	rl_cleanup_after_signal ();
726f6388 JA	204
726f6388 JA	205	#if defined (HAVE_POSIX_SIGNALS)
0628567a	206	sigemptyset (&set);
726f6388 JA	207	sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set);
	208	sigdelset (&set, sig);
	209	#else /* !HAVE_POSIX_SIGNALS */
	210	# if defined (HAVE_BSD_SIGNALS)
	211	omask = sigblock (0);
	212	# endif /* HAVE_BSD_SIGNALS */
	213	#endif /* !HAVE_POSIX_SIGNALS */
	214
bb70624e JA	215	#if defined (__EMX__)
	216	signal (sig, SIG_ACK);
	217	#endif
	218
95732b49	219	#if defined (HAVE_KILL)
726f6388	220	kill (getpid (), sig);
95732b49 JA	221	#else
	222	raise (sig); /* assume we have raise */
	223	#endif
726f6388 JA	224
	225	/* Let the signal that we just sent through. */
	226	#if defined (HAVE_POSIX_SIGNALS)
	227	sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL);
	228	#else /* !HAVE_POSIX_SIGNALS */
	229	# if defined (HAVE_BSD_SIGNALS)
	230	sigsetmask (omask & ~(sigmask (sig)));
	231	# endif /* HAVE_BSD_SIGNALS */
	232	#endif /* !HAVE_POSIX_SIGNALS */
	233
b72432fd	234	rl_reset_after_signal ();
726f6388 JA	235	}
726f6388 JA	236
28ef6c31	237	RL_UNSETSTATE(RL_STATE_SIGHANDLER);
ccc6cda3	238	SIGHANDLER_RETURN;
726f6388 JA	239	}
726f6388 JA	240
ccc6cda3 JA	241	#if defined (SIGWINCH)
ccc6cda3 JA	242	static RETSIGTYPE
b72432fd	243	rl_sigwinch_handler (sig)
ccc6cda3 JA	244	int sig;
	245	{
	246	SigHandler *oh;
	247
d166f048 JA	248	#if defined (MUST_REINSTALL_SIGHANDLERS)
	249	sighandler_cxt dummy_winch;
	250
	251	/* We don't want to change old_winch -- it holds the state of SIGWINCH
	252	disposition set by the calling application. We need this state
	253	because we call the application's SIGWINCH handler after updating
	254	our own idea of the screen size. */
b72432fd	255	rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch);
d166f048 JA	256	#endif
d166f048 JA	257
28ef6c31	258	RL_SETSTATE(RL_STATE_SIGHANDLER);
b72432fd	259	rl_resize_terminal ();
ccc6cda3 JA	260
	261	/* If another sigwinch handler has been installed, call it. */
	262	oh = (SigHandler *)old_winch.sa_handler;
	263	if (oh && oh != (SigHandler )SIG_IGN && oh != (SigHandler )SIG_DFL)
	264	(*oh) (sig);
	265
28ef6c31	266	RL_UNSETSTATE(RL_STATE_SIGHANDLER);
ccc6cda3 JA	267	SIGHANDLER_RETURN;
	268	}
	269	#endif /* SIGWINCH */
	270
	271	/* Functions to manage signal handling. */
	272
	273	#if !defined (HAVE_POSIX_SIGNALS)
	274	static int
	275	rl_sigaction (sig, nh, oh)
	276	int sig;
	277	sighandler_cxt nh, oh;
	278	{
	279	oh->sa_handler = signal (sig, nh->sa_handler);
	280	return 0;
	281	}
	282	#endif /* !HAVE_POSIX_SIGNALS */
	283
	284	/* Set up a readline-specific signal handler, saving the old signal
	285	information in OHANDLER. Return the old signal handler, like
	286	signal(). */
726f6388	287	static SigHandler *
ccc6cda3	288	rl_set_sighandler (sig, handler, ohandler)
726f6388 JA	289	int sig;
726f6388 JA	290	SigHandler *handler;
ccc6cda3	291	sighandler_cxt *ohandler;
726f6388	292	{
bb70624e	293	sighandler_cxt old_handler;
ccc6cda3 JA	294	#if defined (HAVE_POSIX_SIGNALS)
ccc6cda3 JA	295	struct sigaction act;
726f6388 JA	296
726f6388 JA	297	act.sa_handler = handler;
3185942a	298	# if defined (SIGWINCH)
b80f6443	299	act.sa_flags = (sig == SIGWINCH) ? SA_RESTART : 0;
3185942a JA	300	# else
	301	act.sa_flags = 0;
	302	# endif /* SIGWINCH */
726f6388	303	sigemptyset (&act.sa_mask);
ccc6cda3	304	sigemptyset (&ohandler->sa_mask);
bb70624e	305	sigaction (sig, &act, &old_handler);
ccc6cda3	306	#else
bb70624e	307	old_handler.sa_handler = (SigHandler *)signal (sig, handler);
726f6388	308	#endif /* !HAVE_POSIX_SIGNALS */
bb70624e JA	309
	310	/* XXX -- assume we have memcpy */
	311	/* If rl_set_signals is called twice in a row, don't set the old handler to
	312	rl_signal_handler, because that would cause infinite recursion. */
	313	if (handler != rl_signal_handler \|\| old_handler.sa_handler != rl_signal_handler)
	314	memcpy (ohandler, &old_handler, sizeof (sighandler_cxt));
	315
ccc6cda3 JA	316	return (ohandler->sa_handler);
ccc6cda3 JA	317	}
726f6388	318
b72432fd JA	319	static void
	320	rl_maybe_set_sighandler (sig, handler, ohandler)
	321	int sig;
	322	SigHandler *handler;
	323	sighandler_cxt *ohandler;
726f6388	324	{
ccc6cda3 JA	325	sighandler_cxt dummy;
	326	SigHandler *oh;
	327
ccc6cda3	328	sigemptyset (&dummy.sa_mask);
b72432fd	329	oh = rl_set_sighandler (sig, handler, ohandler);
ccc6cda3	330	if (oh == (SigHandler *)SIG_IGN)
b72432fd JA	331	rl_sigaction (sig, ohandler, &dummy);
b72432fd JA	332	}
ccc6cda3	333
b72432fd JA	334	int
	335	rl_set_signals ()
	336	{
	337	sighandler_cxt dummy;
	338	SigHandler *oh;
0628567a JA	339	#if defined (HAVE_POSIX_SIGNALS)
	340	static int sigmask_set = 0;
	341	static sigset_t bset, oset;
	342	#endif
	343
	344	#if defined (HAVE_POSIX_SIGNALS)
	345	if (rl_catch_signals && sigmask_set == 0)
	346	{
	347	sigemptyset (&bset);
	348
	349	sigaddset (&bset, SIGINT);
3185942a	350	sigaddset (&bset, SIGTERM);
0628567a JA	351	#if defined (SIGQUIT)
	352	sigaddset (&bset, SIGQUIT);
	353	#endif
	354	#if defined (SIGALRM)
	355	sigaddset (&bset, SIGALRM);
	356	#endif
	357	#if defined (SIGTSTP)
	358	sigaddset (&bset, SIGTSTP);
	359	#endif
	360	#if defined (SIGTTIN)
	361	sigaddset (&bset, SIGTTIN);
	362	#endif
	363	#if defined (SIGTTOU)
	364	sigaddset (&bset, SIGTTOU);
	365	#endif
	366	sigmask_set = 1;
	367	}
	368	#endif /* HAVE_POSIX_SIGNALS */
b72432fd JA	369
	370	if (rl_catch_signals && signals_set_flag == 0)
	371	{
0628567a JA	372	#if defined (HAVE_POSIX_SIGNALS)
	373	sigemptyset (&oset);
	374	sigprocmask (SIG_BLOCK, &bset, &oset);
	375	#endif
	376
b72432fd JA	377	rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int);
b72432fd JA	378	rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term);
95732b49	379	#if defined (SIGQUIT)
b72432fd	380	rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);
95732b49	381	#endif
b72432fd	382
95732b49	383	#if defined (SIGALRM)
b72432fd JA	384	oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm);
	385	if (oh == (SigHandler *)SIG_IGN)
	386	rl_sigaction (SIGALRM, &old_alrm, &dummy);
ccc6cda3	387	#if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART)
b72432fd JA	388	/* If the application using readline has already installed a signal
	389	handler with SA_RESTART, SIGALRM will cause reads to be restarted
	390	automatically, so readline should just get out of the way. Since
	391	we tested for SIG_IGN above, we can just test for SIG_DFL here. */
	392	if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART))
	393	rl_sigaction (SIGALRM, &old_alrm, &dummy);
ccc6cda3	394	#endif /* HAVE_POSIX_SIGNALS */
95732b49	395	#endif /* SIGALRM */
726f6388	396
726f6388	397	#if defined (SIGTSTP)
b72432fd	398	rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp);
726f6388	399	#endif /* SIGTSTP */
ccc6cda3	400
726f6388	401	#if defined (SIGTTOU)
b72432fd	402	rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou);
726f6388 JA	403	#endif /* SIGTTOU */
726f6388 JA	404
b72432fd JA	405	#if defined (SIGTTIN)
	406	rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin);
	407	#endif /* SIGTTIN */
d166f048	408
b72432fd	409	signals_set_flag = 1;
0628567a JA	410
	411	#if defined (HAVE_POSIX_SIGNALS)
	412	sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
	413	#endif
b72432fd	414	}
726f6388 JA	415
726f6388 JA	416	#if defined (SIGWINCH)
b72432fd JA	417	if (rl_catch_sigwinch && sigwinch_set_flag == 0)
	418	{
	419	rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch);
	420	sigwinch_set_flag = 1;
	421	}
726f6388	422	#endif /* SIGWINCH */
ccc6cda3	423
726f6388 JA	424	return 0;
	425	}
	426
ccc6cda3	427	int
726f6388 JA	428	rl_clear_signals ()
726f6388 JA	429	{
ccc6cda3 JA	430	sighandler_cxt dummy;
ccc6cda3 JA	431
b72432fd JA	432	if (rl_catch_signals && signals_set_flag == 1)
	433	{
	434	sigemptyset (&dummy.sa_mask);
726f6388	435
b72432fd JA	436	rl_sigaction (SIGINT, &old_int, &dummy);
b72432fd JA	437	rl_sigaction (SIGTERM, &old_term, &dummy);
95732b49	438	#if defined (SIGQUIT)
b72432fd	439	rl_sigaction (SIGQUIT, &old_quit, &dummy);
95732b49 JA	440	#endif
95732b49 JA	441	#if defined (SIGALRM)
b72432fd	442	rl_sigaction (SIGALRM, &old_alrm, &dummy);
95732b49	443	#endif
726f6388 JA	444
726f6388 JA	445	#if defined (SIGTSTP)
b72432fd JA	446	rl_sigaction (SIGTSTP, &old_tstp, &dummy);
b72432fd JA	447	#endif /* SIGTSTP */
726f6388 JA	448
726f6388 JA	449	#if defined (SIGTTOU)
b72432fd	450	rl_sigaction (SIGTTOU, &old_ttou, &dummy);
726f6388 JA	451	#endif /* SIGTTOU */
726f6388 JA	452
b72432fd JA	453	#if defined (SIGTTIN)
	454	rl_sigaction (SIGTTIN, &old_ttin, &dummy);
	455	#endif /* SIGTTIN */
ccc6cda3	456
b72432fd JA	457	signals_set_flag = 0;
b72432fd JA	458	}
726f6388 JA	459
726f6388 JA	460	#if defined (SIGWINCH)
b72432fd JA	461	if (rl_catch_sigwinch && sigwinch_set_flag == 1)
	462	{
	463	sigemptyset (&dummy.sa_mask);
	464	rl_sigaction (SIGWINCH, &old_winch, &dummy);
	465	sigwinch_set_flag = 0;
	466	}
726f6388 JA	467	#endif
	468
	469	return 0;
	470	}
b72432fd JA	471
	472	/* Clean up the terminal and readline state after catching a signal, before
	473	resending it to the calling application. */
	474	void
	475	rl_cleanup_after_signal ()
	476	{
	477	_rl_clean_up_for_exit ();
95732b49 JA	478	if (rl_deprep_term_function)
95732b49 JA	479	(*rl_deprep_term_function) ();
28ef6c31	480	rl_clear_pending_input ();
0628567a	481	rl_clear_signals ();
b72432fd JA	482	}
	483
	484	/* Reset the terminal and readline state after a signal handler returns. */
	485	void
	486	rl_reset_after_signal ()
	487	{
95732b49 JA	488	if (rl_prep_term_function)
95732b49 JA	489	(*rl_prep_term_function) (_rl_meta_flag);
b72432fd JA	490	rl_set_signals ();
	491	}
	492
	493	/* Free up the readline variable line state for the current line (undo list,
	494	any partial history entry, any keyboard macros in progress, and any
	495	numeric arguments in process) after catching a signal, before calling
	496	rl_cleanup_after_signal(). */
	497	void
	498	rl_free_line_state ()
	499	{
	500	register HIST_ENTRY *entry;
	501
28ef6c31	502	rl_free_undo_list ();
b72432fd JA	503
	504	entry = current_history ();
	505	if (entry)
	506	entry->data = (char *)NULL;
	507
	508	_rl_kill_kbd_macro ();
	509	rl_clear_message ();
95732b49	510	_rl_reset_argument ();
b72432fd JA	511	}
b72432fd JA	512
726f6388	513	#endif /* HANDLE_SIGNALS */
3185942a JA	514
	515	/* **************************************************************** */
	516	/* */
	517	/* SIGINT Management */
	518	/* */
	519	/* **************************************************************** */
	520
	521	#if defined (HAVE_POSIX_SIGNALS)
	522	static sigset_t sigint_set, sigint_oset;
0001803f	523	static sigset_t sigwinch_set, sigwinch_oset;
3185942a JA	524	#else /* !HAVE_POSIX_SIGNALS */
	525	# if defined (HAVE_BSD_SIGNALS)
	526	static int sigint_oldmask;
0001803f	527	static int sigwinch_oldmask;
3185942a JA	528	# endif /* HAVE_BSD_SIGNALS */
	529	#endif /* !HAVE_POSIX_SIGNALS */
	530
	531	static int sigint_blocked;
0001803f	532	static int sigwinch_blocked;
3185942a JA	533
	534	/* Cause SIGINT to not be delivered until the corresponding call to
	535	release_sigint(). */
	536	void
	537	_rl_block_sigint ()
	538	{
	539	if (sigint_blocked)
	540	return;
	541
	542	#if defined (HAVE_POSIX_SIGNALS)
	543	sigemptyset (&sigint_set);
	544	sigemptyset (&sigint_oset);
	545	sigaddset (&sigint_set, SIGINT);
	546	sigprocmask (SIG_BLOCK, &sigint_set, &sigint_oset);
	547	#else /* !HAVE_POSIX_SIGNALS */
	548	# if defined (HAVE_BSD_SIGNALS)
	549	sigint_oldmask = sigblock (sigmask (SIGINT));
	550	# else /* !HAVE_BSD_SIGNALS */
	551	# if defined (HAVE_USG_SIGHOLD)
	552	sighold (SIGINT);
	553	# endif /* HAVE_USG_SIGHOLD */
	554	# endif /* !HAVE_BSD_SIGNALS */
	555	#endif /* !HAVE_POSIX_SIGNALS */
	556
	557	sigint_blocked = 1;
	558	}
	559
	560	/* Allow SIGINT to be delivered. */
	561	void
	562	_rl_release_sigint ()
	563	{
	564	if (sigint_blocked == 0)
	565	return;
	566
	567	#if defined (HAVE_POSIX_SIGNALS)
	568	sigprocmask (SIG_SETMASK, &sigint_oset, (sigset_t *)NULL);
	569	#else
	570	# if defined (HAVE_BSD_SIGNALS)
	571	sigsetmask (sigint_oldmask);
	572	# else /* !HAVE_BSD_SIGNALS */
	573	# if defined (HAVE_USG_SIGHOLD)
	574	sigrelse (SIGINT);
	575	# endif /* HAVE_USG_SIGHOLD */
	576	# endif /* !HAVE_BSD_SIGNALS */
	577	#endif /* !HAVE_POSIX_SIGNALS */
	578
	579	sigint_blocked = 0;
	580	}
	581
0001803f CR	582	/* Cause SIGWINCH to not be delivered until the corresponding call to
	583	release_sigwinch(). */
	584	void
	585	_rl_block_sigwinch ()
	586	{
	587	if (sigwinch_blocked)
	588	return;
	589
	590	#if defined (HAVE_POSIX_SIGNALS)
	591	sigemptyset (&sigwinch_set);
	592	sigemptyset (&sigwinch_oset);
	593	sigaddset (&sigwinch_set, SIGWINCH);
	594	sigprocmask (SIG_BLOCK, &sigwinch_set, &sigwinch_oset);
	595	#else /* !HAVE_POSIX_SIGNALS */
	596	# if defined (HAVE_BSD_SIGNALS)
	597	sigwinch_oldmask = sigblock (sigmask (SIGWINCH));
	598	# else /* !HAVE_BSD_SIGNALS */
	599	# if defined (HAVE_USG_SIGHOLD)
	600	sighold (SIGWINCH);
	601	# endif /* HAVE_USG_SIGHOLD */
	602	# endif /* !HAVE_BSD_SIGNALS */
	603	#endif /* !HAVE_POSIX_SIGNALS */
	604
	605	sigwinch_blocked = 1;
	606	}
	607
	608	/* Allow SIGWINCH to be delivered. */
	609	void
	610	_rl_release_sigwinch ()
	611	{
	612	if (sigwinch_blocked == 0)
	613	return;
	614
	615	#if defined (HAVE_POSIX_SIGNALS)
	616	sigprocmask (SIG_SETMASK, &sigwinch_oset, (sigset_t *)NULL);
	617	#else
	618	# if defined (HAVE_BSD_SIGNALS)
	619	sigsetmask (sigwinch_oldmask);
	620	# else /* !HAVE_BSD_SIGNALS */
	621	# if defined (HAVE_USG_SIGHOLD)
	622	sigrelse (SIGWINCH);
	623	# endif /* HAVE_USG_SIGHOLD */
	624	# endif /* !HAVE_BSD_SIGNALS */
	625	#endif /* !HAVE_POSIX_SIGNALS */
	626
	627	sigwinch_blocked = 0;
	628	}
	629
3185942a JA	630	/* **************************************************************** */
	631	/* */
	632	/* Echoing special control characters */
	633	/* */
	634	/* **************************************************************** */
	635	void
	636	rl_echo_signal_char (sig)
	637	int sig;
	638	{
	639	char cstr[3];
	640	int cslen, c;
	641
0001803f	642	if (_rl_echoctl == 0 \|\| _rl_echo_control_chars == 0)
3185942a JA	643	return;
	644
	645	switch (sig)
	646	{
	647	case SIGINT: c = _rl_intr_char; break;
0001803f	648	#if defined (SIGQUIT)
3185942a	649	case SIGQUIT: c = _rl_quit_char; break;
0001803f CR	650	#endif
0001803f CR	651	#if defined (SIGTSTP)
3185942a	652	case SIGTSTP: c = _rl_susp_char; break;
0001803f	653	#endif
3185942a JA	654	default: return;
	655	}
	656
	657	if (CTRL_CHAR (c) \|\| c == RUBOUT)
	658	{
	659	cstr[0] = '^';
	660	cstr[1] = CTRL_CHAR (c) ? UNCTRL (c) : '?';
	661	cstr[cslen = 2] = '\0';
	662	}
	663	else
	664	{
	665	cstr[0] = c;
	666	cstr[cslen = 1] = '\0';
	667	}
	668
	669	_rl_output_some_chars (cstr, cslen);
	670	}