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 __P((int, SigHandler *, sighandler_cxt *));
78 /* Exported variables for use by applications. */
80 /* If non-zero, readline will install its own signal handlers for
81 SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
82 int rl_catch_signals = 1;
84 /* If non-zero, readline will install a signal handler for SIGWINCH. */
86 int rl_catch_sigwinch = 1;
89 static int signals_set_flag;
90 static int sigwinch_set_flag;
92 /* **************************************************************** */
96 /* **************************************************************** */
98 static sighandler_cxt old_int, old_term, old_alrm, old_quit;
100 static sighandler_cxt old_tstp, old_ttou, old_ttin;
102 #if defined (SIGWINCH)
103 static sighandler_cxt old_winch;
106 /* Readline signal handler functions. */
109 rl_signal_handler (sig)
112 #if defined (HAVE_POSIX_SIGNALS)
114 #else /* !HAVE_POSIX_SIGNALS */
115 # if defined (HAVE_BSD_SIGNALS)
117 # else /* !HAVE_BSD_SIGNALS */
118 sighandler_cxt dummy_cxt; /* needed for rl_set_sighandler call */
119 # endif /* !HAVE_BSD_SIGNALS */
120 #endif /* !HAVE_POSIX_SIGNALS */
122 RL_SETSTATE(RL_STATE_SIGHANDLER);
124 #if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS)
125 /* Since the signal will not be blocked while we are in the signal
126 handler, ignore it until rl_clear_signals resets the catcher. */
127 if (sig == SIGINT || sig == SIGALRM)
128 rl_set_sighandler (sig, SIG_IGN, &dummy_cxt);
129 #endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */
134 rl_free_line_state ();
137 #if defined (SIGTSTP)
145 rl_cleanup_after_signal ();
147 #if defined (HAVE_POSIX_SIGNALS)
148 sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set);
149 sigdelset (&set, sig);
150 #else /* !HAVE_POSIX_SIGNALS */
151 # if defined (HAVE_BSD_SIGNALS)
152 omask = sigblock (0);
153 # endif /* HAVE_BSD_SIGNALS */
154 #endif /* !HAVE_POSIX_SIGNALS */
156 #if defined (__EMX__)
157 signal (sig, SIG_ACK);
160 kill (getpid (), sig);
162 /* Let the signal that we just sent through. */
163 #if defined (HAVE_POSIX_SIGNALS)
164 sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL);
165 #else /* !HAVE_POSIX_SIGNALS */
166 # if defined (HAVE_BSD_SIGNALS)
167 sigsetmask (omask & ~(sigmask (sig)));
168 # endif /* HAVE_BSD_SIGNALS */
169 #endif /* !HAVE_POSIX_SIGNALS */
171 rl_reset_after_signal ();
174 RL_UNSETSTATE(RL_STATE_SIGHANDLER);
178 #if defined (SIGWINCH)
180 rl_sigwinch_handler (sig)
185 #if defined (MUST_REINSTALL_SIGHANDLERS)
186 sighandler_cxt dummy_winch;
188 /* We don't want to change old_winch -- it holds the state of SIGWINCH
189 disposition set by the calling application. We need this state
190 because we call the application's SIGWINCH handler after updating
191 our own idea of the screen size. */
192 rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch);
195 RL_SETSTATE(RL_STATE_SIGHANDLER);
196 rl_resize_terminal ();
198 /* If another sigwinch handler has been installed, call it. */
199 oh = (SigHandler *)old_winch.sa_handler;
200 if (oh && oh != (SigHandler *)SIG_IGN && oh != (SigHandler *)SIG_DFL)
203 RL_UNSETSTATE(RL_STATE_SIGHANDLER);
206 #endif /* SIGWINCH */
208 /* Functions to manage signal handling. */
210 #if !defined (HAVE_POSIX_SIGNALS)
212 rl_sigaction (sig, nh, oh)
214 sighandler_cxt *nh, *oh;
216 oh->sa_handler = signal (sig, nh->sa_handler);
219 #endif /* !HAVE_POSIX_SIGNALS */
221 /* Set up a readline-specific signal handler, saving the old signal
222 information in OHANDLER. Return the old signal handler, like
225 rl_set_sighandler (sig, handler, ohandler)
228 sighandler_cxt *ohandler;
230 sighandler_cxt old_handler;
231 #if defined (HAVE_POSIX_SIGNALS)
232 struct sigaction act;
234 act.sa_handler = handler;
236 sigemptyset (&act.sa_mask);
237 sigemptyset (&ohandler->sa_mask);
238 sigaction (sig, &act, &old_handler);
240 old_handler.sa_handler = (SigHandler *)signal (sig, handler);
241 #endif /* !HAVE_POSIX_SIGNALS */
243 /* XXX -- assume we have memcpy */
244 /* If rl_set_signals is called twice in a row, don't set the old handler to
245 rl_signal_handler, because that would cause infinite recursion. */
246 if (handler != rl_signal_handler || old_handler.sa_handler != rl_signal_handler)
247 memcpy (ohandler, &old_handler, sizeof (sighandler_cxt));
249 return (ohandler->sa_handler);
253 rl_maybe_set_sighandler (sig, handler, ohandler)
256 sighandler_cxt *ohandler;
258 sighandler_cxt dummy;
261 sigemptyset (&dummy.sa_mask);
262 oh = rl_set_sighandler (sig, handler, ohandler);
263 if (oh == (SigHandler *)SIG_IGN)
264 rl_sigaction (sig, ohandler, &dummy);
270 sighandler_cxt dummy;
273 if (rl_catch_signals && signals_set_flag == 0)
275 rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int);
276 rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term);
277 rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);
279 oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm);
280 if (oh == (SigHandler *)SIG_IGN)
281 rl_sigaction (SIGALRM, &old_alrm, &dummy);
282 #if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART)
283 /* If the application using readline has already installed a signal
284 handler with SA_RESTART, SIGALRM will cause reads to be restarted
285 automatically, so readline should just get out of the way. Since
286 we tested for SIG_IGN above, we can just test for SIG_DFL here. */
287 if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART))
288 rl_sigaction (SIGALRM, &old_alrm, &dummy);
289 #endif /* HAVE_POSIX_SIGNALS */
291 #if defined (SIGTSTP)
292 rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp);
295 #if defined (SIGTTOU)
296 rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou);
299 #if defined (SIGTTIN)
300 rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin);
303 signals_set_flag = 1;
306 #if defined (SIGWINCH)
307 if (rl_catch_sigwinch && sigwinch_set_flag == 0)
309 rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch);
310 sigwinch_set_flag = 1;
312 #endif /* SIGWINCH */
320 sighandler_cxt dummy;
322 if (rl_catch_signals && signals_set_flag == 1)
324 sigemptyset (&dummy.sa_mask);
326 rl_sigaction (SIGINT, &old_int, &dummy);
327 rl_sigaction (SIGTERM, &old_term, &dummy);
328 rl_sigaction (SIGQUIT, &old_quit, &dummy);
329 rl_sigaction (SIGALRM, &old_alrm, &dummy);
331 #if defined (SIGTSTP)
332 rl_sigaction (SIGTSTP, &old_tstp, &dummy);
335 #if defined (SIGTTOU)
336 rl_sigaction (SIGTTOU, &old_ttou, &dummy);
339 #if defined (SIGTTIN)
340 rl_sigaction (SIGTTIN, &old_ttin, &dummy);
343 signals_set_flag = 0;
346 #if defined (SIGWINCH)
347 if (rl_catch_sigwinch && sigwinch_set_flag == 1)
349 sigemptyset (&dummy.sa_mask);
350 rl_sigaction (SIGWINCH, &old_winch, &dummy);
351 sigwinch_set_flag = 0;
358 /* Clean up the terminal and readline state after catching a signal, before
359 resending it to the calling application. */
361 rl_cleanup_after_signal ()
363 _rl_clean_up_for_exit ();
364 (*rl_deprep_term_function) ();
366 rl_clear_pending_input ();
369 /* Reset the terminal and readline state after a signal handler returns. */
371 rl_reset_after_signal ()
373 (*rl_prep_term_function) (_rl_meta_flag);
377 /* Free up the readline variable line state for the current line (undo list,
378 any partial history entry, any keyboard macros in progress, and any
379 numeric arguments in process) after catching a signal, before calling
380 rl_cleanup_after_signal(). */
382 rl_free_line_state ()
384 register HIST_ENTRY *entry;
386 rl_free_undo_list ();
388 entry = current_history ();
390 entry->data = (char *)NULL;
392 _rl_kill_kbd_macro ();
394 _rl_init_argument ();
397 #endif /* HANDLE_SIGNALS */