1 /* signals.c -- signal handling support for readline. */
3 /* Copyright (C) 1987, 1989, 1992 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 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
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 #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 */
76 static SigHandler
*rl_set_sighandler
PARAMS((int, SigHandler
*, sighandler_cxt
*));
77 static void rl_maybe_set_sighandler
PARAMS((int, SigHandler
*, sighandler_cxt
*));
79 /* Exported variables for use by applications. */
81 /* If non-zero, readline will install its own signal handlers for
82 SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
83 int rl_catch_signals
= 1;
85 /* If non-zero, readline will install a signal handler for SIGWINCH. */
87 int rl_catch_sigwinch
= 1;
90 static int signals_set_flag
;
92 static int sigwinch_set_flag
;
95 /* **************************************************************** */
99 /* **************************************************************** */
101 static sighandler_cxt old_int
, old_term
, old_alrm
, old_quit
;
102 #if defined (SIGTSTP)
103 static sighandler_cxt old_tstp
, old_ttou
, old_ttin
;
105 #if defined (SIGWINCH)
106 static sighandler_cxt old_winch
;
109 /* Readline signal handler functions. */
112 rl_signal_handler (sig
)
115 #if defined (HAVE_POSIX_SIGNALS)
117 #else /* !HAVE_POSIX_SIGNALS */
118 # if defined (HAVE_BSD_SIGNALS)
120 # else /* !HAVE_BSD_SIGNALS */
121 sighandler_cxt dummy_cxt
; /* needed for rl_set_sighandler call */
122 # endif /* !HAVE_BSD_SIGNALS */
123 #endif /* !HAVE_POSIX_SIGNALS */
125 RL_SETSTATE(RL_STATE_SIGHANDLER
);
127 #if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS)
128 /* Since the signal will not be blocked while we are in the signal
129 handler, ignore it until rl_clear_signals resets the catcher. */
135 rl_set_sighandler (sig
, SIG_IGN
, &dummy_cxt
);
136 #endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */
141 rl_free_line_state ();
144 #if defined (SIGTSTP)
156 rl_cleanup_after_signal ();
158 #if defined (HAVE_POSIX_SIGNALS)
159 sigprocmask (SIG_BLOCK
, (sigset_t
*)NULL
, &set
);
160 sigdelset (&set
, sig
);
161 #else /* !HAVE_POSIX_SIGNALS */
162 # if defined (HAVE_BSD_SIGNALS)
163 omask
= sigblock (0);
164 # endif /* HAVE_BSD_SIGNALS */
165 #endif /* !HAVE_POSIX_SIGNALS */
167 #if defined (__EMX__)
168 signal (sig
, SIG_ACK
);
171 /* If we have the POSIX kill function, use it; otherwise, fall
172 back to the ISO C raise function. (Windows is an example of
173 a platform that has raise, but not kill.) */
175 kill (getpid (), sig
);
180 /* Let the signal that we just sent through. */
181 #if defined (HAVE_POSIX_SIGNALS)
182 sigprocmask (SIG_SETMASK
, &set
, (sigset_t
*)NULL
);
183 #else /* !HAVE_POSIX_SIGNALS */
184 # if defined (HAVE_BSD_SIGNALS)
185 sigsetmask (omask
& ~(sigmask (sig
)));
186 # endif /* HAVE_BSD_SIGNALS */
187 #endif /* !HAVE_POSIX_SIGNALS */
189 rl_reset_after_signal ();
192 RL_UNSETSTATE(RL_STATE_SIGHANDLER
);
196 #if defined (SIGWINCH)
198 rl_sigwinch_handler (sig
)
203 #if defined (MUST_REINSTALL_SIGHANDLERS)
204 sighandler_cxt dummy_winch
;
206 /* We don't want to change old_winch -- it holds the state of SIGWINCH
207 disposition set by the calling application. We need this state
208 because we call the application's SIGWINCH handler after updating
209 our own idea of the screen size. */
210 rl_set_sighandler (SIGWINCH
, rl_sigwinch_handler
, &dummy_winch
);
213 RL_SETSTATE(RL_STATE_SIGHANDLER
);
214 rl_resize_terminal ();
216 /* If another sigwinch handler has been installed, call it. */
217 oh
= (SigHandler
*)old_winch
.sa_handler
;
218 if (oh
&& oh
!= (SigHandler
*)SIG_IGN
&& oh
!= (SigHandler
*)SIG_DFL
)
221 RL_UNSETSTATE(RL_STATE_SIGHANDLER
);
224 #endif /* SIGWINCH */
226 /* Functions to manage signal handling. */
228 #if !defined (HAVE_POSIX_SIGNALS)
230 rl_sigaction (sig
, nh
, oh
)
232 sighandler_cxt
*nh
, *oh
;
234 oh
->sa_handler
= signal (sig
, nh
->sa_handler
);
237 #endif /* !HAVE_POSIX_SIGNALS */
239 /* Set up a readline-specific signal handler, saving the old signal
240 information in OHANDLER. Return the old signal handler, like
243 rl_set_sighandler (sig
, handler
, ohandler
)
246 sighandler_cxt
*ohandler
;
248 sighandler_cxt old_handler
;
249 #if defined (HAVE_POSIX_SIGNALS)
250 struct sigaction act
;
252 act
.sa_handler
= handler
;
253 act
.sa_flags
= 0; /* XXX - should we set SA_RESTART for SIGWINCH? */
254 sigemptyset (&act
.sa_mask
);
255 sigemptyset (&ohandler
->sa_mask
);
256 sigaction (sig
, &act
, &old_handler
);
258 old_handler
.sa_handler
= (SigHandler
*)signal (sig
, handler
);
259 #endif /* !HAVE_POSIX_SIGNALS */
261 /* XXX -- assume we have memcpy */
262 /* If rl_set_signals is called twice in a row, don't set the old handler to
263 rl_signal_handler, because that would cause infinite recursion. */
264 if (handler
!= rl_signal_handler
|| old_handler
.sa_handler
!= rl_signal_handler
)
265 memcpy (ohandler
, &old_handler
, sizeof (sighandler_cxt
));
267 return (ohandler
->sa_handler
);
271 rl_maybe_set_sighandler (sig
, handler
, ohandler
)
274 sighandler_cxt
*ohandler
;
276 sighandler_cxt dummy
;
279 sigemptyset (&dummy
.sa_mask
);
280 oh
= rl_set_sighandler (sig
, handler
, ohandler
);
281 if (oh
== (SigHandler
*)SIG_IGN
)
282 rl_sigaction (sig
, ohandler
, &dummy
);
288 sighandler_cxt dummy
;
291 if (rl_catch_signals
&& signals_set_flag
== 0)
293 rl_maybe_set_sighandler (SIGINT
, rl_signal_handler
, &old_int
);
294 rl_maybe_set_sighandler (SIGTERM
, rl_signal_handler
, &old_term
);
296 rl_maybe_set_sighandler (SIGQUIT
, rl_signal_handler
, &old_quit
);
300 oh
= rl_set_sighandler (SIGALRM
, rl_signal_handler
, &old_alrm
);
301 if (oh
== (SigHandler
*)SIG_IGN
)
302 rl_sigaction (SIGALRM
, &old_alrm
, &dummy
);
303 #if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART)
304 /* If the application using readline has already installed a signal
305 handler with SA_RESTART, SIGALRM will cause reads to be restarted
306 automatically, so readline should just get out of the way. Since
307 we tested for SIG_IGN above, we can just test for SIG_DFL here. */
308 if (oh
!= (SigHandler
*)SIG_DFL
&& (old_alrm
.sa_flags
& SA_RESTART
))
309 rl_sigaction (SIGALRM
, &old_alrm
, &dummy
);
310 #endif /* HAVE_POSIX_SIGNALS */
313 #if defined (SIGTSTP)
314 rl_maybe_set_sighandler (SIGTSTP
, rl_signal_handler
, &old_tstp
);
317 #if defined (SIGTTOU)
318 rl_maybe_set_sighandler (SIGTTOU
, rl_signal_handler
, &old_ttou
);
321 #if defined (SIGTTIN)
322 rl_maybe_set_sighandler (SIGTTIN
, rl_signal_handler
, &old_ttin
);
325 signals_set_flag
= 1;
328 #if defined (SIGWINCH)
329 if (rl_catch_sigwinch
&& sigwinch_set_flag
== 0)
331 rl_maybe_set_sighandler (SIGWINCH
, rl_sigwinch_handler
, &old_winch
);
332 sigwinch_set_flag
= 1;
334 #endif /* SIGWINCH */
342 sighandler_cxt dummy
;
344 if (rl_catch_signals
&& signals_set_flag
== 1)
346 sigemptyset (&dummy
.sa_mask
);
348 rl_sigaction (SIGINT
, &old_int
, &dummy
);
349 rl_sigaction (SIGTERM
, &old_term
, &dummy
);
351 rl_sigaction (SIGQUIT
, &old_quit
, &dummy
);
354 rl_sigaction (SIGALRM
, &old_alrm
, &dummy
);
357 #if defined (SIGTSTP)
358 rl_sigaction (SIGTSTP
, &old_tstp
, &dummy
);
361 #if defined (SIGTTOU)
362 rl_sigaction (SIGTTOU
, &old_ttou
, &dummy
);
365 #if defined (SIGTTIN)
366 rl_sigaction (SIGTTIN
, &old_ttin
, &dummy
);
369 signals_set_flag
= 0;
372 #if defined (SIGWINCH)
373 if (rl_catch_sigwinch
&& sigwinch_set_flag
== 1)
375 sigemptyset (&dummy
.sa_mask
);
376 rl_sigaction (SIGWINCH
, &old_winch
, &dummy
);
377 sigwinch_set_flag
= 0;
384 /* Clean up the terminal and readline state after catching a signal, before
385 resending it to the calling application. */
387 rl_cleanup_after_signal ()
389 _rl_clean_up_for_exit ();
390 (*rl_deprep_term_function
) ();
392 rl_clear_pending_input ();
395 /* Reset the terminal and readline state after a signal handler returns. */
397 rl_reset_after_signal ()
399 (*rl_prep_term_function
) (_rl_meta_flag
);
403 /* Free up the readline variable line state for the current line (undo list,
404 any partial history entry, any keyboard macros in progress, and any
405 numeric arguments in process) after catching a signal, before calling
406 rl_cleanup_after_signal(). */
408 rl_free_line_state ()
410 register HIST_ENTRY
*entry
;
412 rl_free_undo_list ();
414 entry
= current_history ();
416 entry
->data
= (char *)NULL
;
418 _rl_kill_kbd_macro ();
420 _rl_init_argument ();
423 #endif /* HANDLE_SIGNALS */