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 sigemptyset (&set); 164 sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set); 165 sigdelset (&set, sig); 166#else /* !HAVE_POSIX_SIGNALS */ 167# if defined (HAVE_BSD_SIGNALS) 168 omask = sigblock (0); 169# endif /* HAVE_BSD_SIGNALS */ 170#endif /* !HAVE_POSIX_SIGNALS */ 171 172#if defined (__EMX__) 173 signal (sig, SIG_ACK); 174#endif 175 176#if defined (HAVE_KILL) 177 kill (getpid (), sig); 178#else 179 raise (sig); /* assume we have raise */ 180#endif 181 182 /* Let the signal that we just sent through. */ 183#if defined (HAVE_POSIX_SIGNALS) 184 sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL); 185#else /* !HAVE_POSIX_SIGNALS */ 186# if defined (HAVE_BSD_SIGNALS) 187 sigsetmask (omask & ~(sigmask (sig))); 188# endif /* HAVE_BSD_SIGNALS */ 189#endif /* !HAVE_POSIX_SIGNALS */ 190 191 rl_reset_after_signal (); 192 } 193 194 RL_UNSETSTATE(RL_STATE_SIGHANDLER); 195 SIGHANDLER_RETURN; 196} 197 198#if defined (SIGWINCH) 199static RETSIGTYPE 200rl_sigwinch_handler (sig) 201 int sig; 202{ 203 SigHandler *oh; 204 205#if defined (MUST_REINSTALL_SIGHANDLERS) 206 sighandler_cxt dummy_winch; 207 208 /* We don't want to change old_winch -- it holds the state of SIGWINCH 209 disposition set by the calling application. We need this state 210 because we call the application's SIGWINCH handler after updating 211 our own idea of the screen size. */ 212 rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch); 213#endif 214 215 RL_SETSTATE(RL_STATE_SIGHANDLER); 216 rl_resize_terminal (); 217 218 /* If another sigwinch handler has been installed, call it. */ 219 oh = (SigHandler *)old_winch.sa_handler; 220 if (oh && oh != (SigHandler *)SIG_IGN && oh != (SigHandler *)SIG_DFL) 221 (*oh) (sig); 222 223 RL_UNSETSTATE(RL_STATE_SIGHANDLER); 224 SIGHANDLER_RETURN; 225} 226#endif /* SIGWINCH */ 227 228/* Functions to manage signal handling. */ 229 230#if !defined (HAVE_POSIX_SIGNALS) 231static int 232rl_sigaction (sig, nh, oh) 233 int sig; 234 sighandler_cxt *nh, *oh; 235{ 236 oh->sa_handler = signal (sig, nh->sa_handler); 237 return 0; 238} 239#endif /* !HAVE_POSIX_SIGNALS */ 240 241/* Set up a readline-specific signal handler, saving the old signal 242 information in OHANDLER. Return the old signal handler, like 243 signal(). */ 244static SigHandler * 245rl_set_sighandler (sig, handler, ohandler) 246 int sig; 247 SigHandler *handler; 248 sighandler_cxt *ohandler; 249{ 250 sighandler_cxt old_handler; 251#if defined (HAVE_POSIX_SIGNALS) 252 struct sigaction act; 253 254 act.sa_handler = handler; 255 act.sa_flags = (sig == SIGWINCH) ? SA_RESTART : 0; 256 sigemptyset (&act.sa_mask); 257 sigemptyset (&ohandler->sa_mask); 258 sigaction (sig, &act, &old_handler); 259#else 260 old_handler.sa_handler = (SigHandler *)signal (sig, handler); 261#endif /* !HAVE_POSIX_SIGNALS */ 262 263 /* XXX -- assume we have memcpy */ 264 /* If rl_set_signals is called twice in a row, don't set the old handler to 265 rl_signal_handler, because that would cause infinite recursion. */ 266 if (handler != rl_signal_handler || old_handler.sa_handler != rl_signal_handler) 267 memcpy (ohandler, &old_handler, sizeof (sighandler_cxt)); 268 269 return (ohandler->sa_handler); 270} 271 272static void 273rl_maybe_set_sighandler (sig, handler, ohandler) 274 int sig; 275 SigHandler *handler; 276 sighandler_cxt *ohandler; 277{ 278 sighandler_cxt dummy; 279 SigHandler *oh; 280 281 sigemptyset (&dummy.sa_mask); 282 oh = rl_set_sighandler (sig, handler, ohandler); 283 if (oh == (SigHandler *)SIG_IGN) 284 rl_sigaction (sig, ohandler, &dummy); 285} 286 287int 288rl_set_signals () 289{ 290 sighandler_cxt dummy; 291 SigHandler *oh; 292#if defined (HAVE_POSIX_SIGNALS) 293 static int sigmask_set = 0; 294 static sigset_t bset, oset; 295#endif 296 297#if defined (HAVE_POSIX_SIGNALS) 298 if (rl_catch_signals && sigmask_set == 0) 299 { 300 sigemptyset (&bset); 301 302 sigaddset (&bset, SIGINT); 303 sigaddset (&bset, SIGINT); 304#if defined (SIGQUIT) 305 sigaddset (&bset, SIGQUIT); 306#endif 307#if defined (SIGALRM) 308 sigaddset (&bset, SIGALRM); 309#endif 310#if defined (SIGTSTP) 311 sigaddset (&bset, SIGTSTP); 312#endif 313#if defined (SIGTTIN) 314 sigaddset (&bset, SIGTTIN); 315#endif 316#if defined (SIGTTOU) 317 sigaddset (&bset, SIGTTOU); 318#endif 319 sigmask_set = 1; 320 } 321#endif /* HAVE_POSIX_SIGNALS */ 322 323 if (rl_catch_signals && signals_set_flag == 0) 324 { 325#if defined (HAVE_POSIX_SIGNALS) 326 sigemptyset (&oset); 327 sigprocmask (SIG_BLOCK, &bset, &oset); 328#endif 329 330 rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int); 331 rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term); 332#if defined (SIGQUIT) 333 rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit); 334#endif 335 336#if defined (SIGALRM) 337 oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm); 338 if (oh == (SigHandler *)SIG_IGN) 339 rl_sigaction (SIGALRM, &old_alrm, &dummy); 340#if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART) 341 /* If the application using readline has already installed a signal 342 handler with SA_RESTART, SIGALRM will cause reads to be restarted 343 automatically, so readline should just get out of the way. Since 344 we tested for SIG_IGN above, we can just test for SIG_DFL here. */ 345 if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART)) 346 rl_sigaction (SIGALRM, &old_alrm, &dummy); 347#endif /* HAVE_POSIX_SIGNALS */ 348#endif /* SIGALRM */ 349 350#if defined (SIGTSTP) 351 rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp); 352#endif /* SIGTSTP */ 353 354#if defined (SIGTTOU) 355 rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou); 356#endif /* SIGTTOU */ 357 358#if defined (SIGTTIN) 359 rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin); 360#endif /* SIGTTIN */ 361 362 signals_set_flag = 1; 363 364#if defined (HAVE_POSIX_SIGNALS) 365 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL); 366#endif 367 } 368 369#if defined (SIGWINCH) 370 if (rl_catch_sigwinch && sigwinch_set_flag == 0) 371 { 372 rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch); 373 sigwinch_set_flag = 1; 374 } 375#endif /* SIGWINCH */ 376 377 return 0; 378} 379 380int 381rl_clear_signals () 382{ 383 sighandler_cxt dummy; 384 385 if (rl_catch_signals && signals_set_flag == 1) 386 { 387 sigemptyset (&dummy.sa_mask); 388 389 rl_sigaction (SIGINT, &old_int, &dummy); 390 rl_sigaction (SIGTERM, &old_term, &dummy); 391#if defined (SIGQUIT) 392 rl_sigaction (SIGQUIT, &old_quit, &dummy); 393#endif 394#if defined (SIGALRM) 395 rl_sigaction (SIGALRM, &old_alrm, &dummy); 396#endif 397 398#if defined (SIGTSTP) 399 rl_sigaction (SIGTSTP, &old_tstp, &dummy); 400#endif /* SIGTSTP */ 401 402#if defined (SIGTTOU) 403 rl_sigaction (SIGTTOU, &old_ttou, &dummy); 404#endif /* SIGTTOU */ 405 406#if defined (SIGTTIN) 407 rl_sigaction (SIGTTIN, &old_ttin, &dummy); 408#endif /* SIGTTIN */ 409 410 signals_set_flag = 0; 411 } 412 413#if defined (SIGWINCH) 414 if (rl_catch_sigwinch && sigwinch_set_flag == 1) 415 { 416 sigemptyset (&dummy.sa_mask); 417 rl_sigaction (SIGWINCH, &old_winch, &dummy); 418 sigwinch_set_flag = 0; 419 } 420#endif 421 422 return 0; 423} 424 425/* Clean up the terminal and readline state after catching a signal, before 426 resending it to the calling application. */ 427void 428rl_cleanup_after_signal () 429{ 430 _rl_clean_up_for_exit (); 431 if (rl_deprep_term_function) 432 (*rl_deprep_term_function) (); 433 rl_clear_pending_input (); 434 rl_clear_signals (); 435} 436 437/* Reset the terminal and readline state after a signal handler returns. */ 438void 439rl_reset_after_signal () 440{ 441 if (rl_prep_term_function) 442 (*rl_prep_term_function) (_rl_meta_flag); 443 rl_set_signals (); 444} 445 446/* Free up the readline variable line state for the current line (undo list, 447 any partial history entry, any keyboard macros in progress, and any 448 numeric arguments in process) after catching a signal, before calling 449 rl_cleanup_after_signal(). */ 450void 451rl_free_line_state () 452{ 453 register HIST_ENTRY *entry; 454 455 rl_free_undo_list (); 456 457 entry = current_history (); 458 if (entry) 459 entry->data = (char *)NULL; 460 461 _rl_kill_kbd_macro (); 462 rl_clear_message (); 463 _rl_reset_argument (); 464} 465 466#endif /* HANDLE_SIGNALS */ 467