import of readlilne 5.1
[external/binutils.git] / readline / signals.c
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); */
66 typedef RETSIGTYPE SigHandler ();
67
68 #if defined (HAVE_POSIX_SIGNALS)
69 typedef struct sigaction sighandler_cxt;
70 #  define rl_sigaction(s, nh, oh)       sigaction(s, nh, oh)
71 #else
72 typedef 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
80 static SigHandler *rl_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
81 static 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. */
87 int rl_catch_signals = 1;
88
89 /* If non-zero, readline will install a signal handler for SIGWINCH. */
90 #ifdef SIGWINCH
91 int rl_catch_sigwinch = 1;
92 #else
93 int rl_catch_sigwinch = 0;      /* for the readline state struct in readline.c */
94 #endif
95
96 static int signals_set_flag;
97 static int sigwinch_set_flag;
98
99 /* **************************************************************** */
100 /*                                                                  */
101 /*                         Signal Handling                          */
102 /*                                                                  */
103 /* **************************************************************** */
104
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;
108 #endif
109 #if defined (SIGWINCH)
110 static sighandler_cxt old_winch;
111 #endif
112
113 /* Readline signal handler functions. */
114
115 static RETSIGTYPE
116 rl_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)
198 static RETSIGTYPE
199 rl_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)
230 static int
231 rl_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(). */
243 static SigHandler *
244 rl_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
271 static void
272 rl_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
286 int
287 rl_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
340 int
341 rl_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. */
387 void
388 rl_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. */
398 void
399 rl_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(). */ 
410 void
411 rl_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 */