source: vendor/bash/3.1/lib/readline/signals.c

Last change on this file was 3228, checked in by bird, 18 years ago

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