readline/signals.c

   1 /* signals.c -- signal handling support for readline. */
   2
   3 /* Copyright (C) 1987-2005 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 2, 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    59 Temple Place, Suite 330, Boston, MA 02111 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 (HANDLE_SIGNALS)
  44 /* Some standard library routines. */
  45 #include "readline.h"
  46 #include "history.h"
  47
  48 #include "rlprivate.h"
  49
  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
  64 /* This typedef is equivalent to the one for Function; it allows us
  65    to say SigHandler *foo = signal (SIGKILL, SIG_IGN); */
  66 typedef RETSIGTYPE SigHandler ();
  67
  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 */
  75
  76 #ifndef SA_RESTART
  77 #  define SA_RESTART 0
  78 #endif
  79
  80 static SigHandler *rl_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
  81 static void rl_maybe_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
  82
  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;
  92 #else
  93 int rl_catch_sigwinch = 0;      /* for the readline state struct in readline.c */
  94 #endif
  95
  96 static int signals_set_flag;
  97 static int sigwinch_set_flag;
  98
  99 /* **************************************************************** */
 100 /*                                                                  */
 101 /*                         Signal Handling                          */
 102 /*                                                                  */
 103 /* **************************************************************** */
 104
 105 static sighandler_cxt old_int, old_term, old_alrm, old_quit;
 106 #if defined (SIGTSTP)
 107 static sighandler_cxt old_tstp, old_ttou, old_ttin;
 108 #endif
 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
 129   RL_SETSTATE(RL_STATE_SIGHANDLER);
 130
 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. */
 134 #  if defined (SIGALRM)
 135   if (sig == SIGINT || sig == SIGALRM)
 136 #  else
 137   if (sig == SIGINT)
 138 #  endif
 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:
 145       rl_free_line_state ();
 146       /* FALLTHROUGH */
 147
 148     case SIGTERM:
 149 #if defined (SIGTSTP)
 150     case SIGTSTP:
 151     case SIGTTOU:
 152     case SIGTTIN:
 153 #endif /* SIGTSTP */
 154 #if defined (SIGALRM)
 155     case SIGALRM:
 156 #endif
 157 #if defined (SIGQUIT)
 158     case SIGQUIT:
 159 #endif
 160       rl_cleanup_after_signal ();
 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
 171 #if defined (__EMX__)
 172       signal (sig, SIG_ACK);
 173 #endif
 174
 175 #if defined (HAVE_KILL)
 176       kill (getpid (), sig);
 177 #else
 178       raise (sig);              /* assume we have raise */
 179 #endif
 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
 190       rl_reset_after_signal ();
 191     }
 192
 193   RL_UNSETSTATE(RL_STATE_SIGHANDLER);
 194   SIGHANDLER_RETURN;
 195 }
 196
 197 #if defined (SIGWINCH)
 198 static RETSIGTYPE
 199 rl_sigwinch_handler (sig)
 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. */
 211   rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch);
 212 #endif
 213
 214   RL_SETSTATE(RL_STATE_SIGHANDLER);
 215   rl_resize_terminal ();
 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
 222   RL_UNSETSTATE(RL_STATE_SIGHANDLER);
 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 {
 249   sighandler_cxt old_handler;
 250 #if defined (HAVE_POSIX_SIGNALS)
 251   struct sigaction act;
 252
 253   act.sa_handler = handler;
 254 #if defined (SIGWINCH)
 255   act.sa_flags = (sig == SIGWINCH) ? SA_RESTART : 0;
 256 #else
 257   act.sa_flags = 0;
 258 #endif
 259   sigemptyset (&act.sa_mask);
 260   sigemptyset (&ohandler->sa_mask);
 261   sigaction (sig, &act, &old_handler);
 262 #else
 263   old_handler.sa_handler = (SigHandler *)signal (sig, handler);
 264 #endif /* !HAVE_POSIX_SIGNALS */
 265
 266   /* XXX -- assume we have memcpy */
 267   /* If rl_set_signals is called twice in a row, don't set the old handler to
 268      rl_signal_handler, because that would cause infinite recursion. */
 269   if (handler != rl_signal_handler || old_handler.sa_handler != rl_signal_handler)
 270     memcpy (ohandler, &old_handler, sizeof (sighandler_cxt));
 271
 272   return (ohandler->sa_handler);
 273 }
 274
 275 static void
 276 rl_maybe_set_sighandler (sig, handler, ohandler)
 277      int sig;
 278      SigHandler *handler;
 279      sighandler_cxt *ohandler;
 280 {
 281   sighandler_cxt dummy;
 282   SigHandler *oh;
 283
 284   sigemptyset (&dummy.sa_mask);
 285   oh = rl_set_sighandler (sig, handler, ohandler);
 286   if (oh == (SigHandler *)SIG_IGN)
 287     rl_sigaction (sig, ohandler, &dummy);
 288 }
 289
 290 int
 291 rl_set_signals ()
 292 {
 293   sighandler_cxt dummy;
 294   SigHandler *oh;
 295
 296   if (rl_catch_signals && signals_set_flag == 0)
 297     {
 298       rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int);
 299       rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term);
 300 #if defined (SIGQUIT)
 301       rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);
 302 #endif
 303
 304 #if defined (SIGALRM)
 305       oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm);
 306       if (oh == (SigHandler *)SIG_IGN)
 307         rl_sigaction (SIGALRM, &old_alrm, &dummy);
 308 #if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART)
 309       /* If the application using readline has already installed a signal
 310          handler with SA_RESTART, SIGALRM will cause reads to be restarted
 311          automatically, so readline should just get out of the way.  Since
 312          we tested for SIG_IGN above, we can just test for SIG_DFL here. */
 313       if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART))
 314         rl_sigaction (SIGALRM, &old_alrm, &dummy);
 315 #endif /* HAVE_POSIX_SIGNALS */
 316 #endif /* SIGALRM */
 317
 318 #if defined (SIGTSTP)
 319       rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp);
 320 #endif /* SIGTSTP */
 321
 322 #if defined (SIGTTOU)
 323       rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou);
 324 #endif /* SIGTTOU */
 325
 326 #if defined (SIGTTIN)
 327       rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin);
 328 #endif /* SIGTTIN */
 329
 330       signals_set_flag = 1;
 331     }
 332
 333 #if defined (SIGWINCH)
 334   if (rl_catch_sigwinch && sigwinch_set_flag == 0)
 335     {
 336       rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch);
 337       sigwinch_set_flag = 1;
 338     }
 339 #endif /* SIGWINCH */
 340
 341   return 0;
 342 }
 343
 344 int
 345 rl_clear_signals ()
 346 {
 347   sighandler_cxt dummy;
 348
 349   if (rl_catch_signals && signals_set_flag == 1)
 350     {
 351       sigemptyset (&dummy.sa_mask);
 352
 353       rl_sigaction (SIGINT, &old_int, &dummy);
 354       rl_sigaction (SIGTERM, &old_term, &dummy);
 355 #if defined (SIGQUIT)
 356       rl_sigaction (SIGQUIT, &old_quit, &dummy);
 357 #endif
 358 #if defined (SIGALRM)
 359       rl_sigaction (SIGALRM, &old_alrm, &dummy);
 360 #endif
 361
 362 #if defined (SIGTSTP)
 363       rl_sigaction (SIGTSTP, &old_tstp, &dummy);
 364 #endif /* SIGTSTP */
 365
 366 #if defined (SIGTTOU)
 367       rl_sigaction (SIGTTOU, &old_ttou, &dummy);
 368 #endif /* SIGTTOU */
 369
 370 #if defined (SIGTTIN)
 371       rl_sigaction (SIGTTIN, &old_ttin, &dummy);
 372 #endif /* SIGTTIN */
 373
 374       signals_set_flag = 0;
 375     }
 376
 377 #if defined (SIGWINCH)
 378   if (rl_catch_sigwinch && sigwinch_set_flag == 1)
 379     {
 380       sigemptyset (&dummy.sa_mask);
 381       rl_sigaction (SIGWINCH, &old_winch, &dummy);
 382       sigwinch_set_flag = 0;
 383     }
 384 #endif
 385
 386   return 0;
 387 }
 388
 389 /* Clean up the terminal and readline state after catching a signal, before
 390    resending it to the calling application. */
 391 void
 392 rl_cleanup_after_signal ()
 393 {
 394   _rl_clean_up_for_exit ();
 395   if (rl_deprep_term_function)
 396     (*rl_deprep_term_function) ();
 397   rl_clear_signals ();
 398   rl_clear_pending_input ();
 399 }
 400
 401 /* Reset the terminal and readline state after a signal handler returns. */
 402 void
 403 rl_reset_after_signal ()
 404 {
 405   if (rl_prep_term_function)
 406     (*rl_prep_term_function) (_rl_meta_flag);
 407   rl_set_signals ();
 408 }
 409
 410 /* Free up the readline variable line state for the current line (undo list,
 411    any partial history entry, any keyboard macros in progress, and any
 412    numeric arguments in process) after catching a signal, before calling
 413    rl_cleanup_after_signal(). */
 414 void
 415 rl_free_line_state ()
 416 {
 417   register HIST_ENTRY *entry;
 418
 419   rl_free_undo_list ();
 420
 421   entry = current_history ();
 422   if (entry)
 423     entry->data = (char *)NULL;
 424
 425   _rl_kill_kbd_macro ();
 426   rl_clear_message ();
 427   _rl_reset_argument ();
 428 }
 429
 430 #endif  /* HANDLE_SIGNALS */