lib/readline/signals.c

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