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