1/* stty.c - Get/set terminal configuration. 2 * 3 * Copyright 2017 The Android Open Source Project. 4 * 5 * See http://pubs.opengroup.org/onlinepubs/9699919799/utilities/stty.html 6 7USE_STTY(NEWTOY(stty, "?aF:g[!ag]", TOYFLAG_BIN)) 8 9config STTY 10 bool "stty" 11 default n 12 help 13 usage: stty [-ag] [-F device] SETTING... 14 15 Get/set terminal configuration. 16 17 -F Open device instead of stdin 18 -a Show all current settings (default differences from "sane") 19 -g Show all current settings usable as input to stty 20 21 Special characters (syntax ^c or undef): intr quit erase kill eof eol eol2 22 swtch start stop susp rprnt werase lnext discard 23 24 Control/input/output/local settings as shown by -a, '-' prefix to disable 25 26 Combo settings: cooked/raw, evenp/oddp/parity, nl, ek, sane 27 28 N set input and output speed (ispeed N or ospeed N for just one) 29 cols N set number of columns 30 rows N set number of rows 31 line N set line discipline 32 min N set minimum chars per read 33 time N set read timeout 34 speed show speed only 35 size show size only 36*/ 37 38#define FOR_stty 39#include "toys.h" 40 41#include <linux/tty.h> 42 43GLOBALS( 44 char *device; 45 46 int fd, col; 47 unsigned output_cols; 48) 49 50static const int bauds[] = { 51 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 9600, 52 19200, 38400, 57600, 115200, 230400, 460800, 500000, 576000, 921600, 53 1000000, 1152000, 1500000, 2000000, 2500000, 3000000, 3500000, 4000000 54}; 55 56static int baud(speed_t speed) 57{ 58 if (speed&CBAUDEX) speed=(speed&~CBAUDEX)+15; 59 return bauds[speed]; 60} 61 62static speed_t speed(int baud) 63{ 64 int i; 65 66 for (i=0;i<ARRAY_LEN(bauds);i++) if (bauds[i] == baud) break; 67 if (i == ARRAY_LEN(bauds)) error_exit("unknown speed: %d", baud); 68 return i+4081*(i>16); 69} 70 71struct flag { 72 char *name; 73 int value; 74 int mask; 75}; 76 77static const struct flag chars[] = { 78 { "intr", VINTR }, { "quit", VQUIT }, { "erase", VERASE }, { "kill", VKILL }, 79 { "eof", VEOF }, { "eol", VEOL }, { "eol2", VEOL2 }, { "swtch", VSWTC }, 80 { "start", VSTART }, { "stop", VSTOP }, { "susp", VSUSP }, 81 { "rprnt", VREPRINT }, { "werase", VWERASE }, { "lnext", VLNEXT }, 82 { "discard", VDISCARD }, { "min", VMIN }, { "time", VTIME }, 83}; 84 85static const struct flag cflags[] = { 86 { "parenb", PARENB }, { "parodd", PARODD }, { "cmspar", CMSPAR }, 87 { "cs5", CS5, CSIZE }, { "cs6", CS6, CSIZE }, { "cs7", CS7, CSIZE }, 88 { "cs8", CS8, CSIZE }, { "hupcl", HUPCL }, { "cstopb", CSTOPB }, 89 { "cread", CREAD }, { "clocal", CLOCAL }, { "crtscts", CRTSCTS }, 90}; 91 92static const struct flag iflags[] = { 93 { "ignbrk", IGNBRK }, { "brkint", BRKINT }, { "ignpar", IGNPAR }, 94 { "parmrk", PARMRK }, { "inpck", INPCK }, { "istrip", ISTRIP }, 95 { "inlcr", INLCR }, { "igncr", IGNCR }, { "icrnl", ICRNL }, { "ixon", IXON }, 96 { "ixoff", IXOFF }, { "iuclc", IUCLC }, { "ixany", IXANY }, 97 { "imaxbel", IMAXBEL }, { "iutf8", IUTF8 }, 98}; 99 100static const struct flag oflags[] = { 101 { "opost", OPOST }, { "olcuc", OLCUC }, { "ocrnl", OCRNL }, 102 { "onlcr", ONLCR }, { "onocr", ONOCR }, { "onlret", ONLRET }, 103 { "ofill", OFILL }, { "ofdel", OFDEL }, { "nl0", NL0, NLDLY }, 104 { "nl1", NL1, NLDLY }, { "cr0", CR0, CRDLY }, { "cr1", CR1, CRDLY }, 105 { "cr2", CR2, CRDLY }, { "cr3", CR3, CRDLY }, { "tab0", TAB0, TABDLY }, 106 { "tab1", TAB1, TABDLY }, { "tab2", TAB2, TABDLY }, { "tab3", TAB3, TABDLY }, 107 { "bs0", BS0, BSDLY }, { "bs1", BS1, BSDLY }, { "vt0", VT0, VTDLY }, 108 { "vt1", VT1, VTDLY }, { "ff0", FF0, FFDLY }, { "ff1", FF1, FFDLY }, 109}; 110 111static const struct flag lflags[] = { 112 { "isig", ISIG }, { "icanon", ICANON }, { "iexten", IEXTEN }, 113 { "echo", ECHO }, { "echoe", ECHOE }, { "echok", ECHOK }, 114 { "echonl", ECHONL }, { "noflsh", NOFLSH }, { "xcase", XCASE }, 115 { "tostop", TOSTOP }, { "echoprt", ECHOPRT }, { "echoctl", ECHOCTL }, 116 { "echoke", ECHOKE }, { "flusho", FLUSHO }, { "extproc", EXTPROC }, 117}; 118 119static const struct synonym { 120 char *from; 121 char *to; 122} synonyms[] = { 123 { "cbreak", "-icanon" }, { "-cbreak", "icanon" }, { "-cooked", "raw" }, 124 { "crterase", "echoe" }, { "-crterase", "-echoe" }, { "crtkill", "echoke" }, 125 { "-crtkill", "-echoke" }, { "ctlecho", "echoctl" }, { "-tandem", "-ixoff" }, 126 { "-ctlecho", "-echoctl" }, { "hup", "hupcl" }, { "-hup", "-hupcl" }, 127 { "prterase", "echoprt" }, { "-prterase", "-echoprt" }, { "-raw", "cooked" }, 128 { "tabs", "tab0" }, { "-tabs", "tab3" }, { "tandem", "ixoff" }, 129}; 130 131static void out(const char *fmt, ...) 132{ 133 va_list va; 134 int len; 135 char *prefix = " "; 136 137 va_start(va, fmt); 138 len = vsnprintf(toybuf, sizeof(toybuf), fmt, va); 139 va_end(va); 140 141 if (TT.output_cols == 0) { 142 TT.output_cols = 80; 143 terminal_size(&TT.output_cols, NULL); 144 } 145 146 if (TT.col == 0 || *fmt == '\n') prefix = ""; 147 else if (TT.col + 1 + len >= TT.output_cols) { 148 prefix = "\n"; 149 TT.col = 0; 150 } 151 xprintf("%s%s", prefix, toybuf); 152 153 if (toybuf[len-1] == '\n') TT.col = 0; 154 else TT.col += strlen(prefix) + len; 155} 156 157static void show_flags(tcflag_t actual, tcflag_t sane, 158 const struct flag *flags, int len) 159{ 160 int i, j, value, mask; 161 162 // Implement -a by ensuring that sane != actual so we'll show everything. 163 if (toys.optflags&FLAG_a) sane = ~actual; 164 165 for (i=j=0;i<len;i++) { 166 value = flags[i].value; 167 if ((mask = flags[i].mask)) { 168 if ((actual&mask)==value && (sane&mask)!=value) { 169 out("%s", flags[i].name); 170 j++; 171 } 172 } else { 173 if ((actual&value) != (sane&value)) { 174 out("%s%s", actual&value?"":"-", flags[i].name); 175 j++; 176 } 177 } 178 } 179 if (j) out("\n"); 180} 181 182static void show_size(int verbose) 183{ 184 struct winsize ws; 185 186 if (ioctl(TT.fd, TIOCGWINSZ, &ws)) perror_exit("TIOCGWINSZ %s", TT.device); 187 out(verbose ? "rows %d; columns %d;" : "%d %d\n", ws.ws_row, ws.ws_col); 188} 189 190static void show_speed(struct termios *t, int verbose) 191{ 192 int ispeed = baud(cfgetispeed(t)), ospeed = baud(cfgetospeed(t)); 193 char *fmt = verbose ? "ispeed %d baud; ospeed %d baud;" : "%d %d\n"; 194 195 if (ispeed == ospeed) fmt += (verbose ? 17 : 3); 196 out(fmt, ispeed, ospeed); 197} 198 199static int get_arg(int *i, long long low, long long high) 200{ 201 (*i)++; 202 if (!toys.optargs[*i]) error_exit("missing arg"); 203 return atolx_range(toys.optargs[*i], low, high); 204} 205 206static int set_flag(tcflag_t *f, const struct flag *flags, int len, 207 char *name, int on) 208{ 209 int i; 210 211 for (i=0;i<len;i++) { 212 if (!strcmp(flags[i].name, name)) { 213 if (on) { 214 *f &= ~flags[i].mask; 215 *f |= flags[i].value; 216 } else { 217 if (flags[i].mask) error_exit("%s isn't a boolean", name); 218 *f &= ~flags[i].value; 219 } 220 return 1; 221 } 222 } 223 return 0; 224} 225 226static void set_option(struct termios *new, char *option) 227{ 228 int on = (*option != '-'); 229 230 if (!on) option++; 231 if (!set_flag(&new->c_cflag, cflags, ARRAY_LEN(cflags), option, on) && 232 !set_flag(&new->c_iflag, iflags, ARRAY_LEN(iflags), option, on) && 233 !set_flag(&new->c_oflag, oflags, ARRAY_LEN(oflags), option, on) && 234 !set_flag(&new->c_lflag, lflags, ARRAY_LEN(lflags), option, on)) 235 error_exit("unknown option: %s", option); 236} 237 238static void set_options(struct termios* new, ...) 239{ 240 va_list va; 241 char *option; 242 243 va_start(va, new); 244 while ((option = va_arg(va, char *))) set_option(new, option); 245 va_end(va); 246} 247 248static void set_size(int is_rows, unsigned short value) 249{ 250 struct winsize ws; 251 252 if (ioctl(TT.fd, TIOCGWINSZ, &ws)) perror_exit("TIOCGWINSZ %s", TT.device); 253 if (is_rows) ws.ws_row = value; 254 else ws.ws_col = value; 255 if (ioctl(TT.fd, TIOCSWINSZ, &ws)) perror_exit("TIOCSWINSZ %s", TT.device); 256} 257 258static int set_special_character(struct termios *new, int *i, char *char_name) 259{ 260 int j; 261 262 // The -2 is to ignore VMIN and VTIME, which are just unsigned integers. 263 for (j=0;j<ARRAY_LEN(chars)-2;j++) { 264 if (!strcmp(chars[j].name, char_name)) { 265 char *arg = toys.optargs[++(*i)]; 266 cc_t ch; 267 268 if (!arg) error_exit("missing arg"); 269 if (!strcmp(arg, "^-") || !strcmp(arg, "undef")) ch = _POSIX_VDISABLE; 270 else if (!strcmp(arg, "^?")) ch = 0x7f; 271 else if (arg[0] == '^' && arg[2] == 0) ch = (toupper(arg[1])-'@'); 272 else if (!arg[1]) ch = arg[0]; 273 else error_exit("invalid arg: %s", arg); 274 xprintf("setting %s to %s (%02x)\n", char_name, arg, ch); 275 new->c_cc[chars[j].value] = ch; 276 return 1; 277 } 278 } 279 return 0; 280} 281 282static void make_sane(struct termios *t) 283{ 284 // POSIX has no opinion about what "sane" means. From "man stty". 285 // "cs8" is missing from the man page, but needed to get identical results. 286 set_options(t, "cread", "-ignbrk", "brkint", "-inlcr", "-igncr", "icrnl", 287 "icanon", "iexten", "echo", "echoe", "echok", "-echonl", "-noflsh", 288 "-ixoff", "-iutf8", "-iuclc", "-ixany", "imaxbel", "-xcase", "-olcuc", 289 "-ocrnl", "opost", "-ofill", "onlcr", "-onocr", "-onlret", "nl0", "cr0", 290 "tab0", "bs0", "vt0", "ff0", "isig", "-tostop", "-ofdel", "-echoprt", 291 "echoctl", "echoke", "-extproc", "-flusho", "cs8", NULL); 292 memset(t->c_cc, 0, NCCS); 293 t->c_cc[VINTR] = 0x3; 294 t->c_cc[VQUIT] = 0x1c; 295 t->c_cc[VERASE] = 0x7f; 296 t->c_cc[VKILL] = 0x15; 297 t->c_cc[VEOF] = 0x4; 298 t->c_cc[VTIME] = 0; 299 t->c_cc[VMIN] = 1; 300 t->c_cc[VSWTC] = 0; 301 t->c_cc[VSTART] = 0x11; 302 t->c_cc[VSTOP] = 0x13; 303 t->c_cc[VSUSP] = 0x1a; 304 t->c_cc[VEOL] = 0; 305 t->c_cc[VREPRINT] = 0x12; 306 t->c_cc[VDISCARD] = 0xf; 307 t->c_cc[VWERASE] = 0x17; 308 t->c_cc[VLNEXT] = 0x16; 309 t->c_cc[VEOL2] = 0; 310} 311 312static void xtcgetattr(struct termios *t) 313{ 314 if (tcgetattr(TT.fd, t)) perror_exit("tcgetattr %s", TT.device); 315} 316 317static void do_stty() 318{ 319 struct termios old, sane; 320 int i, j, n; 321 322 xtcgetattr(&old); 323 324 if (*toys.optargs) { 325 struct termios new = old; 326 327 for (i=0; toys.optargs[i]; i++) { 328 char *arg = toys.optargs[i]; 329 330 if (!strcmp(arg, "size")) show_size(0); 331 else if (!strcmp(arg, "speed")) show_speed(&old, 0); 332 else if (!strcmp(arg, "line")) new.c_line = get_arg(&i, N_TTY, NR_LDISCS); 333 else if (!strcmp(arg, "min")) new.c_cc[VMIN] = get_arg(&i, 0, 255); 334 else if (!strcmp(arg, "time")) new.c_cc[VTIME] = get_arg(&i, 0, 255); 335 else if (atoi(arg) > 0) { 336 int new_speed = speed(atolx_range(arg, 0, 4000000)); 337 338 cfsetispeed(&new, new_speed); 339 cfsetospeed(&new, new_speed); 340 } else if (!strcmp(arg, "ispeed")) 341 cfsetispeed(&new, speed(get_arg(&i, 0, 4000000))); 342 else if (!strcmp(arg, "ospeed")) 343 cfsetospeed(&new, speed(get_arg(&i, 0, 4000000))); 344 else if (!strcmp(arg, "rows")) set_size(1, get_arg(&i, 0, USHRT_MAX)); 345 else if (!strcmp(arg, "cols") || !strcmp(arg, "columns")) 346 set_size(0, get_arg(&i, 0, USHRT_MAX)); 347 else if (sscanf(arg, "%x:%x:%x:%x:%n", &new.c_iflag, &new.c_oflag, 348 &new.c_cflag, &new.c_lflag, &n) == 4) 349 { 350 int value; 351 352 arg += n; 353 for (j=0;j<NCCS;j++) { 354 if (sscanf(arg, "%x%n", &value, &n) != 1) error_exit("bad -g string"); 355 new.c_cc[j] = value; 356 arg += n+1; 357 } 358 } else if (set_special_character(&new, &i, arg)); 359 // Already done as a side effect. 360 else if (!strcmp(arg, "cooked")) 361 set_options(&new, "brkint", "ignpar", "istrip", "icrnl", "ixon", 362 "opost", "isig", "icanon", NULL); 363 else if (!strcmp(arg, "evenp") || !strcmp(arg, "parity")) 364 set_options(&new, "parenb", "cs7", "-parodd", NULL); 365 else if (!strcmp(arg, "oddp")) 366 set_options(&new, "parenb", "cs7", "parodd", NULL); 367 else if (!strcmp(arg, "-parity") || !strcmp(arg, "-evenp") || 368 !strcmp(arg, "-oddp")) { 369 set_options(&new, "-parenb", "cs8", NULL); 370 } else if (!strcmp(arg, "raw")) { 371 // POSIX and "man stty" differ wildly. This is "man stty". 372 set_options(&new, "-ignbrk", "-brkint", "-ignpar", "-parmrk", "-inpck", 373 "-istrip", "-inlcr", "-igncr", "-icrnl", "-ixon", "-ixoff", "-iuclc", 374 "-ixany", "-imaxbel", "-opost", "-isig", "-icanon", "-xcase", NULL); 375 new.c_cc[VMIN] = 1; 376 new.c_cc[VTIME] = 0; 377 } else if (!strcmp(arg, "nl")) 378 set_options(&new, "-icrnl", "-ocrnl", NULL); 379 else if (!strcmp(arg, "-nl")) 380 set_options(&new, "icrnl", "ocrnl", "-inlcr", "-igncr", NULL); 381 else if (!strcmp(arg, "ek")) { 382 new.c_cc[VERASE] = 0x7f; 383 new.c_cc[VKILL] = 0x15; 384 } else if (!strcmp(arg, "sane")) make_sane(&new); 385 else { 386 // Translate historical cruft into canonical forms. 387 for (j=0;j<ARRAY_LEN(synonyms);j++) { 388 if (!strcmp(synonyms[j].from, arg)) { 389 arg = synonyms[j].to; 390 break; 391 } 392 } 393 set_option(&new, arg); 394 } 395 } 396 tcsetattr(TT.fd, TCSAFLUSH, &new); 397 xtcgetattr(&old); 398 if (memcmp(&old, &new, sizeof(old))) 399 error_exit("unable to perform all requested operations on %s", TT.device); 400 401 return; 402 } 403 404 if (toys.optflags&FLAG_g) { 405 xprintf("%x:%x:%x:%x:", old.c_iflag, old.c_oflag, old.c_cflag, old.c_lflag); 406 for (i=0;i<NCCS;i++) xprintf("%x%c", old.c_cc[i], i==NCCS-1?'\n':':'); 407 return; 408 } 409 410 // Without arguments, "stty" only shows the speed, the line discipline, 411 // special characters and any flags that differ from the "sane" settings. 412 make_sane(&sane); 413 show_speed(&old, 1); 414 if (toys.optflags&FLAG_a) show_size(1); 415 out("line = %d;\n", old.c_line); 416 417 for (i=j=0;i<ARRAY_LEN(chars);i++) { 418 char vis[16] = {}; 419 cc_t ch = old.c_cc[chars[i].value]; 420 421 if (ch == sane.c_cc[chars[i].value] && (toys.optflags&FLAG_a)==0) 422 continue; 423 424 if (chars[i].value == VMIN || chars[i].value == VTIME) { 425 snprintf(vis, sizeof(vis), "%u", ch); 426 } else if (ch == _POSIX_VDISABLE) { 427 strcat(vis, "<undef>"); 428 } else { 429 if (ch > 0x7f) { 430 strcat(vis, "M-"); 431 ch -= 128; 432 } 433 if (ch < ' ') sprintf(vis+strlen(vis), "^%c", (ch+'@')); 434 else if (ch == 0x7f) strcat(vis, "^?"); 435 else sprintf(vis+strlen(vis), "%c", ch); 436 } 437 out("%s = %s;", chars[i].name, vis); 438 j++; 439 } 440 if (j) out("\n"); 441 442 show_flags(old.c_cflag, sane.c_cflag, cflags, ARRAY_LEN(cflags)); 443 show_flags(old.c_iflag, sane.c_iflag, iflags, ARRAY_LEN(iflags)); 444 show_flags(old.c_oflag, sane.c_oflag, oflags, ARRAY_LEN(oflags)); 445 show_flags(old.c_lflag, sane.c_lflag, lflags, ARRAY_LEN(lflags)); 446} 447 448void stty_main(void) 449{ 450 if (toys.optflags&(FLAG_a|FLAG_g) && *toys.optargs) 451 error_exit("can't make settings with -a/-g"); 452 453 if (!TT.device) TT.device = "standard input"; 454 else TT.fd=xopen(TT.device, (O_RDWR*!!*toys.optargs)|O_NOCTTY|O_NONBLOCK); 455 456 do_stty(); 457 458 if (CFG_TOYBOX_FREE && TT.device) close(TT.fd); 459} 460