slang/slutty.c

   1 /* slutty.c --- Unix Low level terminal (tty) functions for S-Lang */
   2 /* Copyright (c) 1992, 1995 John E. Davis
   3  * All rights reserved.
   4  *
   5  * You may distribute under the terms of either the GNU General Public
   6  * License or the Perl Artistic License.
   7  */
   8
   9
  10 #include "config.h"
  11
  12 #include <stdio.h>
  13 #include <signal.h>
  14 /* sequent support thanks to Kenneth Lorber <keni@oasys.dt.navy.mil> */
  15 /* SYSV (SYSV ISC R3.2 v3.0) provided by iain.lea@erlm.siemens.de */
  16
  17 #if defined (_AIX) && !defined (_ALL_SOURCE)
  18 # define _ALL_SOURCE    /* so NBBY is defined in <sys/types.h> */
  19 #endif
  20
  21 #ifdef HAVE_STDLIB_H
  22 # include <stdlib.h>
  23 #endif
  24
  25 #ifdef HAVE_UNISTD_H
  26 # include <unistd.h>
  27 #endif
  28
  29 #include <sys/time.h>
  30 #include <sys/types.h>
  31
  32 #ifdef SYSV
  33 # include <fcntl.h>
  34 # ifndef CRAY
  35 #  include <sys/termio.h>
  36 #  include <sys/stream.h>
  37 #  include <sys/ptem.h>
  38 #  include <sys/tty.h>
  39 # endif
  40 #endif
  41
  42
  43 #ifdef __BEOS__
  44 /* Prototype for select */
  45 # include <net/socket.h>
  46 #endif
  47
  48 #include <sys/file.h>
  49
  50 #ifndef sun
  51 # include <sys/ioctl.h>
  52 #endif
  53
  54 #ifdef __QNX__
  55 # include <sys/select.h>
  56 #endif
  57
  58 #include <sys/stat.h>
  59 #include <errno.h>
  60
  61 #if defined (_AIX) && !defined (FD_SET)
  62 # include <sys/select.h>        /* for FD_ISSET, FD_SET, FD_ZERO */
  63 #endif
  64
  65 #ifndef O_RDWR
  66 # include <fcntl.h>
  67 #endif
  68
  69
  70 #include "_slang.h"
  71
  72 int SLang_TT_Read_FD = -1;
  73 int SLang_TT_Baud_Rate;
  74
  75
  76 #ifdef HAVE_TERMIOS_H
  77 # if !defined(HAVE_TCGETATTR) || !defined(HAVE_TCSETATTR)
  78 #   undef HAVE_TERMIOS_H
  79 # endif
  80 #endif
  81
  82 #ifndef HAVE_TERMIOS_H
  83
  84 # if !defined(CBREAK) && defined(sun)
  85 #  ifndef BSD_COMP
  86 #   define BSD_COMP 1
  87 #  endif
  88 #  include <sys/ioctl.h>
  89 # endif
  90
  91 typedef struct
  92   {
  93       struct tchars t;
  94       struct ltchars lt;
  95       struct sgttyb s;
  96   }
  97 TTY_Termio_Type;
  98 #else
  99 # include <termios.h>
 100 typedef struct termios TTY_Termio_Type;
 101 #endif
 102
 103 static TTY_Termio_Type Old_TTY;
 104
 105 #ifdef HAVE_TERMIOS_H
 106 static struct
 107 {
 108     speed_t key;
 109     int value;
 110 } Baud_Rates[] =
 111 {
 112    {B0, 0},
 113    {B50, 50},
 114    {B75, 75},
 115    {B110, 110},
 116    {B134, 134},
 117    {B150, 150},
 118    {B200, 200},
 119    {B300, 300},
 120    {B600, 600},
 121    {B1200, 1200},
 122    {B1800, 1800},
 123    {B2400, 2400},
 124    {B4800, 4800},
 125    {B9600, 9600},
 126    {B19200, 19200},
 127    {B38400, 38400}
 128 #ifdef B57600
 129    , {B57600, 57600}
 130 #endif
 131 #ifdef B115200
 132    , {B115200, 115200}
 133 #endif
 134 #ifdef B230400
 135    , {B230400, 230400}
 136 #endif
 137 };
 138 #endif
 139
 140 #ifdef HAVE_TERMIOS_H
 141 # define GET_TERMIOS(fd, x) tcgetattr(fd, x)
 142 # define SET_TERMIOS(fd, x) tcsetattr(fd, TCSADRAIN, x)
 143 #else
 144 # ifdef TCGETS
 145 #  define GET_TERMIOS(fd, x) ioctl(fd, TCGETS, x)
 146 #  define SET_TERMIOS(fd, x) ioctl(fd, TCSETS, x)
 147 # else
 148 #  define X(x,m)  &(((TTY_Termio_Type *)(x))->m)
 149 #  define GET_TERMIOS(fd, x)    \
 150     ((ioctl(fd, TIOCGETC, X(x,t)) || \
 151       ioctl(fd, TIOCGLTC, X(x,lt)) || \
 152       ioctl(fd, TIOCGETP, X(x,s))) ? -1 : 0)
 153 #  define SET_TERMIOS(fd, x)    \
 154     ((ioctl(fd, TIOCSETC, X(x,t)) ||\
 155       ioctl(fd, TIOCSLTC, X(x,lt)) || \
 156       ioctl(fd, TIOCSETP, X(x,s))) ? -1 : 0)
 157 # endif
 158 #endif
 159
 160 static int TTY_Inited = 0;
 161 static int TTY_Open = 0;
 162
 163 #ifdef ultrix   /* Ultrix gets _POSIX_VDISABLE wrong! */
 164 # define NULL_VALUE -1
 165 #else
 166 # ifdef _POSIX_VDISABLE
 167 #  define NULL_VALUE _POSIX_VDISABLE
 168 # else
 169 #  define NULL_VALUE 255
 170 # endif
 171 #endif
 172
 173 static int
 174 speed_t2baud_rate (speed_t s)
 175 {
 176     int i;
 177
 178     for (i = 0; i < sizeof (Baud_Rates)/sizeof (Baud_Rates[0]); i++)
 179         if (Baud_Rates[i].key == s)
 180             return (Baud_Rates[i].value);
 181     return 0;
 182 }
 183
 184 int SLang_init_tty (int abort_char, int no_flow_control, int opost)
 185 {
 186    TTY_Termio_Type newtty;
 187
 188    SLsig_block_signals ();
 189
 190    if (TTY_Inited)
 191      {
 192         SLsig_unblock_signals ();
 193         return 0;
 194      }
 195
 196    TTY_Open = 0;
 197
 198    if ((SLang_TT_Read_FD == -1)
 199        || (1 != isatty (SLang_TT_Read_FD)))
 200      {
 201 #if 0
 202 #ifdef O_RDWR
 203 # ifndef __BEOS__  /* I have been told that BEOS will HANG if passed /dev/tty */
 204         if ((SLang_TT_Read_FD = open("/dev/tty", O_RDWR)) >= 0)
 205           {
 206              TTY_Open = 1;
 207           }
 208 # endif
 209 #endif
 210 #endif /* 0 */
 211         if (TTY_Open == 0)
 212           {
 213
 214 #if 0
 215 /* In the Midnight Commander we bind stderr sometimes to a pipe. If we
 216    use stderr for terminal input and call SLang_getkey while stderr is
 217    bound to a pipe MC will hang completly in SLsys_input_pending.
 218    NOTE: There's an independent fix for this problem in src/slint.c for
 219    the case that the Midnight Commander is linked against a shared slang
 220    library compiled from different sources.
 221  */
 222              SLang_TT_Read_FD = fileno (stderr);
 223              if (1 != isatty (SLang_TT_Read_FD))
 224 #endif
 225                {
 226                   SLang_TT_Read_FD = fileno (stdin);
 227                   if (1 != isatty (SLang_TT_Read_FD))
 228                     {
 229                        fprintf (stderr, "Failed to open terminal.");
 230                        return -1;
 231                     }
 232                }
 233           }
 234      }
 235
 236    SLang_Abort_Char = abort_char;
 237
 238    /* Some systems may not permit signals to be blocked.  As a result, the
 239     * return code must be checked.
 240     */
 241    while (-1 == GET_TERMIOS(SLang_TT_Read_FD, &Old_TTY))
 242      {
 243         if (errno != EINTR)
 244           {
 245              SLsig_unblock_signals ();
 246              return -1;
 247           }
 248      }
 249
 250    while (-1 == GET_TERMIOS(SLang_TT_Read_FD, &newtty))
 251      {
 252         if (errno != EINTR)
 253           {
 254              SLsig_unblock_signals ();
 255              return -1;
 256           }
 257      }
 258
 259 #ifndef HAVE_TERMIOS_H
 260    newtty.s.sg_flags &= ~(ECHO);
 261    newtty.s.sg_flags &= ~(CRMOD);
 262    /*   if (Flow_Control == 0) newtty.s.sg_flags &= ~IXON; */
 263    newtty.t.t_eofc = 1;
 264    if (abort_char == -1) SLang_Abort_Char = newtty.t.t_intrc;
 265    newtty.t.t_intrc = SLang_Abort_Char; /* ^G */
 266    newtty.t.t_quitc = 255;
 267    newtty.lt.t_suspc = 255;   /* to ignore ^Z */
 268    newtty.lt.t_dsuspc = 255;    /* to ignore ^Y */
 269    newtty.lt.t_lnextc = 255;
 270    newtty.s.sg_flags |= CBREAK;         /* do I want cbreak or raw????? */
 271 #else
 272
 273    /* get baud rate */
 274
 275    /* [not only QNX related !?!]
 276     * ECHO(0x08) is a c_lflag bit, it means here PARMRK(0x08) in c_iflag!!!
 277     */
 278    /*newtty.c_iflag &= ~(ECHO | INLCR | ICRNL);*/
 279    newtty.c_iflag &= ~(INLCR | ICRNL);
 280 #ifdef ISTRIP
 281    /* newtty.c_iflag &= ~ISTRIP; */
 282 #endif
 283    if (opost == 0) newtty.c_oflag &= ~OPOST;
 284
 285    if (SLang_TT_Baud_Rate == 0)
 286      {
 287 /* Note:  if this generates an compiler error, simply remove
 288    the statement */
 289 #ifdef HAVE_CFGETOSPEED
 290         SLang_TT_Baud_Rate = cfgetospeed (&newtty);
 291 #endif
 292         SLang_TT_Baud_Rate = speed_t2baud_rate (SLang_TT_Baud_Rate);
 293      }
 294    if (no_flow_control) newtty.c_iflag &= ~IXON; else newtty.c_iflag |= IXON;
 295
 296    newtty.c_cc[VMIN] = 1;
 297    newtty.c_cc[VTIME] = 0;
 298    newtty.c_cc[VEOF] = 1;
 299    newtty.c_lflag = ISIG | NOFLSH;
 300    if (abort_char == -1) SLang_Abort_Char = newtty.c_cc[VINTR];
 301    newtty.c_cc[VINTR] = SLang_Abort_Char;   /* ^G */
 302    newtty.c_cc[VQUIT] = NULL_VALUE;
 303    newtty.c_cc[VSUSP] = NULL_VALUE;   /* to ignore ^Z */
 304 #ifdef VSWTCH
 305    newtty.c_cc[VSWTCH] = NULL_VALUE;   /* to ignore who knows what */
 306 #endif
 307 #endif /* NOT HAVE_TERMIOS_H */
 308
 309    while (-1 == SET_TERMIOS(SLang_TT_Read_FD, &newtty))
 310      {
 311         if (errno != EINTR)
 312           {
 313              SLsig_unblock_signals ();
 314              return -1;
 315           }
 316      }
 317
 318    TTY_Inited = 1;
 319    SLsig_unblock_signals ();
 320    return 0;
 321 }
 322
 323 void SLtty_set_suspend_state (int mode)
 324 {
 325    TTY_Termio_Type newtty;
 326
 327    SLsig_block_signals ();
 328
 329    if (TTY_Inited == 0)
 330      {
 331         SLsig_unblock_signals ();
 332         return;
 333      }
 334
 335    while ((-1 == GET_TERMIOS (SLang_TT_Read_FD, &newtty))
 336           && (errno == EINTR))
 337      ;
 338
 339 #ifndef HAVE_TERMIOS_H
 340    if (mode == 0) newtty.lt.t_suspc = 255;
 341    else newtty.lt.t_suspc = Old_TTY.lt.t_suspc;
 342 #else
 343    if (mode == 0) newtty.c_cc[VSUSP] = NULL_VALUE;
 344    else newtty.c_cc[VSUSP] = Old_TTY.c_cc[VSUSP];
 345 #endif
 346
 347    while ((-1 == SET_TERMIOS (SLang_TT_Read_FD, &newtty))
 348           && (errno == EINTR))
 349      ;
 350
 351    SLsig_unblock_signals ();
 352 }
 353
 354 void SLang_reset_tty (void)
 355 {
 356    SLsig_block_signals ();
 357
 358    if (TTY_Inited == 0)
 359      {
 360         SLsig_unblock_signals ();
 361         return;
 362      }
 363
 364    while ((-1 == SET_TERMIOS(SLang_TT_Read_FD, &Old_TTY))
 365           && (errno == EINTR))
 366      ;
 367
 368    if (TTY_Open)
 369      {
 370         while ((-1 == close (SLang_TT_Read_FD))
 371                && (errno == EINTR))
 372           ;
 373
 374         TTY_Open = 0;
 375         SLang_TT_Read_FD = -1;
 376      }
 377
 378    TTY_Inited = 0;
 379    SLsig_unblock_signals ();
 380 }
 381
 382 static void default_sigint (int sig)
 383 {
 384    sig = errno;                        /* use parameter */
 385
 386    SLKeyBoard_Quit = 1;
 387    if (SLang_Ignore_User_Abort == 0) SLang_Error = USER_BREAK;
 388    SLsignal_intr (SIGINT, default_sigint);
 389    errno = sig;
 390 }
 391
 392 void SLang_set_abort_signal (void (*hand)(int))
 393 {
 394    int save_errno = errno;
 395
 396    if (hand == NULL) hand = default_sigint;
 397    SLsignal_intr (SIGINT, hand);
 398
 399    errno = save_errno;
 400 }
 401
 402 #ifndef FD_SET
 403 #define FD_SET(fd, tthis) *(tthis) = 1 << (fd)
 404 #define FD_ZERO(tthis)    *(tthis) = 0
 405 #define FD_ISSET(fd, tthis) (*(tthis) & (1 << fd))
 406 typedef int fd_set;
 407 #endif
 408
 409 static fd_set Read_FD_Set;
 410
 411
 412 /* HACK: If > 0, use 1/10 seconds.  If < 0, use 1/1000 seconds */
 413
 414 int SLsys_input_pending(int tsecs)
 415 {
 416    struct timeval wait;
 417    long usecs, secs;
 418
 419    if (TTY_Inited == 0) return -1;
 420
 421    if (tsecs >= 0)
 422      {
 423         secs = tsecs / 10;
 424         usecs = (tsecs % 10) * 100000;
 425      }
 426    else
 427      {
 428         tsecs = -tsecs;
 429         secs = tsecs / 1000;
 430         usecs = (tsecs % 1000) * 1000;
 431      }
 432
 433    wait.tv_sec = secs;
 434    wait.tv_usec = usecs;
 435
 436    FD_ZERO(&Read_FD_Set);
 437    FD_SET(SLang_TT_Read_FD, &Read_FD_Set);
 438
 439    return select(SLang_TT_Read_FD + 1, &Read_FD_Set, NULL, NULL, &wait);
 440 }
 441
 442
 443 int (*SLang_getkey_intr_hook) (void);
 444
 445 static int handle_interrupt (void)
 446 {
 447    if (SLang_getkey_intr_hook != NULL)
 448      {
 449         int save_tty_fd = SLang_TT_Read_FD;
 450
 451         if (-1 == (*SLang_getkey_intr_hook) ())
 452           return -1;
 453
 454         if (save_tty_fd != SLang_TT_Read_FD)
 455           return -1;
 456      }
 457
 458    return 0;
 459 }
 460
 461 unsigned int SLsys_getkey (void)
 462 {
 463    unsigned char c;
 464    unsigned int i;
 465
 466    if (TTY_Inited == 0)
 467      {
 468         int ic = fgetc (stdin);
 469         if (ic == EOF) return SLANG_GETKEY_ERROR;
 470         return (unsigned int) ic;
 471      }
 472
 473    while (1)
 474      {
 475         int ret;
 476
 477         if (SLKeyBoard_Quit)
 478           return SLang_Abort_Char;
 479
 480         if (0 == (ret = SLsys_input_pending (100)))
 481           continue;
 482
 483         if (ret != -1)
 484           break;
 485
 486         if (SLKeyBoard_Quit)
 487           return SLang_Abort_Char;
 488
 489         if (errno == EINTR)
 490           {
 491              if (-1 == handle_interrupt ())
 492                return SLANG_GETKEY_ERROR;
 493
 494              continue;
 495           }
 496
 497         break;                         /* let read handle it */
 498      }
 499
 500    while (-1 == (i = read(SLang_TT_Read_FD, (char *) &c, 1)))
 501      {
 502         if (errno == EINTR)
 503           {
 504              if (-1 == handle_interrupt ())
 505                return SLANG_GETKEY_ERROR;
 506
 507              if (SLKeyBoard_Quit)
 508                return SLang_Abort_Char;
 509
 510              continue;
 511           }
 512 #ifdef EAGAIN
 513         if (errno == EAGAIN)
 514           {
 515              sleep (1);
 516              continue;
 517           }
 518 #endif
 519 #ifdef EWOULDBLOCK
 520         if (errno == EWOULDBLOCK)
 521           {
 522              sleep (1);
 523              continue;
 524           }
 525 #endif
 526 #ifdef EIO
 527         if (errno == EIO)
 528           {
 529              SLang_exit_error ("SLsys_getkey: EIO error.");
 530           }
 531 #endif
 532         return SLANG_GETKEY_ERROR;
 533      }
 534
 535    if (i == 0)
 536         return SLANG_GETKEY_ERROR;
 537
 538    return((unsigned int) c);
 539 }
 540