aboutsummaryrefslogtreecommitdiff
path: root/toys/pending
diff options
context:
space:
mode:
Diffstat (limited to 'toys/pending')
-rw-r--r--toys/pending/stty.c528
1 files changed, 528 insertions, 0 deletions
diff --git a/toys/pending/stty.c b/toys/pending/stty.c
new file mode 100644
index 00000000..9ad353aa
--- /dev/null
+++ b/toys/pending/stty.c
@@ -0,0 +1,528 @@
+/* stty.c - Get/set terminal configuration.
+ *
+ * Copyright 2017 The Android Open Source Project.
+ *
+ * See http://pubs.opengroup.org/onlinepubs/9699919799/utilities/stty.html
+
+USE_STTY(NEWTOY(stty, "?aF:g[!ag]", TOYFLAG_BIN))
+
+config STTY
+ bool "stty"
+ default y
+ help
+ usage: stty [-ag] [-F device] SETTING...
+
+ Get/set terminal configuration.
+
+ -a Show all current settings (default differences from "sane").
+ -g Show all current settings usable as input to stty.
+
+ Special characters (syntax ^c or undef): intr quit erase kill eof eol eol2
+ swtch start stop susp rprnt werase lnext discard
+
+ Control/input/output/local settings as shown by -a, '-' prefix to disable
+
+ Combo settings: cooked/raw, evenp/oddp/parity, nl, ek, sane
+
+ N set input and output speed (ispeed N or ospeed N for just one)
+ cols N set number of columns
+ rows N set number of rows
+ line N set line discipline
+ min N set minimum chars per read
+ time N set read timeout
+ speed show speed only
+ size show size only
+*/
+
+#define FOR_stty
+#include "toys.h"
+
+#include <linux/tty.h>
+
+GLOBALS(
+ char *device;
+
+ int fd, col;
+ unsigned output_cols;
+)
+
+static const int bauds[] = {
+ 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 9600,
+ 19200, 38400, 57600, 115200, 230400, 460800, 500000, 576000, 921600,
+ 1000000, 1152000, 1500000, 2000000, 2500000, 3000000, 3500000, 4000000
+};
+
+static int baud(speed_t speed)
+{
+ if (speed&CBAUDEX) speed=(speed&~CBAUDEX)+15;
+ return bauds[speed];
+}
+
+static speed_t speed(int baud)
+{
+ int i;
+
+ for (i=0;i<ARRAY_LEN(bauds);i++) if (bauds[i] == baud) break;
+ if (i == ARRAY_LEN(bauds)) error_exit("unknown speed: %d", baud);
+ return i+4081*(i>16);
+}
+
+struct flag {
+ char *name;
+ int value;
+ int mask;
+};
+
+static const struct flag chars[] = {
+ { "intr", VINTR },
+ { "quit", VQUIT },
+ { "erase", VERASE },
+ { "kill", VKILL },
+ { "eof", VEOF },
+ { "eol", VEOL },
+ { "eol2", VEOL2 },
+ { "swtch", VSWTC },
+ { "start", VSTART },
+ { "stop", VSTOP },
+ { "susp", VSUSP },
+ { "rprnt", VREPRINT },
+ { "werase", VWERASE },
+ { "lnext", VLNEXT },
+ { "discard", VDISCARD },
+ { "min", VMIN },
+ { "time", VTIME },
+};
+
+static const struct flag cflags[] = {
+ { "parenb", PARENB },
+ { "parodd", PARODD },
+ { "cmspar", CMSPAR },
+ { "cs5", CS5, CSIZE },
+ { "cs6", CS6, CSIZE },
+ { "cs7", CS7, CSIZE },
+ { "cs8", CS8, CSIZE },
+ { "hupcl", HUPCL },
+ { "cstopb", CSTOPB },
+ { "cread", CREAD },
+ { "clocal", CLOCAL },
+ { "crtscts", CRTSCTS },
+};
+
+static const struct flag iflags[] = {
+ { "ignbrk", IGNBRK },
+ { "brkint", BRKINT },
+ { "ignpar", IGNPAR },
+ { "parmrk", PARMRK },
+ { "inpck", INPCK },
+ { "istrip", ISTRIP },
+ { "inlcr", INLCR },
+ { "igncr", IGNCR },
+ { "icrnl", ICRNL },
+ { "ixon", IXON },
+ { "ixoff", IXOFF },
+ { "iuclc", IUCLC },
+ { "ixany", IXANY },
+ { "imaxbel", IMAXBEL },
+ { "iutf8", IUTF8 },
+};
+
+static const struct flag oflags[] = {
+ { "opost", OPOST },
+ { "olcuc", OLCUC },
+ { "ocrnl", OCRNL },
+ { "onlcr", ONLCR },
+ { "onocr", ONOCR },
+ { "onlret", ONLRET },
+ { "ofill", OFILL },
+ { "ofdel", OFDEL },
+ { "nl0", NL0, NLDLY },
+ { "nl1", NL1, NLDLY },
+ { "cr0", CR0, CRDLY },
+ { "cr1", CR1, CRDLY },
+ { "cr2", CR2, CRDLY },
+ { "cr3", CR3, CRDLY },
+ { "tab0", TAB0, TABDLY },
+ { "tab1", TAB1, TABDLY },
+ { "tab2", TAB2, TABDLY },
+ { "tab3", TAB3, TABDLY },
+ { "bs0", BS0, BSDLY },
+ { "bs1", BS1, BSDLY },
+ { "vt0", VT0, VTDLY },
+ { "vt1", VT1, VTDLY },
+ { "ff0", FF0, FFDLY },
+ { "ff1", FF1, FFDLY },
+};
+
+static const struct flag lflags[] = {
+ { "isig", ISIG },
+ { "icanon", ICANON },
+ { "iexten", IEXTEN },
+ { "echo", ECHO },
+ { "echoe", ECHOE },
+ { "echok", ECHOK },
+ { "echonl", ECHONL },
+ { "noflsh", NOFLSH },
+ { "xcase", XCASE },
+ { "tostop", TOSTOP },
+ { "echoprt", ECHOPRT },
+ { "echoctl", ECHOCTL },
+ { "echoke", ECHOKE },
+ { "flusho", FLUSHO },
+ { "extproc", EXTPROC },
+};
+
+static const struct synonym {
+ char *from;
+ char *to;
+} synonyms[] = {
+ { "cbreak", "-icanon" },
+ { "-cbreak", "icanon" },
+ { "-cooked", "raw" },
+ { "crterase", "echoe" },
+ { "-crterase", "-echoe" },
+ { "crtkill", "echoke" },
+ { "-crtkill", "-echoke" },
+ { "ctlecho", "echoctl" },
+ { "-ctlecho", "-echoctl" },
+ { "hup", "hupcl" },
+ { "-hup", "-hupcl" },
+ { "prterase", "echoprt" },
+ { "-prterase", "-echoprt" },
+ { "-raw", "cooked" },
+ { "tabs", "tab0" },
+ { "-tabs", "tab3" },
+ { "tandem", "ixoff" },
+ { "-tandem", "-ixoff" },
+};
+
+static void out(const char *fmt, ...)
+{
+ va_list va;
+ int len;
+ char *prefix = " ";
+
+ va_start(va, fmt);
+ len = vsnprintf(toybuf, sizeof(toybuf), fmt, va);
+ va_end(va);
+
+ if (TT.output_cols == 0) {
+ TT.output_cols = 80;
+ terminal_size(&TT.output_cols, NULL);
+ }
+
+ if (TT.col == 0 || *fmt == '\n') prefix = "";
+ else if (TT.col + 1 + len >= TT.output_cols) {
+ prefix = "\n";
+ TT.col = 0;
+ }
+ xprintf("%s%s", prefix, toybuf);
+
+ if (toybuf[len-1] == '\n') TT.col = 0;
+ else TT.col += strlen(prefix) + len;
+}
+
+static void show_flags(tcflag_t actual, tcflag_t sane,
+ const struct flag *flags, int len)
+{
+ int i, j, value, mask;
+
+ // Implement -a by ensuring that sane != actual so we'll show everything.
+ if (toys.optflags&FLAG_a) sane = ~actual;
+
+ for (i=j=0;i<len;i++) {
+ value = flags[i].value;
+ if ((mask = flags[i].mask)) {
+ if ((actual&mask)==value && (sane&mask)!=value) {
+ out("%s", flags[i].name);
+ j++;
+ }
+ } else {
+ if ((actual&value) != (sane&value)) {
+ out("%s%s", actual&value?"":"-", flags[i].name);
+ j++;
+ }
+ }
+ }
+ if (j) out("\n");
+}
+
+static void show_size(int verbose)
+{
+ struct winsize ws;
+
+ if (ioctl(TT.fd, TIOCGWINSZ, &ws)) perror_exit("TIOCGWINSZ %s", TT.device);
+ out(verbose ? "rows %d; columns %d;" : "%d %d\n", ws.ws_row, ws.ws_col);
+}
+
+static void show_speed(struct termios *t, int verbose)
+{
+ int ispeed = baud(cfgetispeed(t)), ospeed = baud(cfgetospeed(t));
+ char *fmt = verbose ? "ispeed %d baud; ospeed %d baud;" : "%d %d\n";
+
+ if (ispeed == ospeed) fmt += (verbose ? 17 : 3);
+ out(fmt, ispeed, ospeed);
+}
+
+static int get_arg(int *i, long long low, long long high)
+{
+ (*i)++;
+ if (!toys.optargs[*i]) error_exit("missing arg");
+ return atolx_range(toys.optargs[*i], low, high);
+}
+
+static int set_flag(tcflag_t *f, const struct flag *flags, int len,
+ char *name, int on)
+{
+ int i;
+
+ for (i=0;i<len;i++) {
+ if (!strcmp(flags[i].name, name)) {
+ if (on) {
+ *f &= ~flags[i].mask;
+ *f |= flags[i].value;
+ } else {
+ if (flags[i].mask) error_exit("%s isn't a boolean", name);
+ *f &= ~flags[i].value;
+ }
+ return 1;
+ }
+ }
+ return 0;
+}
+
+static void set_option(struct termios *new, char *option)
+{
+ int on = (*option != '-');
+
+ if (!on) option++;
+ if (!set_flag(&new->c_cflag, cflags, ARRAY_LEN(cflags), option, on) &&
+ !set_flag(&new->c_iflag, iflags, ARRAY_LEN(iflags), option, on) &&
+ !set_flag(&new->c_oflag, oflags, ARRAY_LEN(oflags), option, on) &&
+ !set_flag(&new->c_lflag, lflags, ARRAY_LEN(lflags), option, on))
+ error_exit("unknown option: %s", option);
+}
+
+static void set_options(struct termios* new, ...)
+{
+ va_list va;
+ char *option;
+
+ va_start(va, new);
+ while ((option = va_arg(va, char *))) {
+ set_option(new, option);
+ }
+ va_end(va);
+}
+
+static void set_size(int is_rows, unsigned short value)
+{
+ struct winsize ws;
+
+ if (ioctl(TT.fd, TIOCGWINSZ, &ws)) perror_exit("TIOCGWINSZ %s", TT.device);
+ if (is_rows) ws.ws_row = value;
+ else ws.ws_col = value;
+ if (ioctl(TT.fd, TIOCSWINSZ, &ws)) perror_exit("TIOCSWINSZ %s", TT.device);
+}
+
+static int set_special_character(struct termios *new, int *i, char *char_name)
+{
+ int j;
+
+ // The -2 is to ignore VMIN and VTIME, which are just unsigned integers.
+ for (j=0;j<ARRAY_LEN(chars)-2;j++) {
+ if (!strcmp(chars[j].name, char_name)) {
+ char *arg = toys.optargs[++(*i)];
+ cc_t ch;
+
+ if (!arg) error_exit("missing arg");
+ if (!strcmp(arg, "^-") || !strcmp(arg, "undef")) ch = _POSIX_VDISABLE;
+ else if (!strcmp(arg, "^?")) ch = 0x7f;
+ else if (arg[0] == '^' && arg[2] == 0) ch = (toupper(arg[1])-'@');
+ else if (!arg[1]) ch = arg[0];
+ else error_exit("invalid arg: %s", arg);
+ xprintf("setting %s to %s (%02x)\n", char_name, arg, ch);
+ new->c_cc[chars[j].value] = ch;
+ return 1;
+ }
+ }
+ return 0;
+}
+
+static void make_sane(struct termios *t)
+{
+ // POSIX has no opinion about what "sane" means. From "man stty".
+ // "cs8" is missing from the man page, but needed to get identical results.
+ set_options(t, "cread", "-ignbrk", "brkint", "-inlcr", "-igncr", "icrnl",
+ "icanon", "iexten", "echo", "echoe", "echok", "-echonl", "-noflsh",
+ "-ixoff", "-iutf8", "-iuclc", "-ixany", "imaxbel", "-xcase", "-olcuc",
+ "-ocrnl", "opost", "-ofill", "onlcr", "-onocr", "-onlret", "nl0", "cr0",
+ "tab0", "bs0", "vt0", "ff0", "isig", "-tostop", "-ofdel", "-echoprt",
+ "echoctl", "echoke", "-extproc", "-flusho", "cs8", 0);
+ memset(t->c_cc, 0, NCCS);
+ t->c_cc[VINTR] = 0x3;
+ t->c_cc[VQUIT] = 0x1c;
+ t->c_cc[VERASE] = 0x7f;
+ t->c_cc[VKILL] = 0x15;
+ t->c_cc[VEOF] = 0x4;
+ t->c_cc[VTIME] = 0;
+ t->c_cc[VMIN] = 1;
+ t->c_cc[VSWTC] = 0;
+ t->c_cc[VSTART] = 0x11;
+ t->c_cc[VSTOP] = 0x13;
+ t->c_cc[VSUSP] = 0x1a;
+ t->c_cc[VEOL] = 0;
+ t->c_cc[VREPRINT] = 0x12;
+ t->c_cc[VDISCARD] = 0xf;
+ t->c_cc[VWERASE] = 0x17;
+ t->c_cc[VLNEXT] = 0x16;
+ t->c_cc[VEOL2] = 0;
+}
+
+static void do_stty()
+{
+ struct termios old, sane;
+ int i, j, n;
+
+ if (tcgetattr(TT.fd, &old)) perror_exit("tcgetattr %s", TT.device);
+
+ if (*toys.optargs) {
+ struct termios new = old;
+
+ for (i=0; toys.optargs[i]; i++) {
+ char *arg = toys.optargs[i];
+
+ if (!strcmp(arg, "size")) show_size(0);
+ else if (!strcmp(arg, "speed")) show_speed(&old, 0);
+ else if (!strcmp(arg, "line")) new.c_line = get_arg(&i, N_TTY, NR_LDISCS);
+ else if (!strcmp(arg, "min")) new.c_cc[VMIN] = get_arg(&i, 0, 255);
+ else if (!strcmp(arg, "time")) new.c_cc[VTIME] = get_arg(&i, 0, 255);
+ else if (atoi(arg) > 0) {
+ int new_speed = speed(atolx_range(arg, 0, 4000000));
+
+ cfsetispeed(&new, new_speed);
+ cfsetospeed(&new, new_speed);
+ } else if (!strcmp(arg, "ispeed")) {
+ cfsetispeed(&new, speed(get_arg(&i, 0, 4000000)));
+ } else if (!strcmp(arg, "ospeed")) {
+ cfsetospeed(&new, speed(get_arg(&i, 0, 4000000)));
+ } else if (!strcmp(arg, "rows")) {
+ set_size(1, get_arg(&i, 0, USHRT_MAX));
+ } else if (!strcmp(arg, "cols") || !strcmp(arg, "columns")) {
+ set_size(0, get_arg(&i, 0, USHRT_MAX));
+ } else if (sscanf(arg, "%x:%x:%x:%x:%n", &new.c_iflag, &new.c_oflag,
+ &new.c_cflag, &new.c_lflag, &n) == 4) {
+ int value;
+
+ arg += n;
+ for (j=0;j<NCCS;j++) {
+ if (sscanf(arg, "%x%n", &value, &n) != 1) error_exit("bad -g string");
+ new.c_cc[j] = value;
+ arg += n+1;
+ }
+ } else if (set_special_character(&new, &i, arg)) {
+ // Already done as a side effect.
+ } else if (!strcmp(arg, "cooked")) {
+ set_options(&new, "brkint", "ignpar", "istrip", "icrnl", "ixon",
+ "opost", "isig", "icanon", 0);
+ } else if (!strcmp(arg, "evenp") || !strcmp(arg, "parity")) {
+ set_options(&new, "parenb", "cs7", "-parodd", 0);
+ } else if (!strcmp(arg, "oddp")) {
+ set_options(&new, "parenb", "cs7", "parodd", 0);
+ } else if (!strcmp(arg, "-parity") || !strcmp(arg, "-evenp") ||
+ !strcmp(arg, "-oddp")) {
+ set_options(&new, "-parenb", "cs8", 0);
+ } else if (!strcmp(arg, "raw")) {
+ // POSIX and "man stty" differ wildly. This is "man stty".
+ set_options(&new, "-ignbrk", "-brkint", "-ignpar", "-parmrk", "-inpck",
+ "-istrip", "-inlcr", "-igncr", "-icrnl", "-ixon", "-ixoff", "-iuclc",
+ "-ixany", "-imaxbel", "-opost", "-isig", "-icanon", "-xcase", 0);
+ new.c_cc[VMIN] = 1;
+ new.c_cc[VTIME] = 0;
+ } else if (!strcmp(arg, "nl")) {
+ set_options(&new, "-icrnl", "-ocrnl", 0);
+ } else if (!strcmp(arg, "-nl")) {
+ set_options(&new, "icrnl", "ocrnl", "-inlcr", "-igncr", 0);
+ } else if (!strcmp(arg, "ek")) {
+ new.c_cc[VERASE] = 0x7f;
+ new.c_cc[VKILL] = 0x15;
+ } else if (!strcmp(arg, "sane")) {
+ make_sane(&new);
+ } else {
+ // Translate historical cruft into canonical forms.
+ for (j=0;j<ARRAY_LEN(synonyms);j++) {
+ if (!strcmp(synonyms[j].from, arg)) {
+ arg = synonyms[j].to;
+ break;
+ }
+ }
+ set_option(&new, arg);
+ }
+ }
+ if (tcsetattr(TT.fd,TCSAFLUSH,&new)) perror_exit("tcsetattr %s",TT.device);
+
+ // tcsetattr returns success if *any* change is made, so double-check...
+ old = new;
+ if (tcgetattr(TT.fd,&new)) perror_exit("tcgetattr %s",TT.device);
+ if (memcmp(&old, &new, sizeof(old)))
+ error_exit("unable to perform all requested operations on %s", TT.device);
+ return;
+ }
+
+ if (toys.optflags&FLAG_g) {
+ xprintf("%x:%x:%x:%x:", old.c_iflag, old.c_oflag, old.c_cflag, old.c_lflag);
+ for (i=0;i<NCCS;i++) xprintf("%x%c", old.c_cc[i], i==NCCS-1?'\n':':');
+ return;
+ }
+
+ // Without arguments, "stty" only shows the speed, the line discipline,
+ // special characters and any flags that differ from the "sane" settings.
+ make_sane(&sane);
+ show_speed(&old, 1);
+ if (toys.optflags&FLAG_a) show_size(1);
+ out("line = %d;\n", old.c_line);
+
+ for (i=j=0;i<ARRAY_LEN(chars);i++) {
+ char vis[16] = {};
+ cc_t ch = old.c_cc[chars[i].value];
+
+ if (ch == sane.c_cc[chars[i].value] && (toys.optflags&FLAG_a)==0)
+ continue;
+
+ if (chars[i].value == VMIN || chars[i].value == VTIME) {
+ snprintf(vis, sizeof(vis), "%u", ch);
+ } else if (ch == _POSIX_VDISABLE) {
+ strcat(vis, "<undef>");
+ } else {
+ if (ch > 0x7f) {
+ strcat(vis, "M-");
+ ch -= 128;
+ }
+ if (ch < ' ') sprintf(vis+strlen(vis), "^%c", (ch+'@'));
+ else if (ch == 0x7f) strcat(vis, "^?");
+ else sprintf(vis+strlen(vis), "%c", ch);
+ }
+ out("%s = %s;", chars[i].name, vis);
+ j++;
+ }
+ if (j) out("\n");
+
+ show_flags(old.c_cflag, sane.c_cflag, cflags, ARRAY_LEN(cflags));
+ show_flags(old.c_iflag, sane.c_iflag, iflags, ARRAY_LEN(iflags));
+ show_flags(old.c_oflag, sane.c_oflag, oflags, ARRAY_LEN(oflags));
+ show_flags(old.c_lflag, sane.c_lflag, lflags, ARRAY_LEN(lflags));
+}
+
+void stty_main(void)
+{
+ if (toys.optflags&(FLAG_a|FLAG_g) && *toys.optargs)
+ error_exit("can't make settings with -a/-g");
+
+ if (TT.device) {
+ TT.fd=xopen(TT.device,(*toys.optargs?O_RDWR:O_RDONLY)|O_NOCTTY|O_NONBLOCK);
+ do_stty();
+ close(TT.fd);
+ } else {
+ TT.device = "standard input";
+ do_stty();
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-30 00:49:59 +0000