1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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
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
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
285
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
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
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
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
411
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
