git.maemo.org Git - busybox4maemo/blob - 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; // = bb_msg_standard_input;
 623         /* The width of the screen, for output wrapping */
 624         unsigned max_col; // = 80;
 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() \
 631         do { \
 632                 G.device_name = bb_msg_standard_input; \
 633                 G.max_col = 80; \
 634         } while (0)
 635
 636
 637 /* Return a string that is the printable representation of character CH */
 638 /* Adapted from 'cat' by Torbjorn Granlund */
 639 static const char *visible(unsigned ch)
 640 {
 641         char *bpout = G.buf;
 642
 643         if (ch == _POSIX_VDISABLE)
 644                 return "<undef>";
 645
 646         if (ch >= 128) {
 647                 ch -= 128;
 648                 *bpout++ = 'M';
 649                 *bpout++ = '-';
 650         }
 651
 652         if (ch < 32) {
 653                 *bpout++ = '^';
 654                 *bpout++ = ch + 64;
 655         } else if (ch < 127) {
 656                 *bpout++ = ch;
 657         } else {
 658                 *bpout++ = '^';
 659                 *bpout++ = '?';
 660         }
 661
 662         *bpout = '\0';
 663         return G.buf;
 664 }
 665
 666 static tcflag_t *mode_type_flag(unsigned type, const struct termios *mode)
 667 {
 668         static const uint8_t tcflag_offsets[] ALIGN1 = {
 669                 offsetof(struct termios, c_cflag), /* control */
 670                 offsetof(struct termios, c_iflag), /* input */
 671                 offsetof(struct termios, c_oflag), /* output */
 672                 offsetof(struct termios, c_lflag)  /* local */
 673         };
 674
 675         if (type <= local) {
 676                 return (tcflag_t*) (((char*)mode) + tcflag_offsets[type]);
 677         }
 678         return NULL;
 679 }
 680
 681 static void set_speed_or_die(enum speed_setting type, const char *const arg,
 682                                         struct termios * const mode)
 683 {
 684         speed_t baud;
 685
 686         baud = tty_value_to_baud(xatou(arg));
 687
 688         if (type != output_speed) {     /* either input or both */
 689                 cfsetispeed(mode, baud);
 690         }
 691         if (type != input_speed) {      /* either output or both */
 692                 cfsetospeed(mode, baud);
 693         }
 694 }
 695
 696 static ATTRIBUTE_NORETURN void perror_on_device_and_die(const char *fmt)
 697 {
 698         bb_perror_msg_and_die(fmt, G.device_name);
 699 }
 700
 701 static void perror_on_device(const char *fmt)
 702 {
 703         bb_perror_msg(fmt, G.device_name);
 704 }
 705
 706 /* Print format string MESSAGE and optional args.
 707    Wrap to next line first if it won't fit.
 708    Print a space first unless MESSAGE will start a new line */
 709 static void wrapf(const char *message, ...)
 710 {
 711         char buf[128];
 712         va_list args;
 713         int buflen;
 714
 715         va_start(args, message);
 716         buflen = vsnprintf(buf, sizeof(buf), message, args);
 717         va_end(args);
 718         /* We seem to be called only with suitable lengths, but check if
 719            somebody failed to adhere to this assumption just to be sure.  */
 720         if (!buflen || buflen >= sizeof(buf)) return;
 721
 722         if (G.current_col > 0) {
 723                 G.current_col++;
 724                 if (buf[0] != '\n') {
 725                         if (G.current_col + buflen >= G.max_col) {
 726                                 bb_putchar('\n');
 727                                 G.current_col = 0;
 728                         } else
 729                                 bb_putchar(' ');
 730                 }
 731         }
 732         fputs(buf, stdout);
 733         G.current_col += buflen;
 734         if (buf[buflen-1] == '\n')
 735                 G.current_col = 0;
 736 }
 737
 738 static void set_window_size(const int rows, const int cols)
 739 {
 740         struct winsize win = { 0, 0, 0, 0 };
 741
 742         if (ioctl(STDIN_FILENO, TIOCGWINSZ, &win)) {
 743                 if (errno != EINVAL) {
 744                         goto bail;
 745                 }
 746                 memset(&win, 0, sizeof(win));
 747         }
 748
 749         if (rows >= 0)
 750                 win.ws_row = rows;
 751         if (cols >= 0)
 752                 win.ws_col = cols;
 753
 754         if (ioctl(STDIN_FILENO, TIOCSWINSZ, (char *) &win))
 755 bail:
 756                 perror_on_device("%s");
 757 }
 758
 759 static void display_window_size(const int fancy)
 760 {
 761         const char *fmt_str = "%s\0%s: no size information for this device";
 762         unsigned width, height;
 763
 764         if (get_terminal_width_height(STDIN_FILENO, &width, &height)) {
 765                 if ((errno != EINVAL) || ((fmt_str += 2), !fancy)) {
 766                         perror_on_device(fmt_str);
 767                 }
 768         } else {
 769                 wrapf(fancy ? "rows %d; columns %d;" : "%d %d\n",
 770                                 height, width);
 771         }
 772 }
 773
 774 static const struct suffix_mult stty_suffixes[] = {
 775         { "b",  512 },
 776         { "k", 1024 },
 777         { "B", 1024 },
 778         { }
 779 };
 780
 781 static const struct mode_info *find_mode(const char *name)
 782 {
 783         int i = index_in_strings(mode_name, name);
 784         return i >= 0 ? &mode_info[i] : NULL;
 785 }
 786
 787 static const struct control_info *find_control(const char *name)
 788 {
 789         int i = index_in_strings(control_name, name);
 790         return i >= 0 ? &control_info[i] : NULL;
 791 }
 792
 793 enum {
 794         param_need_arg = 0x80,
 795         param_line    = 1 | 0x80,
 796         param_rows    = 2 | 0x80,
 797         param_cols    = 3 | 0x80,
 798         param_columns = 4 | 0x80,
 799         param_size    = 5,
 800         param_speed   = 6,
 801         param_ispeed  = 7 | 0x80,
 802         param_ospeed  = 8 | 0x80,
 803 };
 804
 805 static int find_param(const char *const name)
 806 {
 807         static const char params[] ALIGN1 =
 808                 "line\0"    /* 1 */
 809                 "rows\0"    /* 2 */
 810                 "cols\0"    /* 3 */
 811                 "columns\0" /* 4 */
 812                 "size\0"    /* 5 */
 813                 "speed\0"   /* 6 */
 814                 "ispeed\0"
 815                 "ospeed\0";
 816         int i = index_in_strings(params, name) + 1;
 817         if (i == 0)
 818                 return 0;
 819         if (i != 5 && i != 6)
 820                 i |= 0x80;
 821         return i;
 822 }
 823
 824 static int recover_mode(const char *arg, struct termios *mode)
 825 {
 826         int i, n;
 827         unsigned chr;
 828         unsigned long iflag, oflag, cflag, lflag;
 829
 830         /* Scan into temporaries since it is too much trouble to figure out
 831            the right format for 'tcflag_t' */
 832         if (sscanf(arg, "%lx:%lx:%lx:%lx%n",
 833                            &iflag, &oflag, &cflag, &lflag, &n) != 4)
 834                 return 0;
 835         mode->c_iflag = iflag;
 836         mode->c_oflag = oflag;
 837         mode->c_cflag = cflag;
 838         mode->c_lflag = lflag;
 839         arg += n;
 840         for (i = 0; i < NCCS; ++i) {
 841                 if (sscanf(arg, ":%x%n", &chr, &n) != 1)
 842                         return 0;
 843                 mode->c_cc[i] = chr;
 844                 arg += n;
 845         }
 846
 847         /* Fail if there are too many fields */
 848         if (*arg != '\0')
 849                 return 0;
 850
 851         return 1;
 852 }
 853
 854 static void display_recoverable(const struct termios *mode,
 855                                 int ATTRIBUTE_UNUSED dummy)
 856 {
 857         int i;
 858         printf("%lx:%lx:%lx:%lx",
 859                    (unsigned long) mode->c_iflag, (unsigned long) mode->c_oflag,
 860                    (unsigned long) mode->c_cflag, (unsigned long) mode->c_lflag);
 861         for (i = 0; i < NCCS; ++i)
 862                 printf(":%x", (unsigned int) mode->c_cc[i]);
 863         bb_putchar('\n');
 864 }
 865
 866 static void display_speed(const struct termios *mode, int fancy)
 867 {
 868                              //01234567 8 9
 869         const char *fmt_str = "%lu %lu\n\0ispeed %lu baud; ospeed %lu baud;";
 870         unsigned long ispeed, ospeed;
 871
 872         ospeed = ispeed = cfgetispeed(mode);
 873         if (ispeed == 0 || ispeed == (ospeed = cfgetospeed(mode))) {
 874                 ispeed = ospeed;                /* in case ispeed was 0 */
 875                          //0123 4 5 6 7 8 9
 876                 fmt_str = "%lu\n\0\0\0\0\0speed %lu baud;";
 877         }
 878         if (fancy) fmt_str += 9;
 879         wrapf(fmt_str, tty_baud_to_value(ispeed), tty_baud_to_value(ospeed));
 880 }
 881
 882 static void do_display(const struct termios *mode, const int all)
 883 {
 884         int i;
 885         tcflag_t *bitsp;
 886         unsigned long mask;
 887         int prev_type = control;
 888
 889         display_speed(mode, 1);
 890         if (all)
 891                 display_window_size(1);
 892 #ifdef HAVE_C_LINE
 893         wrapf("line = %d;\n", mode->c_line);
 894 #else
 895         wrapf("\n");
 896 #endif
 897
 898         for (i = 0; i != CIDX_min; ++i) {
 899                 /* If swtch is the same as susp, don't print both */
 900 #if VSWTCH == VSUSP
 901                 if (i == CIDX_swtch)
 902                         continue;
 903 #endif
 904                 /* If eof uses the same slot as min, only print whichever applies */
 905 #if VEOF == VMIN
 906                 if ((mode->c_lflag & ICANON) == 0
 907                  && (i == CIDX_eof || i == CIDX_eol)
 908                 ) {
 909                         continue;
 910                 }
 911 #endif
 912                 wrapf("%s = %s;", nth_string(control_name, i),
 913                           visible(mode->c_cc[control_info[i].offset]));
 914         }
 915 #if VEOF == VMIN
 916         if ((mode->c_lflag & ICANON) == 0)
 917 #endif
 918                 wrapf("min = %d; time = %d;", mode->c_cc[VMIN], mode->c_cc[VTIME]);
 919         if (G.current_col) wrapf("\n");
 920
 921         for (i = 0; i < NUM_mode_info; ++i) {
 922                 if (mode_info[i].flags & OMIT)
 923                         continue;
 924                 if (mode_info[i].type != prev_type) {
 925                         /* wrapf("\n"); */
 926                         if (G.current_col) wrapf("\n");
 927                         prev_type = mode_info[i].type;
 928                 }
 929
 930                 bitsp = mode_type_flag(mode_info[i].type, mode);
 931                 mask = mode_info[i].mask ? mode_info[i].mask : mode_info[i].bits;
 932                 if ((*bitsp & mask) == mode_info[i].bits) {
 933                         if (all || (mode_info[i].flags & SANE_UNSET))
 934                                 wrapf("-%s"+1, nth_string(mode_name, i));
 935                 } else {
 936                         if ((all && mode_info[i].flags & REV)
 937                          || (!all && (mode_info[i].flags & (SANE_SET | REV)) == (SANE_SET | REV))
 938                         ) {
 939                                 wrapf("-%s", nth_string(mode_name, i));
 940                         }
 941                 }
 942         }
 943         if (G.current_col) wrapf("\n");
 944 }
 945
 946 static void sane_mode(struct termios *mode)
 947 {
 948         int i;
 949         tcflag_t *bitsp;
 950
 951         for (i = 0; i < NUM_control_info; ++i) {
 952 #if VMIN == VEOF
 953                 if (i == CIDX_min)
 954                         break;
 955 #endif
 956                 mode->c_cc[control_info[i].offset] = control_info[i].saneval;
 957         }
 958
 959         for (i = 0; i < NUM_mode_info; ++i) {
 960                 if (mode_info[i].flags & SANE_SET) {
 961                         bitsp = mode_type_flag(mode_info[i].type, mode);
 962                         *bitsp = (*bitsp & ~((unsigned long)mode_info[i].mask))
 963                                 | mode_info[i].bits;
 964                 } else if (mode_info[i].flags & SANE_UNSET) {
 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                 }
 969         }
 970 }
 971
 972 /* Save set_mode from #ifdef forest plague */
 973 #ifndef ONLCR
 974 #define ONLCR 0
 975 #endif
 976 #ifndef OCRNL
 977 #define OCRNL 0
 978 #endif
 979 #ifndef ONLRET
 980 #define ONLRET 0
 981 #endif
 982 #ifndef XCASE
 983 #define XCASE 0
 984 #endif
 985 #ifndef IXANY
 986 #define IXANY 0
 987 #endif
 988 #ifndef TABDLY
 989 #define TABDLY 0
 990 #endif
 991 #ifndef OXTABS
 992 #define OXTABS 0
 993 #endif
 994 #ifndef IUCLC
 995 #define IUCLC 0
 996 #endif
 997 #ifndef OLCUC
 998 #define OLCUC 0
 999 #endif
