1 /* signals.c -- signal handling support for readline. */
3 /* Copyright (C) 1987-2005 Free Software Foundation, Inc.
5 This file is part of the GNU Readline Library, a library for
6 reading lines of text with interactive input and history editing.
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.
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.
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 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
22 #define READLINE_LIBRARY
24 #if defined (HAVE_CONFIG_H)
25 # include "config_readline.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 #if defined (HANDLE_SIGNALS)
44 /* Some standard library routines. */
48 #include "rlprivate.h"
50 #if !defined (RETSIGTYPE)
51 # if defined (VOID_SIGHANDLER)
52 # define RETSIGTYPE void
54 # define RETSIGTYPE int
55 # endif /* !VOID_SIGHANDLER */
56 #endif /* !RETSIGTYPE */
58 #if defined (VOID_SIGHANDLER)
59 # define SIGHANDLER_RETURN return
61 # define SIGHANDLER_RETURN return (0)
64 /* This typedef is equivalent to the one for Function; it allows us
65 to say SigHandler *foo = signal (SIGKILL, SIG_IGN); */
66 typedef RETSIGTYPE
SigHandler ();
68 #if defined (HAVE_POSIX_SIGNALS)
69 typedef struct sigaction sighandler_cxt
;
70 # define rl_sigaction(s, nh, oh) sigaction(s, nh, oh)
72 typedef struct { SigHandler
*sa_handler
; int sa_mask
, sa_flags
; } sighandler_cxt
;
73 # define sigemptyset(m)
74 #endif /* !HAVE_POSIX_SIGNALS */
80 static SigHandler
*rl_set_sighandler
PARAMS((int, SigHandler
*, sighandler_cxt
*));
81 static void rl_maybe_set_sighandler
PARAMS((int, SigHandler
*, sighandler_cxt
*));
83 /* Exported variables for use by applications. */
85 /* If non-zero, readline will install its own signal handlers for
86 SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
87 int rl_catch_signals
= 1;
89 /* If non-zero, readline will install a signal handler for SIGWINCH. */
91 int rl_catch_sigwinch
= 1;
93 int rl_catch_sigwinch
= 0; /* for the readline state struct in readline.c */
96 static int signals_set_flag
;
97 static int sigwinch_set_flag
;
99 /* **************************************************************** */
101 /* Signal Handling */
103 /* **************************************************************** */
105 static sighandler_cxt old_int
, old_term
, old_alrm
, old_quit
;
106 #if defined (SIGTSTP)
107 static sighandler_cxt old_tstp
, old_ttou
, old_ttin
;
109 #if defined (SIGWINCH)
110 static sighandler_cxt old_winch
;
113 /* Readline signal handler functions. */
116 rl_signal_handler (sig
)
119 #if defined (HAVE_POSIX_SIGNALS)
121 #else /* !HAVE_POSIX_SIGNALS */
122 # if defined (HAVE_BSD_SIGNALS)
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 */
129 RL_SETSTATE(RL_STATE_SIGHANDLER
);
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
)
139 rl_set_sighandler (sig
, SIG_IGN
, &dummy_cxt
);
140 #endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */
145 rl_free_line_state ();
149 #if defined (SIGTSTP)
154 #if defined (SIGALRM)
157 #if defined (SIGQUIT)
160 rl_cleanup_after_signal ();
162 #if defined (HAVE_POSIX_SIGNALS)
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 */
172 #if defined (__EMX__)
173 signal (sig
, SIG_ACK
);
176 #if defined (HAVE_KILL)
177 kill (getpid (), sig
);
179 raise (sig
); /* assume we have raise */
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 */
191 rl_reset_after_signal ();
194 RL_UNSETSTATE(RL_STATE_SIGHANDLER
);
198 #if defined (SIGWINCH)
200 rl_sigwinch_handler (sig
)
205 #if defined (MUST_REINSTALL_SIGHANDLERS)
206 sighandler_cxt dummy_winch
;
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
);
215 RL_SETSTATE(RL_STATE_SIGHANDLER
);
216 rl_resize_terminal ();
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
)
223 RL_UNSETSTATE(RL_STATE_SIGHANDLER
);
226 #endif /* SIGWINCH */
228 /* Functions to manage signal handling. */
230 #if !defined (HAVE_POSIX_SIGNALS)
232 rl_sigaction (sig
, nh
, oh
)
234 sighandler_cxt
*nh
, *oh
;
236 oh
->sa_handler
= signal (sig
, nh
->sa_handler
);
239 #endif /* !HAVE_POSIX_SIGNALS */
241 /* Set up a readline-specific signal handler, saving the old signal
242 information in OHANDLER. Return the old signal handler, like
245 rl_set_sighandler (sig
, handler
, ohandler
)
248 sighandler_cxt
*ohandler
;
250 sighandler_cxt old_handler
;
251 #if defined (HAVE_POSIX_SIGNALS)
252 struct sigaction act
;
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
);
260 old_handler
.sa_handler
= (SigHandler
*)signal (sig
, handler
);
261 #endif /* !HAVE_POSIX_SIGNALS */
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
));
269 return (ohandler
->sa_handler
);
273 rl_maybe_set_sighandler (sig
, handler
, ohandler
)
276 sighandler_cxt
*ohandler
;
278 sighandler_cxt dummy
;
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
);
290 sighandler_cxt dummy
;
292 #if defined (HAVE_POSIX_SIGNALS)
293 static int sigmask_set
= 0;
294 static sigset_t bset
, oset
;
297 #if defined (HAVE_POSIX_SIGNALS)
298 if (rl_catch_signals
&& sigmask_set
== 0)
302 sigaddset (&bset
, SIGINT
);
303 sigaddset (&bset
, SIGINT
);
304 #if defined (SIGQUIT)
305 sigaddset (&bset
, SIGQUIT
);
307 #if defined (SIGALRM)
308 sigaddset (&bset
, SIGALRM
);
310 #if defined (SIGTSTP)
311 sigaddset (&bset
, SIGTSTP
);
313 #if defined (SIGTTIN)
314 sigaddset (&bset
, SIGTTIN
);
316 #if defined (SIGTTOU)
317 sigaddset (&bset
, SIGTTOU
);
321 #endif /* HAVE_POSIX_SIGNALS */
323 if (rl_catch_signals
&& signals_set_flag
== 0)
325 #if defined (HAVE_POSIX_SIGNALS)
327 sigprocmask (SIG_BLOCK
, &bset
, &oset
);
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
);
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 */
350 #if defined (SIGTSTP)
351 rl_maybe_set_sighandler (SIGTSTP
, rl_signal_handler
, &old_tstp
);
354 #if defined (SIGTTOU)
355 rl_maybe_set_sighandler (SIGTTOU
, rl_signal_handler
, &old_ttou
);
358 #if defined (SIGTTIN)
359 rl_maybe_set_sighandler (SIGTTIN
, rl_signal_handler
, &old_ttin
);
362 signals_set_flag
= 1;
364 #if defined (HAVE_POSIX_SIGNALS)
365 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
369 #if defined (SIGWINCH)
370 if (rl_catch_sigwinch
&& sigwinch_set_flag
== 0)
372 rl_maybe_set_sighandler (SIGWINCH
, rl_sigwinch_handler
, &old_winch
);
373 sigwinch_set_flag
= 1;
375 #endif /* SIGWINCH */
383 sighandler_cxt dummy
;
385 if (rl_catch_signals
&& signals_set_flag
== 1)
387 sigemptyset (&dummy
.sa_mask
);
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
);
394 #if defined (SIGALRM)
395 rl_sigaction (SIGALRM
, &old_alrm
, &dummy
);
398 #if defined (SIGTSTP)
399 rl_sigaction (SIGTSTP
, &old_tstp
, &dummy
);
402 #if defined (SIGTTOU)
403 rl_sigaction (SIGTTOU
, &old_ttou
, &dummy
);
406 #if defined (SIGTTIN)
407 rl_sigaction (SIGTTIN
, &old_ttin
, &dummy
);
410 signals_set_flag
= 0;
413 #if defined (SIGWINCH)
414 if (rl_catch_sigwinch
&& sigwinch_set_flag
== 1)
416 sigemptyset (&dummy
.sa_mask
);
417 rl_sigaction (SIGWINCH
, &old_winch
, &dummy
);
418 sigwinch_set_flag
= 0;
425 /* Clean up the terminal and readline state after catching a signal, before
426 resending it to the calling application. */
428 rl_cleanup_after_signal ()
430 _rl_clean_up_for_exit ();
431 if (rl_deprep_term_function
)
432 (*rl_deprep_term_function
) ();
433 rl_clear_pending_input ();
437 /* Reset the terminal and readline state after a signal handler returns. */
439 rl_reset_after_signal ()
441 if (rl_prep_term_function
)
442 (*rl_prep_term_function
) (_rl_meta_flag
);
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(). */
451 rl_free_line_state ()
453 register HIST_ENTRY
*entry
;
455 rl_free_undo_list ();
457 entry
= current_history ();
459 entry
->data
= (char *)NULL
;
461 _rl_kill_kbd_macro ();
463 _rl_reset_argument ();
466 #endif /* HANDLE_SIGNALS */