X-Git-Url: http://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=ncurses%2Ftty%2Flib_tstp.c;h=42d5ccb41522e068e7fc29cfdb18b5b07fbac26d;hp=d01a62f714879b573878e2f5796900ebdddc539b;hb=8d8a3537cd58af7879c6e1921235daeed2b74926;hpb=b1f61d9f3aa244512045a6b02e759825d7049d34 diff --git a/ncurses/tty/lib_tstp.c b/ncurses/tty/lib_tstp.c index d01a62f7..42d5ccb4 100644 --- a/ncurses/tty/lib_tstp.c +++ b/ncurses/tty/lib_tstp.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1998,1999 Free Software Foundation, Inc. * + * Copyright (c) 1998-2014,2017 Free Software Foundation, Inc. * * * * Permission is hereby granted, free of charge, to any person obtaining a * * copy of this software and associated documentation files (the * @@ -29,26 +29,20 @@ /**************************************************************************** * Author: Zeyd M. Ben-Halim 1992,1995 * * and: Eric S. Raymond * + * and: Thomas E. Dickey 1995-on * ****************************************************************************/ - /* ** lib_tstp.c ** ** The routine _nc_signal_handler(). ** */ - #include -#include #include -#if defined(SVR4_ACTION) && !defined(_POSIX_SOURCE) -#define _POSIX_SOURCE -#endif - -MODULE_ID("$Id: lib_tstp.c,v 1.21 2000/05/20 23:28:56 tom Exp $") +MODULE_ID("$Id: lib_tstp.c,v 1.49 2017/07/22 23:29:58 tom Exp $") #if defined(SIGTSTP) && (HAVE_SIGACTION || HAVE_SIGVEC) #define USE_SIGTSTP 1 @@ -56,6 +50,45 @@ MODULE_ID("$Id: lib_tstp.c,v 1.21 2000/05/20 23:28:56 tom Exp $") #define USE_SIGTSTP 0 #endif +#ifdef TRACE +static const char * +signal_name(int sig) +{ + switch (sig) { +#ifdef SIGALRM + case SIGALRM: + return "SIGALRM"; +#endif +#ifdef SIGCONT + case SIGCONT: + return "SIGCONT"; +#endif + case SIGINT: + return "SIGINT"; +#ifdef SIGQUIT + case SIGQUIT: + return "SIGQUIT"; +#endif + case SIGTERM: + return "SIGTERM"; +#ifdef SIGTSTP + case SIGTSTP: + return "SIGTSTP"; +#endif +#ifdef SIGTTOU + case SIGTTOU: + return "SIGTTOU"; +#endif +#ifdef SIGWINCH + case SIGWINCH: + return "SIGWINCH"; +#endif + default: + return "unknown signal"; + } +} +#endif + /* * Note: This code is fragile! Its problem is that different OSs * handle restart of system calls interrupted by signals differently. @@ -100,154 +133,167 @@ MODULE_ID("$Id: lib_tstp.c,v 1.21 2000/05/20 23:28:56 tom Exp $") */ #if USE_SIGTSTP -static void tstp(int dummy GCC_UNUSED) +static void +handle_SIGTSTP(int dummy GCC_UNUSED) { - sigset_t mask, omask; - sigaction_t act, oact; + SCREEN *sp = CURRENT_SCREEN; + sigset_t mask, omask; + sigaction_t act, oact; #ifdef SIGTTOU - int sigttou_blocked; + int sigttou_blocked; #endif - T(("tstp() called")); - - /* - * The user may have changed the prog_mode tty bits, so save them. - * - * But first try to detect whether we still are in the foreground - * process group - if not, an interactive shell may already have - * taken ownership of the tty and modified the settings when our - * parent was stopped before us, and we would likely pick up the - * settings already modified by the shell. - */ - if (SP != 0 && !SP->_endwin) /* don't do this if we're not in curses */ + _nc_globals.have_sigtstp = 1; + T(("handle_SIGTSTP() called")); + + /* + * The user may have changed the prog_mode tty bits, so save them. + * + * But first try to detect whether we still are in the foreground + * process group - if not, an interactive shell may already have + * taken ownership of the tty and modified the settings when our + * parent was stopped before us, and we would likely pick up the + * settings already modified by the shell. + * + * Don't do this if we're not in curses - + */ + if (sp != 0 && (sp->_endwin == ewRunning)) #if HAVE_TCGETPGRP if (tcgetpgrp(STDIN_FILENO) == getpgrp()) #endif - def_prog_mode(); - - /* - * Block window change and timer signals. The latter - * is because applications use timers to decide when - * to repaint the screen. - */ - (void)sigemptyset(&mask); - (void)sigaddset(&mask, SIGALRM); + NCURSES_SP_NAME(def_prog_mode) (NCURSES_SP_ARG); + + /* + * Block window change and timer signals. The latter + * is because applications use timers to decide when + * to repaint the screen. + */ + (void) sigemptyset(&mask); +#ifdef SIGALRM + (void) sigaddset(&mask, SIGALRM); +#endif #if USE_SIGWINCH - (void)sigaddset(&mask, SIGWINCH); + (void) sigaddset(&mask, SIGWINCH); #endif - (void)sigprocmask(SIG_BLOCK, &mask, &omask); + (void) sigprocmask(SIG_BLOCK, &mask, &omask); #ifdef SIGTTOU - sigttou_blocked = sigismember(&omask, SIGTTOU); - if (!sigttou_blocked) { - (void)sigemptyset(&mask); - (void)sigaddset(&mask, SIGTTOU); - (void)sigprocmask(SIG_BLOCK, &mask, NULL); - } + sigttou_blocked = sigismember(&omask, SIGTTOU); + if (!sigttou_blocked) { + (void) sigemptyset(&mask); + (void) sigaddset(&mask, SIGTTOU); + (void) sigprocmask(SIG_BLOCK, &mask, NULL); + } #endif - /* - * End window mode, which also resets the terminal state to the - * original (pre-curses) modes. - */ - endwin(); + /* + * End window mode, which also resets the terminal state to the + * original (pre-curses) modes. + */ + NCURSES_SP_NAME(endwin) (NCURSES_SP_ARG); - /* Unblock SIGTSTP. */ - (void)sigemptyset(&mask); - (void)sigaddset(&mask, SIGTSTP); + /* Unblock SIGTSTP. */ + (void) sigemptyset(&mask); + (void) sigaddset(&mask, SIGTSTP); #ifdef SIGTTOU - if (!sigttou_blocked) { - /* Unblock this too if it wasn't blocked on entry */ - (void)sigaddset(&mask, SIGTTOU); - } + if (!sigttou_blocked) { + /* Unblock this too if it wasn't blocked on entry */ + (void) sigaddset(&mask, SIGTTOU); + } #endif - (void)sigprocmask(SIG_UNBLOCK, &mask, NULL); + (void) sigprocmask(SIG_UNBLOCK, &mask, NULL); - /* Now we want to resend SIGSTP to this process and suspend it */ - act.sa_handler = SIG_DFL; - sigemptyset(&act.sa_mask); - act.sa_flags = 0; + /* Now we want to resend SIGSTP to this process and suspend it */ + act.sa_handler = SIG_DFL; + sigemptyset(&act.sa_mask); + act.sa_flags = 0; #ifdef SA_RESTART - act.sa_flags |= SA_RESTART; + act.sa_flags |= SA_RESTART; #endif /* SA_RESTART */ - sigaction(SIGTSTP, &act, &oact); - kill(getpid(), SIGTSTP); + sigaction(SIGTSTP, &act, &oact); + kill(getpid(), SIGTSTP); - /* Process gets suspended...time passes...process resumes */ + /* Process gets suspended...time passes...process resumes */ - T(("SIGCONT received")); - sigaction(SIGTSTP, &oact, NULL); - flushinp(); + T(("SIGCONT received")); + sigaction(SIGTSTP, &oact, NULL); + NCURSES_SP_NAME(flushinp) (NCURSES_SP_ARG); - /* - * If the user modified the tty state while suspended, he wants - * those changes to stick. So save the new "default" terminal state. - */ - def_shell_mode(); + /* + * If the user modified the tty state while suspended, he wants + * those changes to stick. So save the new "default" terminal state. + */ + NCURSES_SP_NAME(def_shell_mode) (NCURSES_SP_ARG); - /* - * This relies on the fact that doupdate() will restore the - * program-mode tty state, and issue enter_ca_mode if need be. - */ - doupdate(); + /* + * This relies on the fact that doupdate() will restore the + * program-mode tty state, and issue enter_ca_mode if need be. + */ + NCURSES_SP_NAME(doupdate) (NCURSES_SP_ARG); - /* Reset the signals. */ - (void)sigprocmask(SIG_SETMASK, &omask, NULL); + /* Reset the signals. */ + (void) sigprocmask(SIG_SETMASK, &omask, NULL); } -#endif /* USE_SIGTSTP */ +#endif /* USE_SIGTSTP */ -static void cleanup(int sig) +static void +handle_SIGINT(int sig) { - static int nested; - - /* - * Actually, doing any sort of I/O from within an signal handler is - * "unsafe". But we'll _try_ to clean up the screen and terminal - * settings on the way out. - */ - if (!nested++ - && (sig == SIGINT - || sig == SIGQUIT)) { + SCREEN *sp = CURRENT_SCREEN; + + /* + * Much of this is unsafe from a signal handler. But we'll _try_ to clean + * up the screen and terminal settings on the way out. + * + * There are at least the following problems: + * 1) Walking the SCREEN list is unsafe, since all list management + * is done without any signal blocking. + * 2) On systems which have REENTRANT turned on, set_term() uses + * _nc_lock_global() which could deadlock or misbehave in other ways. + * 3) endwin() calls all sorts of stuff, many of which use stdio or + * other library functions which are clearly unsafe. + */ + if (!_nc_globals.cleanup_nested++ + && (sig == SIGINT || sig == SIGTERM)) { #if HAVE_SIGACTION || HAVE_SIGVEC - sigaction_t act; - sigemptyset(&act.sa_mask); - act.sa_flags = 0; - act.sa_handler = SIG_IGN; - if (sigaction(sig, &act, (sigaction_t *)0) == 0) + sigaction_t act; + sigemptyset(&act.sa_mask); + act.sa_flags = 0; + act.sa_handler = SIG_IGN; + if (sigaction(sig, &act, NULL) == 0) #else - if (signal(sig, SIG_IGN) != SIG_ERR) + if (signal(sig, SIG_IGN) != SIG_ERR) #endif - { - SCREEN *scan = _nc_screen_chain; - while(scan) - { - if (SP != 0 - && SP->_ofp != 0 - && isatty(fileno(SP->_ofp))) { - SP->_cleanup = TRUE; - SP->_outch = _nc_outch; - } - set_term(scan); - endwin(); - if (SP) - SP->_endwin = FALSE; /* in case we have an atexit! */ - scan = scan->_next_screen; - } + { + SCREEN *scan; + for (each_screen(scan)) { + if (scan->_ofp != 0 + && NC_ISATTY(fileno(scan->_ofp))) { + scan->_outch = NCURSES_SP_NAME(_nc_outch); } + set_term(scan); + NCURSES_SP_NAME(endwin) (NCURSES_SP_ARG); + if (sp) + sp->_endwin = ewInitial; /* in case of reuse */ + } } - exit(EXIT_FAILURE); + } + _exit(EXIT_FAILURE); } #if USE_SIGWINCH -static void sigwinch(int sig GCC_UNUSED) +static void +handle_SIGWINCH(int sig GCC_UNUSED) { - SCREEN *scan = _nc_screen_chain; - while(scan) - { - scan->_sig_winch = TRUE; - scan = scan->_next_screen; + _nc_globals.have_sigwinch = 1; +# if USE_PTHREADS_EINTR + if (_nc_globals.read_thread) { + if (!pthread_equal(pthread_self(), _nc_globals.read_thread)) + pthread_kill(_nc_globals.read_thread, SIGWINCH); + _nc_globals.read_thread = 0; } +# endif } #endif /* USE_SIGWINCH */ @@ -255,41 +301,57 @@ static void sigwinch(int sig GCC_UNUSED) * If the given signal is still in its default state, set it to the given * handler. */ -#if HAVE_SIGACTION || HAVE_SIGVEC -static int CatchIfDefault(int sig, sigaction_t *act) +static int +CatchIfDefault(int sig, void (*handler) (int)) { - sigaction_t old_act; + int result; +#if HAVE_SIGACTION || HAVE_SIGVEC + sigaction_t old_act; + sigaction_t new_act; + + memset(&new_act, 0, sizeof(new_act)); + sigemptyset(&new_act.sa_mask); +#ifdef SA_RESTART +#ifdef SIGWINCH + if (sig != SIGWINCH) +#endif + new_act.sa_flags |= SA_RESTART; +#endif /* SA_RESTART */ + new_act.sa_handler = handler; - if (sigaction(sig, (sigaction_t *)0, &old_act) == 0 - && (old_act.sa_handler == SIG_DFL + if (sigaction(sig, NULL, &old_act) == 0 + && (old_act.sa_handler == SIG_DFL + || old_act.sa_handler == handler #if USE_SIGWINCH || (sig == SIGWINCH && old_act.sa_handler == SIG_IGN) #endif - )) { - (void)sigaction(sig, act, (sigaction_t *)0); - return TRUE; - } - return FALSE; -} -#else -static int CatchIfDefault(int sig, RETSIGTYPE (*handler)(int)) -{ - void (*ohandler)(int); + )) { + (void) sigaction(sig, &new_act, NULL); + result = TRUE; + } else { + result = FALSE; + } +#else /* !HAVE_SIGACTION */ + void (*ohandler) (int); - ohandler = signal(sig, SIG_IGN); - if (ohandler == SIG_DFL + ohandler = signal(sig, SIG_IGN); + if (ohandler == SIG_DFL + || ohandler == handler #if USE_SIGWINCH - || (sig == SIGWINCH && ohandler == SIG_IGN) + || (sig == SIGWINCH && ohandler == SIG_IGN) #endif ) { - signal(sig, handler); - return TRUE; - } else { - signal(sig, ohandler); - return FALSE; - } -} + signal(sig, handler); + result = TRUE; + } else { + signal(sig, ohandler); + result = FALSE; + } #endif + T(("CatchIfDefault - will %scatch %s", + result ? "" : "not ", signal_name(sig))); + return result; +} /* * This is invoked once at the beginning (e.g., from 'initscr()'), to @@ -302,69 +364,46 @@ static int CatchIfDefault(int sig, RETSIGTYPE (*handler)(int)) * The XSI document implies that we shouldn't keep the SIGTSTP handler if * the caller later changes its mind, but that doesn't seem correct. */ -void _nc_signal_handler(bool enable) +NCURSES_EXPORT(void) +_nc_signal_handler(int enable) { -#if USE_SIGTSTP /* Xenix 2.x doesn't have SIGTSTP, for example */ -static sigaction_t act, oact; -static int ignore; - - if (!ignore) - { - if (!enable) - { - act.sa_handler = SIG_IGN; - sigaction(SIGTSTP, &act, &oact); - } - else if (act.sa_handler) - { - sigaction(SIGTSTP, &oact, NULL); - } - else /*initialize */ - { - sigemptyset(&act.sa_mask); - act.sa_flags = 0; -#if USE_SIGWINCH - act.sa_handler = sigwinch; - CatchIfDefault(SIGWINCH, &act); -#endif - + T((T_CALLED("_nc_signal_handler(%d)"), enable)); +#if USE_SIGTSTP /* Xenix 2.x doesn't have SIGTSTP, for example */ + { + static bool ignore_tstp = FALSE; + + if (!ignore_tstp) { + static sigaction_t new_sigaction, old_sigaction; + + if (!enable) { + new_sigaction.sa_handler = SIG_IGN; + sigaction(SIGTSTP, &new_sigaction, &old_sigaction); + } else if (new_sigaction.sa_handler != SIG_DFL) { + sigaction(SIGTSTP, &old_sigaction, NULL); + } else if (sigaction(SIGTSTP, NULL, &old_sigaction) == 0 + && (old_sigaction.sa_handler == SIG_DFL)) { + sigemptyset(&new_sigaction.sa_mask); #ifdef SA_RESTART - act.sa_flags |= SA_RESTART; + new_sigaction.sa_flags |= SA_RESTART; #endif /* SA_RESTART */ - act.sa_handler = cleanup; - CatchIfDefault(SIGINT, &act); - CatchIfDefault(SIGTERM, &act); - - act.sa_handler = tstp; - if (!CatchIfDefault(SIGTSTP, &act)) - ignore = TRUE; - } + new_sigaction.sa_handler = handle_SIGTSTP; + (void) sigaction(SIGTSTP, &new_sigaction, NULL); + } else { + ignore_tstp = TRUE; + } } -#else /* !USE_SIGTSTP */ - if (enable) - { -#if HAVE_SIGACTION || HAVE_SIGVEC - static sigaction_t act; - sigemptyset(&act.sa_mask); -#if USE_SIGWINCH - act.sa_handler = sigwinch; - CatchIfDefault(SIGWINCH, &act); -#endif -#ifdef SA_RESTART - act.sa_flags |= SA_RESTART; -#endif /* SA_RESTART */ - act.sa_handler = cleanup; - CatchIfDefault(SIGINT, &act); - CatchIfDefault(SIGTERM, &act); - -#else /* !(HAVE_SIGACTION || HAVE_SIGVEC) */ + } +#endif /* !USE_SIGTSTP */ - CatchIfDefault(SIGINT, cleanup); - CatchIfDefault(SIGTERM, cleanup); + if (!_nc_globals.init_signals) { + if (enable) { + CatchIfDefault(SIGINT, handle_SIGINT); + CatchIfDefault(SIGTERM, handle_SIGINT); #if USE_SIGWINCH - CatchIfDefault(SIGWINCH, sigwinch); + CatchIfDefault(SIGWINCH, handle_SIGWINCH); #endif -#endif /* !(HAVE_SIGACTION || HAVE_SIGVEC) */ + _nc_globals.init_signals = TRUE; } -#endif /* !USE_SIGTSTP */ + } + returnVoid; }