1000 #ifndef ECHOCTL
1001 #define ECHOCTL 0
1002 #endif
1003 #ifndef ECHOKE
1004 #define ECHOKE 0
1005 #endif
1006
1007 static void set_mode(const struct mode_info *info, int reversed,
1008                                         struct termios *mode)
1009 {
1010         tcflag_t *bitsp;
1011
1012         bitsp = mode_type_flag(info->type, mode);
1013
1014         if (bitsp) {
1015                 if (reversed)
1016                         *bitsp = *bitsp & ~info->mask & ~info->bits;
1017                 else
1018                         *bitsp = (*bitsp & ~info->mask) | info->bits;
1019                 return;
1020         }
1021
1022         /* Combination mode */
1023         if (info == &mode_info[IDX_evenp] || info == &mode_info[IDX_parity]) {
1024                 if (reversed)
1025                         mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
1026                 else
1027                         mode->c_cflag = (mode->c_cflag & ~PARODD & ~CSIZE) | PARENB | CS7;
1028         } else if (info == &mode_info[IDX_oddp]) {
1029                 if (reversed)
1030                         mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
1031                 else
1032                         mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARODD | PARENB;
1033         } else if (info == &mode_info[IDX_nl]) {
1034                 if (reversed) {
1035                         mode->c_iflag = (mode->c_iflag | ICRNL) & ~INLCR & ~IGNCR;
1036                         mode->c_oflag = (mode->c_oflag | ONLCR) & ~OCRNL & ~ONLRET;
1037                 } else {
1038                         mode->c_iflag = mode->c_iflag & ~ICRNL;
1039                         if (ONLCR) mode->c_oflag = mode->c_oflag & ~ONLCR;
1040                 }
1041         } else if (info == &mode_info[IDX_ek]) {
1042                 mode->c_cc[VERASE] = CERASE;
1043                 mode->c_cc[VKILL] = CKILL;
1044         } else if (info == &mode_info[IDX_sane]) {
1045                 sane_mode(mode);
1046         } else if (info == &mode_info[IDX_cbreak]) {
1047                 if (reversed)
1048                         mode->c_lflag |= ICANON;
1049                 else
1050                         mode->c_lflag &= ~ICANON;
1051         } else if (info == &mode_info[IDX_pass8]) {
1052                 if (reversed) {
1053                         mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARENB;
1054                         mode->c_iflag |= ISTRIP;
1055                 } else {
1056                         mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
1057                         mode->c_iflag &= ~ISTRIP;
1058                 }
1059         } else if (info == &mode_info[IDX_litout]) {
1060                 if (reversed) {
1061                         mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARENB;
1062                         mode->c_iflag |= ISTRIP;
1063                         mode->c_oflag |= OPOST;
1064                 } else {
1065                         mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
1066                         mode->c_iflag &= ~ISTRIP;
1067                         mode->c_oflag &= ~OPOST;
1068                 }
1069         } else if (info == &mode_info[IDX_raw] || info == &mode_info[IDX_cooked]) {
1070                 if ((info == &mode_info[IDX_raw] && reversed)
1071                  || (info == &mode_info[IDX_cooked] && !reversed)
1072                 ) {
1073                         /* Cooked mode */
1074                         mode->c_iflag |= BRKINT | IGNPAR | ISTRIP | ICRNL | IXON;
1075                         mode->c_oflag |= OPOST;
1076                         mode->c_lflag |= ISIG | ICANON;
1077 #if VMIN == VEOF
1078                         mode->c_cc[VEOF] = CEOF;
1079 #endif
1080 #if VTIME == VEOL
1081                         mode->c_cc[VEOL] = CEOL;
1082 #endif
1083                 } else {
1084                         /* Raw mode */
1085                         mode->c_iflag = 0;
1086                         mode->c_oflag &= ~OPOST;
1087                         mode->c_lflag &= ~(ISIG | ICANON | XCASE);
1088                         mode->c_cc[VMIN] = 1;
1089                         mode->c_cc[VTIME] = 0;
1090                 }
1091         }
1092         else if (IXANY && info == &mode_info[IDX_decctlq]) {
1093                 if (reversed)
1094                         mode->c_iflag |= IXANY;
1095                 else
1096                         mode->c_iflag &= ~IXANY;
1097         }
1098         else if (TABDLY && info == &mode_info[IDX_tabs]) {
1099                 if (reversed)
1100                         mode->c_oflag = (mode->c_oflag & ~TABDLY) | TAB3;
1101                 else
1102                         mode->c_oflag = (mode->c_oflag & ~TABDLY) | TAB0;
1103         }
1104         else if (OXTABS && info == &mode_info[IDX_tabs]) {
1105                 if (reversed)
1106                         mode->c_oflag |= OXTABS;
1107                 else
1108                         mode->c_oflag &= ~OXTABS;
1109         } else
1110         if (XCASE && IUCLC && OLCUC
1111          && (info == &mode_info[IDX_lcase] || info == &mode_info[IDX_LCASE])
1112         ) {
1113                 if (reversed) {
1114                         mode->c_lflag &= ~XCASE;
1115                         mode->c_iflag &= ~IUCLC;
1116                         mode->c_oflag &= ~OLCUC;
1117                 } else {
1118                         mode->c_lflag |= XCASE;
1119                         mode->c_iflag |= IUCLC;
1120                         mode->c_oflag |= OLCUC;
1121                 }
1122         } else if (info == &mode_info[IDX_crt]) {
1123                 mode->c_lflag |= ECHOE | ECHOCTL | ECHOKE;
1124         } else if (info == &mode_info[IDX_dec]) {
1125                 mode->c_cc[VINTR] = 3; /* ^C */
1126                 mode->c_cc[VERASE] = 127; /* DEL */
1127                 mode->c_cc[VKILL] = 21; /* ^U */
1128                 mode->c_lflag |= ECHOE | ECHOCTL | ECHOKE;
1129                 if (IXANY) mode->c_iflag &= ~IXANY;
1130         }
1131 }
1132
1133 static void set_control_char_or_die(const struct control_info *info,
1134                         const char *arg, struct termios *mode)
1135 {
1136         unsigned char value;
1137
1138         if (info == &control_info[CIDX_min] || info == &control_info[CIDX_time])
1139                 value = xatoul_range_sfx(arg, 0, 0xff, stty_suffixes);
1140         else if (arg[0] == '\0' || arg[1] == '\0')
1141                 value = arg[0];
1142         else if (!strcmp(arg, "^-") || !strcmp(arg, "undef"))
1143                 value = _POSIX_VDISABLE;
1144         else if (arg[0] == '^') { /* Ignore any trailing junk (^Cjunk) */
1145                 value = arg[1] & 0x1f; /* Non-letters get weird results */
1146                 if (arg[1] == '?')
1147                         value = 127;
1148         } else
1149                 value = xatoul_range_sfx(arg, 0, 0xff, stty_suffixes);
1150         mode->c_cc[info->offset] = value;
1151 }
1152
1153 #define STTY_require_set_attr   (1 << 0)
1154 #define STTY_speed_was_set      (1 << 1)
1155 #define STTY_verbose_output     (1 << 2)
1156 #define STTY_recoverable_output (1 << 3)
1157 #define STTY_noargs             (1 << 4)
1158
1159 int stty_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1160 int stty_main(int argc, char **argv)
1161 {
1162         struct termios mode;
1163         void (*output_func)(const struct termios *, const int);
1164         const char *file_name = NULL;
1165         int display_all = 0;
1166         int stty_state;
1167         int k;
1168
1169         INIT_G();
1170
1171         stty_state = STTY_noargs;
1172         output_func = do_display;
1173
1174         /* First pass: only parse/verify command line params */
1175         k = 0;
1176         while (argv[++k]) {
1177                 const struct mode_info *mp;
1178                 const struct control_info *cp;
1179                 const char *arg = argv[k];
1180                 const char *argnext = argv[k+1];
1181                 int param;
1182
1183                 if (arg[0] == '-') {
1184                         int i;
1185                         mp = find_mode(arg+1);
1186                         if (mp) {
1187                                 if (!(mp->flags & REV))
1188                                         goto invalid_argument;
1189                                 stty_state &= ~STTY_noargs;
1190                                 continue;
1191                         }
1192                         /* It is an option - parse it */
1193                         i = 0;
1194                         while (arg[++i]) {
1195                                 switch (arg[i]) {
1196                                 case 'a':
1197                                         stty_state |= STTY_verbose_output;
1198                                         output_func = do_display;
1199                                         display_all = 1;
1200                                         break;
1201                                 case 'g':
1202                                         stty_state |= STTY_recoverable_output;
1203                                         output_func = display_recoverable;
1204                                         break;
1205                                 case 'F':
1206                                         if (file_name)
1207                                                 bb_error_msg_and_die("only one device may be specified");
1208                                         file_name = &arg[i+1]; /* "-Fdevice" ? */
1209                                         if (!file_name[0]) { /* nope, "-F device" */
1210                                                 int p = k+1; /* argv[p] is argnext */
1211                                                 file_name = argnext;
1212                                                 if (!file_name)
1213                                                         bb_error_msg_and_die(bb_msg_requires_arg, "-F");
1214                                                 /* remove -F param from arg[vc] */
1215                                                 --argc;
1216                                                 while (argv[p]) { argv[p] = argv[p+1]; ++p; }
1217                                         }
1218                                         goto end_option;
1219                                 default:
1220                                         goto invalid_argument;
1221                                 }
1222                         }
1223  end_option:
1224                         continue;
1225                 }
1226
1227                 mp = find_mode(arg);
1228                 if (mp) {
1229                         stty_state &= ~STTY_noargs;
1230                         continue;
1231                 }
1232
1233                 cp = find_control(arg);
1234                 if (cp) {
1235                         if (!argnext)
1236                                 bb_error_msg_and_die(bb_msg_requires_arg, arg);
1237                         /* called for the side effect of xfunc death only */
1238                         set_control_char_or_die(cp, argnext, &mode);
1239                         stty_state &= ~STTY_noargs;
1240                         ++k;
1241                         continue;
1242                 }
1243
1244                 param = find_param(arg);
1245                 if (param & param_need_arg) {
1246                         if (!argnext)
1247                                 bb_error_msg_and_die(bb_msg_requires_arg, arg);
1248                         ++k;
1249                 }
1250
1251                 switch (param) {
1252 #ifdef HAVE_C_LINE
1253                 case param_line:
1254 # ifndef TIOCGWINSZ
1255                         xatoul_range_sfx(argnext, 1, INT_MAX, stty_suffixes);
1256                         break;
1257 # endif /* else fall-through */
1258 #endif
1259 #ifdef TIOCGWINSZ
1260                 case param_rows:
1261                 case param_cols:
1262                 case param_columns:
1263                         xatoul_range_sfx(argnext, 1, INT_MAX, stty_suffixes);
1264                         break;
1265                 case param_size:
1266 #endif
1267                 case param_speed:
1268                         break;
1269                 case param_ispeed:
1270                         /* called for the side effect of xfunc death only */
1271                         set_speed_or_die(input_speed, argnext, &mode);
1272                         break;
1273                 case param_ospeed:
1274                         /* called for the side effect of xfunc death only */
1275                         set_speed_or_die(output_speed, argnext, &mode);
1276                         break;
1277                 default:
1278                         if (recover_mode(arg, &mode) == 1) break;
1279                         if (tty_value_to_baud(xatou(arg)) != (speed_t) -1) break;
1280  invalid_argument:
1281                         bb_error_msg_and_die("invalid argument '%s'", arg);
1282                 }
1283                 stty_state &= ~STTY_noargs;
1284         }
1285
1286         /* Specifying both -a and -g is an error */
1287         if ((stty_state & (STTY_verbose_output | STTY_recoverable_output)) ==
1288                 (STTY_verbose_output | STTY_recoverable_output))
1289                 bb_error_msg_and_die("verbose and stty-readable output styles are mutually exclusive");
1290         /* Specifying -a or -g with non-options is an error */
1291         if (!(stty_state & STTY_noargs) &&
1292                 (stty_state & (STTY_verbose_output | STTY_recoverable_output)))
1293                 bb_error_msg_and_die("modes may not be set when specifying an output style");
1294
1295         /* Now it is safe to start doing things */
1296         if (file_name) {
1297                 int fd, fdflags;
1298                 G.device_name = file_name;
1299                 fd = xopen(G.device_name, O_RDONLY | O_NONBLOCK);
1300                 if (fd != STDIN_FILENO) {
1301                         dup2(fd, STDIN_FILENO);
1302                         close(fd);
1303                 }
1304                 fdflags = fcntl(STDIN_FILENO, F_GETFL);
1305                 if (fdflags < 0 ||
1306                         fcntl(STDIN_FILENO, F_SETFL, fdflags & ~O_NONBLOCK) < 0)
1307                         perror_on_device_and_die("%s: cannot reset non-blocking mode");
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                         set_window_size(-1, xatoul_sfx(argnext, stty_suffixes));
1371                         break;
1372                 case param_size:
1373                         display_window_size(0);
1374                         break;
1375                 case param_rows:
1376                         set_window_size(xatoul_sfx(argnext, stty_suffixes), -1);
1377                         break;
1378 #endif
1379                 case param_speed:
1380                         display_speed(&mode, 0);
1381                         break;
1382                 case param_ispeed:
1383                         set_speed_or_die(input_speed, argnext, &mode);
1384                         stty_state |= (STTY_require_set_attr | STTY_speed_was_set);
1385                         break;
1386                 case param_ospeed:
1387                         set_speed_or_die(output_speed, argnext, &mode);
1388                         stty_state |= (STTY_require_set_attr | STTY_speed_was_set);
1389                         break;
1390                 default:
1391                         if (recover_mode(arg, &mode) == 1)
1392                                 stty_state |= STTY_require_set_attr;
1393                         else /* true: if (tty_value_to_baud(xatou(arg)) != (speed_t) -1) */{
1394                                 set_speed_or_die(both_speeds, arg, &mode);
1395                                 stty_state |= (STTY_require_set_attr | STTY_speed_was_set);
1396                         } /* else - impossible (caught in the first pass):
1397                                 bb_error_msg_and_die("invalid argument '%s'", arg); */
1398                 }
1399         }
1400
1401         if (stty_state & STTY_require_set_attr) {
1402                 struct termios new_mode;
1403
1404                 if (tcsetattr(STDIN_FILENO, TCSADRAIN, &mode))
1405                         perror_on_device_and_die("%s");
1406
1407                 /* POSIX (according to Zlotnick's book) tcsetattr returns zero if
1408                    it performs *any* of the requested operations.  This means it
1409                    can report 'success' when it has actually failed to perform
1410                    some proper subset of the requested operations.  To detect
1411                    this partial failure, get the current terminal attributes and
1412                    compare them to the requested ones */
1413
1414                 /* Initialize to all zeroes so there is no risk memcmp will report a
1415                    spurious difference in an uninitialized portion of the structure */
1416                 memset(&new_mode, 0, sizeof(new_mode));
1417                 if (tcgetattr(STDIN_FILENO, &new_mode))
1418                         perror_on_device_and_die("%s");
1419
1420                 if (memcmp(&mode, &new_mode, sizeof(mode)) != 0) {
1421 #ifdef CIBAUD
1422                         /* SunOS 4.1.3 (at least) has the problem that after this sequence,
1423                            tcgetattr (&m1); tcsetattr (&m1); tcgetattr (&m2);
1424                            sometimes (m1 != m2).  The only difference is in the four bits
1425                            of the c_cflag field corresponding to the baud rate.  To save
1426                            Sun users a little confusion, don't report an error if this
1427                            happens.  But suppress the error only if we haven't tried to
1428                            set the baud rate explicitly -- otherwise we'd never give an
1429                            error for a true failure to set the baud rate */
1430
1431                         new_mode.c_cflag &= (~CIBAUD);
1432                         if ((stty_state & STTY_speed_was_set)
1433                          || memcmp(&mode, &new_mode, sizeof(mode)) != 0)
1434 #endif
1435                                 perror_on_device_and_die("%s: cannot perform all requested operations");
1436                 }
1437         }
1438
1439         return EXIT_SUCCESS;
1440 }