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 */
427