coreutils/stty.c

   1 /* vi: set sw=4 ts=4: */
   2 /* stty -- change and print terminal line settings
   3    Copyright (C) 1990-1999 Free Software Foundation, Inc.
   4
   5    Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
   6 */
   7 /* Usage: stty [-ag] [-F device] [setting...]
   8
   9    Options:
  10    -a Write all current settings to stdout in human-readable form.
  11    -g Write all current settings to stdout in stty-readable form.
  12    -F Open and use the specified device instead of stdin
  13
  14    If no args are given, write to stdout the baud rate and settings that
  15    have been changed from their defaults.  Mode reading and changes
  16    are done on the specified device, or stdin if none was specified.
  17
  18    David MacKenzie <djm@gnu.ai.mit.edu>
  19
  20    Special for busybox ported by Vladimir Oleynik <dzo@simtreas.ru> 2001
  21
  22    */
  23
  24 #include "libbb.h"
  25
  26 #ifndef _POSIX_VDISABLE
  27 # define _POSIX_VDISABLE ((unsigned char) 0)
  28 #endif
  29
  30 #define Control(c) ((c) & 0x1f)
  31 /* Canonical values for control characters */
  32 #ifndef CINTR
  33 # define CINTR Control('c')
  34 #endif
  35 #ifndef CQUIT
  36 # define CQUIT 28
  37 #endif
  38 #ifndef CERASE
  39 # define CERASE 127
  40 #endif
  41 #ifndef CKILL
  42 # define CKILL Control('u')
  43 #endif
  44 #ifndef CEOF
  45 # define CEOF Control('d')
  46 #endif
  47 #ifndef CEOL
  48 # define CEOL _POSIX_VDISABLE
  49 #endif
  50 #ifndef CSTART
  51 # define CSTART Control('q')
  52 #endif
  53 #ifndef CSTOP
  54 # define CSTOP Control('s')
  55 #endif
  56 #ifndef CSUSP
  57 # define CSUSP Control('z')
  58 #endif
  59 #if defined(VEOL2) && !defined(CEOL2)
  60 # define CEOL2 _POSIX_VDISABLE
  61 #endif
  62 /* ISC renamed swtch to susp for termios, but we'll accept either name */
  63 #if defined(VSUSP) && !defined(VSWTCH)
  64 # define VSWTCH VSUSP
  65 # define CSWTCH CSUSP
  66 #endif
  67 #if defined(VSWTCH) && !defined(CSWTCH)
  68 # define CSWTCH _POSIX_VDISABLE
  69 #endif
  70
  71 /* SunOS 5.3 loses (^Z doesn't work) if 'swtch' is the same as 'susp'.
  72    So the default is to disable 'swtch.'  */
  73 #if defined(__sparc__) && defined(__svr4__)
  74 # undef CSWTCH
  75 # define CSWTCH _POSIX_VDISABLE
  76 #endif
  77
  78 #if defined(VWERSE) && !defined(VWERASE)       /* AIX-3.2.5 */
  79 # define VWERASE VWERSE
  80 #endif
  81 #if defined(VDSUSP) && !defined(CDSUSP)
  82 # define CDSUSP Control('y')
  83 #endif
  84 #if !defined(VREPRINT) && defined(VRPRNT)       /* Irix 4.0.5 */
  85 # define VREPRINT VRPRNT
  86 #endif
  87 #if defined(VREPRINT) && !defined(CRPRNT)
  88 # define CRPRNT Control('r')
  89 #endif
  90 #if defined(VWERASE) && !defined(CWERASE)
  91 # define CWERASE Control('w')
  92 #endif
  93 #if defined(VLNEXT) && !defined(CLNEXT)
  94 # define CLNEXT Control('v')
  95 #endif
  96 #if defined(VDISCARD) && !defined(VFLUSHO)
  97 # define VFLUSHO VDISCARD
  98 #endif
  99 #if defined(VFLUSH) && !defined(VFLUSHO)        /* Ultrix 4.2 */
 100 # define VFLUSHO VFLUSH
 101 #endif
 102 #if defined(CTLECH) && !defined(ECHOCTL)        /* Ultrix 4.3 */
 103 # define ECHOCTL CTLECH
 104 #endif
 105 #if defined(TCTLECH) && !defined(ECHOCTL)       /* Ultrix 4.2 */
 106 # define ECHOCTL TCTLECH
 107 #endif
 108 #if defined(CRTKIL) && !defined(ECHOKE)         /* Ultrix 4.2 and 4.3 */
 109 # define ECHOKE CRTKIL
 110 #endif
 111 #if defined(VFLUSHO) && !defined(CFLUSHO)
 112 # define CFLUSHO Control('o')
 113 #endif
 114 #if defined(VSTATUS) && !defined(CSTATUS)
 115 # define CSTATUS Control('t')
 116 #endif
 117
 118 /* Which speeds to set */
 119 enum speed_setting {
 120         input_speed, output_speed, both_speeds
 121 };
 122
 123 /* Which member(s) of 'struct termios' a mode uses */
 124 enum {
 125         /* Do NOT change the order or values, as mode_type_flag()
 126          * depends on them */
 127         control, input, output, local, combination
 128 };
 129
 130 /* Flags for 'struct mode_info' */
 131 #define SANE_SET 1              /* Set in 'sane' mode                  */
 132 #define SANE_UNSET 2            /* Unset in 'sane' mode                */
 133 #define REV 4                   /* Can be turned off by prepending '-' */
 134 #define OMIT 8                  /* Don't display value                 */
 135
 136
 137 /* Each mode.
 138  * This structure should be kept as small as humanly possible.
 139  */
 140 struct mode_info {
 141         const uint8_t type;           /* Which structure element to change    */
 142         const uint8_t flags;          /* Setting and display options          */
 143         /* only these values are ever used, so... */
 144 #if   (CSIZE | NLDLY | CRDLY | TABDLY | BSDLY | VTDLY | FFDLY) < 0x100
 145         const uint8_t mask;
 146 #elif (CSIZE | NLDLY | CRDLY | TABDLY | BSDLY | VTDLY | FFDLY) < 0x10000
 147         const uint16_t mask;
 148 #else
 149         const tcflag_t mask;          /* Other bits to turn off for this mode */
 150 #endif
 151         /* was using short here, but ppc32 was unhappy */
 152         const tcflag_t bits;          /* Bits to set for this mode            */
 153 };
 154
 155 enum {
 156         /* Must match mode_name[] and mode_info[] order! */
 157         IDX_evenp = 0,
 158         IDX_parity,
 159         IDX_oddp,
 160         IDX_nl,
 161         IDX_ek,
 162         IDX_sane,
 163         IDX_cooked,
 164         IDX_raw,
 165         IDX_pass8,
 166         IDX_litout,
 167         IDX_cbreak,
 168         IDX_crt,
 169         IDX_dec,
 170 #ifdef IXANY
 171         IDX_decctlq,
 172 #endif
 173 #if defined(TABDLY) || defined(OXTABS)
 174         IDX_tabs,
 175 #endif
 176 #if defined(XCASE) && defined(IUCLC) && defined(OLCUC)
 177         IDX_lcase,
 178         IDX_LCASE,
 179 #endif
 180 };
 181
 182 #define MI_ENTRY(N,T,F,B,M) N "\0"
 183
 184 /* Mode names given on command line */
 185 static const char mode_name[] =
 186         MI_ENTRY("evenp",    combination, REV        | OMIT, 0,          0 )
 187         MI_ENTRY("parity",   combination, REV        | OMIT, 0,          0 )
 188         MI_ENTRY("oddp",     combination, REV        | OMIT, 0,          0 )
 189         MI_ENTRY("nl",       combination, REV        | OMIT, 0,          0 )
 190         MI_ENTRY("ek",       combination, OMIT,              0,          0 )
 191         MI_ENTRY("sane",     combination, OMIT,              0,          0 )
 192         MI_ENTRY("cooked",   combination, REV        | OMIT, 0,          0 )
 193         MI_ENTRY("raw",      combination, REV        | OMIT, 0,          0 )
 194         MI_ENTRY("pass8",    combination, REV        | OMIT, 0,          0 )
 195         MI_ENTRY("litout",   combination, REV        | OMIT, 0,          0 )
 196         MI_ENTRY("cbreak",   combination, REV        | OMIT, 0,          0 )
 197         MI_ENTRY("crt",      combination, OMIT,              0,          0 )
 198         MI_ENTRY("dec",      combination, OMIT,              0,          0 )
 199 #ifdef IXANY
 200         MI_ENTRY("decctlq",  combination, REV        | OMIT, 0,          0 )
 201 #endif
 202 #if defined(TABDLY) || defined(OXTABS)
 203         MI_ENTRY("tabs",     combination, REV        | OMIT, 0,          0 )
 204 #endif
 205 #if defined(XCASE) && defined(IUCLC) && defined(OLCUC)
 206         MI_ENTRY("lcase",    combination, REV        | OMIT, 0,          0 )
 207         MI_ENTRY("LCASE",    combination, REV        | OMIT, 0,          0 )
 208 #endif
 209         MI_ENTRY("parenb",   control,     REV,               PARENB,     0 )
 210         MI_ENTRY("parodd",   control,     REV,               PARODD,     0 )
 211         MI_ENTRY("cs5",      control,     0,                 CS5,     CSIZE)
 212         MI_ENTRY("cs6",      control,     0,                 CS6,     CSIZE)
 213         MI_ENTRY("cs7",      control,     0,                 CS7,     CSIZE)
 214         MI_ENTRY("cs8",      control,     0,                 CS8,     CSIZE)
 215         MI_ENTRY("hupcl",    control,     REV,               HUPCL,      0 )
 216         MI_ENTRY("hup",      control,     REV        | OMIT, HUPCL,      0 )
 217         MI_ENTRY("cstopb",   control,     REV,               CSTOPB,     0 )
 218         MI_ENTRY("cread",    control,     SANE_SET   | REV,  CREAD,      0 )
 219         MI_ENTRY("clocal",   control,     REV,               CLOCAL,     0 )
 220 #ifdef CRTSCTS
 221         MI_ENTRY("crtscts",  control,     REV,               CRTSCTS,    0 )
 222 #endif
 223         MI_ENTRY("ignbrk",   input,       SANE_UNSET | REV,  IGNBRK,     0 )
 224         MI_ENTRY("brkint",   input,       SANE_SET   | REV,  BRKINT,     0 )
 225         MI_ENTRY("ignpar",   input,       REV,               IGNPAR,     0 )
 226         MI_ENTRY("parmrk",   input,       REV,               PARMRK,     0 )
 227         MI_ENTRY("inpck",    input,       REV,               INPCK,      0 )
 228         MI_ENTRY("istrip",   input,       REV,               ISTRIP,     0 )
 229         MI_ENTRY("inlcr",    input,       SANE_UNSET | REV,  INLCR,      0 )
 230         MI_ENTRY("igncr",    input,       SANE_UNSET | REV,  IGNCR,      0 )
 231         MI_ENTRY("icrnl",    input,       SANE_SET   | REV,  ICRNL,      0 )
 232         MI_ENTRY("ixon",     input,       REV,               IXON,       0 )
 233         MI_ENTRY("ixoff",    input,       SANE_UNSET | REV,  IXOFF,      0 )
 234         MI_ENTRY("tandem",   input,       REV        | OMIT, IXOFF,      0 )
 235 #ifdef IUCLC
 236         MI_ENTRY("iuclc",    input,       SANE_UNSET | REV,  IUCLC,      0 )
 237 #endif
 238 #ifdef IXANY
 239         MI_ENTRY("ixany",    input,       SANE_UNSET | REV,  IXANY,      0 )
 240 #endif
 241 #ifdef IMAXBEL
 242         MI_ENTRY("imaxbel",  input,       SANE_SET   | REV,  IMAXBEL,    0 )
 243 #endif
 244         MI_ENTRY("opost",    output,      SANE_SET   | REV,  OPOST,      0 )
 245 #ifdef OLCUC
 246         MI_ENTRY("olcuc",    output,      SANE_UNSET | REV,  OLCUC,      0 )
 247 #endif
 248 #ifdef OCRNL
 249         MI_ENTRY("ocrnl",    output,      SANE_UNSET | REV,  OCRNL,      0 )
 250 #endif
 251 #ifdef ONLCR
 252         MI_ENTRY("onlcr",    output,      SANE_SET   | REV,  ONLCR,      0 )
 253 #endif
 254 #ifdef ONOCR
 255         MI_ENTRY("onocr",    output,      SANE_UNSET | REV,  ONOCR,      0 )
 256 #endif
 257 #ifdef ONLRET
 258         MI_ENTRY("onlret",   output,      SANE_UNSET | REV,  ONLRET,     0 )
 259 #endif
 260 #ifdef OFILL
 261         MI_ENTRY("ofill",    output,      SANE_UNSET | REV,  OFILL,      0 )
 262 #endif
 263 #ifdef OFDEL
 264         MI_ENTRY("ofdel",    output,      SANE_UNSET | REV,  OFDEL,      0 )
 265 #endif
 266 #ifdef NLDLY
 267         MI_ENTRY("nl1",      output,      SANE_UNSET,        NL1,     NLDLY)
 268         MI_ENTRY("nl0",      output,      SANE_SET,          NL0,     NLDLY)
 269 #endif
 270 #ifdef CRDLY
 271         MI_ENTRY("cr3",      output,      SANE_UNSET,        CR3,     CRDLY)
 272         MI_ENTRY("cr2",      output,      SANE_UNSET,        CR2,     CRDLY)
 273         MI_ENTRY("cr1",      output,      SANE_UNSET,        CR1,     CRDLY)
 274         MI_ENTRY("cr0",      output,      SANE_SET,          CR0,     CRDLY)
 275 #endif
 276
 277 #ifdef TABDLY
 278         MI_ENTRY("tab3",     output,      SANE_UNSET,        TAB3,   TABDLY)
 279         MI_ENTRY("tab2",     output,      SANE_UNSET,        TAB2,   TABDLY)
 280         MI_ENTRY("tab1",     output,      SANE_UNSET,        TAB1,   TABDLY)
 281         MI_ENTRY("tab0",     output,      SANE_SET,          TAB0,   TABDLY)
 282 #else
 283 # ifdef OXTABS
 284         MI_ENTRY("tab3",     output,      SANE_UNSET,        OXTABS,     0 )
 285 # endif
 286 #endif
 287
 288 #ifdef BSDLY
 289         MI_ENTRY("bs1",      output,      SANE_UNSET,        BS1,     BSDLY)
 290         MI_ENTRY("bs0",      output,      SANE_SET,          BS0,     BSDLY)
 291 #endif
 292 #ifdef VTDLY
 293         MI_ENTRY("vt1",      output,      SANE_UNSET,        VT1,     VTDLY)
 294         MI_ENTRY("vt0",      output,      SANE_SET,          VT0,     VTDLY)
 295 #endif
 296 #ifdef FFDLY
 297         MI_ENTRY("ff1",      output,      SANE_UNSET,        FF1,     FFDLY)
 298         MI_ENTRY("ff0",      output,      SANE_SET,          FF0,     FFDLY)
 299 #endif
 300         MI_ENTRY("isig",     local,       SANE_SET   | REV,  ISIG,       0 )
 301         MI_ENTRY("icanon",   local,       SANE_SET   | REV,  ICANON,     0 )
 302 #ifdef IEXTEN
 303         MI_ENTRY("iexten",   local,       SANE_SET   | REV,  IEXTEN,     0 )
 304 #endif
 305         MI_ENTRY("echo",     local,       SANE_SET   | REV,  ECHO,       0 )
 306         MI_ENTRY("echoe",    local,       SANE_SET   | REV,  ECHOE,      0 )
 307         MI_ENTRY("crterase", local,       REV        | OMIT, ECHOE,      0 )
 308         MI_ENTRY("echok",    local,       SANE_SET   | REV,  ECHOK,      0 )
 309         MI_ENTRY("echonl",   local,       SANE_UNSET | REV,  ECHONL,     0 )
 310         MI_ENTRY("noflsh",   local,       SANE_UNSET | REV,  NOFLSH,     0 )
 311 #ifdef XCASE
 312         MI_ENTRY("xcase",    local,       SANE_UNSET | REV,  XCASE,      0 )
 313 #endif
 314 #ifdef TOSTOP
 315         MI_ENTRY("tostop",   local,       SANE_UNSET | REV,  TOSTOP,     0 )
 316 #endif
 317 #ifdef ECHOPRT
 318         MI_ENTRY("echoprt",  local,       SANE_UNSET | REV,  ECHOPRT,    0 )
 319         MI_ENTRY("prterase", local,       REV | OMIT,        ECHOPRT,    0 )
 320 #endif
 321 #ifdef ECHOCTL
 322         MI_ENTRY("echoctl",  local,       SANE_SET   | REV,  ECHOCTL,    0 )
 323         MI_ENTRY("ctlecho",  local,       REV        | OMIT, ECHOCTL,    0 )
 324 #endif
 325 #ifdef ECHOKE
 326         MI_ENTRY("echoke",   local,       SANE_SET   | REV,  ECHOKE,     0 )
 327         MI_ENTRY("crtkill",  local,       REV        | OMIT, ECHOKE,     0 )
 328 #endif
 329         ;
 330
 331 #undef MI_ENTRY
 332 #define MI_ENTRY(N,T,F,B,M) { T, F, M, B },
 333
 334 static const struct mode_info mode_info[] = {
 335         /* This should be verbatim cut-n-paste copy of the above MI_ENTRYs */
 336         MI_ENTRY("evenp",    combination, REV        | OMIT, 0,          0 )
 337         MI_ENTRY("parity",   combination, REV        | OMIT, 0,          0 )
 338         MI_ENTRY("oddp",     combination, REV        | OMIT, 0,          0 )
 339         MI_ENTRY("nl",       combination, REV        | OMIT, 0,          0 )
 340         MI_ENTRY("ek",       combination, OMIT,              0,          0 )
 341         MI_ENTRY("sane",     combination, OMIT,              0,          0 )
 342         MI_ENTRY("cooked",   combination, REV        | OMIT, 0,          0 )
 343         MI_ENTRY("raw",      combination, REV        | OMIT, 0,          0 )
 344         MI_ENTRY("pass8",    combination, REV        | OMIT, 0,          0 )
 345         MI_ENTRY("litout",   combination, REV        | OMIT, 0,          0 )
 346         MI_ENTRY("cbreak",   combination, REV        | OMIT, 0,          0 )
 347         MI_ENTRY("crt",      combination, OMIT,              0,          0 )
 348         MI_ENTRY("dec",      combination, OMIT,              0,          0 )
 349 #ifdef IXANY
 350         MI_ENTRY("decctlq",  combination, REV        | OMIT, 0,          0 )
 351 #endif
 352 #if defined(TABDLY) || defined(OXTABS)
 353         MI_ENTRY("tabs",     combination, REV        | OMIT, 0,          0 )
 354 #endif
 355 #if defined(XCASE) && defined(IUCLC) && defined(OLCUC)
 356         MI_ENTRY("lcase",    combination, REV        | OMIT, 0,          0 )
 357         MI_ENTRY("LCASE",    combination, REV        | OMIT, 0,          0 )
 358 #endif
 359         MI_ENTRY("parenb",   control,     REV,               PARENB,     0 )
 360         MI_ENTRY("parodd",   control,     REV,               PARODD,     0 )
 361         MI_ENTRY("cs5",      control,     0,                 CS5,     CSIZE)
 362         MI_ENTRY("cs6",      control,     0,                 CS6,     CSIZE)
 363         MI_ENTRY("cs7",      control,     0,                 CS7,     CSIZE)
 364         MI_ENTRY("cs8",      control,     0,                 CS8,     CSIZE)
 365         MI_ENTRY("hupcl",    control,     REV,               HUPCL,      0 )
 366         MI_ENTRY("hup",      control,     REV        | OMIT, HUPCL,      0 )
 367         MI_ENTRY("cstopb",   control,     REV,               CSTOPB,     0 )
 368         MI_ENTRY("cread",    control,     SANE_SET   | REV,  CREAD,      0 )
 369         MI_ENTRY("clocal",   control,     REV,               CLOCAL,     0 )
 370 #ifdef CRTSCTS
 371         MI_ENTRY("crtscts",  control,     REV,               CRTSCTS,    0 )
 372 #endif
 373         MI_ENTRY("ignbrk",   input,       SANE_UNSET | REV,  IGNBRK,     0 )
 374         MI_ENTRY("brkint",   input,       SANE_SET   | REV,  BRKINT,     0 )
 375         MI_ENTRY("ignpar",   input,       REV,               IGNPAR,     0 )
 376         MI_ENTRY("parmrk",   input,       REV,               PARMRK,     0 )
 377         MI_ENTRY("inpck",    input,       REV,               INPCK,      0 )
 378         MI_ENTRY("istrip",   input,       REV,               ISTRIP,     0 )
 379         MI_ENTRY("inlcr",    input,       SANE_UNSET | REV,  INLCR,      0 )
 380         MI_ENTRY("igncr",    input,       SANE_UNSET | REV,  IGNCR,      0 )
 381         MI_ENTRY("icrnl",    input,       SANE_SET   | REV,  ICRNL,      0 )
 382         MI_ENTRY("ixon",     input,       REV,               IXON,       0 )
 383         MI_ENTRY("ixoff",    input,       SANE_UNSET | REV,  IXOFF,      0 )
 384         MI_ENTRY("tandem",   input,       REV        | OMIT, IXOFF,      0 )
 385 #ifdef IUCLC
 386         MI_ENTRY("iuclc",    input,       SANE_UNSET | REV,  IUCLC,      0 )
 387 #endif
 388 #ifdef IXANY
 389         MI_ENTRY("ixany",    input,       SANE_UNSET | REV,  IXANY,      0 )
 390 #endif
 391 #ifdef IMAXBEL
 392         MI_ENTRY("imaxbel",  input,       SANE_SET   | REV,  IMAXBEL,    0 )
 393 #endif
 394         MI_ENTRY("opost",    output,      SANE_SET   | REV,  OPOST,      0 )
 395 #ifdef OLCUC
 396         MI_ENTRY("olcuc",    output,      SANE_UNSET | REV,  OLCUC,      0 )
 397 #endif
 398 #ifdef OCRNL
 399         MI_ENTRY("ocrnl",    output,      SANE_UNSET | REV,  OCRNL,      0 )
 400 #endif
 401 #ifdef ONLCR
 402         MI_ENTRY("onlcr",    output,      SANE_SET   | REV,  ONLCR,      0 )
 403 #endif
 404 #ifdef ONOCR
 405         MI_ENTRY("onocr",    output,      SANE_UNSET | REV,  ONOCR,      0 )
 406 #endif
 407 #ifdef ONLRET
 408         MI_ENTRY("onlret",   output,      SANE_UNSET | REV,  ONLRET,     0 )
 409 #endif
 410 #ifdef OFILL
 411         MI_ENTRY("ofill",    output,      SANE_UNSET | REV,  OFILL,      0 )
 412 #endif
 413 #ifdef OFDEL
 414         MI_ENTRY("ofdel",    output,      SANE_UNSET | REV,  OFDEL,      0 )
 415 #endif
 416 #ifdef NLDLY
 417         MI_ENTRY("nl1",      output,      SANE_UNSET,        NL1,     NLDLY)
 418         MI_ENTRY("nl0",      output,      SANE_SET,          NL0,     NLDLY)
 419 #endif
 420 #ifdef CRDLY
 421         MI_ENTRY("cr3",      output,      SANE_UNSET,        CR3,     CRDLY)
 422         MI_ENTRY("cr2",      output,      SANE_UNSET,        CR2,     CRDLY)
 423         MI_ENTRY("cr1",      output,      SANE_UNSET,        CR1,     CRDLY)
 424         MI_ENTRY("cr0",      output,      SANE_SET,          CR0,     CRDLY)
 425 #endif
 426
 427 #ifdef TABDLY
 428         MI_ENTRY("tab3",     output,      SANE_UNSET,        TAB3,   TABDLY)
 429         MI_ENTRY("tab2",     output,      SANE_UNSET,        TAB2,   TABDLY)
 430         MI_ENTRY("tab1",     output,      SANE_UNSET,        TAB1,   TABDLY)
 431         MI_ENTRY("tab0",     output,      SANE_SET,          TAB0,   TABDLY)
 432 #else
 433 # ifdef OXTABS
 434         MI_ENTRY("tab3",     output,      SANE_UNSET,        OXTABS,     0 )
 435 # endif
 436 #endif
 437
 438 #ifdef BSDLY
 439         MI_ENTRY("bs1",      output,      SANE_UNSET,        BS1,     BSDLY)
 440         MI_ENTRY("bs0",      output,      SANE_SET,          BS0,     BSDLY)
 441 #endif
 442 #ifdef VTDLY
 443         MI_ENTRY("vt1",      output,      SANE_UNSET,        VT1,     VTDLY)
 444         MI_ENTRY("vt0",      output,      SANE_SET,          VT0,     VTDLY)
 445 #endif
 446 #ifdef FFDLY
 447         MI_ENTRY("ff1",      output,      SANE_UNSET,        FF1,     FFDLY)
 448         MI_ENTRY("ff0",      output,      SANE_SET,          FF0,     FFDLY)
 449 #endif
 450         MI_ENTRY("isig",     local,       SANE_SET   | REV,  ISIG,       0 )
 451         MI_ENTRY("icanon",   local,       SANE_SET   | REV,  ICANON,     0 )
 452 #ifdef IEXTEN
 453         MI_ENTRY("iexten",   local,       SANE_SET   | REV,  IEXTEN,     0 )
 454 #endif
 455         MI_ENTRY("echo",     local,       SANE_SET   | REV,  ECHO,       0 )
 456         MI_ENTRY("echoe",    local,       SANE_SET   | REV,  ECHOE,      0 )
 457         MI_ENTRY("crterase", local,       REV        | OMIT, ECHOE,      0 )
 458         MI_ENTRY("echok",    local,       SANE_SET   | REV,  ECHOK,      0 )
 459         MI_ENTRY("echonl",   local,       SANE_UNSET | REV,  ECHONL,     0 )
 460         MI_ENTRY("noflsh",   local,       SANE_UNSET | REV,  NOFLSH,     0 )
 461 #ifdef XCASE
 462         MI_ENTRY("xcase",    local,       SANE_UNSET | REV,  XCASE,      0 )
 463 #endif
 464 #ifdef TOSTOP
 465         MI_ENTRY("tostop",   local,       SANE_UNSET | REV,  TOSTOP,     0 )
 466 #endif
 467 #ifdef ECHOPRT
 468         MI_ENTRY("echoprt",  local,       SANE_UNSET | REV,  ECHOPRT,    0 )
 469         MI_ENTRY("prterase", local,       REV | OMIT,        ECHOPRT,    0 )
 470 #endif
 471 #ifdef ECHOCTL
 472         MI_ENTRY("echoctl",  local,       SANE_SET   | REV,  ECHOCTL,    0 )
 473         MI_ENTRY("ctlecho",  local,       REV        | OMIT, ECHOCTL,    0 )
 474 #endif
 475 #ifdef ECHOKE
 476         MI_ENTRY("echoke",   local,       SANE_SET   | REV,  ECHOKE,     0 )
 477         MI_ENTRY("crtkill",  local,       REV        | OMIT, ECHOKE,     0 )
 478 #endif
 479 };
 480
 481 enum {
 482         NUM_mode_info = ARRAY_SIZE(mode_info)
 483 };
 484
 485
 486 /* Control characters */
 487 struct control_info {
 488         const uint8_t saneval;  /* Value to set for 'stty sane' */
 489         const uint8_t offset;   /* Offset in c_cc */
 490 };
 491
 492 enum {
 493         /* Must match control_name[] and control_info[] order! */
 494         CIDX_intr = 0,
 495         CIDX_quit,
 496         CIDX_erase,
 497         CIDX_kill,
 498         CIDX_eof,
 499         CIDX_eol,
 500 #ifdef VEOL2
 501         CIDX_eol2,
 502 #endif
 503 #ifdef VSWTCH
 504         CIDX_swtch,
 505 #endif
 506         CIDX_start,
 507         CIDX_stop,
 508         CIDX_susp,
 509 #ifdef VDSUSP
 510         CIDX_dsusp,
 511 #endif
 512 #ifdef VREPRINT
 513         CIDX_rprnt,
 514 #endif
 515 #ifdef VWERASE
 516         CIDX_werase,
 517 #endif
 518 #ifdef VLNEXT
 519         CIDX_lnext,
 520 #endif
 521 #ifdef VFLUSHO
 522         CIDX_flush,
 523 #endif
 524 #ifdef VSTATUS
 525         CIDX_status,
 526 #endif
 527         CIDX_min,
 528         CIDX_time,
 529 };
 530
 531 #define CI_ENTRY(n,s,o) n "\0"
 532
 533 /* Name given on command line */
 534 static const char control_name[] =
 535         CI_ENTRY("intr",     CINTR,   VINTR   )
 536         CI_ENTRY("quit",     CQUIT,   VQUIT   )
 537         CI_ENTRY("erase",    CERASE,  VERASE  )
 538         CI_ENTRY("kill",     CKILL,   VKILL   )
 539         CI_ENTRY("eof",      CEOF,    VEOF    )
 540         CI_ENTRY("eol",      CEOL,    VEOL    )
 541 #ifdef VEOL2
 542         CI_ENTRY("eol2",     CEOL2,   VEOL2   )
 543 #endif
 544 #ifdef VSWTCH
 545         CI_ENTRY("swtch",    CSWTCH,  VSWTCH  )
 546 #endif
 547         CI_ENTRY("start",    CSTART,  VSTART  )
 548         CI_ENTRY("stop",     CSTOP,   VSTOP   )
 549         CI_ENTRY("susp",     CSUSP,   VSUSP   )
 550 #ifdef VDSUSP
 551         CI_ENTRY("dsusp",    CDSUSP,  VDSUSP  )
 552 #endif
 553 #ifdef VREPRINT
 554         CI_ENTRY("rprnt",    CRPRNT,  VREPRINT)
 555 #endif
 556 #ifdef VWERASE
 557         CI_ENTRY("werase",   CWERASE, VWERASE )
 558 #endif
 559 #ifdef VLNEXT
 560         CI_ENTRY("lnext",    CLNEXT,  VLNEXT  )
 561 #endif
 562 #ifdef VFLUSHO
 563         CI_ENTRY("flush",    CFLUSHO, VFLUSHO )
 564 #endif
 565 #ifdef VSTATUS
 566         CI_ENTRY("status",   CSTATUS, VSTATUS )
 567 #endif
 568         /* These must be last because of the display routines */
 569         CI_ENTRY("min",      1,       VMIN    )
 570         CI_ENTRY("time",     0,       VTIME   )
 571         ;
 572
 573 #undef CI_ENTRY
 574 #define CI_ENTRY(n,s,o) { s, o },
 575
 576 static const struct control_info control_info[] = {
 577         /* This should be verbatim cut-n-paste copy of the above CI_ENTRYs */
 578         CI_ENTRY("intr",     CINTR,   VINTR   )
 579         CI_ENTRY("quit",     CQUIT,   VQUIT   )
 580         CI_ENTRY("erase",    CERASE,  VERASE  )
 581         CI_ENTRY("kill",     CKILL,   VKILL   )
 582         CI_ENTRY("eof",      CEOF,    VEOF    )
 583         CI_ENTRY("eol",      CEOL,    VEOL    )
 584 #ifdef VEOL2
 585         CI_ENTRY("eol2",     CEOL2,   VEOL2   )
 586 #endif
 587 #ifdef VSWTCH
 588         CI_ENTRY("swtch",    CSWTCH,  VSWTCH  )
 589 #endif
 590         CI_ENTRY("start",    CSTART,  VSTART  )
 591         CI_ENTRY("stop",     CSTOP,   VSTOP   )
 592         CI_ENTRY("susp",     CSUSP,   VSUSP   )
 593 #ifdef VDSUSP
 594         CI_ENTRY("dsusp",    CDSUSP,  VDSUSP  )
 595 #endif
 596 #ifdef VREPRINT
 597         CI_ENTRY("rprnt",    CRPRNT,  VREPRINT)
 598 #endif
 599 #ifdef VWERASE
 600         CI_ENTRY("werase",   CWERASE, VWERASE )
 601 #endif
 602 #ifdef VLNEXT
 603         CI_ENTRY("lnext",    CLNEXT,  VLNEXT  )
 604 #endif
 605 #ifdef VFLUSHO
 606         CI_ENTRY("flush",    CFLUSHO, VFLUSHO )
 607 #endif
 608 #ifdef VSTATUS
 609         CI_ENTRY("status",   CSTATUS, VSTATUS )
 610 #endif
 611         /* These must be last because of the display routines */
 612         CI_ENTRY("min",      1,       VMIN    )
 613         CI_ENTRY("time",     0,       VTIME   )
 614 };
 615
 616 enum {
 617         NUM_control_info = ARRAY_SIZE(control_info)
 618 };
 619
 620
 621 struct globals {
 622         const char *device_name;
 623         /* The width of the screen, for output wrapping */
 624         unsigned max_col;
 625         /* Current position, to know when to wrap */
 626         unsigned current_col;
 627         char buf[10];
 628 };
 629 #define G (*(struct globals*)&bb_common_bufsiz1)
 630 #define INIT_G() do { \
 631         G.device_name = bb_msg_standard_input; \
 632         G.max_col = 80; \
 633 } while (0)
 634
 635
 636 /* Return a string that is the printable representation of character CH */
 637 /* Adapted from 'cat' by Torbjorn Granlund */
 638 static const char *visible(unsigned ch)
 639 {
 640         char *bpout = G.buf;
 641
 642         if (ch == _POSIX_VDISABLE)
 643                 return "<undef>";
 644
 645         if (ch >= 128) {
 646                 ch -= 128;
 647                 *bpout++ = 'M';
 648                 *bpout++ = '-';
 649         }
 650
 651         if (ch < 32) {
 652                 *bpout++ = '^';
 653                 *bpout++ = ch + 64;
 654         } else if (ch < 127) {
 655                 *bpout++ = ch;
 656         } else {
 657                 *bpout++ = '^';
 658                 *bpout++ = '?';
 659         }
 660
 661         *bpout = '\0';
 662         return G.buf;
 663 }
 664
 665 static tcflag_t *mode_type_flag(unsigned type, const struct termios *mode)
 666 {
 667         static const uint8_t tcflag_offsets[] ALIGN1 = {
 668                 offsetof(struct termios, c_cflag), /* control */
 669                 offsetof(struct termios, c_iflag), /* input */
 670                 offsetof(struct termios, c_oflag), /* output */
 671                 offsetof(struct termios, c_lflag)  /* local */
 672         };
 673
 674         if (type <= local) {
 675                 return (tcflag_t*) (((char*)mode) + tcflag_offsets[type]);
 676         }
 677         return NULL;
 678 }
 679
 680 static void set_speed_or_die(enum speed_setting type, const char *arg,
 681                                         struct termios *mode)
 682 {
 683         speed_t baud;
 684
 685         baud = tty_value_to_baud(xatou(arg));
 686
 687         if (type != output_speed) {     /* either input or both */
 688                 cfsetispeed(mode, baud);
 689         }
 690         if (type != input_speed) {      /* either output or both */
 691                 cfsetospeed(mode, baud);
 692         }
 693 }
 694
 695 static NORETURN void perror_on_device_and_die(const char *fmt)
 696 {
 697         bb_perror_msg_and_die(fmt, G.device_name);
 698 }
 699
 700 static void perror_on_device(const char *fmt)
 701 {
 702         bb_perror_msg(fmt, G.device_name);
 703 }
 704
 705 /* Print format string MESSAGE and optional args.
 706    Wrap to next line first if it won't fit.
 707    Print a space first unless MESSAGE will start a new line */
 708 static void wrapf(const char *message, ...)
 709 {
 710         char buf[128];
 711         va_list args;
 712         unsigned buflen;
 713
 714         va_start(args, message);
 715         buflen = vsnprintf(buf, sizeof(buf), message, args);
 716         va_end(args);
 717         /* We seem to be called only with suitable lengths, but check if
 718            somebody failed to adhere to this assumption just to be sure.  */
 719         if (!buflen || buflen >= sizeof(buf)) return;
 720
 721         if (G.current_col > 0) {
 722                 G.current_col++;
 723                 if (buf[0] != '\n') {
 724                         if (G.current_col + buflen >= G.max_col) {
 725                                 bb_putchar('\n');
 726                                 G.current_col = 0;
 727                         } else
 728                                 bb_putchar(' ');
 729                 }
 730         }
 731         fputs(buf, stdout);
 732         G.current_col += buflen;
 733         if (buf[buflen-1] == '\n')
 734                 G.current_col = 0;
 735 }
 736
 737 static void newline(void)
 738 {
 739         if (G.current_col != 0)
 740                 wrapf("\n");
 741 }
 742
 743 static void set_window_size(int rows, int cols)
 744 {
 745         struct winsize win = { 0, 0, 0, 0 };
 746
 747         if (ioctl(STDIN_FILENO, TIOCGWINSZ, &win)) {
 748                 if (errno != EINVAL) {
 749                         goto bail;
 750                 }
 751                 memset(&win, 0, sizeof(win));
 752         }
 753
 754         if (rows >= 0)
 755                 win.ws_row = rows;
 756         if (cols >= 0)
 757                 win.ws_col = cols;
 758
 759         if (ioctl(STDIN_FILENO, TIOCSWINSZ, (char *) &win))
 760 bail:
 761                 perror_on_device("%s");
 762 }
 763
 764 static void display_window_size(int fancy)
 765 {
 766         const char *fmt_str = "%s\0%s: no size information for this device";
 767         unsigned width, height;
 768
 769         if (get_terminal_width_height(STDIN_FILENO, &width, &height)) {
 770                 if ((errno != EINVAL) || ((fmt_str += 2), !fancy)) {
 771                         perror_on_device(fmt_str);
 772                 }
 773         } else {
 774                 wrapf(fancy ? "rows %u; columns %u;" : "%u %u\n",
 775                                 height, width);
 776         }
 777 }
 778
 779 static const struct suffix_mult stty_suffixes[] = {
 780         { "b",  512 },
 781         { "k", 1024 },
 782         { "B", 1024 },
 783         { "", 0 }
 784 };
 785
 786 static const struct mode_info *find_mode(const char *name)
 787 {
 788         int i = index_in_strings(mode_name, name);
 789         return i >= 0 ? &mode_info[i] : NULL;
 790 }
 791
 792 static const struct control_info *find_control(const char *name)
 793 {
 794         int i = index_in_strings(control_name, name);
 795         return i >= 0 ? &control_info[i] : NULL;
 796 }
 797
 798 enum {
 799         param_need_arg = 0x80,
 800         param_line    = 1 | 0x80,
 801         param_rows    = 2 | 0x80,
 802         param_cols    = 3 | 0x80,
 803         param_columns = 4 | 0x80,
 804         param_size    = 5,
 805         param_speed   = 6,
 806         param_ispeed  = 7 | 0x80,
 807         param_ospeed  = 8 | 0x80,
 808 };
 809
 810 static int find_param(const char *name)
 811 {
 812         static const char params[] ALIGN1 =
 813                 "line\0"    /* 1 */
 814                 "rows\0"    /* 2 */
 815                 "cols\0"    /* 3 */
 816                 "columns\0" /* 4 */
 817                 "size\0"    /* 5 */
 818                 "speed\0"   /* 6 */
 819                 "ispeed\0"
 820                 "ospeed\0";
 821         int i = index_in_strings(params, name) + 1;
 822         if (i == 0)
 823                 return 0;
 824         if (i != 5 && i != 6)
 825                 i |= 0x80;
 826         return i;
 827 }
 828
 829 static int recover_mode(const char *arg, struct termios *mode)
 830 {
 831         int i, n;
 832         unsigned chr;
 833         unsigned long iflag, oflag, cflag, lflag;
 834
 835         /* Scan into temporaries since it is too much trouble to figure out
 836            the right format for 'tcflag_t' */
 837         if (sscanf(arg, "%lx:%lx:%lx:%lx%n",
 838                            &iflag, &oflag, &cflag, &lflag, &n) != 4)
 839                 return 0;
 840         mode->c_iflag = iflag;
 841         mode->c_oflag = oflag;
 842         mode->c_cflag = cflag;
 843         mode->c_lflag = lflag;
 844         arg += n;
 845         for (i = 0; i < NCCS; ++i) {
 846                 if (sscanf(arg, ":%x%n", &chr, &n) != 1)
 847                         return 0;
 848                 mode->c_cc[i] = chr;
 849                 arg += n;
 850         }
 851
 852         /* Fail if there are too many fields */
 853         if (*arg != '\0')
 854                 return 0;
 855
 856         return 1;
 857 }
 858
 859 static void display_recoverable(const struct termios *mode,
 860                                 int UNUSED_PARAM dummy)
 861 {
 862         int i;
 863         printf("%lx:%lx:%lx:%lx",
 864                    (unsigned long) mode->c_iflag, (unsigned long) mode->c_oflag,
 865                    (unsigned long) mode->c_cflag, (unsigned long) mode->c_lflag);
 866         for (i = 0; i < NCCS; ++i)
 867                 printf(":%x", (unsigned int) mode->c_cc[i]);
 868         bb_putchar('\n');
 869 }
 870
 871 static void display_speed(const struct termios *mode, int fancy)
 872 {
 873         //____________________ 01234567 8 9
 874         const char *fmt_str = "%lu %lu\n\0ispeed %lu baud; ospeed %lu baud;";
 875         unsigned long ispeed, ospeed;
 876
 877         ospeed = ispeed = cfgetispeed(mode);
 878         if (ispeed == 0 || ispeed == (ospeed = cfgetospeed(mode))) {
 879                 ispeed = ospeed;                /* in case ispeed was 0 */
 880                 //________ 0123 4 5 6 7 8 9
 881                 fmt_str = "%lu\n\0\0\0\0\0speed %lu baud;";
 882         }
 883         if (fancy) fmt_str += 9;
 884         wrapf(fmt_str, tty_baud_to_value(ispeed), tty_baud_to_value(ospeed));
 885 }
 886
 887 static void do_display(const struct termios *mode, int all)
 888 {
 889         int i;
 890         tcflag_t *bitsp;
 891         unsigned long mask;
 892         int prev_type = control;
 893
 894         display_speed(mode, 1);
 895         if (all)
 896                 display_window_size(1);
 897 #ifdef HAVE_C_LINE
 898         wrapf("line = %u;\n", mode->c_line);
 899 #else
 900         newline();
 901 #endif
 902
 903         for (i = 0; i != CIDX_min; ++i) {
 904                 /* If swtch is the same as susp, don't print both */
 905 #if VSWTCH == VSUSP
 906                 if (i == CIDX_swtch)
 907                         continue;
 908 #endif
 909                 /* If eof uses the same slot as min, only print whichever applies */
 910 #if VEOF == VMIN
 911                 if (!(mode->c_lflag & ICANON)
 912                  && (i == CIDX_eof || i == CIDX_eol)
 913                 ) {
 914                         continue;
 915                 }
 916 #endif
 917                 wrapf("%s = %s;", nth_string(control_name, i),
 918                           visible(mode->c_cc[control_info[i].offset]));
 919         }
 920 #if VEOF == VMIN
 921         if ((mode->c_lflag & ICANON) == 0)
 922 #endif
 923                 wrapf("min = %u; time = %u;", mode->c_cc[VMIN], mode->c_cc[VTIME]);
 924         newline();
 925
 926         for (i = 0; i < NUM_mode_info; ++i) {
 927                 if (mode_info[i].flags & OMIT)
 928                         continue;
 929                 if (mode_info[i].type != prev_type) {
 930                         newline();
 931                         prev_type = mode_info[i].type;
 932                 }
 933
 934                 bitsp = mode_type_flag(mode_info[i].type, mode);
 935                 mask = mode_info[i].mask ? mode_info[i].mask : mode_info[i].bits;
 936                 if ((*bitsp & mask) == mode_info[i].bits) {
 937                         if (all || (mode_info[i].flags & SANE_UNSET))
 938                                 wrapf("-%s"+1, nth_string(mode_name, i));
 939                 } else {
 940                         if ((all && mode_info[i].flags & REV)
 941                          || (!all && (mode_info[i].flags & (SANE_SET | REV)) == (SANE_SET | REV))
 942                         ) {
 943                                 wrapf("-%s", nth_string(mode_name, i));
 944                         }
 945                 }
 946         }
 947         newline();
 948 }
 949
 950 static void sane_mode(struct termios *mode)
 951 {
 952         int i;
 953         tcflag_t *bitsp;
 954
 955         for (i = 0; i < NUM_control_info; ++i) {
 956 #if VMIN == VEOF
 957                 if (i == CIDX_min)
 958                         break;
 959 #endif
 960                 mode->c_cc[control_info[i].offset] = control_info[i].saneval;
 961         }
 962
 963         for (i = 0; i < NUM_mode_info; ++i) {
 964                 if (mode_info[i].flags & SANE_SET) {
 965                         bitsp = mode_type_flag(mode_info[i].type, mode);
 966                         *bitsp = (*bitsp & ~((unsigned long)mode_info[i].mask))
 967                                 | mode_info[i].bits;
 968                 } else if (mode_info[i].flags & SANE_UNSET) {
 969                         bitsp = mode_type_flag(mode_info[i].type, mode);
 970                         *bitsp = *bitsp & ~((unsigned long)mode_info[i].mask)
 971                                 & ~mode_info[i].bits;
 972                 }
 973         }
 974 }
 975
 976 /* Save set_mode from #ifdef forest plague */
 977 #ifndef ONLCR
 978 #define ONLCR 0
 979 #endif
 980 #ifndef OCRNL
 981 #define OCRNL 0
 982 #endif
 983 #ifndef ONLRET
 984 #define ONLRET 0
 985 #endif
 986 #ifndef XCASE
 987 #define XCASE 0
 988 #endif
 989 #ifndef IXANY
 990 #define IXANY 0
 991 #endif
 992 #ifndef TABDLY
 993 #define TABDLY 0
 994 #endif
 995 #ifndef OXTABS
 996 #define OXTABS 0
 997 #endif
 998 #ifndef IUCLC
 999 #define IUCLC 0
