ncurses 5.9 - patch 20110625
[ncurses.git] / ncurses / tty / lib_tstp.c
1 /****************************************************************************
2  * Copyright (c) 1998-2010,2011 Free Software Foundation, Inc.              *
3  *                                                                          *
4  * Permission is hereby granted, free of charge, to any person obtaining a  *
5  * copy of this software and associated documentation files (the            *
6  * "Software"), to deal in the Software without restriction, including      *
7  * without limitation the rights to use, copy, modify, merge, publish,      *
8  * distribute, distribute with modifications, sublicense, and/or sell       *
9  * copies of the Software, and to permit persons to whom the Software is    *
10  * furnished to do so, subject to the following conditions:                 *
11  *                                                                          *
12  * The above copyright notice and this permission notice shall be included  *
13  * in all copies or substantial portions of the Software.                   *
14  *                                                                          *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
22  *                                                                          *
23  * Except as contained in this notice, the name(s) of the above copyright   *
24  * holders shall not be used in advertising or otherwise to promote the     *
25  * sale, use or other dealings in this Software without prior written       *
26  * authorization.                                                           *
27  ****************************************************************************/
28
29 /****************************************************************************
30  *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
31  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
32  *     and: Thomas E. Dickey                        1995-on                 *
33  ****************************************************************************/
34
35 /*
36 **      lib_tstp.c
37 **
38 **      The routine _nc_signal_handler().
39 **
40 */
41 #include <curses.priv.h>
42
43 #include <SigAction.h>
44
45 MODULE_ID("$Id: lib_tstp.c,v 1.44 2011/06/25 21:22:16 tom Exp $")
46
47 #if defined(SIGTSTP) && (HAVE_SIGACTION || HAVE_SIGVEC)
48 #define USE_SIGTSTP 1
49 #else
50 #define USE_SIGTSTP 0
51 #endif
52
53 #ifdef TRACE
54 static const char *
55 signal_name(int sig)
56 {
57     switch (sig) {
58 #ifdef SIGALRM
59     case SIGALRM:
60         return "SIGALRM";
61 #endif
62 #ifdef SIGCONT
63     case SIGCONT:
64         return "SIGCONT";
65 #endif
66     case SIGINT:
67         return "SIGINT";
68 #ifdef SIGQUIT
69     case SIGQUIT:
70         return "SIGQUIT";
71 #endif
72     case SIGTERM:
73         return "SIGTERM";
74 #ifdef SIGTSTP
75     case SIGTSTP:
76         return "SIGTSTP";
77 #endif
78 #ifdef SIGTTOU
79     case SIGTTOU:
80         return "SIGTTOU";
81 #endif
82 #ifdef SIGWINCH
83     case SIGWINCH:
84         return "SIGWINCH";
85 #endif
86     default:
87         return "unknown signal";
88     }
89 }
90 #endif
91
92 /*
93  * Note: This code is fragile!  Its problem is that different OSs
94  * handle restart of system calls interrupted by signals differently.
95  * The ncurses code needs signal-call restart to happen -- otherwise,
96  * interrupted wgetch() calls will return FAIL, probably making the
97  * application think the input stream has ended and it should
98  * terminate.  In particular, you know you have this problem if, when
99  * you suspend an ncurses-using lynx with ^Z and resume, it dies
100  * immediately.
101  *
102  * Default behavior of POSIX sigaction(2) is not to restart
103  * interrupted system calls, but Linux's sigaction does it anyway (at
104  * least, on and after the 1.1.47 I (esr) use).  Thus this code works
105  * OK under Linux.  The 4.4BSD sigaction(2) supports a (non-portable)
106  * SA_RESTART flag that forces the right behavior.  Thus, this code
107  * should work OK under BSD/OS, NetBSD, and FreeBSD (let us know if it
108  * does not).
109  *
110  * Stock System Vs (and anything else using a strict-POSIX
111  * sigaction(2) without SA_RESTART) may have a problem.  Possible
112  * solutions:
113  *
114  *    sigvec      restarts by default (SV_INTERRUPT flag to not restart)
115  *    signal      restarts by default in SVr4 (assuming you link with -lucb)
116  *                and BSD, but not SVr3.
117  *    sigset      restarts, but is only available under SVr4/Solaris.
118  *
119  * The signal(3) call is mandated by the ANSI standard, and its
120  * interaction with sigaction(2) is described in the POSIX standard
121  * (3.3.4.2, page 72,line 934).  According to section 8.1, page 191,
122  * however, signal(3) itself is not required by POSIX.1.  And POSIX is
123  * silent on whether it is required to restart signals.
124  *
125  * So.  The present situation is, we use sigaction(2) with no
126  * guarantee of restart anywhere but on Linux and BSD.  We could
127  * switch to signal(3) and collar Linux, BSD, and SVr4.  Any way
128  * we slice it, System V UNIXes older than SVr4 will probably lose
129  * (this may include XENIX).
130  *
131  * This implementation will probably be changed to use signal(3) in
132  * the future.  If nothing else, it's simpler...
133  */
134
135 #if USE_SIGTSTP
136 static void
137 tstp(int dummy GCC_UNUSED)
138 {
139     SCREEN *sp = CURRENT_SCREEN;
140     sigset_t mask, omask;
141     sigaction_t act, oact;
142
143 #ifdef SIGTTOU
144     int sigttou_blocked;
145 #endif
146
147     T(("tstp() called"));
148
149     /*
150      * The user may have changed the prog_mode tty bits, so save them.
151      *
152      * But first try to detect whether we still are in the foreground
153      * process group - if not, an interactive shell may already have
154      * taken ownership of the tty and modified the settings when our
155      * parent was stopped before us, and we would likely pick up the
156      * settings already modified by the shell.
157      */
158     if (sp != 0 && !sp->_endwin)        /* don't do this if we're not in curses */
159 #if HAVE_TCGETPGRP
160         if (tcgetpgrp(STDIN_FILENO) == getpgrp())
161 #endif
162             NCURSES_SP_NAME(def_prog_mode) (NCURSES_SP_ARG);
163
164     /*
165      * Block window change and timer signals.  The latter
166      * is because applications use timers to decide when
167      * to repaint the screen.
168      */
169     (void) sigemptyset(&mask);
170 #ifdef SIGALRM
171     (void) sigaddset(&mask, SIGALRM);
172 #endif
173 #if USE_SIGWINCH
174     (void) sigaddset(&mask, SIGWINCH);
175 #endif
176     (void) sigprocmask(SIG_BLOCK, &mask, &omask);
177
178 #ifdef SIGTTOU
179     sigttou_blocked = sigismember(&omask, SIGTTOU);
180     if (!sigttou_blocked) {
181         (void) sigemptyset(&mask);
182         (void) sigaddset(&mask, SIGTTOU);
183         (void) sigprocmask(SIG_BLOCK, &mask, NULL);
184     }
185 #endif
186
187     /*
188      * End window mode, which also resets the terminal state to the
189      * original (pre-curses) modes.
190      */
191     NCURSES_SP_NAME(endwin) (NCURSES_SP_ARG);
192
193     /* Unblock SIGTSTP. */
194     (void) sigemptyset(&mask);
195     (void) sigaddset(&mask, SIGTSTP);
196 #ifdef SIGTTOU
197     if (!sigttou_blocked) {
198         /* Unblock this too if it wasn't blocked on entry */
199         (void) sigaddset(&mask, SIGTTOU);
200     }
201 #endif
202     (void) sigprocmask(SIG_UNBLOCK, &mask, NULL);
203
204     /* Now we want to resend SIGSTP to this process and suspend it */
205     act.sa_handler = SIG_DFL;
206     sigemptyset(&act.sa_mask);
207     act.sa_flags = 0;
208 #ifdef SA_RESTART
209     act.sa_flags |= SA_RESTART;
210 #endif /* SA_RESTART */
211     sigaction(SIGTSTP, &act, &oact);
212     kill(getpid(), SIGTSTP);
213
214     /* Process gets suspended...time passes...process resumes */
215
216     T(("SIGCONT received"));
217     sigaction(SIGTSTP, &oact, NULL);
218     NCURSES_SP_NAME(flushinp) (NCURSES_SP_ARG);
219
220     /*
221      * If the user modified the tty state while suspended, he wants
222      * those changes to stick.  So save the new "default" terminal state.
223      */
224     NCURSES_SP_NAME(def_shell_mode) (NCURSES_SP_ARG);
225
226     /*
227      * This relies on the fact that doupdate() will restore the
228      * program-mode tty state, and issue enter_ca_mode if need be.
229      */
230     NCURSES_SP_NAME(doupdate) (NCURSES_SP_ARG);
231
232     /* Reset the signals. */
233     (void) sigprocmask(SIG_SETMASK, &omask, NULL);
234 }
235 #endif /* USE_SIGTSTP */
236
237 static void
238 cleanup(int sig)
239 {
240     SCREEN *sp = CURRENT_SCREEN;
241
242     /*
243      * Much of this is unsafe from a signal handler.  But we'll _try_ to clean
244      * up the screen and terminal settings on the way out.
245      *
246      * There are at least the following problems:
247      * 1) Walking the SCREEN list is unsafe, since all list management
248      *    is done without any signal blocking.
249      * 2) On systems which have REENTRANT turned on, set_term() uses
250      *    _nc_lock_global() which could deadlock or misbehave in other ways.
251      * 3) endwin() calls all sorts of stuff, many of which use stdio or
252      *    other library functions which are clearly unsafe.
253      */
254     if (!_nc_globals.cleanup_nested++
255         && (sig == SIGINT || sig == SIGTERM)) {
256 #if HAVE_SIGACTION || HAVE_SIGVEC
257         sigaction_t act;
258         sigemptyset(&act.sa_mask);
259         act.sa_flags = 0;
260         act.sa_handler = SIG_IGN;
261         if (sigaction(sig, &act, NULL) == 0)
262 #else
263         if (signal(sig, SIG_IGN) != SIG_ERR)
264 #endif
265         {
266             SCREEN *scan;
267             for (each_screen(scan)) {
268                 if (scan->_ofp != 0
269                     && isatty(fileno(scan->_ofp))) {
270                     scan->_cleanup = TRUE;
271                     scan->_outch = NCURSES_SP_NAME(_nc_outch);
272                 }
273                 set_term(scan);
274                 NCURSES_SP_NAME(endwin) (NCURSES_SP_ARG);
275                 if (sp)
276                     sp->_endwin = FALSE;        /* in case of reuse */
277             }
278         }
279     }
280     _exit(EXIT_FAILURE);
281 }
282
283 #if USE_SIGWINCH
284 static void
285 sigwinch(int sig GCC_UNUSED)
286 {
287     _nc_globals.have_sigwinch = 1;
288 # if USE_PTHREADS_EINTR
289     if (_nc_globals.read_thread) {
290         if (!pthread_equal(pthread_self(), _nc_globals.read_thread))
291             pthread_kill(_nc_globals.read_thread, SIGWINCH);
292         _nc_globals.read_thread = 0;
293     }
294 # endif
295 }
296 #endif /* USE_SIGWINCH */
297
298 /*
299  * If the given signal is still in its default state, set it to the given
300  * handler.
301  */
302 static int
303 CatchIfDefault(int sig, RETSIGTYPE (*handler) (int))
304 {
305     int result;
306 #if HAVE_SIGACTION || HAVE_SIGVEC
307     sigaction_t old_act;
308     sigaction_t new_act;
309
310     memset(&new_act, 0, sizeof(new_act));
311     sigemptyset(&new_act.sa_mask);
312 #ifdef SA_RESTART
313 #ifdef SIGWINCH
314     if (sig != SIGWINCH)
315 #endif
316         new_act.sa_flags |= SA_RESTART;
317 #endif /* SA_RESTART */
318     new_act.sa_handler = handler;
319
320     if (sigaction(sig, NULL, &old_act) == 0
321         && (old_act.sa_handler == SIG_DFL
322             || old_act.sa_handler == handler
323 #if USE_SIGWINCH
324             || (sig == SIGWINCH && old_act.sa_handler == SIG_IGN)
325 #endif
326         )) {
327         (void) sigaction(sig, &new_act, NULL);
328         result = TRUE;
329     } else {
330         result = FALSE;
331     }
332 #else /* !HAVE_SIGACTION */
333     RETSIGTYPE (*ohandler) (int);
334
335     ohandler = signal(sig, SIG_IGN);
336     if (ohandler == SIG_DFL
337         || ohandler == handler
338 #if USE_SIGWINCH
339         || (sig == SIGWINCH && ohandler == SIG_IGN)
340 #endif
341         ) {
342         signal(sig, handler);
343         result = TRUE;
344     } else {
345         signal(sig, ohandler);
346         result = FALSE;
347     }
348 #endif
349     T(("CatchIfDefault - will %scatch %s",
350        result ? "" : "not ", signal_name(sig)));
351     return result;
352 }
353
354 /*
355  * This is invoked once at the beginning (e.g., from 'initscr()'), to
356  * initialize the signal catchers, and thereafter when spawning a shell (and
357  * returning) to disable/enable the SIGTSTP (i.e., ^Z) catcher.
358  *
359  * If the application has already set one of the signals, we'll not modify it
360  * (during initialization).
361  *
362  * The XSI document implies that we shouldn't keep the SIGTSTP handler if
363  * the caller later changes its mind, but that doesn't seem correct.
364  */
365 NCURSES_EXPORT(void)
366 _nc_signal_handler(bool enable)
367 {
368     T((T_CALLED("_nc_signal_handler(%d)"), enable));
369 #if USE_SIGTSTP                 /* Xenix 2.x doesn't have SIGTSTP, for example */
370     {
371         static bool ignore_tstp = FALSE;
372
373         if (!ignore_tstp) {
374             static sigaction_t new_sigaction, old_sigaction;
375
376             if (!enable) {
377                 new_sigaction.sa_handler = SIG_IGN;
378                 sigaction(SIGTSTP, &new_sigaction, &old_sigaction);
379             } else if (new_sigaction.sa_handler != SIG_DFL) {
380                 sigaction(SIGTSTP, &old_sigaction, NULL);
381             } else if (sigaction(SIGTSTP, NULL, &old_sigaction) == 0
382                        && (old_sigaction.sa_handler == SIG_DFL)) {
383                 sigemptyset(&new_sigaction.sa_mask);
384 #ifdef SA_RESTART
385                 new_sigaction.sa_flags |= SA_RESTART;
386 #endif /* SA_RESTART */
387                 new_sigaction.sa_handler = tstp;
388                 (void) sigaction(SIGTSTP, &new_sigaction, NULL);
389             } else {
390                 ignore_tstp = TRUE;
391             }
392         }
393     }
394 #endif /* !USE_SIGTSTP */
395
396     if (!_nc_globals.init_signals) {
397         if (enable) {
398             CatchIfDefault(SIGINT, cleanup);
399             CatchIfDefault(SIGTERM, cleanup);
400 #if USE_SIGWINCH
401             CatchIfDefault(SIGWINCH, sigwinch);
402 #endif
403             _nc_globals.init_signals = TRUE;
404         }
405     }
406     returnVoid;
407 }