Automatic date update in version.in
[external/binutils.git] / readline / signals.c
1 /* signals.c -- signal handling support for readline. */
2
3 /* Copyright (C) 1987-2009 Free Software Foundation, Inc.
4
5    This file is part of the GNU Readline Library (Readline), a library
6    for reading lines of text with interactive input and history editing.      
7
8    Readline is free software: you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation, either version 3 of the License, or
11    (at your option) any later version.
12
13    Readline is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with Readline.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
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 /* Some standard library routines. */
44 #include "readline.h"
45 #include "history.h"
46
47 #include "rlprivate.h"
48
49 #if defined (HANDLE_SIGNALS)
50
51 #if !defined (RETSIGTYPE)
52 #  if defined (VOID_SIGHANDLER)
53 #    define RETSIGTYPE void
54 #  else
55 #    define RETSIGTYPE int
56 #  endif /* !VOID_SIGHANDLER */
57 #endif /* !RETSIGTYPE */
58
59 #if defined (VOID_SIGHANDLER)
60 #  define SIGHANDLER_RETURN return
61 #else
62 #  define SIGHANDLER_RETURN return (0)
63 #endif
64
65 /* This typedef is equivalent to the one for Function; it allows us
66    to say SigHandler *foo = signal (SIGKILL, SIG_IGN); */
67 typedef RETSIGTYPE SigHandler ();
68
69 #if defined (HAVE_POSIX_SIGNALS)
70 typedef struct sigaction sighandler_cxt;
71 #  define rl_sigaction(s, nh, oh)       sigaction(s, nh, oh)
72 #else
73 typedef struct { SigHandler *sa_handler; int sa_mask, sa_flags; } sighandler_cxt;
74 #  define sigemptyset(m)
75 #endif /* !HAVE_POSIX_SIGNALS */
76
77 #ifndef SA_RESTART
78 #  define SA_RESTART 0
79 #endif
80
81 static SigHandler *rl_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
82 static void rl_maybe_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
83
84 static RETSIGTYPE rl_signal_handler PARAMS((int));
85 static RETSIGTYPE _rl_handle_signal PARAMS((int));
86      
87 /* Exported variables for use by applications. */
88
89 /* If non-zero, readline will install its own signal handlers for
90    SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
91 int rl_catch_signals = 1;
92
93 /* If non-zero, readline will install a signal handler for SIGWINCH. */
94 #ifdef SIGWINCH
95 int rl_catch_sigwinch = 1;
96 #else
97 int rl_catch_sigwinch = 0;      /* for the readline state struct in readline.c */
98 #endif
99
100 /* Private variables. */
101 int _rl_interrupt_immediately = 0;
102 int volatile _rl_caught_signal = 0;     /* should be sig_atomic_t, but that requires including <signal.h> everywhere */
103
104 /* If non-zero, print characters corresponding to received signals as long as
105    the user has indicated his desire to do so (_rl_echo_control_chars). */
106 int _rl_echoctl = 0;
107
108 int _rl_intr_char = 0;
109 int _rl_quit_char = 0;
110 int _rl_susp_char = 0;
111
112 static int signals_set_flag;
113 static int sigwinch_set_flag;
114
115 /* **************************************************************** */
116 /*                                                                  */
117 /*                         Signal Handling                          */
118 /*                                                                  */
119 /* **************************************************************** */
120
121 static sighandler_cxt old_int, old_term, old_alrm, old_quit;
122 #if defined (SIGTSTP)
123 static sighandler_cxt old_tstp, old_ttou, old_ttin;
124 #endif
125 #if defined (SIGWINCH)
126 static sighandler_cxt old_winch;
127 #endif
128
129 /* Readline signal handler functions. */
130
131 /* Called from RL_CHECK_SIGNALS() macro */
132 RETSIGTYPE
133 _rl_signal_handler (sig)
134      int sig;
135 {
136   _rl_caught_signal = 0;        /* XXX */
137
138   _rl_handle_signal (sig);
139   SIGHANDLER_RETURN;
140 }
141
142 static RETSIGTYPE
143 rl_signal_handler (sig)
144      int sig;
145 {
146   if (_rl_interrupt_immediately || RL_ISSTATE(RL_STATE_CALLBACK))
147     {
148       _rl_interrupt_immediately = 0;
149       _rl_handle_signal (sig);
150     }
151   else
152     _rl_caught_signal = sig;
153
154   SIGHANDLER_RETURN;
155 }
156
157 static RETSIGTYPE
158 _rl_handle_signal (sig)
159      int sig;
160 {
161 #if defined (HAVE_POSIX_SIGNALS)
162   sigset_t set;
163 #else /* !HAVE_POSIX_SIGNALS */
164 #  if defined (HAVE_BSD_SIGNALS)
165   long omask;
166 #  else /* !HAVE_BSD_SIGNALS */
167   sighandler_cxt dummy_cxt;     /* needed for rl_set_sighandler call */
168 #  endif /* !HAVE_BSD_SIGNALS */
169 #endif /* !HAVE_POSIX_SIGNALS */
170
171   RL_SETSTATE(RL_STATE_SIGHANDLER);
172
173 #if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS)
174   /* Since the signal will not be blocked while we are in the signal
175      handler, ignore it until rl_clear_signals resets the catcher. */
176 #  if defined (SIGALRM)
177   if (sig == SIGINT || sig == SIGALRM)
178 #  else
179   if (sig == SIGINT)
180 #  endif
181     rl_set_sighandler (sig, SIG_IGN, &dummy_cxt);
182 #endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */
183
184   switch (sig)
185     {
186     case SIGINT:
187       _rl_reset_completion_state ();
188       rl_free_line_state ();
189       /* FALLTHROUGH */
190
191     case SIGTERM:
192 #if defined (SIGTSTP)
193     case SIGTSTP:
194     case SIGTTOU:
195     case SIGTTIN:
196 #endif /* SIGTSTP */
197 #if defined (SIGALRM)
198     case SIGALRM:
199 #endif
200 #if defined (SIGQUIT)
201     case SIGQUIT:
202 #endif
203       rl_echo_signal_char (sig);
204       rl_cleanup_after_signal ();
205
206 #if defined (HAVE_POSIX_SIGNALS)
207       sigemptyset (&set);
208       sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set);
209       sigdelset (&set, sig);
210 #else /* !HAVE_POSIX_SIGNALS */
211 #  if defined (HAVE_BSD_SIGNALS)
212       omask = sigblock (0);
213 #  endif /* HAVE_BSD_SIGNALS */
214 #endif /* !HAVE_POSIX_SIGNALS */
215
216 #if defined (__EMX__)
217       signal (sig, SIG_ACK);
218 #endif
219
220 #if defined (HAVE_KILL)
221       kill (getpid (), sig);
222 #else
223       raise (sig);              /* assume we have raise */
224 #endif
225
226       /* Let the signal that we just sent through.  */
227 #if defined (HAVE_POSIX_SIGNALS)
228       sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL);
229 #else /* !HAVE_POSIX_SIGNALS */
230 #  if defined (HAVE_BSD_SIGNALS)
231       sigsetmask (omask & ~(sigmask (sig)));
232 #  endif /* HAVE_BSD_SIGNALS */
233 #endif /* !HAVE_POSIX_SIGNALS */
234
235       rl_reset_after_signal ();
236     }
237
238   RL_UNSETSTATE(RL_STATE_SIGHANDLER);
239   SIGHANDLER_RETURN;
240 }
241
242 #if defined (SIGWINCH)
243 static RETSIGTYPE
244 rl_sigwinch_handler (sig)
245      int sig;
246 {
247   SigHandler *oh;
248
249 #if defined (MUST_REINSTALL_SIGHANDLERS)
250   sighandler_cxt dummy_winch;
251
252   /* We don't want to change old_winch -- it holds the state of SIGWINCH
253      disposition set by the calling application.  We need this state
254      because we call the application's SIGWINCH handler after updating
255      our own idea of the screen size. */
256   rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch);
257 #endif
258
259   RL_SETSTATE(RL_STATE_SIGHANDLER);
260   rl_resize_terminal ();
261
262   /* If another sigwinch handler has been installed, call it. */
263   oh = (SigHandler *)old_winch.sa_handler;
264   if (oh &&  oh != (SigHandler *)SIG_IGN && oh != (SigHandler *)SIG_DFL)
265     (*oh) (sig);
266
267   RL_UNSETSTATE(RL_STATE_SIGHANDLER);
268   SIGHANDLER_RETURN;
269 }
270 #endif  /* SIGWINCH */
271
272 /* Functions to manage signal handling. */
273
274 #if !defined (HAVE_POSIX_SIGNALS)
275 static int
276 rl_sigaction (sig, nh, oh)
277      int sig;
278      sighandler_cxt *nh, *oh;
279 {
280   oh->sa_handler = signal (sig, nh->sa_handler);
281   return 0;
282 }
283 #endif /* !HAVE_POSIX_SIGNALS */
284
285 /* Set up a readline-specific signal handler, saving the old signal
286    information in OHANDLER.  Return the old signal handler, like
287    signal(). */
288 static SigHandler *
289 rl_set_sighandler (sig, handler, ohandler)
290      int sig;
291      SigHandler *handler;
292      sighandler_cxt *ohandler;
293 {
294   sighandler_cxt old_handler;
295 #if defined (HAVE_POSIX_SIGNALS)
296   struct sigaction act;
297
298   act.sa_handler = handler;
299 #  if defined (SIGWINCH)
300   act.sa_flags = (sig == SIGWINCH) ? SA_RESTART : 0;
301 #  else
302   act.sa_flags = 0;
303 #  endif /* SIGWINCH */
304   sigemptyset (&act.sa_mask);
305   sigemptyset (&ohandler->sa_mask);
306   sigaction (sig, &act, &old_handler);
307 #else
308   old_handler.sa_handler = (SigHandler *)signal (sig, handler);
309 #endif /* !HAVE_POSIX_SIGNALS */
310
311   /* XXX -- assume we have memcpy */
312   /* If rl_set_signals is called twice in a row, don't set the old handler to
313      rl_signal_handler, because that would cause infinite recursion. */
314   if (handler != rl_signal_handler || old_handler.sa_handler != rl_signal_handler)
315     memcpy (ohandler, &old_handler, sizeof (sighandler_cxt));
316
317   return (ohandler->sa_handler);
318 }
319
320 static void
321 rl_maybe_set_sighandler (sig, handler, ohandler)
322      int sig;
323      SigHandler *handler;
324      sighandler_cxt *ohandler;
325 {
326   sighandler_cxt dummy;
327   SigHandler *oh;
328
329   sigemptyset (&dummy.sa_mask);
330   oh = rl_set_sighandler (sig, handler, ohandler);
331   if (oh == (SigHandler *)SIG_IGN)
332     rl_sigaction (sig, ohandler, &dummy);
333 }
334
335 int
336 rl_set_signals ()
337 {
338   sighandler_cxt dummy;
339   SigHandler *oh;
340 #if defined (HAVE_POSIX_SIGNALS)
341   static int sigmask_set = 0;
342   static sigset_t bset, oset;
343 #endif
344
345 #if defined (HAVE_POSIX_SIGNALS)
346   if (rl_catch_signals && sigmask_set == 0)
347     {
348       sigemptyset (&bset);
349
350       sigaddset (&bset, SIGINT);
351       sigaddset (&bset, SIGTERM);
352 #if defined (SIGQUIT)
353       sigaddset (&bset, SIGQUIT);
354 #endif
355 #if defined (SIGALRM)
356       sigaddset (&bset, SIGALRM);
357 #endif
358 #if defined (SIGTSTP)
359       sigaddset (&bset, SIGTSTP);
360 #endif
361 #if defined (SIGTTIN)
362       sigaddset (&bset, SIGTTIN);
363 #endif
364 #if defined (SIGTTOU)
365       sigaddset (&bset, SIGTTOU);
366 #endif
367       sigmask_set = 1;
368     }      
369 #endif /* HAVE_POSIX_SIGNALS */
370
371   if (rl_catch_signals && signals_set_flag == 0)
372     {
373 #if defined (HAVE_POSIX_SIGNALS)
374       sigemptyset (&oset);
375       sigprocmask (SIG_BLOCK, &bset, &oset);
376 #endif
377
378       rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int);
379       rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term);
380 #if defined (SIGQUIT)
381       rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);
382 #endif
383
384 #if defined (SIGALRM)
385       oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm);
386       if (oh == (SigHandler *)SIG_IGN)
387         rl_sigaction (SIGALRM, &old_alrm, &dummy);
388 #if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART)
389       /* If the application using readline has already installed a signal
390          handler with SA_RESTART, SIGALRM will cause reads to be restarted
391          automatically, so readline should just get out of the way.  Since
392          we tested for SIG_IGN above, we can just test for SIG_DFL here. */
393       if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART))
394         rl_sigaction (SIGALRM, &old_alrm, &dummy);
395 #endif /* HAVE_POSIX_SIGNALS */
396 #endif /* SIGALRM */
397
398 #if defined (SIGTSTP)
399       rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp);
400 #endif /* SIGTSTP */
401
402 #if defined (SIGTTOU)
403       rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou);
404 #endif /* SIGTTOU */
405
406 #if defined (SIGTTIN)
407       rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin);
408 #endif /* SIGTTIN */
409
410       signals_set_flag = 1;
411
412 #if defined (HAVE_POSIX_SIGNALS)
413       sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
414 #endif
415     }
416
417 #if defined (SIGWINCH)
418   if (rl_catch_sigwinch && sigwinch_set_flag == 0)
419     {
420       rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch);
421       sigwinch_set_flag = 1;
422     }
423 #endif /* SIGWINCH */
424
425   return 0;
426 }
427
428 int
429 rl_clear_signals ()
430 {
431   sighandler_cxt dummy;
432
433   if (rl_catch_signals && signals_set_flag == 1)
434     {
435       sigemptyset (&dummy.sa_mask);
436
437       rl_sigaction (SIGINT, &old_int, &dummy);
438       rl_sigaction (SIGTERM, &old_term, &dummy);
439 #if defined (SIGQUIT)
440       rl_sigaction (SIGQUIT, &old_quit, &dummy);
441 #endif
442 #if defined (SIGALRM)
443       rl_sigaction (SIGALRM, &old_alrm, &dummy);
444 #endif
445
446 #if defined (SIGTSTP)
447       rl_sigaction (SIGTSTP, &old_tstp, &dummy);
448 #endif /* SIGTSTP */
449
450 #if defined (SIGTTOU)
451       rl_sigaction (SIGTTOU, &old_ttou, &dummy);
452 #endif /* SIGTTOU */
453
454 #if defined (SIGTTIN)
455       rl_sigaction (SIGTTIN, &old_ttin, &dummy);
456 #endif /* SIGTTIN */
457
458       signals_set_flag = 0;
459     }
460
461 #if defined (SIGWINCH)
462   if (rl_catch_sigwinch && sigwinch_set_flag == 1)
463     {
464       sigemptyset (&dummy.sa_mask);
465       rl_sigaction (SIGWINCH, &old_winch, &dummy);
466       sigwinch_set_flag = 0;
467     }
468 #endif
469
470   return 0;
471 }
472
473 /* Clean up the terminal and readline state after catching a signal, before
474    resending it to the calling application. */
475 void
476 rl_cleanup_after_signal ()
477 {
478   _rl_clean_up_for_exit ();
479   if (rl_deprep_term_function)
480     (*rl_deprep_term_function) ();
481   rl_clear_pending_input ();
482   rl_clear_signals ();
483 }
484
485 /* Reset the terminal and readline state after a signal handler returns. */
486 void
487 rl_reset_after_signal ()
488 {
489   if (rl_prep_term_function)
490     (*rl_prep_term_function) (_rl_meta_flag);
491   rl_set_signals ();
492 }
493
494 /* Free up the readline variable line state for the current line (undo list,
495    any partial history entry, any keyboard macros in progress, and any
496    numeric arguments in process) after catching a signal, before calling
497    rl_cleanup_after_signal(). */ 
498 void
499 rl_free_line_state ()
500 {
501   register HIST_ENTRY *entry;
502
503   rl_free_undo_list ();
504
505   entry = current_history ();
506   if (entry)
507     entry->data = (char *)NULL;
508
509   _rl_kill_kbd_macro ();
510   rl_clear_message ();
511   _rl_reset_argument ();
512 }
513
514 #endif  /* HANDLE_SIGNALS */
515
516 /* **************************************************************** */
517 /*                                                                  */
518 /*                         SIGINT Management                        */
519 /*                                                                  */
520 /* **************************************************************** */
521
522 #if defined (HAVE_POSIX_SIGNALS)
523 static sigset_t sigint_set, sigint_oset;
524 static sigset_t sigwinch_set, sigwinch_oset;
525 #else /* !HAVE_POSIX_SIGNALS */
526 #  if defined (HAVE_BSD_SIGNALS)
527 static int sigint_oldmask;
528 static int sigwinch_oldmask;
529 #  endif /* HAVE_BSD_SIGNALS */
530 #endif /* !HAVE_POSIX_SIGNALS */
531
532 static int sigint_blocked;
533 static int sigwinch_blocked;
534
535 /* Cause SIGINT to not be delivered until the corresponding call to
536    release_sigint(). */
537 void
538 _rl_block_sigint ()
539 {
540   if (sigint_blocked)
541     return;
542
543 #if defined (HAVE_POSIX_SIGNALS)
544   sigemptyset (&sigint_set);
545   sigemptyset (&sigint_oset);
546   sigaddset (&sigint_set, SIGINT);
547   sigprocmask (SIG_BLOCK, &sigint_set, &sigint_oset);
548 #else /* !HAVE_POSIX_SIGNALS */
549 #  if defined (HAVE_BSD_SIGNALS)
550   sigint_oldmask = sigblock (sigmask (SIGINT));
551 #  else /* !HAVE_BSD_SIGNALS */
552 #    if defined (HAVE_USG_SIGHOLD)
553   sighold (SIGINT);
554 #    endif /* HAVE_USG_SIGHOLD */
555 #  endif /* !HAVE_BSD_SIGNALS */
556 #endif /* !HAVE_POSIX_SIGNALS */
557
558   sigint_blocked = 1;
559 }
560
561 /* Allow SIGINT to be delivered. */
562 void
563 _rl_release_sigint ()
564 {
565   if (sigint_blocked == 0)
566     return;
567
568 #if defined (HAVE_POSIX_SIGNALS)
569   sigprocmask (SIG_SETMASK, &sigint_oset, (sigset_t *)NULL);
570 #else
571 #  if defined (HAVE_BSD_SIGNALS)
572   sigsetmask (sigint_oldmask);
573 #  else /* !HAVE_BSD_SIGNALS */
574 #    if defined (HAVE_USG_SIGHOLD)
575   sigrelse (SIGINT);
576 #    endif /* HAVE_USG_SIGHOLD */
577 #  endif /* !HAVE_BSD_SIGNALS */
578 #endif /* !HAVE_POSIX_SIGNALS */
579
580   sigint_blocked = 0;
581 }
582
583 #ifdef SIGWINCH
584 /* Cause SIGWINCH to not be delivered until the corresponding call to
585    release_sigwinch(). */
586 void
587 _rl_block_sigwinch ()
588 {
589   if (sigwinch_blocked)
590     return;
591
592 #if defined (HAVE_POSIX_SIGNALS)
593   sigemptyset (&sigwinch_set);
594   sigemptyset (&sigwinch_oset);
595   sigaddset (&sigwinch_set, SIGWINCH);
596   sigprocmask (SIG_BLOCK, &sigwinch_set, &sigwinch_oset);
597 #else /* !HAVE_POSIX_SIGNALS */
598 #  if defined (HAVE_BSD_SIGNALS)
599   sigwinch_oldmask = sigblock (sigmask (SIGWINCH));
600 #  else /* !HAVE_BSD_SIGNALS */
601 #    if defined (HAVE_USG_SIGHOLD)
602   sighold (SIGWINCH);
603 #    endif /* HAVE_USG_SIGHOLD */
604 #  endif /* !HAVE_BSD_SIGNALS */
605 #endif /* !HAVE_POSIX_SIGNALS */
606
607   sigwinch_blocked = 1;
608 }
609
610 /* Allow SIGWINCH to be delivered. */
611 void
612 _rl_release_sigwinch ()
613 {
614   if (sigwinch_blocked == 0)
615     return;
616
617 #if defined (HAVE_POSIX_SIGNALS)
618   sigprocmask (SIG_SETMASK, &sigwinch_oset, (sigset_t *)NULL);
619 #else
620 #  if defined (HAVE_BSD_SIGNALS)
621   sigsetmask (sigwinch_oldmask);
622 #  else /* !HAVE_BSD_SIGNALS */
623 #    if defined (HAVE_USG_SIGHOLD)
624   sigrelse (SIGWINCH);
625 #    endif /* HAVE_USG_SIGHOLD */
626 #  endif /* !HAVE_BSD_SIGNALS */
627 #endif /* !HAVE_POSIX_SIGNALS */
628
629   sigwinch_blocked = 0;
630 }
631 #endif /* SIGWINCH */
632
633 /* **************************************************************** */
634 /*                                                                  */
635 /*              Echoing special control characters                  */
636 /*                                                                  */
637 /* **************************************************************** */
638 void
639 rl_echo_signal_char (sig)
640      int sig;
641 {
642   char cstr[3];
643   int cslen, c;
644
645   if (_rl_echoctl == 0 || _rl_echo_control_chars == 0)
646     return;
647
648   switch (sig)
649     {
650     case SIGINT:  c = _rl_intr_char; break;
651 #if defined (SIGQUIT)
652     case SIGQUIT: c = _rl_quit_char; break;
653 #endif
654 #if defined (SIGTSTP)
655     case SIGTSTP: c = _rl_susp_char; break;
656 #endif
657     default: return;
658     }
659
660   if (CTRL_CHAR (c) || c == RUBOUT)
661     {
662       cstr[0] = '^';
663       cstr[1] = CTRL_CHAR (c) ? UNCTRL (c) : '?';
664       cstr[cslen = 2] = '\0';
665     }
666   else
667     {
668       cstr[0] = c;
669       cstr[cslen = 1] = '\0';
670     }
671
672   _rl_output_some_chars (cstr, cslen);
673 }