pico/osdep/raw.c

   1 /*
   2  * ========================================================================
   3  * Copyright 2006 University of Washington
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * ========================================================================
  12  */
  13
  14 /*
  15  * TTY setup routines.
  16  */
  17
  18 #include <system.h>
  19 #include <general.h>
  20
  21 #include "../estruct.h"
  22
  23 #include "raw.h"
  24
  25
  26 #if     HAS_TERMIOS
  27 /*
  28  * These are the TERMIOS-style (POSIX) routines.
  29  */
  30
  31 static struct termios _raw_tty, _original_tty;
  32
  33 #elif   HAS_TERMIO
  34 /*
  35  * These are the TERMIO-style (System V) routines.
  36  */
  37
  38 static struct termio _raw_tty, _original_tty;
  39
  40 #else   /* RAW_BSD */
  41 /*
  42  * These are for the BSD-style routines.
  43  */
  44
  45 static struct sgttyb  _raw_tty,     _original_tty;
  46 static struct ltchars _raw_ltchars, _original_ltchars;
  47 static struct tchars  _raw_tchars,  _original_tchars;
  48 static int            _raw_lmode,   _original_lmode;
  49
  50 #endif
  51
  52 /*
  53  * current raw state
  54  */
  55 static short _inraw = 0;
  56
  57 /*
  58  *  Set up the tty driver
  59  *
  60  * Args: state -- which state to put it in. 1 means go into raw (cbreak),
  61  *                0 out of raw.
  62  *
  63  * Result: returns 0 if successful and -1 if not.
  64  */
  65 int
  66 Raw(int state)
  67 {
  68     /** state is either ON or OFF, as indicated by call **/
  69     /* Check return code only on first call. If it fails we're done for and
  70        if it goes OK the others will probably go OK too. */
  71
  72     if(state == 0 && _inraw){
  73         /*----- restore state to original -----*/
  74
  75 #if     HAS_TERMIOS
  76
  77         if(tcsetattr(STDIN_FD, TCSADRAIN, &_original_tty) < 0)
  78           return -1;
  79
  80 #elif   HAS_TERMIO
  81
  82         if(ioctl(STDIN_FD, TCSETAW, &_original_tty) < 0)
  83           return(-1);
  84
  85 #else   /* RAW_BSD */
  86
  87         if(ioctl(STDIN_FD, TIOCSETP, &_original_tty) < 0)
  88           return(-1);
  89
  90         (void)ioctl(STDIN_FD, TIOCSLTC, &_original_ltchars);
  91         (void)ioctl(STDIN_FD, TIOCSETC, &_original_tchars);
  92         (void)ioctl(STDIN_FD, TIOCLSET, &_original_lmode);
  93
  94 #endif
  95
  96         _inraw = 0;
  97     }
  98     else if(state == 1 && ! _inraw){
  99         /*----- Go into raw mode (cbreak actually) ----*/
 100
 101 #if     HAS_TERMIOS
 102
 103         if(tcgetattr(STDIN_FD, &_original_tty) < 0)
 104           return -1;
 105
 106         tcgetattr(STDIN_FD, &_raw_tty);
 107         _raw_tty.c_lflag &= ~(ICANON | ECHO | IEXTEN); /* noecho raw mode    */
 108         _raw_tty.c_lflag &= ~ISIG;              /* disable signals           */
 109         _raw_tty.c_iflag &= ~ICRNL;             /* turn off CR->NL on input  */
 110         _raw_tty.c_oflag &= ~ONLCR;             /* turn off NL->CR on output */
 111
 112         _raw_tty.c_cc[VMIN]  = '\01';           /* min # of chars to queue  */
 113         _raw_tty.c_cc[VTIME] = '\0';            /* min time to wait for input*/
 114         _raw_tty.c_cc[VINTR] = ctrl('C');       /* make it our special char */
 115         _raw_tty.c_cc[VQUIT] = 0;
 116         _raw_tty.c_cc[VSUSP] = 0;
 117         tcsetattr(STDIN_FD, TCSADRAIN, &_raw_tty);
 118
 119 #elif   HAS_TERMIO
 120
 121         if(ioctl(STDIN_FD, TCGETA, &_original_tty) < 0)
 122           return(-1);
 123
 124         (void)ioctl(STDIN_FD, TCGETA, &_raw_tty);    /** again! **/
 125         _raw_tty.c_lflag &= ~(ICANON | ECHO);   /* noecho raw mode  */
 126         _raw_tty.c_lflag &= ~ISIG;              /* disable signals */
 127         _raw_tty.c_iflag &= ~ICRNL;             /* turn off CR->NL on input  */
 128         _raw_tty.c_oflag &= ~ONLCR;             /* turn off NL->CR on output */
 129         _raw_tty.c_cc[VMIN]  = 1;               /* min # of chars to queue   */
 130         _raw_tty.c_cc[VTIME] = 0;               /* min time to wait for input*/
 131         _raw_tty.c_cc[VINTR] = ctrl('C');       /* make it our special char */
 132         _raw_tty.c_cc[VQUIT] = 0;
 133         (void)ioctl(STDIN_FD, TCSETAW, &_raw_tty);
 134
 135 #else   /* RAW_BSD */
 136         if(ioctl(STDIN_FD, TIOCGETP, &_original_tty) < 0)
 137           return(-1);
 138
 139         (void)ioctl(STDIN_FD, TIOCGETP, &_raw_tty);
 140         (void)ioctl(STDIN_FD, TIOCGETC, &_original_tchars);
 141         (void)ioctl(STDIN_FD, TIOCGETC, &_raw_tchars);
 142         (void)ioctl(STDIN_FD, TIOCGLTC, &_original_ltchars);
 143         (void)ioctl(STDIN_FD, TIOCGLTC, &_raw_ltchars);
 144         (void)ioctl(STDIN_FD, TIOCLGET, &_original_lmode);
 145         (void)ioctl(STDIN_FD, TIOCLGET, &_raw_lmode);
 146
 147         _raw_tty.sg_flags &= ~(ECHO);   /* echo off */
 148         _raw_tty.sg_flags |= CBREAK;    /* raw on    */
 149         _raw_tty.sg_flags &= ~CRMOD;    /* Turn off CR -> LF mapping */
 150
 151         _raw_tchars.t_intrc = -1;       /* Turn off ^C and ^D */
 152         _raw_tchars.t_eofc  = -1;
 153
 154         _raw_ltchars.t_lnextc = -1;     /* Turn off ^V so we can use it */
 155         _raw_ltchars.t_dsuspc = -1;     /* Turn off ^Y so we can use it */
 156         _raw_ltchars.t_suspc  = -1;     /* Turn off ^Z; we just read 'em */
 157         _raw_ltchars.t_werasc = -1;     /* Turn off ^w word erase */
 158         _raw_ltchars.t_rprntc = -1;     /* Turn off ^R reprint line */
 159         _raw_ltchars.t_flushc = -1;     /* Turn off ^O output flush */
 160
 161         (void)ioctl(STDIN_FD, TIOCSETP, &_raw_tty);
 162         (void)ioctl(STDIN_FD, TIOCSLTC, &_raw_ltchars);
 163         (void)ioctl(STDIN_FD, TIOCSETC, &_raw_tchars);
 164         (void)ioctl(STDIN_FD, TIOCLSET, &_raw_lmode);
 165 #endif
 166         _inraw = 1;
 167     }
 168
 169     return(0);
 170 }
 171
 172
 173 /*
 174  *  Set up the tty driver to use XON/XOFF flow control
 175  *
 176  * Args: state -- True to make sure XON/XOFF turned on, FALSE off.
 177  *
 178  * Result: none.
 179  */
 180 void
 181 xonxoff_proc(int state)
 182 {
 183     if(_inraw){
 184         if(state){
 185 #if     HAS_TERMIOS
 186
 187             if(!(_raw_tty.c_iflag & IXON)){
 188                 _raw_tty.c_iflag |= IXON;
 189                 tcsetattr (STDIN_FD, TCSADRAIN, &_raw_tty);
 190             }
 191
 192 #elif   HAS_TERMIO
 193
 194             if(!(_raw_tty.c_iflag & IXON)){
 195                 _raw_tty.c_iflag |= IXON;       /* turn ON ^S/^Q on input   */
 196                 (void)ioctl(STDIN_FD, TCSETAW, &_raw_tty);
 197
 198 #else   /* RAW_BSD */
 199
 200             if(_raw_tchars.t_startc == -1 || _raw_tchars.t_stopc == -1){
 201                 _raw_tchars.t_startc = 'Q' - '@'; /* Turn ON ^S/^Q */
 202                 _raw_tchars.t_stopc  = 'S' - '@';
 203                 (void)ioctl(STDIN_FD, TIOCSETC, &_raw_tchars);
 204             }
 205
 206 #endif
 207         }
 208         else{
 209 #if     HAS_TERMIOS
 210
 211             if(_raw_tty.c_iflag & IXON){
 212                 _raw_tty.c_iflag &= ~IXON;      /* turn off ^S/^Q on input   */
 213                 tcsetattr (STDIN_FD, TCSADRAIN, &_raw_tty);
 214             }
 215
 216 #elif   HAS_TERMIO
 217
 218             if(_raw_tty.c_iflag & IXON){
 219                 _raw_tty.c_iflag &= ~IXON;      /* turn off ^S/^Q on input   */
 220                 (void)ioctl(STDIN_FD, TCSETAW, &_raw_tty);
 221             }
 222
 223 #else   /* RAW_BSD */
 224             if(!(_raw_tchars.t_startc == -1 && _raw_tchars.t_stopc == -1)){
 225                 _raw_tchars.t_startc = -1;      /* Turn off ^S/^Q */
 226                 _raw_tchars.t_stopc  = -1;
 227                 (void)ioctl(STDIN_FD, TIOCSETC, &_raw_tchars);
 228             }
 229 #endif
 230         }
 231     }
 232 }
 233
 234
 235 /*
 236  *  Set up the tty driver to do LF->CR translation
 237  *
 238  * Args: state -- True to turn on translation, false to write raw LF's
 239  *
 240  * Result: none.
 241  */
 242 void
 243 crlf_proc(int state)
 244 {
 245     if(_inraw){
 246         if(state){                              /* turn ON NL->CR on output */
 247 #if     HAS_TERMIOS
 248
 249             if(!(_raw_tty.c_oflag & ONLCR)){
 250                 _raw_tty.c_oflag |= ONLCR;
 251                 tcsetattr (STDIN_FD, TCSADRAIN, &_raw_tty);
 252             }
 253
 254 #elif   HAS_TERMIO
 255
 256             if(!(_raw_tty.c_oflag & ONLCR)){
 257                 _raw_tty.c_oflag |= ONLCR;
 258                 (void)ioctl(STDIN_FD, TCSETAW, &_raw_tty);
 259             }
 260
 261 #else   /* RAW_BSD */
 262             if(!(_raw_tty.sg_flags & CRMOD)){
 263                 _raw_tty.sg_flags |= CRMOD;
 264                 (void)ioctl(STDIN_FD, TIOCSETP, &_raw_tty);
 265             }
 266 #endif
 267         }
 268         else{                                   /* turn OFF NL-CR on output */
 269 #if     HAS_TERMIOS
 270
 271             if(_raw_tty.c_oflag & ONLCR){
 272                 _raw_tty.c_oflag &= ~ONLCR;
 273                 tcsetattr (STDIN_FD, TCSADRAIN, &_raw_tty);
 274             }
 275
 276 #elif   HAS_TERMIO
 277
 278             if(_raw_tty.c_oflag & ONLCR){
 279                 _raw_tty.c_oflag &= ~ONLCR;
 280                 (void)ioctl(STDIN_FD, TCSETAW, &_raw_tty);
 281             }
 282
 283 #else   /* RAW_BSD */
 284
 285             if(_raw_tty.sg_flags & CRMOD){
 286                 _raw_tty.sg_flags &= ~CRMOD;
 287                 (void)ioctl(STDIN_FD, TIOCSETP, &_raw_tty);
 288             }
 289
 290 #endif
 291         }
 292     }
 293 }
 294
 295
 296 /*
 297  *  Set up the tty driver to handle interrupt char
 298  *
 299  * Args: state -- True to turn on interrupt char, false to not
 300  *
 301  * Result: tty driver that'll send us SIGINT or not
 302  */
 303 void
 304 intr_proc(int state)
 305 {
 306     if(_inraw){
 307         if(state){
 308 #if     HAS_TERMIOS
 309
 310             _raw_tty.c_lflag |= ISIG;           /* enable signals */
 311             tcsetattr(STDIN_FD, TCSADRAIN, &_raw_tty);
 312
 313 #elif   HAS_TERMIO
 314
 315             _raw_tty.c_lflag |= ISIG;           /* enable signals */
 316             (void)ioctl(STDIN_FD, TCSETAW, &_raw_tty);
 317
 318 #else   /* RAW_BSD */
 319
 320             _raw_tchars.t_intrc = ctrl('C');
 321             (void)ioctl(STDIN_FD, TIOCSETC, &_raw_tchars);
 322
 323 #endif
 324         }
 325         else{
 326 #if     HAS_TERMIOS
 327
 328             _raw_tty.c_lflag &= ~ISIG;          /* disable signals */
 329             tcsetattr(STDIN_FD, TCSADRAIN, &_raw_tty);
 330
 331 #elif   HAS_TERMIO
 332
 333             _raw_tty.c_lflag &= ~ISIG;          /* disable signals */
 334             (void)ioctl(STDIN_FD, TCSETAW, &_raw_tty);
 335
 336 #else   /* RAW_BSD */
 337             _raw_tchars.t_intrc = -1;
 338             (void)ioctl(STDIN_FD, TIOCSETC, &_raw_tchars);
 339 #endif
 340         }
 341     }
 342 }
 343
 344
 345 /*
 346  * Discard any pending input characters
 347  *
 348  * Args:  none
 349  *
 350  * Result: pending input buffer flushed
 351  */
 352 void
 353 flush_input(void)
 354 {
 355 #if     HAS_TERMIOS
 356
 357     tcflush(STDIN_FD, TCIFLUSH);
 358
 359 #elif   HAS_TERMIO
 360
 361     ioctl(STDIN_FD, TCFLSH, 0);
 362
 363 #else   /* RAW_BSD */
 364
 365 #ifdef  TIOCFLUSH
 366 #ifdef  FREAD
 367     int i = FREAD;
 368 #else
 369     int i = 1;
 370 #endif
 371     ioctl(STDIN_FD, TIOCFLUSH, &i);
 372 #endif  /* TIOCFLUSH */
 373
 374 #endif
 375 }
 376
 377
 378 /*
 379  * Turn off hi bit stripping
 380  */
 381 void
 382 bit_strip_off(void)
 383 {
 384 #if     HAS_TERMIOS
 385
 386     _raw_tty.c_iflag &= ~ISTRIP;
 387     tcsetattr(STDIN_FD, TCSADRAIN, &_raw_tty);
 388
 389 #elif   HAS_TERMIO
 390
 391     /* no op */
 392
 393 #else   /* RAW_BSD */
 394
 395 #ifdef  LPASS8
 396     _raw_lmode |= LPASS8;
 397 #endif
 398
 399 #ifdef  LPASS8OUT
 400     _raw_lmode |= LPASS8OUT;
 401 #endif
 402
 403     (void)ioctl(STDIN_FD, TIOCLSET, &_raw_lmode);
 404
 405 #endif
 406 }
 407
 408
 409 /*
 410  * Turn off quit character (^\) if possible
 411  */
 412 void
 413 quit_char_off(void)
 414 {
 415 #if     HAS_TERMIOS
 416
 417 #elif   HAS_TERMIO
 418
 419 #else   /* RAW_BSD */
 420     _raw_tchars.t_quitc = -1;
 421     (void)ioctl(STDIN_FD, TIOCSETC, &_raw_tchars);
 422 #endif
 423 }
 424
 425
 426 /*
 427  * Returns TRUE if tty is < 4800, 0 otherwise.
 428  */
 429 int
 430 ttisslow(void)
 431 {
 432 #if     HAS_TERMIOS
 433
 434     return(cfgetospeed(&_raw_tty) < B4800);
 435
 436 #elif   HAS_TERMIO
 437
 438     return((_raw_tty.c_cflag&CBAUD) < (unsigned int)B4800);
 439
 440 #else   /* RAW_BSD */
 441
 442     return((int)_raw_tty.sg_ispeed < B4800);
 443
 444 #endif
 445 }