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 "busybox.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 mode_type {
 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 static const char evenp     [] = "evenp";
 131 static const char raw       [] = "raw";
 132 static const char stty_min  [] = "min";
 133 static const char stty_time [] = "time";
 134 static const char stty_swtch[] = "swtch";
 135 static const char stty_eol  [] = "eol";
 136 static const char stty_eof  [] = "eof";
 137 static const char parity    [] = "parity";
 138 static const char stty_oddp [] = "oddp";
 139 static const char stty_nl   [] = "nl";
 140 static const char stty_ek   [] = "ek";
 141 static const char stty_sane [] = "sane";
 142 static const char cbreak    [] = "cbreak";
 143 static const char stty_pass8[] = "pass8";
 144 static const char litout    [] = "litout";
 145 static const char cooked    [] = "cooked";
 146 static const char decctlq   [] = "decctlq";
 147 static const char stty_tabs [] = "tabs";
 148 static const char stty_lcase[] = "lcase";
 149 static const char stty_LCASE[] = "LCASE";
 150 static const char stty_crt  [] = "crt";
 151 static const char stty_dec  [] = "dec";
 152
 153 /* Flags for `struct mode_info' */
 154 #define SANE_SET 1              /* Set in `sane' mode                  */
 155 #define SANE_UNSET 2            /* Unset in `sane' mode                */
 156 #define REV 4                   /* Can be turned off by prepending `-' */
 157 #define OMIT 8                  /* Don't display value                 */
 158
 159 /* Each mode */
 160 struct mode_info {
 161         const char *name;       /* Name given on command line            */
 162         /* enum mode_type type; */
 163         char type;              /* Which structure element to change     */
 164         char flags;             /* Setting and display options           */
 165         unsigned short mask;     /* Other bits to turn off for this mode */
 166         unsigned long bits;     /* Bits to set for this mode             */
 167 };
 168 #define EMT(t) ((enum mode_type)(t))
 169
 170 #define MI_ENTRY(N,T,F,B,M) { N, T, F, M, B }
 171
 172 static const struct mode_info mode_info[] = {
 173         MI_ENTRY("parenb",   control,     REV,               PARENB,     0 ),
 174         MI_ENTRY("parodd",   control,     REV,               PARODD,     0 ),
 175         MI_ENTRY("cs5",      control,     0,                 CS5,     CSIZE),
 176         MI_ENTRY("cs6",      control,     0,                 CS6,     CSIZE),
 177         MI_ENTRY("cs7",      control,     0,                 CS7,     CSIZE),
 178         MI_ENTRY("cs8",      control,     0,                 CS8,     CSIZE),
 179         MI_ENTRY("hupcl",    control,     REV,               HUPCL,      0 ),
 180         MI_ENTRY("hup",      control,     REV        | OMIT, HUPCL,      0 ),
 181         MI_ENTRY("cstopb",   control,     REV,               CSTOPB,     0 ),
 182         MI_ENTRY("cread",    control,     SANE_SET   | REV,  CREAD,      0 ),
 183         MI_ENTRY("clocal",   control,     REV,               CLOCAL,     0 ),
 184 #ifdef CRTSCTS
 185         MI_ENTRY("crtscts",  control,     REV,               CRTSCTS,    0 ),
 186 #endif
 187         MI_ENTRY("ignbrk",   input,       SANE_UNSET | REV,  IGNBRK,     0 ),
 188         MI_ENTRY("brkint",   input,       SANE_SET   | REV,  BRKINT,     0 ),
 189         MI_ENTRY("ignpar",   input,       REV,               IGNPAR,     0 ),
 190         MI_ENTRY("parmrk",   input,       REV,               PARMRK,     0 ),
 191         MI_ENTRY("inpck",    input,       REV,               INPCK,      0 ),
 192         MI_ENTRY("istrip",   input,       REV,               ISTRIP,     0 ),
 193         MI_ENTRY("inlcr",    input,       SANE_UNSET | REV,  INLCR,      0 ),
 194         MI_ENTRY("igncr",    input,       SANE_UNSET | REV,  IGNCR,      0 ),
 195         MI_ENTRY("icrnl",    input,       SANE_SET   | REV,  ICRNL,      0 ),
 196         MI_ENTRY("ixon",     input,       REV,               IXON,       0 ),
 197         MI_ENTRY("ixoff",    input,       SANE_UNSET | REV,  IXOFF,      0 ),
 198         MI_ENTRY("tandem",   input,       REV        | OMIT, IXOFF,      0 ),
 199 #ifdef IUCLC
 200         MI_ENTRY("iuclc",    input,       SANE_UNSET | REV,  IUCLC,      0 ),
 201 #endif
 202 #ifdef IXANY
 203         MI_ENTRY("ixany",    input,       SANE_UNSET | REV,  IXANY,      0 ),
 204 #endif
 205 #ifdef IMAXBEL
 206         MI_ENTRY("imaxbel",  input,       SANE_SET   | REV,  IMAXBEL,    0 ),
 207 #endif
 208         MI_ENTRY("opost",    output,      SANE_SET   | REV,  OPOST,      0 ),
 209 #ifdef OLCUC
 210         MI_ENTRY("olcuc",    output,      SANE_UNSET | REV,  OLCUC,      0 ),
 211 #endif
 212 #ifdef OCRNL
 213         MI_ENTRY("ocrnl",    output,      SANE_UNSET | REV,  OCRNL,      0 ),
 214 #endif
 215 #ifdef ONLCR
 216         MI_ENTRY("onlcr",    output,      SANE_SET   | REV,  ONLCR,      0 ),
 217 #endif
 218 #ifdef ONOCR
 219         MI_ENTRY("onocr",    output,      SANE_UNSET | REV,  ONOCR,      0 ),
 220 #endif
 221 #ifdef ONLRET
 222         MI_ENTRY("onlret",   output,      SANE_UNSET | REV,  ONLRET,     0 ),
 223 #endif
 224 #ifdef OFILL
 225         MI_ENTRY("ofill",    output,      SANE_UNSET | REV,  OFILL,      0 ),
 226 #endif
 227 #ifdef OFDEL
 228         MI_ENTRY("ofdel",    output,      SANE_UNSET | REV,  OFDEL,      0 ),
 229 #endif
 230 #ifdef NLDLY
 231         MI_ENTRY("nl1",      output,      SANE_UNSET,        NL1,     NLDLY),
 232         MI_ENTRY("nl0",      output,      SANE_SET,          NL0,     NLDLY),
 233 #endif
 234 #ifdef CRDLY
 235         MI_ENTRY("cr3",      output,      SANE_UNSET,        CR3,     CRDLY),
 236         MI_ENTRY("cr2",      output,      SANE_UNSET,        CR2,     CRDLY),
 237         MI_ENTRY("cr1",      output,      SANE_UNSET,        CR1,     CRDLY),
 238         MI_ENTRY("cr0",      output,      SANE_SET,          CR0,     CRDLY),
 239 #endif
 240
 241 #ifdef TABDLY
 242         MI_ENTRY("tab3",     output,      SANE_UNSET,        TAB3,   TABDLY),
 243         MI_ENTRY("tab2",     output,      SANE_UNSET,        TAB2,   TABDLY),
 244         MI_ENTRY("tab1",     output,      SANE_UNSET,        TAB1,   TABDLY),
 245         MI_ENTRY("tab0",     output,      SANE_SET,          TAB0,   TABDLY),
 246 #else
 247 # ifdef OXTABS
 248         MI_ENTRY("tab3",     output,      SANE_UNSET,        OXTABS,     0 ),
 249 # endif
 250 #endif
 251
 252 #ifdef BSDLY
 253         MI_ENTRY("bs1",      output,      SANE_UNSET,        BS1,     BSDLY),
 254         MI_ENTRY("bs0",      output,      SANE_SET,          BS0,     BSDLY),
 255 #endif
 256 #ifdef VTDLY
 257         MI_ENTRY("vt1",      output,      SANE_UNSET,        VT1,     VTDLY),
 258         MI_ENTRY("vt0",      output,      SANE_SET,          VT0,     VTDLY),
 259 #endif
 260 #ifdef FFDLY
 261         MI_ENTRY("ff1",      output,      SANE_UNSET,        FF1,     FFDLY),
 262         MI_ENTRY("ff0",      output,      SANE_SET,          FF0,     FFDLY),
 263 #endif
 264         MI_ENTRY("isig",     local,       SANE_SET   | REV,  ISIG,       0 ),
 265         MI_ENTRY("icanon",   local,       SANE_SET   | REV,  ICANON,     0 ),
 266 #ifdef IEXTEN
 267         MI_ENTRY("iexten",   local,       SANE_SET   | REV,  IEXTEN,     0 ),
 268 #endif
 269         MI_ENTRY("echo",     local,       SANE_SET   | REV,  ECHO,       0 ),
 270         MI_ENTRY("echoe",    local,       SANE_SET   | REV,  ECHOE,      0 ),
 271         MI_ENTRY("crterase", local,       REV        | OMIT, ECHOE,      0 ),
 272         MI_ENTRY("echok",    local,       SANE_SET   | REV,  ECHOK,      0 ),
 273         MI_ENTRY("echonl",   local,       SANE_UNSET | REV,  ECHONL,     0 ),
 274         MI_ENTRY("noflsh",   local,       SANE_UNSET | REV,  NOFLSH,     0 ),
 275 #ifdef XCASE
 276         MI_ENTRY("xcase",    local,       SANE_UNSET | REV,  XCASE,      0 ),
 277 #endif
 278 #ifdef TOSTOP
 279         MI_ENTRY("tostop",   local,       SANE_UNSET | REV,  TOSTOP,     0 ),
 280 #endif
 281 #ifdef ECHOPRT
 282         MI_ENTRY("echoprt",  local,       SANE_UNSET | REV,  ECHOPRT,    0 ),
 283         MI_ENTRY("prterase", local,       REV | OMIT,        ECHOPRT,    0 ),
 284 #endif
 285 #ifdef ECHOCTL
 286         MI_ENTRY("echoctl",  local,       SANE_SET   | REV,  ECHOCTL,    0 ),
 287         MI_ENTRY("ctlecho",  local,       REV        | OMIT, ECHOCTL,    0 ),
 288 #endif
 289 #ifdef ECHOKE
 290         MI_ENTRY("echoke",   local,       SANE_SET   | REV,  ECHOKE,     0 ),
 291         MI_ENTRY("crtkill",  local,       REV        | OMIT, ECHOKE,     0 ),
 292 #endif
 293         MI_ENTRY(evenp,      combination, REV        | OMIT, 0,          0 ),
 294         MI_ENTRY(parity,     combination, REV        | OMIT, 0,          0 ),
 295         MI_ENTRY(stty_oddp,  combination, REV        | OMIT, 0,          0 ),
 296         MI_ENTRY(stty_nl,    combination, REV        | OMIT, 0,          0 ),
 297         MI_ENTRY(stty_ek,    combination, OMIT,              0,          0 ),
 298         MI_ENTRY(stty_sane,  combination, OMIT,              0,          0 ),
 299         MI_ENTRY(cooked,     combination, REV        | OMIT, 0,          0 ),
 300         MI_ENTRY(raw,        combination, REV        | OMIT, 0,          0 ),
 301         MI_ENTRY(stty_pass8, combination, REV        | OMIT, 0,          0 ),
 302         MI_ENTRY(litout,     combination, REV        | OMIT, 0,          0 ),
 303         MI_ENTRY(cbreak,     combination, REV        | OMIT, 0,          0 ),
 304 #ifdef IXANY
 305         MI_ENTRY(decctlq,    combination, REV        | OMIT, 0,          0 ),
 306 #endif
 307 #if defined(TABDLY) || defined(OXTABS)
 308         MI_ENTRY(stty_tabs,  combination, REV        | OMIT, 0,          0 ),
 309 #endif
 310 #if defined(XCASE) && defined(IUCLC) && defined(OLCUC)
 311         MI_ENTRY(stty_lcase, combination, REV        | OMIT, 0,          0 ),
 312         MI_ENTRY(stty_LCASE, combination, REV        | OMIT, 0,          0 ),
 313 #endif
 314         MI_ENTRY(stty_crt,   combination, OMIT,              0,          0 ),
 315         MI_ENTRY(stty_dec,   combination, OMIT,              0,          0 ),
 316 };
 317
 318 enum {
 319         NUM_mode_info = (sizeof(mode_info) / sizeof(mode_info[0]))
 320 };
 321
 322 /* Control character settings */
 323 struct control_info {
 324         const char *name;                       /* Name given on command line */
 325         unsigned char saneval;          /* Value to set for `stty sane' */
 326         unsigned char offset;                           /* Offset in c_cc */
 327 };
 328
 329 /* Control characters */
 330
 331 static const struct control_info control_info[] = {
 332         {"intr",     CINTR,   VINTR},
 333         {"quit",     CQUIT,   VQUIT},
 334         {"erase",    CERASE,  VERASE},
 335         {"kill",     CKILL,   VKILL},
 336         {stty_eof,   CEOF,    VEOF},
 337         {stty_eol,   CEOL,    VEOL},
 338 #ifdef VEOL2
 339         {"eol2",     CEOL2,   VEOL2},
 340 #endif
 341 #ifdef VSWTCH
 342         {stty_swtch, CSWTCH,  VSWTCH},
 343 #endif
 344         {"start",    CSTART,  VSTART},
 345         {"stop",     CSTOP,   VSTOP},
 346         {"susp",     CSUSP,   VSUSP},
 347 #ifdef VDSUSP
 348         {"dsusp",    CDSUSP,  VDSUSP},
 349 #endif
 350 #ifdef VREPRINT
 351         {"rprnt",    CRPRNT,  VREPRINT},
 352 #endif
 353 #ifdef VWERASE
 354         {"werase",   CWERASE, VWERASE},
 355 #endif
 356 #ifdef VLNEXT
 357         {"lnext",    CLNEXT,  VLNEXT},
 358 #endif
 359 #ifdef VFLUSHO
 360         {"flush",    CFLUSHO, VFLUSHO},
 361 #endif
 362 #ifdef VSTATUS
 363         {"status",   CSTATUS, VSTATUS},
 364 #endif
 365         /* These must be last because of the display routines */
 366         {stty_min,   1,       VMIN},
 367         {stty_time,  0,       VTIME},
 368 };
 369
 370 enum {
 371         NUM_control_info = (sizeof(control_info) / sizeof(control_info[0]))
 372 };
 373
 374 /* The width of the screen, for output wrapping */
 375 static int max_col;
 376
 377 /* Current position, to know when to wrap */
 378 static int current_col;
 379
 380 static const char *  visible(unsigned int ch);
 381 static int           recover_mode(const char *arg, struct termios *mode);
 382 static int           screen_columns(void);
 383 static void          set_mode(const struct mode_info *info,
 384                                         int reversed, struct termios *mode);
 385 static speed_t       string_to_baud(const char *arg);
 386 static tcflag_t*     mode_type_flag(enum mode_type type, const struct termios *mode);
 387 static void          display_all(const struct termios *mode);
 388 static void          display_changed(const struct termios *mode);
 389 static void          display_recoverable(const struct termios *mode);
 390 static void          display_speed(const struct termios *mode, int fancy);
 391 static void          display_window_size(int fancy);
 392 static void          sane_mode(struct termios *mode);
 393 static void          set_control_char(const struct control_info *info,
 394                                         const char *arg, struct termios *mode);
 395 static void          set_speed(enum speed_setting type,
 396                                         const char *arg, struct termios *mode);
 397 static void          set_window_size(int rows, int cols);
 398
 399 static const char *device_name = bb_msg_standard_input;
 400
 401 static ATTRIBUTE_NORETURN void perror_on_device(const char *fmt)
 402 {
 403         bb_perror_msg_and_die(fmt, device_name);
 404 }
 405
 406 /* No, inline won't be as efficient (gcc 3.4.3) */
 407 #define streq(a,b) (!strcmp((a),(b)))
 408
 409 /* Print format string MESSAGE and optional args.
 410    Wrap to next line first if it won't fit.
 411    Print a space first unless MESSAGE will start a new line */
 412 static void wrapf(const char *message, ...)
 413 {
 414         char buf[128];
 415         va_list args;
 416         int buflen;
 417
 418         va_start(args, message);
 419         vsnprintf(buf, sizeof(buf), message, args);
 420         va_end(args);
 421         buflen = strlen(buf);
 422         if (!buflen) return;
 423
 424         if (current_col > 0) {
 425                 current_col++;
 426                 if (current_col + buflen >= max_col) {
 427                         putchar('\n');
 428                         current_col = 0;
 429                 } else
 430                         if (buf[0] != '\n') putchar(' ');
 431         }
 432         fputs(buf, stdout);
 433         current_col += buflen;
 434         if (buf[buflen-1] == '\n')
 435                 current_col = 0;
 436 }
 437
 438 static const struct suffix_mult stty_suffixes[] = {
 439         {"b",  512 },
 440         {"k",  1024},
 441         {"B",  1024},
 442         {NULL, 0   }
 443 };
 444
 445 static const struct mode_info *find_mode(const char *name)
 446 {
 447         int i;
 448         for (i = 0; i < NUM_mode_info; ++i)
 449                 if (streq(name, mode_info[i].name))
 450                         return &mode_info[i];
 451         return 0;
 452 }
 453
 454 static const struct control_info *find_control(const char *name)
 455 {
 456         int i;
 457         for (i = 0; i < NUM_control_info; ++i)
 458                 if (streq(name, control_info[i].name))
 459                         return &control_info[i];
 460         return 0;
 461 }
 462
 463 enum {
 464         param_need_arg = 0x80,
 465         param_line   = 1 | 0x80,
 466         param_rows   = 2 | 0x80,
 467         param_cols   = 3 | 0x80,
 468         param_size   = 4,
 469         param_ispeed = 5 | 0x80,
 470         param_ospeed = 6 | 0x80,
 471         param_speed  = 7,
 472 };
 473
 474 static int find_param(const char *name)
 475 {
 476 #ifdef HAVE_C_LINE
 477         if (streq(name, "line")) return param_line;
 478 #endif
 479 #ifdef TIOCGWINSZ
 480         if (streq(name, "rows")) return param_rows;
 481         if (streq(name, "cols")) return param_cols;
 482         if (streq(name, "columns")) return param_cols;
 483         if (streq(name, "size")) return param_size;
 484 #endif
 485         if (streq(name, "ispeed")) return param_ispeed;
 486         if (streq(name, "ospeed")) return param_ospeed;
 487         if (streq(name, "speed")) return param_speed;
 488         return 0;
 489 }
 490
 491
 492 int stty_main(int argc, char **argv)
 493 {
 494         struct termios mode;
 495         void (*output_func)(const struct termios *);
 496         const char *file_name = NULL;
 497         int require_set_attr;
 498         int speed_was_set;
 499         int verbose_output;
 500         int recoverable_output;
 501         int noargs;
 502         int k;
 503
 504         output_func = display_changed;
 505         noargs = 1;
 506         speed_was_set = 0;
 507         require_set_attr = 0;
 508         verbose_output = 0;
 509         recoverable_output = 0;
 510
 511         /* First pass: only parse/verify command line params */
 512         k = 0;
 513         while (argv[++k]) {
 514                 const struct mode_info *mp;
 515                 const struct control_info *cp;
 516                 const char *arg = argv[k];
 517                 const char *argnext = argv[k+1];
 518                 int param;
 519
 520                 if (arg[0] == '-') {
 521                         int i;
 522                         mp = find_mode(arg+1);
 523                         if (mp) {
 524                                 if (!(mp->flags & REV))
 525                                         bb_error_msg_and_die("invalid argument '%s'", arg);
 526                                 noargs = 0;
 527                                 continue;
 528                         }
 529                         /* It is an option - parse it */
 530                         i = 0;
 531                         while (arg[++i]) {
 532                                 switch (arg[i]) {
 533                                 case 'a':
 534                                         verbose_output = 1;
 535                                         output_func = display_all;
 536                                         break;
 537                                 case 'g':
 538                                         recoverable_output = 1;
 539                                         output_func = display_recoverable;
 540                                         break;
 541                                 case 'F':
 542                                         if (file_name)
 543                                                 bb_error_msg_and_die("only one device may be specified");
 544                                         file_name = &arg[i+1]; /* "-Fdevice" ? */
 545                                         if (!file_name[0]) { /* nope, "-F device" */
 546                                                 int p = k+1; /* argv[p] is argnext */
 547                                                 file_name = argnext;
 548                                                 if (!file_name)
 549                                                         bb_error_msg_and_die(bb_msg_requires_arg, "-F");
 550                                                 /* remove -F param from arg[vc] */
 551                                                 --argc;
 552                                                 while (argv[p+1]) { argv[p] = argv[p+1]; ++p; }
 553                                         }
 554                                         goto end_option;
 555                                 default:
 556                                         bb_error_msg_and_die("invalid argument '%s'", arg);
 557                                 }
 558                         }
 559 end_option:
 560                         continue;
 561                 }
 562
 563                 mp = find_mode(arg);
 564                 if (mp) {
 565                         noargs = 0;
 566                         continue;
 567                 }
 568
 569                 cp = find_control(arg);
 570                 if (cp) {
 571                         if (!argnext)
 572                                 bb_error_msg_and_die(bb_msg_requires_arg, arg);
 573                         noargs = 0;
 574                         ++k;
 575                         continue;
 576                 }
 577
 578                 param = find_param(arg);
 579                 if (param & param_need_arg) {
 580                         if (!argnext)
 581                                 bb_error_msg_and_die(bb_msg_requires_arg, arg);
 582                         ++k;
 583                 }
 584
 585                 switch (param) {
 586 #ifdef HAVE_C_LINE
 587                 case param_line:
 588 # ifndef TIOCGWINSZ
 589                         bb_xparse_number(argnext, stty_suffixes);
 590                         break;
 591 # endif /* else fall-through */
 592 #endif
 593 #ifdef TIOCGWINSZ
 594                 case param_rows:
 595                 case param_cols:
 596                         bb_xparse_number(argnext, stty_suffixes);
 597                         break;
 598                 case param_size:
 599 #endif
 600                 case param_ispeed:
 601                 case param_ospeed:
 602                 case param_speed:
 603                         break;
 604                 default:
 605                         if (recover_mode(arg, &mode) == 1) break;
 606                         if (string_to_baud(arg) != (speed_t) -1) break;
 607                         bb_error_msg_and_die("invalid argument '%s'", arg);
 608                 }
 609                 noargs = 0;
 610         }
 611
 612         /* Specifying both -a and -g is an error */
 613         if (verbose_output && recoverable_output)
 614                 bb_error_msg_and_die("verbose and stty-readable output styles are mutually exclusive");
 615         /* Specifying -a or -g with non-options is an error */
 616         if (!noargs && (verbose_output || recoverable_output))
 617                 bb_error_msg_and_die("modes may not be set when specifying an output style");
 618
 619         /* Now it is safe to start doing things */
 620         if (file_name) {
 621                 int fd, fdflags;
 622                 device_name = file_name;
 623                 fd = xopen(device_name, O_RDONLY | O_NONBLOCK);
 624                 if (fd != 0) {
 625                         dup2(fd, 0);
 626                         close(fd);
 627                 }
 628                 fdflags = fcntl(STDIN_FILENO, F_GETFL);
 629                 if (fdflags == -1 || fcntl(STDIN_FILENO, F_SETFL, fdflags & ~O_NONBLOCK) < 0)
 630                         perror_on_device("%s: couldn't reset non-blocking mode");
 631         }
 632
 633         /* Initialize to all zeroes so there is no risk memcmp will report a
 634            spurious difference in an uninitialized portion of the structure */
 635         memset(&mode, 0, sizeof(mode));
 636         if (tcgetattr(STDIN_FILENO, &mode))
 637                 perror_on_device("%s");
 638
 639         if (verbose_output || recoverable_output || noargs) {
 640                 max_col = screen_columns();
 641                 current_col = 0;
 642                 output_func(&mode);
 643                 return EXIT_SUCCESS;
 644         }
 645
 646         /* Second pass: perform actions */
 647         k = 0;
 648         while (argv[++k]) {
 649                 const struct mode_info *mp;
 650                 const struct control_info *cp;
 651                 const char *arg = argv[k];
 652                 const char *argnext = argv[k+1];
 653                 int param;
 654
 655                 if (arg[0] == '-') {
 656                         mp = find_mode(arg+1);
 657                         if (mp) {
 658                                 set_mode(mp, 1 /* reversed */, &mode);
 659                         }
 660                         /* It is an option - already parsed. Skip it */
 661                         continue;
 662                 }
 663
 664                 mp = find_mode(arg);
 665                 if (mp) {
 666                         set_mode(mp, 0 /* non-reversed */, &mode);
 667                         continue;
 668                 }
 669
 670                 cp = find_control(arg);
 671                 if (cp) {
 672                         ++k;
 673                         set_control_char(cp, argnext, &mode);
 674                         continue;
 675                 }
 676
 677                 param = find_param(arg);
 678                 if (param & param_need_arg) {
 679                         ++k;
 680                 }
 681
 682                 switch (param) {
 683 #ifdef HAVE_C_LINE
 684                 case param_line:
 685                         mode.c_line = bb_xparse_number(argnext, stty_suffixes);
 686                         require_set_attr = 1;
 687                         break;
 688 #endif
 689 #ifdef TIOCGWINSZ
 690                 case param_cols:
 691                         set_window_size(-1, (int) bb_xparse_number(argnext, stty_suffixes));
 692                         break;
 693                 case param_size:
 694                         max_col = screen_columns();
 695                         current_col = 0;
 696                         display_window_size(0);
 697                         break;
 698                 case param_rows:
 699                         set_window_size((int) bb_xparse_number(argnext, stty_suffixes), -1);
 700                         break;
 701 #endif
 702                 case param_ispeed:
 703                         set_speed(input_speed, argnext, &mode);
 704                         speed_was_set = 1;
 705                         require_set_attr = 1;
 706                         break;
 707                 case param_ospeed:
 708                         set_speed(output_speed, argnext, &mode);
 709                         speed_was_set = 1;
 710                         require_set_attr = 1;
 711                         break;
 712                 case param_speed:
 713                         max_col = screen_columns();
 714                         display_speed(&mode, 0);
 715                         break;
 716                 default:
 717                         if (recover_mode(arg, &mode) == 1)
 718                                 require_set_attr = 1;
 719                         else /* true: if (string_to_baud(arg) != (speed_t) -1) */ {
 720                                 set_speed(both_speeds, arg, &mode);
 721                                 speed_was_set = 1;
 722                                 require_set_attr = 1;
 723                         } /* else - impossible (caught in the first pass):
 724                                 bb_error_msg_and_die("invalid argument '%s'", arg); */
 725                 }
 726         }
 727
 728         if (require_set_attr) {
 729                 struct termios new_mode;
 730
 731                 if (tcsetattr(STDIN_FILENO, TCSADRAIN, &mode))
 732                         perror_on_device("%s");
 733
 734                 /* POSIX (according to Zlotnick's book) tcsetattr returns zero if
 735                    it performs *any* of the requested operations.  This means it
 736                    can report `success' when it has actually failed to perform
 737                    some proper subset of the requested operations.  To detect
 738                    this partial failure, get the current terminal attributes and
 739                    compare them to the requested ones */
 740
 741                 /* Initialize to all zeroes so there is no risk memcmp will report a
 742                    spurious difference in an uninitialized portion of the structure */
 743                 memset(&new_mode, 0, sizeof(new_mode));
 744                 if (tcgetattr(STDIN_FILENO, &new_mode))
 745                         perror_on_device("%s");
 746
 747                 if (memcmp(&mode, &new_mode, sizeof(mode)) != 0) {
 748 #ifdef CIBAUD
 749                         /* SunOS 4.1.3 (at least) has the problem that after this sequence,
 750                            tcgetattr (&m1); tcsetattr (&m1); tcgetattr (&m2);
 751                            sometimes (m1 != m2).  The only difference is in the four bits
 752                            of the c_cflag field corresponding to the baud rate.  To save
 753                            Sun users a little confusion, don't report an error if this
 754                            happens.  But suppress the error only if we haven't tried to
 755                            set the baud rate explicitly -- otherwise we'd never give an
 756                            error for a true failure to set the baud rate */
 757
 758                         new_mode.c_cflag &= (~CIBAUD);
 759                         if (speed_was_set || memcmp(&mode, &new_mode, sizeof(mode)) != 0)
 760 #endif
 761                                 perror_on_device ("%s: unable to perform all requested operations");
 762                 }
 763         }
 764
 765         return EXIT_SUCCESS;
 766 }
 767
 768
 769 static void
 770 set_mode(const struct mode_info *info, int reversed, struct termios *mode)
 771 {
 772         tcflag_t *bitsp;
 773
 774         bitsp = mode_type_flag(EMT(info->type), mode);
 775
 776         if (bitsp == NULL) {
 777                 /* Combination mode */
 778                 if (info->name == evenp || info->name == parity) {
 779                         if (reversed)
 780                                 mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
 781                         else
 782                                 mode->c_cflag =
 783                                         (mode->c_cflag & ~PARODD & ~CSIZE) | PARENB | CS7;
 784                 } else if (info->name == stty_oddp) {
 785                         if (reversed)
 786                                 mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
 787                         else
 788                                 mode->c_cflag =
 789                                         (mode->c_cflag & ~CSIZE) | CS7 | PARODD | PARENB;
 790                 } else if (info->name == stty_nl) {
 791                         if (reversed) {
 792                                 mode->c_iflag = (mode->c_iflag | ICRNL) & ~INLCR & ~IGNCR;
 793                                 mode->c_oflag = (mode->c_oflag
 794 #ifdef ONLCR
 795                                                                  | ONLCR
 796 #endif
 797                                         )
 798 #ifdef OCRNL
 799                                         & ~OCRNL
 800 #endif
 801 #ifdef ONLRET
 802                                         & ~ONLRET
 803 #endif
 804                                         ;
 805                         } else {
 806                                 mode->c_iflag = mode->c_iflag & ~ICRNL;
 807 #ifdef ONLCR
 808                                 mode->c_oflag = mode->c_oflag & ~ONLCR;
 809 #endif
 810                         }
 811                 } else if (info->name == stty_ek) {
 812                         mode->c_cc[VERASE] = CERASE;
 813                         mode->c_cc[VKILL] = CKILL;
 814                 } else if (info->name == stty_sane)
 815                         sane_mode(mode);
 816                 else if (info->name == cbreak) {
 817                         if (reversed)
 818                                 mode->c_lflag |= ICANON;
 819                         else
 820                                 mode->c_lflag &= ~ICANON;
 821                 } else if (info->name == stty_pass8) {
 822                         if (reversed) {
 823                                 mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARENB;
 824                                 mode->c_iflag |= ISTRIP;
 825                         } else {
 826                                 mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
 827                                 mode->c_iflag &= ~ISTRIP;
 828                         }
 829                 } else if (info->name == litout) {
 830                         if (reversed) {
 831                                 mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARENB;
 832                                 mode->c_iflag |= ISTRIP;
 833                                 mode->c_oflag |= OPOST;
 834                         } else {
 835                                 mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
 836                                 mode->c_iflag &= ~ISTRIP;
 837                                 mode->c_oflag &= ~OPOST;
 838                         }
 839                 } else if (info->name == raw || info->name == cooked) {
 840                         if ((info->name[0] == 'r' && reversed)
 841                                 || (info->name[0] == 'c' && !reversed)) {
 842                                 /* Cooked mode */
 843                                 mode->c_iflag |= BRKINT | IGNPAR | ISTRIP | ICRNL | IXON;
 844                                 mode->c_oflag |= OPOST;
 845                                 mode->c_lflag |= ISIG | ICANON;
 846 #if VMIN == VEOF
 847                                 mode->c_cc[VEOF] = CEOF;
 848 #endif
 849 #if VTIME == VEOL
 850                                 mode->c_cc[VEOL] = CEOL;
 851 #endif
 852                         } else {
 853                                 /* Raw mode */
 854                                 mode->c_iflag = 0;
 855                                 mode->c_oflag &= ~OPOST;
 856                                 mode->c_lflag &= ~(ISIG | ICANON
 857 #ifdef XCASE
 858                                                                    | XCASE
 859 #endif
 860                                         );
 861                                 mode->c_cc[VMIN] = 1;
 862                                 mode->c_cc[VTIME] = 0;
 863                         }
 864                 }
 865 #ifdef IXANY
 866                 else if (info->name == decctlq) {
 867                         if (reversed)
 868                                 mode->c_iflag |= IXANY;
 869                         else
 870                                 mode->c_iflag &= ~IXANY;
 871                 }
 872 #endif
 873 #ifdef TABDLY
 874                 else if (info->name == stty_tabs) {
 875                         if (reversed)
 876                                 mode->c_oflag = (mode->c_oflag & ~TABDLY) | TAB3;
 877                         else
 878                                 mode->c_oflag = (mode->c_oflag & ~TABDLY) | TAB0;
 879                 }
 880 #else
 881 # ifdef OXTABS
 882                 else if (info->name == stty_tabs) {
 883                         if (reversed)
 884                                 mode->c_oflag = mode->c_oflag | OXTABS;
 885                         else
 886                                 mode->c_oflag = mode->c_oflag & ~OXTABS;
 887                 }
 888 # endif
 889 #endif
 890 #if defined(XCASE) && defined(IUCLC) && defined(OLCUC)
 891                 else if (info->name == stty_lcase || info->name == stty_LCASE) {
 892                         if (reversed) {
 893                                 mode->c_lflag &= ~XCASE;
 894                                 mode->c_iflag &= ~IUCLC;
 895                                 mode->c_oflag &= ~OLCUC;
 896                         } else {
 897                                 mode->c_lflag |= XCASE;
 898                                 mode->c_iflag |= IUCLC;
 899                                 mode->c_oflag |= OLCUC;
 900                         }
 901                 }
 902 #endif
 903                 else if (info->name == stty_crt)
 904                         mode->c_lflag |= ECHOE
 905 #ifdef ECHOCTL
 906                                 | ECHOCTL
 907 #endif
 908 #ifdef ECHOKE
 909                                 | ECHOKE
 910 #endif
 911                                 ;
 912                 else if (info->name == stty_dec) {
 913                         mode->c_cc[VINTR] = 3;  /* ^C */
 914                         mode->c_cc[VERASE] = 127;       /* DEL */
 915                         mode->c_cc[VKILL] = 21; /* ^U */
 916                         mode->c_lflag |= ECHOE
 917 #ifdef ECHOCTL
 918                                 | ECHOCTL
 919 #endif
 920 #ifdef ECHOKE
 921                                 | ECHOKE
 922 #endif
 923                                 ;
 924 #ifdef IXANY
 925                         mode->c_iflag &= ~IXANY;
 926 #endif
 927                 }
 928         } else if (reversed)
 929                 *bitsp = *bitsp & ~((unsigned long)info->mask) & ~info->bits;
 930         else
 931                 *bitsp = (*bitsp & ~((unsigned long)info->mask)) | info->bits;
 932 }
 933
 934 static void
 935 set_control_char(const struct control_info *info, const char *arg,
 936                                  struct termios *mode)
 937 {
 938         unsigned char value;
 939
 940         if (info->name == stty_min || info->name == stty_time)
 941                 value = bb_xparse_number(arg, stty_suffixes);
 942         else if (arg[0] == '\0' || arg[1] == '\0')
 943                 value = arg[0];
 944         else if (streq(arg, "^-") || streq(arg, "undef"))
 945                 value = _POSIX_VDISABLE;
 946         else if (arg[0] == '^' && arg[1] != '\0') {     /* Ignore any trailing junk */
 947                 if (arg[1] == '?')
 948                         value = 127;
 949                 else
 950                         value = arg[1] & ~0140; /* Non-letters get weird results */
 951         } else
 952                 value = bb_xparse_number(arg, stty_suffixes);
 953         mode->c_cc[info->offset] = value;
 954 }
 955
 956 static void
 957 set_speed(enum speed_setting type, const char *arg, struct termios *mode)
 958 {
 959         speed_t baud;
 960
 961         baud = string_to_baud(arg);
 962
 963         if (type != output_speed) {     /* either input or both */
 964                 cfsetispeed(mode, baud);
 965         }
 966         if (type != input_speed) {      /* either output or both */
 967                 cfsetospeed(mode, baud);
 968         }
 969 }
 970
 971 #ifdef TIOCGWINSZ
 972
 973 static int get_win_size(int fd, struct winsize *win)
 974 {
 975         return ioctl(fd, TIOCGWINSZ, (char *) win);
 976 }
 977
 978 static void
 979 set_window_size(int rows, int cols)
 980 {
 981         struct winsize win;
 982
 983         if (get_win_size(STDIN_FILENO, &win)) {
 984                 if (errno != EINVAL)
 985                         perror_on_device("%s");
 986                 memset(&win, 0, sizeof(win));
 987         }
 988
 989         if (rows >= 0)
 990                 win.ws_row = rows;
 991         if (cols >= 0)
 992                 win.ws_col = cols;
 993
 994 # ifdef TIOCSSIZE
 995         /* Alexander Dupuy <dupuy@cs.columbia.edu> wrote:
 996            The following code deals with a bug in the SunOS 4.x (and 3.x?) kernel.
 997            This comment from sys/ttold.h describes Sun's twisted logic - a better
 998            test would have been (ts_lines > 64k || ts_cols > 64k || ts_cols == 0).
 999            At any rate, the problem is gone in Solaris 2.x */
1000
1001         if (win.ws_row == 0 || win.ws_col == 0) {
1002                 struct ttysize ttysz;
1003
1004                 ttysz.ts_lines = win.ws_row;
1005                 ttysz.ts_cols = win.ws_col;
1006
1007                 win.ws_row = win.ws_col = 1;
1008
1009                 if ((ioctl(STDIN_FILENO, TIOCSWINSZ, (char *) &win) != 0)
1010                         || (ioctl(STDIN_FILENO, TIOCSSIZE, (char *) &ttysz) != 0)) {
1011                         perror_on_device("%s");
1012                 }
1013                 return;
1014         }
1015 # endif
1016
1017         if (ioctl(STDIN_FILENO, TIOCSWINSZ, (char *) &win))
1018                 perror_on_device("%s");
1019 }
1020
1021 static void display_window_size(int fancy)
1022 {
1023         const char *fmt_str = "%s" "\0" "%s: no size information for this device";
1024         struct winsize win;
1025
1026         if (get_win_size(STDIN_FILENO, &win)) {
1027                 if ((errno != EINVAL) || ((fmt_str += 2), !fancy)) {
1028                         perror_on_device(fmt_str);
1029                 }
1030         } else {
1031                 wrapf(fancy ? "rows %d; columns %d;" : "%d %d\n",
1032                           win.ws_row, win.ws_col);
1033         }
1034 }
1035 #endif
1036
1037 static int screen_columns(void)
1038 {
1039         int columns;
1040         const char *s;
1041
1042 #ifdef TIOCGWINSZ
1043         struct winsize win;
1044
1045         /* With Solaris 2.[123], this ioctl fails and errno is set to
1046            EINVAL for telnet (but not rlogin) sessions.
1047            On ISC 3.0, it fails for the console and the serial port
1048            (but it works for ptys).
1049            It can also fail on any system when stdout isn't a tty.
1050            In case of any failure, just use the default */
1051         if (get_win_size(STDOUT_FILENO, &win) == 0 && win.ws_col > 0)
1052                 return win.ws_col;
1053 #endif
1054
1055         columns = 80;
1056         if ((s = getenv("COLUMNS"))) {
1057                 columns = atoi(s);
1058         }
1059         return columns;
1060 }
1061
1062 static tcflag_t *mode_type_flag(enum mode_type type, const struct termios *mode)
1063 {
1064         static const unsigned char tcflag_offsets[] = {
1065                 offsetof(struct termios, c_cflag), /* control */
1066                 offsetof(struct termios, c_iflag), /* input */
1067                 offsetof(struct termios, c_oflag), /* output */
1068                 offsetof(struct termios, c_lflag) /* local */
1069         };
1070
1071         if (((unsigned int) type) <= local) {
1072                 return (tcflag_t *)(((char *) mode) + tcflag_offsets[(int)type]);
1073         }
1074         return NULL;
1075 }
1076
1077 static void display_changed(const struct termios *mode)
1078 {
1079         int i;
1080         tcflag_t *bitsp;
1081         unsigned long mask;
1082         enum mode_type prev_type = control;
1083
1084         display_speed(mode, 1);
1085 #ifdef HAVE_C_LINE
1086         wrapf("line = %d;\n", mode->c_line);
1087 #else
1088         wrapf("\n");
1089 #endif
1090
1091         for (i = 0; control_info[i].name != stty_min; ++i) {
1092                 if (mode->c_cc[control_info[i].offset] == control_info[i].saneval)
1093                         continue;
1094                 /* If swtch is the same as susp, don't print both */
1095 #if VSWTCH == VSUSP
1096                 if (control_info[i].name == stty_swtch)
1097                         continue;
1098 #endif
1099                 /* If eof uses the same slot as min, only print whichever applies */
1100 #if VEOF == VMIN
1101                 if ((mode->c_lflag & ICANON) == 0
1102                         && (control_info[i].name == stty_eof
1103                                 || control_info[i].name == stty_eol)) continue;
1104 #endif
1105                 wrapf("%s = %s;", control_info[i].name,
1106                           visible(mode->c_cc[control_info[i].offset]));
1107         }
1108         if ((mode->c_lflag & ICANON) == 0) {
1109                 wrapf("min = %d; time = %d;", (int) mode->c_cc[VMIN],
1110                           (int) mode->c_cc[VTIME]);
1111         }
1112         if (current_col) wrapf("\n");
1113
1114         for (i = 0; i < NUM_mode_info; ++i) {
1115                 if (mode_info[i].flags & OMIT)
1116                         continue;
1117                 if (EMT(mode_info[i].type) != prev_type) {
1118                         if (current_col) wrapf("\n");
1119                         prev_type = EMT(mode_info[i].type);
1120                 }
1121
1122                 bitsp = mode_type_flag(EMT(mode_info[i].type), mode);
1123                 mask = mode_info[i].mask ? mode_info[i].mask : mode_info[i].bits;
1124                 if ((*bitsp & mask) == mode_info[i].bits) {
1125                         if (mode_info[i].flags & SANE_UNSET) {
1126                                 wrapf("%s", mode_info[i].name);
1127                         }
1128                 } else if ((mode_info[i].flags & (SANE_SET | REV)) == (SANE_SET | REV)) {
1129                         wrapf("-%s", mode_info[i].name);
1130                 }
1131         }
1132         if (current_col) wrapf("\n");
1133 }
1134
1135 static void
1136 display_all(const struct termios *mode)
1137 {
1138         int i;
1139         tcflag_t *bitsp;
1140         unsigned long mask;
1141         enum mode_type prev_type = control;
1142
1143         display_speed(mode, 1);
1144 #ifdef TIOCGWINSZ
1145         display_window_size(1);
1146 #endif
1147 #ifdef HAVE_C_LINE
1148         wrapf("line = %d;\n", mode->c_line);
1149 #else
1150         wrapf("\n");
1151 #endif
1152
1153         for (i = 0; control_info[i].name != stty_min; ++i) {
1154                 /* If swtch is the same as susp, don't print both */
1155 #if VSWTCH == VSUSP
1156                 if (control_info[i].name == stty_swtch)
1157                         continue;
1158 #endif
1159                 /* If eof uses the same slot as min, only print whichever applies */
1160 #if VEOF == VMIN
1161                 if ((mode->c_lflag & ICANON) == 0
1162                         && (control_info[i].name == stty_eof
1163                                 || control_info[i].name == stty_eol)) continue;
1164 #endif
1165                 wrapf("%s = %s;", control_info[i].name,
1166                           visible(mode->c_cc[control_info[i].offset]));
1167         }
1168 #if VEOF == VMIN
1169         if ((mode->c_lflag & ICANON) == 0)
1170 #endif
1171                 wrapf("min = %d; time = %d;", mode->c_cc[VMIN], mode->c_cc[VTIME]);
1172         if (current_col) wrapf("\n");
1173
1174         for (i = 0; i < NUM_mode_info; ++i) {
1175                 if (mode_info[i].flags & OMIT)
1176                         continue;
1177                 if (EMT(mode_info[i].type) != prev_type) {
1178                         putchar('\n');
1179                         current_col = 0;
1180                         prev_type = EMT(mode_info[i].type);
1181                 }
1182
1183                 bitsp = mode_type_flag(EMT(mode_info[i].type), mode);
1184                 mask = mode_info[i].mask ? mode_info[i].mask : mode_info[i].bits;
1185                 if ((*bitsp & mask) == mode_info[i].bits)
1186                         wrapf("%s", mode_info[i].name);
1187                 else if (mode_info[i].flags & REV)
1188                         wrapf("-%s", mode_info[i].name);
1189         }
1190         if (current_col) wrapf("\n");
1191 }
1192
1193 static void display_speed(const struct termios *mode, int fancy)
1194 {
1195                              //12345678 9 10
1196         const char *fmt_str = "%lu %lu\n\0ispeed %lu baud; ospeed %lu baud;";
1197         unsigned long ispeed, ospeed;
1198
1199         ospeed = ispeed = cfgetispeed(mode);
1200         if (ispeed == 0 || ispeed == (ospeed = cfgetospeed(mode))) {
1201                 ispeed = ospeed;                /* in case ispeed was 0 */
1202                          //1234 5 6 7 8 9 10
1203                 fmt_str = "%lu\n\0\0\0\0\0speed %lu baud;";
1204         }
1205         if (fancy) fmt_str += 9;
1206         wrapf(fmt_str, tty_baud_to_value(ispeed), tty_baud_to_value(ospeed));
1207 }
1208
1209 static void display_recoverable(const struct termios *mode)
1210 {
1211         int i;
1212
1213         printf("%lx:%lx:%lx:%lx",
1214                    (unsigned long) mode->c_iflag, (unsigned long) mode->c_oflag,
1215                    (unsigned long) mode->c_cflag, (unsigned long) mode->c_lflag);
1216         for (i = 0; i < NCCS; ++i)
1217                 printf(":%x", (unsigned int) mode->c_cc[i]);
1218         putchar('\n');
1219 }
1220
1221 static int recover_mode(const char *arg, struct termios *mode)
1222 {
1223         int i, n;
1224         unsigned int chr;
1225         unsigned long iflag, oflag, cflag, lflag;
1226
1227         /* Scan into temporaries since it is too much trouble to figure out
1228            the right format for `tcflag_t' */
1229         if (sscanf(arg, "%lx:%lx:%lx:%lx%n",
1230                            &iflag, &oflag, &cflag, &lflag, &n) != 4)
1231                 return 0;
1232         mode->c_iflag = iflag;
1233         mode->c_oflag = oflag;
1234         mode->c_cflag = cflag;
1235         mode->c_lflag = lflag;
1236         arg += n;
1237         for (i = 0; i < NCCS; ++i) {
1238                 if (sscanf(arg, ":%x%n", &chr, &n) != 1)
1239                         return 0;
1240                 mode->c_cc[i] = chr;
1241                 arg += n;
1242         }
1243
1244         /* Fail if there are too many fields */
1245         if (*arg != '\0')
1246                 return 0;
1247
1248         return 1;
1249 }
1250
1251 static speed_t string_to_baud(const char *arg)
1252 {
1253         return tty_value_to_baud(bb_xparse_number(arg, 0));
1254 }
1255
1256 static void sane_mode(struct termios *mode)
1257 {
1258         int i;
1259         tcflag_t *bitsp;
1260
1261         for (i = 0; i < NUM_control_info; ++i) {
1262 #if VMIN == VEOF
1263                 if (control_info[i].name == stty_min)
1264                         break;
1265 #endif
1266                 mode->c_cc[control_info[i].offset] = control_info[i].saneval;
1267         }
1268
1269         for (i = 0; i < NUM_mode_info; ++i) {
1270                 if (mode_info[i].flags & SANE_SET) {
1271                         bitsp = mode_type_flag(EMT(mode_info[i].type), mode);
1272                         *bitsp = (*bitsp & ~((unsigned long)mode_info[i].mask))
1273                                 | mode_info[i].bits;
1274                 } else if (mode_info[i].flags & SANE_UNSET) {
1275                         bitsp = mode_type_flag(EMT(mode_info[i].type), mode);
1276                         *bitsp = *bitsp & ~((unsigned long)mode_info[i].mask)
1277                                 & ~mode_info[i].bits;
1278                 }
1279         }
1280 }
1281
1282 /* Return a string that is the printable representation of character CH */
1283 /* Adapted from `cat' by Torbjorn Granlund */
1284
1285 static const char *visible(unsigned int ch)
1286 {
1287         static char buf[10];
1288         char *bpout = buf;
1289
1290         if (ch == _POSIX_VDISABLE) {
1291                 return "<undef>";
1292         }
1293
1294         if (ch >= 128) {
1295                 ch -= 128;
1296                 *bpout++ = 'M';
1297                 *bpout++ = '-';
1298         }
1299
1300         if (ch < 32) {
1301                 *bpout++ = '^';
1302                 *bpout++ = ch + 64;
1303         } else if (ch < 127) {
1304                 *bpout++ = ch;
1305         } else {
1306                 *bpout++ = '^';
1307                 *bpout++ = '?';
1308         }
1309
1310         *bpout = '\0';
1311         return buf;
1312 }