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      sigemptyset (&set);
164      sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set);
165      sigdelset (&set, sig);
166#else /* !HAVE_POSIX_SIGNALS */
167#  if defined (HAVE_BSD_SIGNALS)
168      omask = sigblock (0);
169#  endif /* HAVE_BSD_SIGNALS */
170#endif /* !HAVE_POSIX_SIGNALS */
171
172#if defined (__EMX__)
173      signal (sig, SIG_ACK);
174#endif
175
176#if defined (HAVE_KILL)
177      kill (getpid (), sig);
178#else
179      raise (sig);		/* assume we have raise */
180#endif
181
182      /* Let the signal that we just sent through.  */
183#if defined (HAVE_POSIX_SIGNALS)
184      sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL);
185#else /* !HAVE_POSIX_SIGNALS */
186#  if defined (HAVE_BSD_SIGNALS)
187      sigsetmask (omask & ~(sigmask (sig)));
188#  endif /* HAVE_BSD_SIGNALS */
189#endif /* !HAVE_POSIX_SIGNALS */
190
191      rl_reset_after_signal ();
192    }
193
194  RL_UNSETSTATE(RL_STATE_SIGHANDLER);
195  SIGHANDLER_RETURN;
196}
197
198#if defined (SIGWINCH)
199static RETSIGTYPE
200rl_sigwinch_handler (sig)
201     int sig;
202{
203  SigHandler *oh;
204
205#if defined (MUST_REINSTALL_SIGHANDLERS)
206  sighandler_cxt dummy_winch;
207
208  /* We don't want to change old_winch -- it holds the state of SIGWINCH
209     disposition set by the calling application.  We need this state
210     because we call the application's SIGWINCH handler after updating
211     our own idea of the screen size. */
212  rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch);
213#endif
214
215  RL_SETSTATE(RL_STATE_SIGHANDLER);
216  rl_resize_terminal ();
217
218  /* If another sigwinch handler has been installed, call it. */
219  oh = (SigHandler *)old_winch.sa_handler;
220  if (oh &&  oh != (SigHandler *)SIG_IGN && oh != (SigHandler *)SIG_DFL)
221    (*oh) (sig);
222
223  RL_UNSETSTATE(RL_STATE_SIGHANDLER);
224  SIGHANDLER_RETURN;
225}
226#endif  /* SIGWINCH */
227
228/* Functions to manage signal handling. */
229
230#if !defined (HAVE_POSIX_SIGNALS)
231static int
232rl_sigaction (sig, nh, oh)
233     int sig;
234     sighandler_cxt *nh, *oh;
235{
236  oh->sa_handler = signal (sig, nh->sa_handler);
237  return 0;
238}
239#endif /* !HAVE_POSIX_SIGNALS */
240
241/* Set up a readline-specific signal handler, saving the old signal
242   information in OHANDLER.  Return the old signal handler, like
243   signal(). */
244static SigHandler *
245rl_set_sighandler (sig, handler, ohandler)
246     int sig;
247     SigHandler *handler;
248     sighandler_cxt *ohandler;
249{
250  sighandler_cxt old_handler;
251#if defined (HAVE_POSIX_SIGNALS)
252  struct sigaction act;
253
254  act.sa_handler = handler;
255  act.sa_flags = (sig == SIGWINCH) ? SA_RESTART : 0;
256  sigemptyset (&act.sa_mask);
257  sigemptyset (&ohandler->sa_mask);
258  sigaction (sig, &act, &old_handler);
259#else
260  old_handler.sa_handler = (SigHandler *)signal (sig, handler);
261#endif /* !HAVE_POSIX_SIGNALS */
262
263  /* XXX -- assume we have memcpy */
264  /* If rl_set_signals is called twice in a row, don't set the old handler to
265     rl_signal_handler, because that would cause infinite recursion. */
266  if (handler != rl_signal_handler || old_handler.sa_handler != rl_signal_handler)
267    memcpy (ohandler, &old_handler, sizeof (sighandler_cxt));
268
269  return (ohandler->sa_handler);
270}
271
272static void
273rl_maybe_set_sighandler (sig, handler, ohandler)
274     int sig;
275     SigHandler *handler;
276     sighandler_cxt *ohandler;
277{
278  sighandler_cxt dummy;
279  SigHandler *oh;
280
281  sigemptyset (&dummy.sa_mask);
282  oh = rl_set_sighandler (sig, handler, ohandler);
283  if (oh == (SigHandler *)SIG_IGN)
284    rl_sigaction (sig, ohandler, &dummy);
285}
286
287int
288rl_set_signals ()
289{
290  sighandler_cxt dummy;
291  SigHandler *oh;
292#if defined (HAVE_POSIX_SIGNALS)
293  static int sigmask_set = 0;
294  static sigset_t bset, oset;
295#endif
296
297#if defined (HAVE_POSIX_SIGNALS)
298  if (rl_catch_signals && sigmask_set == 0)
299    {
300      sigemptyset (&bset);
301
302      sigaddset (&bset, SIGINT);
303      sigaddset (&bset, SIGINT);
304#if defined (SIGQUIT)
305      sigaddset (&bset, SIGQUIT);
306#endif
307#if defined (SIGALRM)
308      sigaddset (&bset, SIGALRM);
309#endif
310#if defined (SIGTSTP)
311      sigaddset (&bset, SIGTSTP);
312#endif
313#if defined (SIGTTIN)
314      sigaddset (&bset, SIGTTIN);
315#endif
316#if defined (SIGTTOU)
317      sigaddset (&bset, SIGTTOU);
318#endif
319      sigmask_set = 1;
320    }
321#endif /* HAVE_POSIX_SIGNALS */
322
323  if (rl_catch_signals && signals_set_flag == 0)
324    {
325#if defined (HAVE_POSIX_SIGNALS)
326      sigemptyset (&oset);
327      sigprocmask (SIG_BLOCK, &bset, &oset);
328#endif
329
330      rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int);
331      rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term);
332#if defined (SIGQUIT)
333      rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);
334#endif
335
336#if defined (SIGALRM)
337      oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm);
338      if (oh == (SigHandler *)SIG_IGN)
339	rl_sigaction (SIGALRM, &old_alrm, &dummy);
340#if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART)
341      /* If the application using readline has already installed a signal
342	 handler with SA_RESTART, SIGALRM will cause reads to be restarted
343	 automatically, so readline should just get out of the way.  Since
344	 we tested for SIG_IGN above, we can just test for SIG_DFL here. */
345      if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART))
346	rl_sigaction (SIGALRM, &old_alrm, &dummy);
347#endif /* HAVE_POSIX_SIGNALS */
348#endif /* SIGALRM */
349
350#if defined (SIGTSTP)
351      rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp);
352#endif /* SIGTSTP */
353
354#if defined (SIGTTOU)
355      rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou);
356#endif /* SIGTTOU */
357
358#if defined (SIGTTIN)
359      rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin);
360#endif /* SIGTTIN */
361
362      signals_set_flag = 1;
363
364#if defined (HAVE_POSIX_SIGNALS)
365      sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
366#endif
367    }
368
369#if defined (SIGWINCH)
370  if (rl_catch_sigwinch && sigwinch_set_flag == 0)
371    {
372      rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch);
373      sigwinch_set_flag = 1;
374    }
375#endif /* SIGWINCH */
376
377  return 0;
378}
379
380int
381rl_clear_signals ()
382{
383  sighandler_cxt dummy;
384
385  if (rl_catch_signals && signals_set_flag == 1)
386    {
387      sigemptyset (&dummy.sa_mask);
388
389      rl_sigaction (SIGINT, &old_int, &dummy);
390      rl_sigaction (SIGTERM, &old_term, &dummy);
391#if defined (SIGQUIT)
392      rl_sigaction (SIGQUIT, &old_quit, &dummy);
393#endif
394#if defined (SIGALRM)
395      rl_sigaction (SIGALRM, &old_alrm, &dummy);
396#endif
397
398#if defined (SIGTSTP)
399      rl_sigaction (SIGTSTP, &old_tstp, &dummy);
400#endif /* SIGTSTP */
401
402#if defined (SIGTTOU)
403      rl_sigaction (SIGTTOU, &old_ttou, &dummy);
404#endif /* SIGTTOU */
405
406#if defined (SIGTTIN)
407      rl_sigaction (SIGTTIN, &old_ttin, &dummy);
408#endif /* SIGTTIN */
409
410      signals_set_flag = 0;
411    }
412
413#if defined (SIGWINCH)
414  if (rl_catch_sigwinch && sigwinch_set_flag == 1)
415    {
416      sigemptyset (&dummy.sa_mask);
417      rl_sigaction (SIGWINCH, &old_winch, &dummy);
418      sigwinch_set_flag = 0;
419    }
420#endif
421
422  return 0;
423}
424
425/* Clean up the terminal and readline state after catching a signal, before
426   resending it to the calling application. */
427void
428rl_cleanup_after_signal ()
429{
430  _rl_clean_up_for_exit ();
431  if (rl_deprep_term_function)
432    (*rl_deprep_term_function) ();
433  rl_clear_pending_input ();
434  rl_clear_signals ();
435}
436
437/* Reset the terminal and readline state after a signal handler returns. */
438void
439rl_reset_after_signal ()
440{
441  if (rl_prep_term_function)
442    (*rl_prep_term_function) (_rl_meta_flag);
443  rl_set_signals ();
444}
445
446/* Free up the readline variable line state for the current line (undo list,
447   any partial history entry, any keyboard macros in progress, and any
448   numeric arguments in process) after catching a signal, before calling
449   rl_cleanup_after_signal(). */
450void
451rl_free_line_state ()
452{
453  register HIST_ENTRY *entry;
454
455  rl_free_undo_list ();
456
457  entry = current_history ();
458  if (entry)
459    entry->data = (char *)NULL;
460
461  _rl_kill_kbd_macro ();
462  rl_clear_message ();
463  _rl_reset_argument ();
464}
465
466#endif  /* HANDLE_SIGNALS */
467