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   act.sa_flags = (sig == SIGWINCH) ? SA_RESTART : 0;
 255   sigemptyset (&act.sa_mask);
 256   sigemptyset (&ohandler->sa_mask);
 257   sigaction (sig, &act, &old_handler);
 258 #else
 259   old_handler.sa_handler = (SigHandler *)signal (sig, handler);
 260 #endif /* !HAVE_POSIX_SIGNALS */
 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
 268   return (ohandler->sa_handler);
 269 }
 270
 271 static void
 272 rl_maybe_set_sighandler (sig, handler, ohandler)
 273      int sig;
 274      SigHandler *handler;
 275      sighandler_cxt *ohandler;
 276 {
 277   sighandler_cxt dummy;
 278   SigHandler *oh;
 279
 280   sigemptyset (&dummy.sa_mask);
 281   oh = rl_set_sighandler (sig, handler, ohandler);
 282   if (oh == (SigHandler *)SIG_IGN)
 283     rl_sigaction (sig, ohandler, &dummy);
 284 }
 285
 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);
 296 #if defined (SIGQUIT)
 297       rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);
 298 #endif
 299
 300 #if defined (SIGALRM)
 301       oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm);
 302       if (oh == (SigHandler *)SIG_IGN)
 303         rl_sigaction (SIGALRM, &old_alrm, &dummy);
 304 #if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART)
 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);
 311 #endif /* HAVE_POSIX_SIGNALS */
 312 #endif /* SIGALRM */
 313
 314 #if defined (SIGTSTP)
 315       rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp);
 316 #endif /* SIGTSTP */
 317
 318 #if defined (SIGTTOU)
 319       rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou);
 320 #endif /* SIGTTOU */
 321
 322 #if defined (SIGTTIN)
 323       rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin);
 324 #endif /* SIGTTIN */
 325
 326       signals_set_flag = 1;
 327     }
 328
 329 #if defined (SIGWINCH)
 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     }
 335 #endif /* SIGWINCH */
 336
 337   return 0;
 338 }
 339
 340 int
 341 rl_clear_signals ()
 342 {
 343   sighandler_cxt dummy;
 344
 345   if (rl_catch_signals && signals_set_flag == 1)
 346     {
 347       sigemptyset (&dummy.sa_mask);
 348
 349       rl_sigaction (SIGINT, &old_int, &dummy);
 350       rl_sigaction (SIGTERM, &old_term, &dummy);
 351 #if defined (SIGQUIT)
 352       rl_sigaction (SIGQUIT, &old_quit, &dummy);
 353 #endif
 354 #if defined (SIGALRM)
 355       rl_sigaction (SIGALRM, &old_alrm, &dummy);
 356 #endif
 357
 358 #if defined (SIGTSTP)
 359       rl_sigaction (SIGTSTP, &old_tstp, &dummy);
 360 #endif /* SIGTSTP */
 361
 362 #if defined (SIGTTOU)
 363       rl_sigaction (SIGTTOU, &old_ttou, &dummy);
 364 #endif /* SIGTTOU */
 365
 366 #if defined (SIGTTIN)
 367       rl_sigaction (SIGTTIN, &old_ttin, &dummy);
 368 #endif /* SIGTTIN */
 369
 370       signals_set_flag = 0;
 371     }
 372
 373 #if defined (SIGWINCH)
 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     }
 380 #endif
 381
 382   return 0;
 383 }
 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 ();
 391   if (rl_deprep_term_function)
 392     (*rl_deprep_term_function) ();
 393   rl_clear_signals ();
 394   rl_clear_pending_input ();
 395 }
 396
 397 /* Reset the terminal and readline state after a signal handler returns. */
 398 void
 399 rl_reset_after_signal ()
 400 {
 401   if (rl_prep_term_function)
 402     (*rl_prep_term_function) (_rl_meta_flag);
 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
 415   rl_free_undo_list ();
 416
 417   entry = current_history ();
 418   if (entry)
 419     entry->data = (char *)NULL;
 420
 421   _rl_kill_kbd_macro ();
 422   rl_clear_message ();
 423   _rl_reset_argument ();
 424 }
 425
 426 #endif  /* HANDLE_SIGNALS */