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#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 275static void 276rl_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 290int 291rl_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 344int 345rl_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. */ 391void 392rl_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. */ 402void 403rl_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(). */ 414void 415rl_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 */ 431