lib/libcurses/tstp.c

   1 /*      $NetBSD: tstp.c,v 1.36 2007/08/27 19:54:29 jdc Exp $    */
   2
   3 /*
   4  * Copyright (c) 1981, 1993, 1994
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #ifndef lint
  34 #if 0
  35 static char sccsid[] = "@(#)tstp.c      8.3 (Berkeley) 5/4/94";
  36 #else
  37 __RCSID("$NetBSD: tstp.c,v 1.36 2007/08/27 19:54:29 jdc Exp $");
  38 #endif
  39 #endif                          /* not lint */
  40
  41 #include <sys/ioctl.h>
  42
  43 #include <errno.h>
  44 #include <signal.h>
  45 #include <termios.h>
  46 #include <unistd.h>
  47
  48 #include "curses.h"
  49 #include "curses_private.h"
  50
  51 static int tstp_set = 0;
  52 static int winch_set = 0;
  53
  54 static void (*otstpfn)
  55 __P((int)) = SIG_DFL;
  56
  57 static struct sigaction owsa;
  58
  59 /*
  60  * stop_signal_handler --
  61  *      Handle stop signals.
  62  */
  63 void
  64 __stop_signal_handler(/*ARGSUSED*/int signo)
  65 {
  66         sigset_t oset, set;
  67
  68         /*
  69          * Block window change and timer signals.  The latter is because
  70          * applications use timers to decide when to repaint the screen.
  71          */
  72         (void) sigemptyset(&set);
  73         (void) sigaddset(&set, SIGALRM);
  74         (void) sigaddset(&set, SIGWINCH);
  75         (void) sigprocmask(SIG_BLOCK, &set, &oset);
  76
  77         /*
  78          * End the window, which also resets the terminal state to the
  79          * original modes.
  80          */
  81         __stopwin();
  82
  83         /* Unblock SIGTSTP. */
  84         (void) sigemptyset(&set);
  85         (void) sigaddset(&set, SIGTSTP);
  86         (void) sigprocmask(SIG_UNBLOCK, &set, NULL);
  87
  88         /* Stop ourselves. */
  89         (void) kill(0, SIGTSTP);
  90
  91         /* Time passes ... */
  92
  93         /* restart things */
  94         __restartwin();
  95
  96         /* Reset the signals. */
  97         (void) sigprocmask(SIG_SETMASK, &oset, NULL);
  98 }
  99
 100 /*
 101  * Set the TSTP handler.
 102  */
 103 void
 104 __set_stophandler(void)
 105 {
 106 #ifdef DEBUG
 107         __CTRACE(__CTRACE_MISC, "__set_stophandler: %d\n", tstp_set);
 108 #endif
 109         if (!tstp_set) {
 110                 otstpfn = signal(SIGTSTP, __stop_signal_handler);
 111                 tstp_set = 1;
 112         }
 113 }
 114
 115 /*
 116  * Restore the TSTP handler.
 117  */
 118 void
 119 __restore_stophandler(void)
 120 {
 121 #ifdef DEBUG
 122         __CTRACE(__CTRACE_MISC, "__restore_stophandler: %d\n", tstp_set);
 123 #endif
 124         if (tstp_set) {
 125                 (void) signal(SIGTSTP, otstpfn);
 126                 tstp_set = 0;
 127         }
 128 }
 129
 130 /*
 131  * winch_signal_handler --
 132  *      Handle winch signals by pushing KEY_RESIZE into the input stream.
 133  */
 134 void
 135 __winch_signal_handler(/*ARGSUSED*/int signo)
 136 {
 137         struct winsize win;
 138
 139         if (ioctl(fileno(_cursesi_screen->outfd), TIOCGWINSZ, &win) != -1 &&
 140             win.ws_row != 0 && win.ws_col != 0) {
 141                 LINES = win.ws_row;
 142                 COLS = win.ws_col;
 143         }
 144         /*
 145          * If there was a previous handler, call that,
 146          * otherwise tell getch() to send KEY_RESIZE.
 147          */
 148         if (owsa.sa_handler !=  NULL)
 149                 owsa.sa_handler(signo);
 150         else
 151                 _cursesi_screen->resized = 1;
 152 }
 153
 154 /*
 155  * Set the WINCH handler.
 156  */
 157 void
 158 __set_winchhandler(void)
 159 {
 160 #ifdef DEBUG
 161         __CTRACE(__CTRACE_MISC, "__set_winchhandler: %d\n", winch_set);
 162 #endif
 163         if (!winch_set) {
 164                 struct sigaction sa;
 165
 166                 sa.sa_handler = __winch_signal_handler;
 167                 sa.sa_flags = 0;
 168                 sigemptyset(&sa.sa_mask);
 169                 sigaction(SIGWINCH, &sa, &owsa);
 170                 winch_set = 1;
 171 #ifdef DEBUG
 172                 __CTRACE(__CTRACE_MISC,
 173                     "__set_winchhandler: owsa.sa_handler=%p\n",
 174                     owsa.sa_handler);
 175 #endif
 176         }
 177 }
 178
 179 /*
 180  * Restore the WINCH handler.
 181  */
 182 void
 183 __restore_winchhandler(void)
 184 {
 185 #ifdef DEBUG
 186         __CTRACE(__CTRACE_MISC, "__restore_winchhandler: %d\n", winch_set);
 187 #endif
 188         if (winch_set > 0) {
 189                 struct sigaction cwsa;
 190
 191                 sigaction(SIGWINCH, NULL, &cwsa);
 192                 if (cwsa.sa_handler == owsa.sa_handler) {
 193                         sigaction(SIGWINCH, &owsa, NULL);
 194                         winch_set = 0;
 195                 } else {
 196                         /*
 197                          * We're now using the programs WINCH handler,
 198                          * so don't restore the previous one.
 199                          */
 200                         winch_set = -1;
 201 #ifdef DEBUG
 202                         __CTRACE(__CTRACE_MISC, "cwsa.sa_handler = %p\n",
 203                             cwsa.sa_handler);
 204 #endif
 205                 }
 206         }
 207 }
 208
 209 /* To allow both SIGTSTP and endwin() to come back nicely, we provide
 210    the following routines. */
 211
 212 int
 213 __stopwin(void)
 214 {
 215 #ifdef DEBUG
 216         __CTRACE(__CTRACE_MISC, "__stopwin\n");
 217 #endif
 218         if (_cursesi_screen->endwin)
 219                 return OK;
 220
 221         /* Get the current terminal state (which the user may have changed). */
 222         (void) tcgetattr(fileno(_cursesi_screen->infd),
 223                          &_cursesi_screen->save_termios);
 224
 225         __restore_stophandler();
 226         __restore_winchhandler();
 227
 228         if (curscr != NULL) {
 229                 __unsetattr(0);
 230                 __mvcur((int) curscr->cury, (int) curscr->curx,
 231                     (int) curscr->maxy - 1, 0, 0);
 232         }
 233
 234         if (__tc_mo != NULL)
 235                 (void) tputs(__tc_mo, 0, __cputchar);
 236
 237         if ((curscr != NULL) && (curscr->flags & __KEYPAD))
 238                 (void) tputs(__tc_ke, 0, __cputchar);
 239         (void) tputs(__tc_ve, 0, __cputchar);
 240         (void) tputs(__tc_te, 0, __cputchar);
 241         (void) fflush(_cursesi_screen->outfd);
 242         (void) setvbuf(_cursesi_screen->outfd, NULL, _IOLBF, (size_t) 0);
 243
 244         _cursesi_screen->endwin = 1;
 245
 246         return (tcsetattr(fileno(_cursesi_screen->infd),
 247                           __tcaction ? TCSASOFT | TCSADRAIN : TCSADRAIN,
 248                           &_cursesi_screen->orig_termios) ? ERR : OK);
 249 }
 250
 251
 252 void
 253 __restartwin(void)
 254 {
 255         struct winsize win;
 256         int nlines, ncols;
 257
 258 #ifdef DEBUG
 259         __CTRACE(__CTRACE_MISC, "__restartwin\n");
 260 #endif
 261         if (!_cursesi_screen->endwin)
 262                 return;
 263
 264         /* Reset the curses SIGTSTP and SIGWINCH signal handlers. */
 265         __set_stophandler();
 266         __set_winchhandler();
 267
 268         /*
 269          * Check to see if the window size has changed.
 270          * If the application didn't update LINES and COLS,
 271          * set the * resized flag to tell getch() to push KEY_RESIZE.
 272          * Update curscr (which also updates __virtscr) and stdscr
 273          * to match the new size.
 274          */
 275         if (ioctl(fileno(_cursesi_screen->outfd), TIOCGWINSZ, &win) != -1 &&
 276             win.ws_row != 0 && win.ws_col != 0) {
 277                 if (win.ws_row != LINES) {
 278                         LINES = win.ws_row;
 279                         _cursesi_screen->resized = 1;
 280                 }
 281                 if (win.ws_col != COLS) {
 282                         COLS = win.ws_col;
 283                         _cursesi_screen->resized = 1;
 284                 }
 285         }
 286         /*
 287          * We need to make local copies of LINES and COLS, otherwise we
 288          * could lose if they are changed between wresize() calls.
 289          */
 290         nlines = LINES;
 291         ncols = COLS;
 292         if (curscr->maxy != nlines || curscr->maxx != ncols)
 293                 wresize(curscr, nlines, ncols);
 294         if (stdscr->maxy != nlines || stdscr->maxx != ncols)
 295                 wresize(stdscr, nlines, ncols);
 296
 297         /* save the new "default" terminal state */
 298         (void) tcgetattr(fileno(_cursesi_screen->infd),
 299                          &_cursesi_screen->orig_termios);
 300
 301         /* Reset the terminal state to the mode just before we stopped. */
 302         (void) tcsetattr(fileno(_cursesi_screen->infd),
 303                          __tcaction ? TCSASOFT | TCSADRAIN : TCSADRAIN,
 304                          &_cursesi_screen->save_termios);
 305
 306         /* Restore colours */
 307         __restore_colors();
 308
 309         /* Reset meta */
 310         __restore_meta_state();
 311
 312         /* Restart the screen. */
 313         __startwin(_cursesi_screen);
 314
 315         /* Reset cursor visibility */
 316         __restore_cursor_vis();
 317
 318         /* Repaint the screen. */
 319         wrefresh(curscr);
 320 }
 321
 322 int
 323 def_prog_mode(void)
 324 {
 325         if (_cursesi_screen->endwin)
 326                 return ERR;
 327
 328         return (tcgetattr(fileno(_cursesi_screen->infd),
 329                           &_cursesi_screen->save_termios) ? ERR : OK);
 330 }
 331
 332 int
 333 reset_prog_mode(void)
 334 {
 335
 336         return tcsetattr(fileno(_cursesi_screen->infd),
 337                          __tcaction ? TCSASOFT | TCSADRAIN : TCSADRAIN,
 338                          &_cursesi_screen->save_termios) ? ERR : OK;
 339 }
 340
 341 int
 342 def_shell_mode(void)
 343 {
 344         return (tcgetattr(fileno(_cursesi_screen->infd),
 345                           &_cursesi_screen->orig_termios) ? ERR : OK);
 346 }
 347
 348 int
 349 reset_shell_mode(void)
 350 {
 351         return (__stopwin());
 352 }