| 1 | /* signals.c -- signal handling support for readline. */ |
| 2 | |
| 3 | /* Copyright (C) 1987, 1989, 1992 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 1, 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 | 675 Mass Ave, Cambridge, MA 02139, 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 (__GO32__) && !defined(__DJGPP__) |
| 44 | # undef HANDLE_SIGNALS |
| 45 | #endif /* __GO32__ && !__DJGPP__ */ |
| 46 | |
| 47 | #if defined (HANDLE_SIGNALS) |
| 48 | /* Some standard library routines. */ |
| 49 | #include "readline.h" |
| 50 | #include "history.h" |
| 51 | |
| 52 | #if !defined (RETSIGTYPE) |
| 53 | # if defined (VOID_SIGHANDLER) |
| 54 | # define RETSIGTYPE void |
| 55 | # else |
| 56 | # define RETSIGTYPE int |
| 57 | # endif /* !VOID_SIGHANDLER */ |
| 58 | #endif /* !RETSIGTYPE */ |
| 59 | |
| 60 | #if defined (VOID_SIGHANDLER) |
| 61 | # define SIGHANDLER_RETURN return |
| 62 | #else |
| 63 | # define SIGHANDLER_RETURN return (0) |
| 64 | #endif |
| 65 | |
| 66 | /* This typedef is equivalant to the one for Function; it allows us |
| 67 | to say SigHandler *foo = signal (SIGKILL, SIG_IGN); */ |
| 68 | typedef RETSIGTYPE SigHandler (); |
| 69 | |
| 70 | extern int readline_echoing_p; |
| 71 | extern int rl_pending_input; |
| 72 | extern int _rl_meta_flag; |
| 73 | |
| 74 | extern void free_undo_list (); |
| 75 | extern void _rl_get_screen_size (); |
| 76 | extern void _rl_redisplay_after_sigwinch (); |
| 77 | extern void _rl_clean_up_for_exit (); |
| 78 | extern void _rl_kill_kbd_macro (); |
| 79 | extern void _rl_init_argument (); |
| 80 | extern void rl_deprep_terminal (), rl_prep_terminal (); |
| 81 | |
| 82 | static SigHandler *rl_set_sighandler (); |
| 83 | |
| 84 | /* Exported variables for use by applications. */ |
| 85 | |
| 86 | /* If non-zero, readline will install its own signal handlers for |
| 87 | SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */ |
| 88 | int rl_catch_signals = 1; |
| 89 | |
| 90 | /* If non-zero, readline will install a signal handler for SIGWINCH. */ |
| 91 | #ifdef SIGWINCH |
| 92 | int rl_catch_sigwinch = 1; |
| 93 | #endif |
| 94 | |
| 95 | static int signals_set_flag; |
| 96 | #ifdef SIGWINCH |
| 97 | static int sigwinch_set_flag; |
| 98 | #endif |
| 99 | |
| 100 | /* **************************************************************** */ |
| 101 | /* */ |
| 102 | /* Signal Handling */ |
| 103 | /* */ |
| 104 | /* **************************************************************** */ |
| 105 | |
| 106 | #if defined (HAVE_POSIX_SIGNALS) |
| 107 | typedef struct sigaction sighandler_cxt; |
| 108 | # define rl_sigaction(s, nh, oh) sigaction(s, nh, oh) |
| 109 | #else |
| 110 | typedef struct { SigHandler *sa_handler; int sa_mask, sa_flags; } sighandler_cxt; |
| 111 | # define sigemptyset(m) |
| 112 | #endif /* !HAVE_POSIX_SIGNALS */ |
| 113 | |
| 114 | static sighandler_cxt old_int, old_term, old_alrm, old_quit; |
| 115 | #if defined (SIGTSTP) |
| 116 | static sighandler_cxt old_tstp, old_ttou, old_ttin; |
| 117 | #endif |
| 118 | #if defined (SIGWINCH) |
| 119 | static sighandler_cxt old_winch; |
| 120 | #endif |
| 121 | |
| 122 | /* Readline signal handler functions. */ |
| 123 | |
| 124 | static RETSIGTYPE |
| 125 | rl_signal_handler (sig) |
| 126 | int sig; |
| 127 | { |
| 128 | #if defined (HAVE_POSIX_SIGNALS) |
| 129 | sigset_t set; |
| 130 | #else /* !HAVE_POSIX_SIGNALS */ |
| 131 | # if defined (HAVE_BSD_SIGNALS) |
| 132 | long omask; |
| 133 | # else /* !HAVE_BSD_SIGNALS */ |
| 134 | sighandler_cxt dummy_cxt; /* needed for rl_set_sighandler call */ |
| 135 | # endif /* !HAVE_BSD_SIGNALS */ |
| 136 | #endif /* !HAVE_POSIX_SIGNALS */ |
| 137 | |
| 138 | #if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS) |
| 139 | /* Since the signal will not be blocked while we are in the signal |
| 140 | handler, ignore it until rl_clear_signals resets the catcher. */ |
| 141 | if (sig == SIGINT || sig == SIGALRM) |
| 142 | rl_set_sighandler (sig, SIG_IGN, &dummy_cxt); |
| 143 | #endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */ |
| 144 | |
| 145 | switch (sig) |
| 146 | { |
| 147 | case SIGINT: |
| 148 | rl_free_line_state (); |
| 149 | /* FALLTHROUGH */ |
| 150 | |
| 151 | #if defined (SIGTSTP) |
| 152 | case SIGTSTP: |
| 153 | case SIGTTOU: |
| 154 | case SIGTTIN: |
| 155 | #endif /* SIGTSTP */ |
| 156 | case SIGALRM: |
| 157 | case SIGTERM: |
| 158 | case SIGQUIT: |
| 159 | rl_cleanup_after_signal (); |
| 160 | |
| 161 | #if defined (HAVE_POSIX_SIGNALS) |
| 162 | sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set); |
| 163 | sigdelset (&set, sig); |
| 164 | #else /* !HAVE_POSIX_SIGNALS */ |
| 165 | # if defined (HAVE_BSD_SIGNALS) |
| 166 | omask = sigblock (0); |
| 167 | # endif /* HAVE_BSD_SIGNALS */ |
| 168 | #endif /* !HAVE_POSIX_SIGNALS */ |
| 169 | |
| 170 | kill (getpid (), sig); |
| 171 | |
| 172 | /* Let the signal that we just sent through. */ |
| 173 | #if defined (HAVE_POSIX_SIGNALS) |
| 174 | sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL); |
| 175 | #else /* !HAVE_POSIX_SIGNALS */ |
| 176 | # if defined (HAVE_BSD_SIGNALS) |
| 177 | sigsetmask (omask & ~(sigmask (sig))); |
| 178 | # endif /* HAVE_BSD_SIGNALS */ |
| 179 | #endif /* !HAVE_POSIX_SIGNALS */ |
| 180 | |
| 181 | rl_reset_after_signal (); |
| 182 | } |
| 183 | |
| 184 | SIGHANDLER_RETURN; |
| 185 | } |
| 186 | |
| 187 | #if defined (SIGWINCH) |
| 188 | static RETSIGTYPE |
| 189 | rl_sigwinch_handler (sig) |
| 190 | int sig; |
| 191 | { |
| 192 | SigHandler *oh; |
| 193 | |
| 194 | #if defined (MUST_REINSTALL_SIGHANDLERS) |
| 195 | sighandler_cxt dummy_winch; |
| 196 | |
| 197 | /* We don't want to change old_winch -- it holds the state of SIGWINCH |
| 198 | disposition set by the calling application. We need this state |
| 199 | because we call the application's SIGWINCH handler after updating |
| 200 | our own idea of the screen size. */ |
| 201 | rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch); |
| 202 | #endif |
| 203 | |
| 204 | rl_resize_terminal (); |
| 205 | |
| 206 | /* If another sigwinch handler has been installed, call it. */ |
| 207 | oh = (SigHandler *)old_winch.sa_handler; |
| 208 | if (oh && oh != (SigHandler *)SIG_IGN && oh != (SigHandler *)SIG_DFL) |
| 209 | (*oh) (sig); |
| 210 | |
| 211 | SIGHANDLER_RETURN; |
| 212 | } |
| 213 | #endif /* SIGWINCH */ |
| 214 | |
| 215 | /* Functions to manage signal handling. */ |
| 216 | |
| 217 | #if !defined (HAVE_POSIX_SIGNALS) |
| 218 | static int |
| 219 | rl_sigaction (sig, nh, oh) |
| 220 | int sig; |
| 221 | sighandler_cxt *nh, *oh; |
| 222 | { |
| 223 | oh->sa_handler = signal (sig, nh->sa_handler); |
| 224 | return 0; |
| 225 | } |
| 226 | #endif /* !HAVE_POSIX_SIGNALS */ |
| 227 | |
| 228 | /* Set up a readline-specific signal handler, saving the old signal |
| 229 | information in OHANDLER. Return the old signal handler, like |
| 230 | signal(). */ |
| 231 | static SigHandler * |
| 232 | rl_set_sighandler (sig, handler, ohandler) |
| 233 | int sig; |
| 234 | SigHandler *handler; |
| 235 | sighandler_cxt *ohandler; |
| 236 | { |
| 237 | #if defined (HAVE_POSIX_SIGNALS) |
| 238 | struct sigaction act; |
| 239 | |
| 240 | act.sa_handler = handler; |
| 241 | act.sa_flags = 0; |
| 242 | sigemptyset (&act.sa_mask); |
| 243 | sigemptyset (&ohandler->sa_mask); |
| 244 | sigaction (sig, &act, ohandler); |
| 245 | #else |
| 246 | ohandler->sa_handler = (SigHandler *)signal (sig, handler); |
| 247 | #endif /* !HAVE_POSIX_SIGNALS */ |
| 248 | return (ohandler->sa_handler); |
| 249 | } |
| 250 | |
| 251 | static void |
| 252 | rl_maybe_set_sighandler (sig, handler, ohandler) |
| 253 | int sig; |
| 254 | SigHandler *handler; |
| 255 | sighandler_cxt *ohandler; |
| 256 | { |
| 257 | sighandler_cxt dummy; |
| 258 | SigHandler *oh; |
| 259 | |
| 260 | sigemptyset (&dummy.sa_mask); |
| 261 | oh = rl_set_sighandler (sig, handler, ohandler); |
| 262 | if (oh == (SigHandler *)SIG_IGN) |
| 263 | rl_sigaction (sig, ohandler, &dummy); |
| 264 | } |
| 265 | |
| 266 | int |
| 267 | rl_set_signals () |
| 268 | { |
| 269 | sighandler_cxt dummy; |
| 270 | SigHandler *oh; |
| 271 | |
| 272 | if (rl_catch_signals && signals_set_flag == 0) |
| 273 | { |
| 274 | rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int); |
| 275 | rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term); |
| 276 | rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit); |
| 277 | |
| 278 | oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm); |
| 279 | if (oh == (SigHandler *)SIG_IGN) |
| 280 | rl_sigaction (SIGALRM, &old_alrm, &dummy); |
| 281 | #if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART) |
| 282 | /* If the application using readline has already installed a signal |
| 283 | handler with SA_RESTART, SIGALRM will cause reads to be restarted |
| 284 | automatically, so readline should just get out of the way. Since |
| 285 | we tested for SIG_IGN above, we can just test for SIG_DFL here. */ |
| 286 | if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART)) |
| 287 | rl_sigaction (SIGALRM, &old_alrm, &dummy); |
| 288 | #endif /* HAVE_POSIX_SIGNALS */ |
| 289 | |
| 290 | #if defined (SIGTSTP) |
| 291 | rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp); |
| 292 | #endif /* SIGTSTP */ |
| 293 | |
| 294 | #if defined (SIGTTOU) |
| 295 | rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou); |
| 296 | #endif /* SIGTTOU */ |
| 297 | |
| 298 | #if defined (SIGTTIN) |
| 299 | rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin); |
| 300 | #endif /* SIGTTIN */ |
| 301 | |
| 302 | signals_set_flag = 1; |
| 303 | } |
| 304 | |
| 305 | #if defined (SIGWINCH) |
| 306 | if (rl_catch_sigwinch && sigwinch_set_flag == 0) |
| 307 | { |
| 308 | rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch); |
| 309 | sigwinch_set_flag = 1; |
| 310 | } |
| 311 | #endif /* SIGWINCH */ |
| 312 | |
| 313 | return 0; |
| 314 | } |
| 315 | |
| 316 | int |
| 317 | rl_clear_signals () |
| 318 | { |
| 319 | sighandler_cxt dummy; |
| 320 | |
| 321 | if (rl_catch_signals && signals_set_flag == 1) |
| 322 | { |
| 323 | sigemptyset (&dummy.sa_mask); |
| 324 | |
| 325 | rl_sigaction (SIGINT, &old_int, &dummy); |
| 326 | rl_sigaction (SIGTERM, &old_term, &dummy); |
| 327 | rl_sigaction (SIGQUIT, &old_quit, &dummy); |
| 328 | rl_sigaction (SIGALRM, &old_alrm, &dummy); |
| 329 | |
| 330 | #if defined (SIGTSTP) |
| 331 | rl_sigaction (SIGTSTP, &old_tstp, &dummy); |
| 332 | #endif /* SIGTSTP */ |
| 333 | |
| 334 | #if defined (SIGTTOU) |
| 335 | rl_sigaction (SIGTTOU, &old_ttou, &dummy); |
| 336 | #endif /* SIGTTOU */ |
| 337 | |
| 338 | #if defined (SIGTTIN) |
| 339 | rl_sigaction (SIGTTIN, &old_ttin, &dummy); |
| 340 | #endif /* SIGTTIN */ |
| 341 | |
| 342 | signals_set_flag = 0; |
| 343 | } |
| 344 | |
| 345 | #if defined (SIGWINCH) |
| 346 | if (rl_catch_sigwinch && sigwinch_set_flag == 1) |
| 347 | { |
| 348 | sigemptyset (&dummy.sa_mask); |
| 349 | rl_sigaction (SIGWINCH, &old_winch, &dummy); |
| 350 | sigwinch_set_flag = 0; |
| 351 | } |
| 352 | #endif |
| 353 | |
| 354 | return 0; |
| 355 | } |
| 356 | |
| 357 | /* Clean up the terminal and readline state after catching a signal, before |
| 358 | resending it to the calling application. */ |
| 359 | void |
| 360 | rl_cleanup_after_signal () |
| 361 | { |
| 362 | _rl_clean_up_for_exit (); |
| 363 | (*rl_deprep_term_function) (); |
| 364 | rl_clear_signals (); |
| 365 | rl_pending_input = 0; |
| 366 | } |
| 367 | |
| 368 | /* Reset the terminal and readline state after a signal handler returns. */ |
| 369 | void |
| 370 | rl_reset_after_signal () |
| 371 | { |
| 372 | (*rl_prep_term_function) (_rl_meta_flag); |
| 373 | rl_set_signals (); |
| 374 | } |
| 375 | |
| 376 | /* Free up the readline variable line state for the current line (undo list, |
| 377 | any partial history entry, any keyboard macros in progress, and any |
| 378 | numeric arguments in process) after catching a signal, before calling |
| 379 | rl_cleanup_after_signal(). */ |
| 380 | void |
| 381 | rl_free_line_state () |
| 382 | { |
| 383 | register HIST_ENTRY *entry; |
| 384 | |
| 385 | free_undo_list (); |
| 386 | |
| 387 | entry = current_history (); |
| 388 | if (entry) |
| 389 | entry->data = (char *)NULL; |
| 390 | |
| 391 | _rl_kill_kbd_macro (); |
| 392 | rl_clear_message (); |
| 393 | _rl_init_argument (); |
| 394 | } |
| 395 | |
| 396 | #endif /* HANDLE_SIGNALS */ |