pico/osdep/raw.c

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