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); */ 66typedef RETSIGTYPE SigHandler (); 67 68#if defined (HAVE_POSIX_SIGNALS) 69typedef struct sigaction sighandler_cxt; 70# define rl_sigaction(s, nh, oh) sigaction(s, nh, oh) 71#else 72typedef 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 80static SigHandler *rl_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *)); 81static 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. */ 87int rl_catch_signals = 1; 88 89/* If non-zero, readline will install a signal handler for SIGWINCH. */ 90#ifdef SIGWINCH 91int rl_catch_sigwinch = 1; 92#else 93int rl_catch_sigwinch = 0; /* for the readline state struct in readline.c */ 94#endif 95 96static int signals_set_flag; 97static int sigwinch_set_flag; 98 99/* **************************************************************** */ 100/* */ 101/* Signal Handling */ 102/* */ 103/* **************************************************************** */ 104 105static sighandler_cxt old_int, old_term, old_alrm, old_quit; 106#if defined (SIGTSTP) 107static sighandler_cxt old_tstp, old_ttou, old_ttin; 108#endif 109#if defined (SIGWINCH) 110static sighandler_cxt old_winch; 111#endif 112 113/* Readline signal handler functions. */ 114 115static RETSIGTYPE 116rl_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) 198static RETSIGTYPE 199rl_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) 230static int 231rl_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(). */ 243static SigHandler * 244rl_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 271static void 272rl_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 286int 287rl_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 340int 341rl_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. */ 387void 388rl_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. */ 398void 399rl_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(). */ 410void 411rl_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 */ 427