1000 #endif
1001 #ifndef OLCUC
1002 #define OLCUC 0
1003 #endif
1004 #ifndef ECHOCTL
1005 #define ECHOCTL 0
1006 #endif
1007 #ifndef ECHOKE
1008 #define ECHOKE 0
1009 #endif
1010
1011 static void set_mode(const struct mode_info *info, int reversed,
1012                                         struct termios *mode)
1013 {
1014         tcflag_t *bitsp;
1015
1016         bitsp = mode_type_flag(info->type, mode);
1017
1018         if (bitsp) {
1019                 if (reversed)
1020                         *bitsp = *bitsp & ~info->mask & ~info->bits;
1021                 else
1022                         *bitsp = (*bitsp & ~info->mask) | info->bits;
1023                 return;
1024         }
1025
1026         /* Combination mode */
1027         if (info == &mode_info[IDX_evenp] || info == &mode_info[IDX_parity]) {
1028                 if (reversed)
1029                         mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
1030                 else
1031                         mode->c_cflag = (mode->c_cflag & ~PARODD & ~CSIZE) | PARENB | CS7;
1032         } else if (info == &mode_info[IDX_oddp]) {
1033                 if (reversed)
1034                         mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
1035                 else
1036                         mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARODD | PARENB;
1037         } else if (info == &mode_info[IDX_nl]) {
1038                 if (reversed) {
1039                         mode->c_iflag = (mode->c_iflag | ICRNL) & ~INLCR & ~IGNCR;
1040                         mode->c_oflag = (mode->c_oflag | ONLCR) & ~OCRNL & ~ONLRET;
1041                 } else {
1042                         mode->c_iflag = mode->c_iflag & ~ICRNL;
1043                         if (ONLCR) mode->c_oflag = mode->c_oflag & ~ONLCR;
1044                 }
1045         } else if (info == &mode_info[IDX_ek]) {
1046                 mode->c_cc[VERASE] = CERASE;
1047                 mode->c_cc[VKILL] = CKILL;
1048         } else if (info == &mode_info[IDX_sane]) {
1049                 sane_mode(mode);
1050         } else if (info == &mode_info[IDX_cbreak]) {
1051                 if (reversed)
1052                         mode->c_lflag |= ICANON;
1053                 else
1054                         mode->c_lflag &= ~ICANON;
1055         } else if (info == &mode_info[IDX_pass8]) {
1056                 if (reversed) {
1057                         mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARENB;
1058                         mode->c_iflag |= ISTRIP;
1059                 } else {
1060                         mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
1061                         mode->c_iflag &= ~ISTRIP;
1062                 }
1063         } else if (info == &mode_info[IDX_litout]) {
1064                 if (reversed) {
1065                         mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARENB;
1066                         mode->c_iflag |= ISTRIP;
1067                         mode->c_oflag |= OPOST;
1068                 } else {
1069                         mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
1070                         mode->c_iflag &= ~ISTRIP;
1071                         mode->c_oflag &= ~OPOST;
1072                 }
1073         } else if (info == &mode_info[IDX_raw] || info == &mode_info[IDX_cooked]) {
1074                 if ((info == &mode_info[IDX_raw] && reversed)
1075                  || (info == &mode_info[IDX_cooked] && !reversed)
1076                 ) {
1077                         /* Cooked mode */
1078                         mode->c_iflag |= BRKINT | IGNPAR | ISTRIP | ICRNL | IXON;
1079                         mode->c_oflag |= OPOST;
1080                         mode->c_lflag |= ISIG | ICANON;
1081 #if VMIN == VEOF
1082                         mode->c_cc[VEOF] = CEOF;
1083 #endif
1084 #if VTIME == VEOL
1085                         mode->c_cc[VEOL] = CEOL;
1086 #endif
1087                 } else {
1088                         /* Raw mode */
1089                         mode->c_iflag = 0;
1090                         mode->c_oflag &= ~OPOST;
1091                         mode->c_lflag &= ~(ISIG | ICANON | XCASE);
1092                         mode->c_cc[VMIN] = 1;
1093                         mode->c_cc[VTIME] = 0;
1094                 }
1095         }
1096         else if (IXANY && info == &mode_info[IDX_decctlq]) {
1097                 if (reversed)
1098                         mode->c_iflag |= IXANY;
1099                 else
1100                         mode->c_iflag &= ~IXANY;
1101         }
1102         else if (TABDLY && info == &mode_info[IDX_tabs]) {
1103                 if (reversed)
1104                         mode->c_oflag = (mode->c_oflag & ~TABDLY) | TAB3;
1105                 else
1106                         mode->c_oflag = (mode->c_oflag & ~TABDLY) | TAB0;
1107         }
1108         else if (OXTABS && info == &mode_info[IDX_tabs]) {
1109                 if (reversed)
1110                         mode->c_oflag |= OXTABS;
1111                 else
1112                         mode->c_oflag &= ~OXTABS;
1113         } else
1114         if (XCASE && IUCLC && OLCUC
1115          && (info == &mode_info[IDX_lcase] || info == &mode_info[IDX_LCASE])
1116         ) {
1117                 if (reversed) {
1118                         mode->c_lflag &= ~XCASE;
1119                         mode->c_iflag &= ~IUCLC;
1120                         mode->c_oflag &= ~OLCUC;
1121                 } else {
1122                         mode->c_lflag |= XCASE;
1123                         mode->c_iflag |= IUCLC;
1124                         mode->c_oflag |= OLCUC;
1125                 }
1126         } else if (info == &mode_info[IDX_crt]) {
1127                 mode->c_lflag |= ECHOE | ECHOCTL | ECHOKE;
1128         } else if (info == &mode_info[IDX_dec]) {
1129                 mode->c_cc[VINTR] = 3; /* ^C */
1130                 mode->c_cc[VERASE] = 127; /* DEL */
1131                 mode->c_cc[VKILL] = 21; /* ^U */
1132                 mode->c_lflag |= ECHOE | ECHOCTL | ECHOKE;
1133                 if (IXANY) mode->c_iflag &= ~IXANY;
1134         }
1135 }
1136
1137 static void set_control_char_or_die(const struct control_info *info,
1138                         const char *arg, struct termios *mode)
1139 {
1140         unsigned char value;
1141
1142         if (info == &control_info[CIDX_min] || info == &control_info[CIDX_time])
1143                 value = xatoul_range_sfx(arg, 0, 0xff, stty_suffixes);
1144         else if (arg[0] == '\0' || arg[1] == '\0')
1145                 value = arg[0];
1146         else if (strcmp(arg, "^-") == 0 || strcmp(arg, "undef") == 0)
1147                 value = _POSIX_VDISABLE;
1148         else if (arg[0] == '^') { /* Ignore any trailing junk (^Cjunk) */
1149                 value = arg[1] & 0x1f; /* Non-letters get weird results */
1150                 if (arg[1] == '?')
1151                         value = 127;
1152         } else
1153                 value = xatoul_range_sfx(arg, 0, 0xff, stty_suffixes);
1154         mode->c_cc[info->offset] = value;
1155 }
1156
1157 #define STTY_require_set_attr   (1 << 0)
1158 #define STTY_speed_was_set      (1 << 1)
1159 #define STTY_verbose_output     (1 << 2)
1160 #define STTY_recoverable_output (1 << 3)
1161 #define STTY_noargs             (1 << 4)
1162
1163 int stty_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1164 int stty_main(int argc UNUSED_PARAM, char **argv)
1165 {
1166         struct termios mode;
1167         void (*output_func)(const struct termios *, int);
1168         const char *file_name = NULL;
1169         int display_all = 0;
1170         int stty_state;
1171         int k;
1172
1173         INIT_G();
1174
1175         stty_state = STTY_noargs;
1176         output_func = do_display;
1177
1178         /* First pass: only parse/verify command line params */
1179         k = 0;
1180         while (argv[++k]) {
1181                 const struct mode_info *mp;
1182                 const struct control_info *cp;
1183                 const char *arg = argv[k];
1184                 const char *argnext = argv[k+1];
1185                 int param;
1186
1187                 if (arg[0] == '-') {
1188                         int i;
1189                         mp = find_mode(arg+1);
1190                         if (mp) {
1191                                 if (!(mp->flags & REV))
1192                                         goto invalid_argument;
1193                                 stty_state &= ~STTY_noargs;
1194                                 continue;
1195                         }
1196                         /* It is an option - parse it */
1197                         i = 0;
1198                         while (arg[++i]) {
1199                                 switch (arg[i]) {
1200                                 case 'a':
1201                                         stty_state |= STTY_verbose_output;
1202                                         output_func = do_display;
1203                                         display_all = 1;
1204                                         break;
1205                                 case 'g':
1206                                         stty_state |= STTY_recoverable_output;
1207                                         output_func = display_recoverable;
1208                                         break;
1209                                 case 'F':
1210                                         if (file_name)
1211                                                 bb_error_msg_and_die("only one device may be specified");
1212                                         file_name = &arg[i+1]; /* "-Fdevice" ? */
1213                                         if (!file_name[0]) { /* nope, "-F device" */
1214                                                 int p = k+1; /* argv[p] is argnext */
1215                                                 file_name = argnext;
1216                                                 if (!file_name)
1217                                                         bb_error_msg_and_die(bb_msg_requires_arg, "-F");
1218                                                 /* remove -F param from arg[vc] */
1219                                                 while (argv[p]) {
1220                                                         argv[p] = argv[p+1];
1221                                                         ++p;
1222                                                 }
1223                                         }
1224                                         goto end_option;
1225                                 default:
1226                                         goto invalid_argument;
1227                                 }
1228                         }
1229  end_option:
1230                         continue;
1231                 }
1232
1233                 mp = find_mode(arg);
1234                 if (mp) {
1235                         stty_state &= ~STTY_noargs;
1236                         continue;
1237                 }
1238
1239                 cp = find_control(arg);
1240                 if (cp) {
1241                         if (!argnext)
1242                                 bb_error_msg_and_die(bb_msg_requires_arg, arg);
1243                         /* called for the side effect of xfunc death only */
1244                         set_control_char_or_die(cp, argnext, &mode);
1245                         stty_state &= ~STTY_noargs;
1246                         ++k;
1247                         continue;
1248                 }
1249
1250                 param = find_param(arg);
1251                 if (param & param_need_arg) {
1252                         if (!argnext)
1253                                 bb_error_msg_and_die(bb_msg_requires_arg, arg);
1254                         ++k;
1255                 }
1256
1257                 switch (param) {
1258 #ifdef HAVE_C_LINE
1259                 case param_line:
1260 # ifndef TIOCGWINSZ
1261                         xatoul_range_sfx(argnext, 1, INT_MAX, stty_suffixes);
1262                         break;
1263 # endif /* else fall-through */
1264 #endif
1265 #ifdef TIOCGWINSZ
1266                 case param_rows:
1267                 case param_cols:
1268                 case param_columns:
1269                         xatoul_range_sfx(argnext, 1, INT_MAX, stty_suffixes);
1270                         break;
1271                 case param_size:
1272 #endif
1273                 case param_speed:
1274                         break;
1275                 case param_ispeed:
1276                         /* called for the side effect of xfunc death only */
1277                         set_speed_or_die(input_speed, argnext, &mode);
1278                         break;
1279                 case param_ospeed:
1280                         /* called for the side effect of xfunc death only */
1281                         set_speed_or_die(output_speed, argnext, &mode);
1282                         break;
1283                 default:
1284                         if (recover_mode(arg, &mode) == 1) break;
1285                         if (tty_value_to_baud(xatou(arg)) != (speed_t) -1) break;
1286  invalid_argument:
1287                         bb_error_msg_and_die("invalid argument '%s'", arg);
1288                 }
1289                 stty_state &= ~STTY_noargs;
1290         }
1291
1292         /* Specifying both -a and -g is an error */
1293         if ((stty_state & (STTY_verbose_output | STTY_recoverable_output)) ==
1294                 (STTY_verbose_output | STTY_recoverable_output))
1295                 bb_error_msg_and_die("verbose and stty-readable output styles are mutually exclusive");
1296         /* Specifying -a or -g with non-options is an error */
1297         if (!(stty_state & STTY_noargs)
1298          && (stty_state & (STTY_verbose_output | STTY_recoverable_output))
1299         ) {
1300                 bb_error_msg_and_die("modes may not be set when specifying an output style");
1301         }
1302
1303         /* Now it is safe to start doing things */
1304         if (file_name) {
1305                 G.device_name = file_name;
1306                 xmove_fd(xopen_nonblocking(G.device_name), STDIN_FILENO);
1307                 ndelay_off(STDIN_FILENO);
1308         }
1309
1310         /* Initialize to all zeroes so there is no risk memcmp will report a
1311            spurious difference in an uninitialized portion of the structure */
1312         memset(&mode, 0, sizeof(mode));
1313         if (tcgetattr(STDIN_FILENO, &mode))
1314                 perror_on_device_and_die("%s");
1315
1316         if (stty_state & (STTY_verbose_output | STTY_recoverable_output | STTY_noargs)) {
1317                 get_terminal_width_height(STDOUT_FILENO, &G.max_col, NULL);
1318                 output_func(&mode, display_all);
1319                 return EXIT_SUCCESS;
1320         }
1321
1322         /* Second pass: perform actions */
1323         k = 0;
1324         while (argv[++k]) {
1325                 const struct mode_info *mp;
1326                 const struct control_info *cp;
1327                 const char *arg = argv[k];
1328                 const char *argnext = argv[k+1];
1329                 int param;
1330
1331                 if (arg[0] == '-') {
1332                         mp = find_mode(arg+1);
1333                         if (mp) {
1334                                 set_mode(mp, 1 /* reversed */, &mode);
1335                                 stty_state |= STTY_require_set_attr;
1336                         }
1337                         /* It is an option - already parsed. Skip it */
1338                         continue;
1339                 }
1340
1341                 mp = find_mode(arg);
1342                 if (mp) {
1343                         set_mode(mp, 0 /* non-reversed */, &mode);
1344                         stty_state |= STTY_require_set_attr;
1345                         continue;
1346                 }
1347
1348                 cp = find_control(arg);
1349                 if (cp) {
1350                         ++k;
1351                         set_control_char_or_die(cp, argnext, &mode);
1352                         stty_state |= STTY_require_set_attr;
1353                         continue;
1354                 }
1355
1356                 param = find_param(arg);
1357                 if (param & param_need_arg) {
1358                         ++k;
1359                 }
1360
1361                 switch (param) {
1362 #ifdef HAVE_C_LINE
1363                 case param_line:
1364                         mode.c_line = xatoul_sfx(argnext, stty_suffixes);
1365                         stty_state |= STTY_require_set_attr;
1366                         break;
1367 #endif
1368 #ifdef TIOCGWINSZ
1369                 case param_cols:
1370                 case param_columns:
1371                         set_window_size(-1, xatoul_sfx(argnext, stty_suffixes));
1372                         break;
1373                 case param_size:
1374                         display_window_size(0);
1375                         break;
1376                 case param_rows:
1377                         set_window_size(xatoul_sfx(argnext, stty_suffixes), -1);
1378                         break;
1379 #endif
1380                 case param_speed:
1381                         display_speed(&mode, 0);
1382                         break;
1383                 case param_ispeed:
1384                         set_speed_or_die(input_speed, argnext, &mode);
1385                         stty_state |= (STTY_require_set_attr | STTY_speed_was_set);
1386                         break;
1387                 case param_ospeed:
1388                         set_speed_or_die(output_speed, argnext, &mode);
1389                         stty_state |= (STTY_require_set_attr | STTY_speed_was_set);
1390                         break;
1391                 default:
1392                         if (recover_mode(arg, &mode) == 1)
1393                                 stty_state |= STTY_require_set_attr;
1394                         else /* true: if (tty_value_to_baud(xatou(arg)) != (speed_t) -1) */{
1395                                 set_speed_or_die(both_speeds, arg, &mode);
1396                                 stty_state |= (STTY_require_set_attr | STTY_speed_was_set);
1397                         } /* else - impossible (caught in the first pass):
1398                                 bb_error_msg_and_die("invalid argument '%s'", arg); */
1399                 }
1400         }
1401
1402         if (stty_state & STTY_require_set_attr) {
1403                 struct termios new_mode;
1404
1405                 if (tcsetattr(STDIN_FILENO, TCSADRAIN, &mode))
1406                         perror_on_device_and_die("%s");
1407
1408                 /* POSIX (according to Zlotnick's book) tcsetattr returns zero if
1409                    it performs *any* of the requested operations.  This means it
1410                    can report 'success' when it has actually failed to perform
1411                    some proper subset of the requested operations.  To detect
1412                    this partial failure, get the current terminal attributes and
1413                    compare them to the requested ones */
1414
1415                 /* Initialize to all zeroes so there is no risk memcmp will report a
1416                    spurious difference in an uninitialized portion of the structure */
1417                 memset(&new_mode, 0, sizeof(new_mode));
1418                 if (tcgetattr(STDIN_FILENO, &new_mode))
1419                         perror_on_device_and_die("%s");
1420
1421                 if (memcmp(&mode, &new_mode, sizeof(mode)) != 0) {
1422 #ifdef CIBAUD
1423                         /* SunOS 4.1.3 (at least) has the problem that after this sequence,
1424                            tcgetattr (&m1); tcsetattr (&m1); tcgetattr (&m2);
1425                            sometimes (m1 != m2).  The only difference is in the four bits
1426                            of the c_cflag field corresponding to the baud rate.  To save
1427                            Sun users a little confusion, don't report an error if this
1428                            happens.  But suppress the error only if we haven't tried to
1429                            set the baud rate explicitly -- otherwise we'd never give an
1430                            error for a true failure to set the baud rate */
1431
1432                         new_mode.c_cflag &= (~CIBAUD);
1433                         if ((stty_state & STTY_speed_was_set)
1434                          || memcmp(&mode, &new_mode, sizeof(mode)) != 0)
1435 #endif
1436                                 perror_on_device_and_die("%s: cannot perform all requested operations");
1437                 }
1438         }
1439
1440         return EXIT_SUCCESS;
1441 }