1 /* signals.c -- signal handling support for readline. */
3 /* Copyright (C) 1987-2009 Free Software Foundation, Inc.
5 This file is part of the GNU Readline Library (Readline), a library
6 for reading lines of text with interactive input and history editing.
8 Readline is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 Readline is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with Readline. If not, see <http://www.gnu.org/licenses/>.
22 #define READLINE_LIBRARY
24 #if defined (HAVE_CONFIG_H)
28 #include <stdio.h> /* Just for NULL. Yuck. */
29 #include <sys/types.h>
32 #if defined (HAVE_UNISTD_H)
34 #endif /* HAVE_UNISTD_H */
36 /* System-specific feature definitions and include files. */
39 #if defined (GWINSZ_IN_SYS_IOCTL)
40 # include <sys/ioctl.h>
41 #endif /* GWINSZ_IN_SYS_IOCTL */
43 /* Some standard library routines. */
47 #include "rlprivate.h"
49 #if defined (HANDLE_SIGNALS)
51 #if !defined (RETSIGTYPE)
52 # if defined (VOID_SIGHANDLER)
53 # define RETSIGTYPE void
55 # define RETSIGTYPE int
56 # endif /* !VOID_SIGHANDLER */
57 #endif /* !RETSIGTYPE */
59 #if defined (VOID_SIGHANDLER)
60 # define SIGHANDLER_RETURN return
62 # define SIGHANDLER_RETURN return (0)
65 /* This typedef is equivalent to the one for Function; it allows us
66 to say SigHandler *foo = signal (SIGKILL, SIG_IGN); */
67 typedef RETSIGTYPE SigHandler ();
69 #if defined (HAVE_POSIX_SIGNALS)
70 typedef struct sigaction sighandler_cxt;
71 # define rl_sigaction(s, nh, oh) sigaction(s, nh, oh)
73 typedef struct { SigHandler *sa_handler; int sa_mask, sa_flags; } sighandler_cxt;
74 # define sigemptyset(m)
75 #endif /* !HAVE_POSIX_SIGNALS */
81 static SigHandler *rl_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
82 static void rl_maybe_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
84 static RETSIGTYPE rl_signal_handler PARAMS((int));
85 static RETSIGTYPE _rl_handle_signal PARAMS((int));
87 /* Exported variables for use by applications. */
89 /* If non-zero, readline will install its own signal handlers for
90 SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
91 int rl_catch_signals = 1;
93 /* If non-zero, readline will install a signal handler for SIGWINCH. */
95 int rl_catch_sigwinch = 1;
97 int rl_catch_sigwinch = 0; /* for the readline state struct in readline.c */
100 /* Private variables. */
101 int _rl_interrupt_immediately = 0;
102 int volatile _rl_caught_signal = 0; /* should be sig_atomic_t, but that requires including <signal.h> everywhere */
104 /* If non-zero, print characters corresponding to received signals as long as
105 the user has indicated his desire to do so (_rl_echo_control_chars). */
108 int _rl_intr_char = 0;
109 int _rl_quit_char = 0;
110 int _rl_susp_char = 0;
112 static int signals_set_flag;
113 static int sigwinch_set_flag;
115 /* **************************************************************** */
117 /* Signal Handling */
119 /* **************************************************************** */
121 static sighandler_cxt old_int, old_term, old_alrm, old_quit;
122 #if defined (SIGTSTP)
123 static sighandler_cxt old_tstp, old_ttou, old_ttin;
125 #if defined (SIGWINCH)
126 static sighandler_cxt old_winch;
129 /* Readline signal handler functions. */
131 /* Called from RL_CHECK_SIGNALS() macro */
133 _rl_signal_handler (sig)
135 _rl_caught_signal = 0; /* XXX */
137 _rl_handle_signal (sig);
142 rl_signal_handler (sig)
145 if (_rl_interrupt_immediately || RL_ISSTATE(RL_STATE_CALLBACK))
147 _rl_interrupt_immediately = 0;
148 _rl_handle_signal (sig);
151 _rl_caught_signal = sig;
157 _rl_handle_signal (sig)
160 #if defined (HAVE_POSIX_SIGNALS)
162 #else /* !HAVE_POSIX_SIGNALS */
163 # if defined (HAVE_BSD_SIGNALS)
165 # else /* !HAVE_BSD_SIGNALS */
166 sighandler_cxt dummy_cxt; /* needed for rl_set_sighandler call */
167 # endif /* !HAVE_BSD_SIGNALS */
168 #endif /* !HAVE_POSIX_SIGNALS */
170 RL_SETSTATE(RL_STATE_SIGHANDLER);
172 #if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS)
173 /* Since the signal will not be blocked while we are in the signal
174 handler, ignore it until rl_clear_signals resets the catcher. */
175 # if defined (SIGALRM)
176 if (sig == SIGINT || sig == SIGALRM)
180 rl_set_sighandler (sig, SIG_IGN, &dummy_cxt);
181 #endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */
186 _rl_reset_completion_state ();
187 rl_free_line_state ();
191 #if defined (SIGTSTP)
196 #if defined (SIGALRM)
199 #if defined (SIGQUIT)
202 rl_echo_signal_char (sig);
203 rl_cleanup_after_signal ();
205 #if defined (HAVE_POSIX_SIGNALS)
207 sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set);
208 sigdelset (&set, sig);
209 #else /* !HAVE_POSIX_SIGNALS */
210 # if defined (HAVE_BSD_SIGNALS)
211 omask = sigblock (0);
212 # endif /* HAVE_BSD_SIGNALS */
213 #endif /* !HAVE_POSIX_SIGNALS */
215 #if defined (__EMX__)
216 signal (sig, SIG_ACK);
219 #if defined (HAVE_KILL)
220 kill (getpid (), sig);
222 raise (sig); /* assume we have raise */
225 /* Let the signal that we just sent through. */
226 #if defined (HAVE_POSIX_SIGNALS)
227 sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL);
228 #else /* !HAVE_POSIX_SIGNALS */
229 # if defined (HAVE_BSD_SIGNALS)
230 sigsetmask (omask & ~(sigmask (sig)));
231 # endif /* HAVE_BSD_SIGNALS */
232 #endif /* !HAVE_POSIX_SIGNALS */
234 rl_reset_after_signal ();
237 RL_UNSETSTATE(RL_STATE_SIGHANDLER);
241 #if defined (SIGWINCH)
243 rl_sigwinch_handler (sig)
248 #if defined (MUST_REINSTALL_SIGHANDLERS)
249 sighandler_cxt dummy_winch;
251 /* We don't want to change old_winch -- it holds the state of SIGWINCH
252 disposition set by the calling application. We need this state
253 because we call the application's SIGWINCH handler after updating
254 our own idea of the screen size. */
255 rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch);
258 RL_SETSTATE(RL_STATE_SIGHANDLER);
259 rl_resize_terminal ();
261 /* If another sigwinch handler has been installed, call it. */
262 oh = (SigHandler *)old_winch.sa_handler;
263 if (oh && oh != (SigHandler *)SIG_IGN && oh != (SigHandler *)SIG_DFL)
266 RL_UNSETSTATE(RL_STATE_SIGHANDLER);
269 #endif /* SIGWINCH */
271 /* Functions to manage signal handling. */
273 #if !defined (HAVE_POSIX_SIGNALS)
275 rl_sigaction (sig, nh, oh)
277 sighandler_cxt *nh, *oh;
279 oh->sa_handler = signal (sig, nh->sa_handler);
282 #endif /* !HAVE_POSIX_SIGNALS */
284 /* Set up a readline-specific signal handler, saving the old signal
285 information in OHANDLER. Return the old signal handler, like
288 rl_set_sighandler (sig, handler, ohandler)
291 sighandler_cxt *ohandler;
293 sighandler_cxt old_handler;
294 #if defined (HAVE_POSIX_SIGNALS)
295 struct sigaction act;
297 act.sa_handler = handler;
298 # if defined (SIGWINCH)
299 act.sa_flags = (sig == SIGWINCH) ? SA_RESTART : 0;
302 # endif /* SIGWINCH */
303 sigemptyset (&act.sa_mask);
304 sigemptyset (&ohandler->sa_mask);
305 sigaction (sig, &act, &old_handler);
307 old_handler.sa_handler = (SigHandler *)signal (sig, handler);
308 #endif /* !HAVE_POSIX_SIGNALS */
310 /* XXX -- assume we have memcpy */
311 /* If rl_set_signals is called twice in a row, don't set the old handler to
312 rl_signal_handler, because that would cause infinite recursion. */
313 if (handler != rl_signal_handler || old_handler.sa_handler != rl_signal_handler)
314 memcpy (ohandler, &old_handler, sizeof (sighandler_cxt));
316 return (ohandler->sa_handler);
320 rl_maybe_set_sighandler (sig, handler, ohandler)
323 sighandler_cxt *ohandler;
325 sighandler_cxt dummy;
328 sigemptyset (&dummy.sa_mask);
329 oh = rl_set_sighandler (sig, handler, ohandler);
330 if (oh == (SigHandler *)SIG_IGN)
331 rl_sigaction (sig, ohandler, &dummy);
337 sighandler_cxt dummy;
339 #if defined (HAVE_POSIX_SIGNALS)
340 static int sigmask_set = 0;
341 static sigset_t bset, oset;
344 #if defined (HAVE_POSIX_SIGNALS)
345 if (rl_catch_signals && sigmask_set == 0)
349 sigaddset (&bset, SIGINT);
350 sigaddset (&bset, SIGTERM);
351 #if defined (SIGQUIT)
352 sigaddset (&bset, SIGQUIT);
354 #if defined (SIGALRM)
355 sigaddset (&bset, SIGALRM);
357 #if defined (SIGTSTP)
358 sigaddset (&bset, SIGTSTP);
360 #if defined (SIGTTIN)
361 sigaddset (&bset, SIGTTIN);
363 #if defined (SIGTTOU)
364 sigaddset (&bset, SIGTTOU);
368 #endif /* HAVE_POSIX_SIGNALS */
370 if (rl_catch_signals && signals_set_flag == 0)
372 #if defined (HAVE_POSIX_SIGNALS)
374 sigprocmask (SIG_BLOCK, &bset, &oset);
377 rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int);
378 rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term);
379 #if defined (SIGQUIT)
380 rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);
383 #if defined (SIGALRM)
384 oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm);
385 if (oh == (SigHandler *)SIG_IGN)
386 rl_sigaction (SIGALRM, &old_alrm, &dummy);
387 #if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART)
388 /* If the application using readline has already installed a signal
389 handler with SA_RESTART, SIGALRM will cause reads to be restarted
390 automatically, so readline should just get out of the way. Since
391 we tested for SIG_IGN above, we can just test for SIG_DFL here. */
392 if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART))
393 rl_sigaction (SIGALRM, &old_alrm, &dummy);
394 #endif /* HAVE_POSIX_SIGNALS */
397 #if defined (SIGTSTP)
398 rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp);
401 #if defined (SIGTTOU)
402 rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou);
405 #if defined (SIGTTIN)
406 rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin);
409 signals_set_flag = 1;
411 #if defined (HAVE_POSIX_SIGNALS)
412 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
416 #if defined (SIGWINCH)
417 if (rl_catch_sigwinch && sigwinch_set_flag == 0)
419 rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch);
420 sigwinch_set_flag = 1;
422 #endif /* SIGWINCH */
430 sighandler_cxt dummy;
432 if (rl_catch_signals && signals_set_flag == 1)
434 sigemptyset (&dummy.sa_mask);
436 rl_sigaction (SIGINT, &old_int, &dummy);
437 rl_sigaction (SIGTERM, &old_term, &dummy);
438 #if defined (SIGQUIT)
439 rl_sigaction (SIGQUIT, &old_quit, &dummy);
441 #if defined (SIGALRM)
442 rl_sigaction (SIGALRM, &old_alrm, &dummy);
445 #if defined (SIGTSTP)
446 rl_sigaction (SIGTSTP, &old_tstp, &dummy);
449 #if defined (SIGTTOU)
450 rl_sigaction (SIGTTOU, &old_ttou, &dummy);
453 #if defined (SIGTTIN)
454 rl_sigaction (SIGTTIN, &old_ttin, &dummy);
457 signals_set_flag = 0;
460 #if defined (SIGWINCH)
461 if (rl_catch_sigwinch && sigwinch_set_flag == 1)
463 sigemptyset (&dummy.sa_mask);
464 rl_sigaction (SIGWINCH, &old_winch, &dummy);
465 sigwinch_set_flag = 0;
472 /* Clean up the terminal and readline state after catching a signal, before
473 resending it to the calling application. */
475 rl_cleanup_after_signal ()
477 _rl_clean_up_for_exit ();
478 if (rl_deprep_term_function)
479 (*rl_deprep_term_function) ();
480 rl_clear_pending_input ();
484 /* Reset the terminal and readline state after a signal handler returns. */
486 rl_reset_after_signal ()
488 if (rl_prep_term_function)
489 (*rl_prep_term_function) (_rl_meta_flag);
493 /* Free up the readline variable line state for the current line (undo list,
494 any partial history entry, any keyboard macros in progress, and any
495 numeric arguments in process) after catching a signal, before calling
496 rl_cleanup_after_signal(). */
498 rl_free_line_state ()
500 register HIST_ENTRY *entry;
502 rl_free_undo_list ();
504 entry = current_history ();
506 entry->data = (char *)NULL;
508 _rl_kill_kbd_macro ();
510 _rl_reset_argument ();
513 #endif /* HANDLE_SIGNALS */
515 /* **************************************************************** */
517 /* SIGINT Management */
519 /* **************************************************************** */
521 #if defined (HAVE_POSIX_SIGNALS)
522 static sigset_t sigint_set, sigint_oset;
523 static sigset_t sigwinch_set, sigwinch_oset;
524 #else /* !HAVE_POSIX_SIGNALS */
525 # if defined (HAVE_BSD_SIGNALS)
526 static int sigint_oldmask;
527 static int sigwinch_oldmask;
528 # endif /* HAVE_BSD_SIGNALS */
529 #endif /* !HAVE_POSIX_SIGNALS */
531 static int sigint_blocked;
532 static int sigwinch_blocked;
534 /* Cause SIGINT to not be delivered until the corresponding call to
542 #if defined (HAVE_POSIX_SIGNALS)
543 sigemptyset (&sigint_set);
544 sigemptyset (&sigint_oset);
545 sigaddset (&sigint_set, SIGINT);
546 sigprocmask (SIG_BLOCK, &sigint_set, &sigint_oset);
547 #else /* !HAVE_POSIX_SIGNALS */
548 # if defined (HAVE_BSD_SIGNALS)
549 sigint_oldmask = sigblock (sigmask (SIGINT));
550 # else /* !HAVE_BSD_SIGNALS */
551 # if defined (HAVE_USG_SIGHOLD)
553 # endif /* HAVE_USG_SIGHOLD */
554 # endif /* !HAVE_BSD_SIGNALS */
555 #endif /* !HAVE_POSIX_SIGNALS */
560 /* Allow SIGINT to be delivered. */
562 _rl_release_sigint ()
564 if (sigint_blocked == 0)
567 #if defined (HAVE_POSIX_SIGNALS)
568 sigprocmask (SIG_SETMASK, &sigint_oset, (sigset_t *)NULL);
570 # if defined (HAVE_BSD_SIGNALS)
571 sigsetmask (sigint_oldmask);
572 # else /* !HAVE_BSD_SIGNALS */
573 # if defined (HAVE_USG_SIGHOLD)
575 # endif /* HAVE_USG_SIGHOLD */
576 # endif /* !HAVE_BSD_SIGNALS */
577 #endif /* !HAVE_POSIX_SIGNALS */
582 /* Cause SIGWINCH to not be delivered until the corresponding call to
583 release_sigwinch(). */
585 _rl_block_sigwinch ()
587 if (sigwinch_blocked)
590 #if defined (HAVE_POSIX_SIGNALS)
591 sigemptyset (&sigwinch_set);
592 sigemptyset (&sigwinch_oset);
593 sigaddset (&sigwinch_set, SIGWINCH);
594 sigprocmask (SIG_BLOCK, &sigwinch_set, &sigwinch_oset);
595 #else /* !HAVE_POSIX_SIGNALS */
596 # if defined (HAVE_BSD_SIGNALS)
597 sigwinch_oldmask = sigblock (sigmask (SIGWINCH));
598 # else /* !HAVE_BSD_SIGNALS */
599 # if defined (HAVE_USG_SIGHOLD)
601 # endif /* HAVE_USG_SIGHOLD */
602 # endif /* !HAVE_BSD_SIGNALS */
603 #endif /* !HAVE_POSIX_SIGNALS */
605 sigwinch_blocked = 1;
608 /* Allow SIGWINCH to be delivered. */
610 _rl_release_sigwinch ()
612 if (sigwinch_blocked == 0)
615 #if defined (HAVE_POSIX_SIGNALS)
616 sigprocmask (SIG_SETMASK, &sigwinch_oset, (sigset_t *)NULL);
618 # if defined (HAVE_BSD_SIGNALS)
619 sigsetmask (sigwinch_oldmask);
620 # else /* !HAVE_BSD_SIGNALS */
621 # if defined (HAVE_USG_SIGHOLD)
623 # endif /* HAVE_USG_SIGHOLD */
624 # endif /* !HAVE_BSD_SIGNALS */
625 #endif /* !HAVE_POSIX_SIGNALS */
627 sigwinch_blocked = 0;
630 /* **************************************************************** */
632 /* Echoing special control characters */
634 /* **************************************************************** */
636 rl_echo_signal_char (sig)
642 if (_rl_echoctl == 0 || _rl_echo_control_chars == 0)
647 case SIGINT: c = _rl_intr_char; break;
648 #if defined (SIGQUIT)
649 case SIGQUIT: c = _rl_quit_char; break;
651 #if defined (SIGTSTP)
652 case SIGTSTP: c = _rl_susp_char; break;
657 if (CTRL_CHAR (c) || c == RUBOUT)
660 cstr[1] = CTRL_CHAR (c) ? UNCTRL (c) : '?';
661 cstr[cslen = 2] = '\0';
666 cstr[cslen = 1] = '\0';
669 _rl_output_some_chars (cstr, cslen);