]> git.ipfire.org Git - thirdparty/util-linux.git/blob - term-utils/setterm.c
projects / thirdparty / util-linux.git / blob
? search:


14fbafb1073d255b648989687b1fc5e7c3b9bd13
[thirdparty/util-linux.git] / term-utils / setterm.c
1 /* setterm.c, set terminal attributes.
2 *
3 * Copyright (C) 1990 Gordon Irlam (gordoni@cs.ua.oz.au). Conditions of use,
4 * modification, and redistribution are contained in the file COPYRIGHT that
5 * forms part of this distribution.
6 *
7 * Adaption to Linux by Peter MacDonald.
8 *
9 * Enhancements by Mika Liljeberg (liljeber@cs.Helsinki.FI)
10 *
11 * Beep modifications by Christophe Jolif (cjolif@storm.gatelink.fr.net)
12 *
13 * Sanity increases by Cafeine Addict [sic].
14 *
15 * Powersave features by todd j. derr <tjd@wordsmith.org>
16 *
17 * Converted to terminfo by Kars de Jong (jongk@cs.utwente.nl)
18 *
19 * 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
20 * - added Native Language Support
21 *
22 * Semantics:
23 *
24 * Setterm writes to standard output a character string that will
25 * invoke the specified terminal capabilities. Where possible
26 * terminfo is consulted to find the string to use. Some options
27 * however do not correspond to a terminfo capability. In this case if
28 * the terminal type is "con*", or "linux*" the string that invokes
29 * the specified capabilities on the PC Linux virtual console driver
30 * is output. Options that are not implemented by the terminal are
31 * ignored.
32 *
33 * The following options are non-obvious.
34 *
35 * -term can be used to override the TERM environment variable.
36 *
37 * -reset displays the terminal reset string, which typically resets the
38 * terminal to its power on state.
39 *
40 * -initialize displays the terminal initialization string, which typically
41 * sets the terminal's rendering options, and other attributes to the
42 * default values.
43 *
44 * -default sets the terminal's rendering options to the default values.
45 *
46 * -store stores the terminal's current rendering options as the default
47 * values. */
48
49 #include <ctype.h>
50 #include <errno.h>
51 #include <fcntl.h>
52 #include <getopt.h>
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <string.h>
56 #include <sys/ioctl.h>
57 #include <sys/klog.h>
58 #include <sys/param.h> /* for MAXPATHLEN */
59 #include <sys/time.h>
60 #include <termios.h>
61 #include <unistd.h>
62
63 #if defined(HAVE_NCURSESW_TERM_H)
64 # include <ncursesw/term.h>
65 #elif defined(HAVE_NCURSES_TERM_H)
66 # include <ncurses/term.h>
67 #elif defined(HAVE_TERM_H)
68 # include <term.h>
69 #endif
70
71 #ifdef HAVE_LINUX_TIOCL_H
72 # include <linux/tiocl.h>
73 #endif
74
75 #include "all-io.h"
76 #include "c.h"
77 #include "closestream.h"
78 #include "nls.h"
79 #include "optutils.h"
80 #include "strutils.h"
81 #include "xalloc.h"
82
83 /* Constants. */
84
85 /* Non-standard return values. */
86 #define EXIT_DUMPFILE -1
87
88 /* Colors. */
89 enum {
90 BLACK = 0,
91 RED,
92 GREEN,
93 YELLOW,
94 BLUE,
95 MAGENTA,
96 CYAN,
97 WHITE,
98 GREY,
99 DEFAULT
100 };
101
102 static const char *colornames[] = {
103 [BLACK] = "black",
104 [RED] = "red",
105 [GREEN] = "green",
106 [YELLOW]= "yellow",
107 [BLUE] = "blue",
108 [MAGENTA]="magenta",
109 [CYAN] = "cyan",
110 [WHITE] = "white",
111 [GREY] = "grey",
112 [DEFAULT] = "default"
113 };
114
115 #define is_valid_color(x) (x >= 0 && (size_t) x < ARRAY_SIZE(colornames))
116
117 /* Blank commands */
118 enum {
119 BLANKSCREEN = -1,
120 UNBLANKSCREEN = -2,
121 BLANKEDSCREEN = -3
122 };
123
124 /* <linux/tiocl.h> fallback */
125 #ifndef TIOCL_BLANKSCREEN
126 enum {
127 TIOCL_UNBLANKSCREEN = 4, /* unblank screen */
128 TIOCL_SETVESABLANK = 10, /* set vesa blanking mode */
129 TIOCL_BLANKSCREEN = 14, /* keep screen blank even if a key is pressed */
130 TIOCL_BLANKEDSCREEN = 15 /* return which vt was blanked */
131 };
132 #endif
133
134 /* Powersave modes */
135 enum {
136 VESA_BLANK_MODE_OFF = 0,
137 VESA_BLANK_MODE_SUSPENDV,
138 VESA_BLANK_MODE_SUSPENDH,
139 VESA_BLANK_MODE_POWERDOWN
140 };
141
142 /* klogctl() actions */
143 enum {
144 SYSLOG_ACTION_CONSOLE_OFF = 6,
145 SYSLOG_ACTION_CONSOLE_ON = 7,
146 SYSLOG_ACTION_CONSOLE_LEVEL = 8
147 };
148
149 /* Console log levels */
150 enum {
151 CONSOLE_LEVEL_MIN = 0,
152 CONSOLE_LEVEL_MAX = 8
153 };
154
155 /* Various numbers */
156 #define DEFAULT_TAB_LEN 8
157 #define BLANK_MAX 60
158 #define TABS_MAX 160
159 #define BLENGTH_MAX 2000
160
161 /* Command controls. */
162 struct setterm_control {
163 char *opt_te_terminal_name; /* terminal name */
164 int opt_bl_min; /* blank screen */
165 int opt_blength_l; /* bell duration in milliseconds */
166 int opt_bfreq_f; /* bell frequency in Hz */
167 int opt_sn_num; /* console number to be snapshot */
168 char *opt_sn_name; /* path to write snap */
169 char *in_device; /* device to snapshot */
170 int opt_msglevel_num; /* printk() logging level */
171 int opt_ps_mode; /* powersave mode */
172 int opt_pd_min; /* powerdown time */
173 int opt_rt_len; /* regular tab length */
174 int opt_tb_array[TABS_MAX + 1]; /* array for tab list */
175 /* colors */
176 unsigned int opt_fo_color:4, opt_ba_color:4, opt_ul_color:4, opt_hb_color:4;
177 /* boolean options */
178 unsigned int opt_cu_on:1, opt_li_on:1, opt_bo_on:1, opt_hb_on:1,
179 opt_bl_on:1, opt_re_on:1, opt_un_on:1, opt_rep_on:1,
180 opt_appck_on:1, opt_invsc_on:1, opt_msg_on:1, opt_cl_all:1,
181 vcterm:1;
182 /* Option flags. Set when an option is invoked. */
183 uint64_t opt_term:1, opt_reset:1, opt_resize:1, opt_initialize:1, opt_cursor:1,
184 opt_linewrap:1, opt_default:1, opt_foreground:1,
185 opt_background:1, opt_bold:1, opt_blink:1, opt_reverse:1,
186 opt_underline:1, opt_store:1, opt_clear:1, opt_blank:1,
187 opt_snap:1, opt_snapfile:1, opt_append:1, opt_ulcolor:1,
188 opt_hbcolor:1, opt_halfbright:1, opt_repeat:1, opt_tabs:1,
189 opt_clrtabs:1, opt_regtabs:1, opt_appcursorkeys:1,
190 opt_inversescreen:1, opt_msg:1, opt_msglevel:1, opt_powersave:1,
191 opt_powerdown:1, opt_blength:1, opt_bfreq:1;
192 };
193
194 static int parse_color(const char *arg)
195 {
196 size_t i;
197
198 for (i = 0; i < ARRAY_SIZE(colornames); i++) {
199 if (strcmp(colornames[i], arg) == 0)
200 return i;
201 }
202
203 return -EINVAL;
204 }
205
206 static int parse_febg_color(const char *arg)
207 {
208 int color = parse_color(arg);
209
210 if (color < 0)
211 color = strtos32_or_err(arg, _("argument error"));
212
213 if (!is_valid_color(color) || color == GREY)
214 errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
215 return color;
216 }
217
218 static int parse_ulhb_color(char **av, int *oi)
219 {
220 char *color_name;
221 int bright = 0;
222 int color = -1;
223
224 if (av[*oi] && strcmp(av[*oi - 1], "bright") == 0) {
225 bright = 1;
226 color_name = av[*oi];
227 (*oi)++;
228 } else
229 color_name = av[*oi - 1];
230
231 color = parse_color(color_name);
232 if (color < 0)
233 color = strtos32_or_err(color_name, _("argument error"));
234 if (!is_valid_color(color) || color == DEFAULT)
235 errx(EXIT_FAILURE, "%s: %s", _("argument error"), color_name);
236 if (bright && (color == BLACK || color == GREY))
237 errx(EXIT_FAILURE, _("argument error: bright %s is not supported"), color_name);
238
239 if (bright)
240 color |= 8;
241
242 return color;
243 }
244
245 static char *find_optional_arg(char **av, char *oa, int *oi)
246 {
247 char *arg;
248 if (oa)
249 return oa;
250 else {
251 arg = av[*oi];
252 if (!arg || arg[0] == '-')
253 return NULL;
254 }
255 (*oi)++;
256 return arg;
257 }
258
259 static int parse_blank(char **av, char *oa, int *oi)
260 {
261 char *arg;
262
263 arg = find_optional_arg(av, oa, oi);
264 if (!arg)
265 return BLANKEDSCREEN;
266 if (!strcmp(arg, "force"))
267 return BLANKSCREEN;
268 else if (!strcmp(arg, "poke"))
269 return UNBLANKSCREEN;
270 else {
271 int ret;
272
273 ret = strtos32_or_err(arg, _("argument error"));
274 if (ret < 0 || BLANK_MAX < ret)
275 errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
276 return ret;
277 }
278 }
279
280 static int parse_powersave(const char *arg)
281 {
282 if (strcmp(arg, "on") == 0)
283 return VESA_BLANK_MODE_SUSPENDV;
284 else if (strcmp(arg, "vsync") == 0)
285 return VESA_BLANK_MODE_SUSPENDV;
286 else if (strcmp(arg, "hsync") == 0)
287 return VESA_BLANK_MODE_SUSPENDH;
288 else if (strcmp(arg, "powerdown") == 0)
289 return VESA_BLANK_MODE_POWERDOWN;
290 else if (strcmp(arg, "off") == 0)
291 return VESA_BLANK_MODE_OFF;
292 errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
293 }
294
295 static int parse_msglevel(const char *arg)
296 {
297 int ret;
298
299 ret = strtos32_or_err(arg, _("argument error"));
300 if (ret < CONSOLE_LEVEL_MIN || CONSOLE_LEVEL_MAX < ret)
301 errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
302 return ret;
303 }
304
305 static int parse_snap(char **av, char *oa, int *oi)
306 {
307 int ret;
308 char *arg;
309
310 arg = find_optional_arg(av, oa, oi);
311 if (!arg)
312 return 0;
313 ret = strtos32_or_err(arg, _("argument error"));
314 if (ret < 1)
315 errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
316 return ret;
317 }
318
319 static void parse_tabs(char **av, char *oa, int *oi, int *tab_array)
320 {
321 int i = 0;
322
323 if (oa) {
324 tab_array[i] = strtos32_or_err(oa, _("argument error"));
325 i++;
326 }
327 while (av[*oi]) {
328 if (TABS_MAX < i)
329 errx(EXIT_FAILURE, _("too many tabs"));
330 if (av[*oi][0] == '-')
331 break;
332 tab_array[i] = strtos32_or_err(av[*oi], _("argument error"));
333 (*oi)++;
334 i++;
335 }
336 tab_array[i] = -1;
337 }
338
339 static int parse_regtabs(char **av, char *oa, int *oi)
340 {
341 int ret;
342 char *arg;
343
344 arg = find_optional_arg(av, oa, oi);
345 if (!arg)
346 return DEFAULT_TAB_LEN;
347 ret = strtos32_or_err(arg, _("argument error"));
348 if (ret < 1 || TABS_MAX < ret)
349 errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
350 return ret;
351 }
352
353 static int parse_blength(char **av, char *oa, int *oi)
354 {
355 int ret = -1;
356 char *arg;
357
358 arg = find_optional_arg(av, oa, oi);
359 if (!arg)
360 return 0;
361 ret = strtos32_or_err(arg, _("argument error"));
362 if (ret < 0 || BLENGTH_MAX < ret)
363 errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
364 return ret;
365 }
366
367 static int parse_bfreq(char **av, char *oa, int *oi)
368 {
369 char *arg;
370
371 arg = find_optional_arg(av, oa, oi);
372 if (!arg)
373 return 0;
374 return strtos32_or_err(arg, _("argument error"));
375 }
376
377 static void __attribute__((__noreturn__)) usage(void)
378 {
379 FILE *out = stdout;
380 fputs(USAGE_HEADER, out);
381 fprintf(out,
382 _(" %s [options]\n"), program_invocation_short_name);
383
384 fputs(USAGE_SEPARATOR, out);
385 fputs(_("Set the attributes of a terminal.\n"), out);
386
387 fputs(USAGE_OPTIONS, out);
388 fputs(_(" --term <terminal_name> override TERM environment variable\n"), out);
389 fputs(_(" --reset reset terminal to power-on state\n"), out);
390 fputs(_(" --resize reset terminal rows and columns\n"), out);
391 fputs(_(" --initialize display init string, and use default settings\n"), out);
392 fputs(_(" --default use default terminal settings\n"), out);
393 fputs(_(" --store save current terminal settings as default\n"), out);
394 fputs(_(" --cursor [on|off] display cursor\n"), out);
395 fputs(_(" --repeat [on|off] keyboard repeat\n"), out);
396 fputs(_(" --appcursorkeys [on|off] cursor key application mode\n"), out);
397 fputs(_(" --linewrap [on|off] continue on a new line when a line is full\n"), out);
398 fputs(_(" --inversescreen [on|off] swap colors for the whole screen\n"), out);
399 fputs(_(" --foreground default|<color> set foreground color\n"), out);
400 fputs(_(" --background default|<color> set background color\n"), out);
401 fputs(_(" --ulcolor [bright] <color> set underlined text color\n"), out);
402 fputs(_(" --hbcolor [bright] <color> set half-bright text color\n"), out);
403 fputs(_(" <color>: black blue cyan green grey magenta red white yellow\n"), out);
404 fputs(_(" --bold [on|off] bold\n"), out);
405 fputs(_(" --half-bright [on|off] dim\n"), out);
406 fputs(_(" --blink [on|off] blink\n"), out);
407 fputs(_(" --underline [on|off] underline\n"), out);
408 fputs(_(" --reverse [on|off] swap foreground and background colors\n"), out);
409 fputs(_(" --clear [all|rest] clear screen and set cursor position\n"), out);
410 fputs(_(" --tabs [<number>...] set these tab stop positions, or show them\n"), out);
411 fputs(_(" --clrtabs [<number>...] clear these tab stop positions, or all\n"), out);
412 fputs(_(" --regtabs [1-160] set a regular tab stop interval\n"), out);
413 fputs(_(" --blank [0-60|force|poke] set time of inactivity before screen blanks\n"), out);
414 fputs(_(" --dump [<number>] write vcsa<number> console dump to file\n"), out);
415 fputs(_(" --append [<number>] append vcsa<number> console dump to file\n"), out);
416 fputs(_(" --file <filename> name of the dump file\n"), out);
417 fputs(_(" --msg [on|off] send kernel messages to console\n"), out);
418 fputs(_(" --msglevel 0-8 kernel console log level\n"), out);
419 fputs(_(" --powersave [on|vsync|hsync|powerdown|off]\n"), out);
420 fputs(_(" set vesa powersaving features\n"), out);
421 fputs(_(" --powerdown [0-60] set vesa powerdown interval in minutes\n"), out);
422 fputs(_(" --blength [0-2000] duration of the bell in milliseconds\n"), out);
423 fputs(_(" --bfreq <number> bell frequency in Hertz\n"), out);
424 printf( " --help %s\n", USAGE_OPTSTR_HELP);
425 printf( " --version %s\n", USAGE_OPTSTR_VERSION);
426
427 printf(USAGE_MAN_TAIL("setterm(1)"));
428 exit(EXIT_SUCCESS);
429 }
430
431 static int __attribute__((__pure__)) set_opt_flag(int opt)
432 {
433 if (opt)
434 errx(EXIT_FAILURE, _("duplicate use of an option"));
435 return 1;
436 }
437
438 static void parse_option(struct setterm_control *ctl, int ac, char **av)
439 {
440 int c;
441 enum {
442 OPT_TERM = CHAR_MAX + 1,
443 OPT_RESET,
444 OPT_RESIZE,
445 OPT_INITIALIZE,
446 OPT_CURSOR,
447 OPT_REPEAT,
448 OPT_APPCURSORKEYS,
449 OPT_LINEWRAP,
450 OPT_DEFAULT,
451 OPT_FOREGROUND,
452 OPT_BACKGROUND,
453 OPT_ULCOLOR,
454 OPT_HBCOLOR,
455 OPT_INVERSESCREEN,
456 OPT_BOLD,
457 OPT_HALF_BRIGHT,
458 OPT_BLINK,
459 OPT_REVERSE,
460 OPT_UNDERLINE,
461 OPT_STORE,
462 OPT_CLEAR,
463 OPT_TABS,
464 OPT_CLRTABS,
465 OPT_REGTABS,
466 OPT_BLANK,
467 OPT_DUMP,
468 OPT_APPEND,
469 OPT_FILE,
470 OPT_MSG,
471 OPT_MSGLEVEL,
472 OPT_POWERSAVE,
473 OPT_POWERDOWN,
474 OPT_BLENGTH,
475 OPT_BFREQ,
476 OPT_VERSION,
477 OPT_HELP
478 };
479 static const struct option longopts[] = {
480 {"term", required_argument, NULL, OPT_TERM},
481 {"reset", no_argument, NULL, OPT_RESET},
482 {"resize", no_argument, NULL, OPT_RESIZE},
483 {"initialize", no_argument, NULL, OPT_INITIALIZE},
484 {"cursor", required_argument, NULL, OPT_CURSOR},
485 {"repeat", required_argument, NULL, OPT_REPEAT},
486 {"appcursorkeys", required_argument, NULL, OPT_APPCURSORKEYS},
487 {"linewrap", required_argument, NULL, OPT_LINEWRAP},
488 {"default", no_argument, NULL, OPT_DEFAULT},
489 {"foreground", required_argument, NULL, OPT_FOREGROUND},
490 {"background", required_argument, NULL, OPT_BACKGROUND},
491 {"ulcolor", required_argument, NULL, OPT_ULCOLOR},
492 {"hbcolor", required_argument, NULL, OPT_HBCOLOR},
493 {"inversescreen", required_argument, NULL, OPT_INVERSESCREEN},
494 {"bold", required_argument, NULL, OPT_BOLD},
495 {"half-bright", required_argument, NULL, OPT_HALF_BRIGHT},
496 {"blink", required_argument, NULL, OPT_BLINK},
497 {"reverse", required_argument, NULL, OPT_REVERSE},
498 {"underline", required_argument, NULL, OPT_UNDERLINE},
499 {"store", no_argument, NULL, OPT_STORE},
500 {"clear", required_argument, NULL, OPT_CLEAR},
501 {"tabs", optional_argument, NULL, OPT_TABS},
502 {"clrtabs", optional_argument, NULL, OPT_CLRTABS},
503 {"regtabs", optional_argument, NULL, OPT_REGTABS},
504 {"blank", optional_argument, NULL, OPT_BLANK},
505 {"dump", optional_argument, NULL, OPT_DUMP},
506 {"append", required_argument, NULL, OPT_APPEND},
507 {"file", required_argument, NULL, OPT_FILE},
508 {"msg", required_argument, NULL, OPT_MSG},
509 {"msglevel", required_argument, NULL, OPT_MSGLEVEL},
510 {"powersave", required_argument, NULL, OPT_POWERSAVE},
511 {"powerdown", optional_argument, NULL, OPT_POWERDOWN},
512 {"blength", optional_argument, NULL, OPT_BLENGTH},
513 {"bfreq", optional_argument, NULL, OPT_BFREQ},
514 {"version", no_argument, NULL, OPT_VERSION},
515 {"help", no_argument, NULL, OPT_HELP},
516 {NULL, 0, NULL, 0}
517 };
518 static const ul_excl_t excl[] = {
519 { OPT_DEFAULT, OPT_STORE },
520 { OPT_TABS, OPT_CLRTABS, OPT_REGTABS },
521 { OPT_MSG, OPT_MSGLEVEL },
522 { 0 }
523 };
524 int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
525
526 while ((c = getopt_long_only(ac, av, "", longopts, NULL)) != -1) {
527 err_exclusive_options(c, longopts, excl, excl_st);
528 switch (c) {
529 case OPT_TERM:
530 ctl->opt_term = set_opt_flag(ctl->opt_term);
531 ctl->opt_te_terminal_name = optarg;
532 break;
533 case OPT_RESET:
534 ctl->opt_reset = set_opt_flag(ctl->opt_reset);
535 break;
536 case OPT_RESIZE:
537 ctl->opt_resize = set_opt_flag(ctl->opt_resize);
538 break;
539 case OPT_INITIALIZE:
540 ctl->opt_initialize = set_opt_flag(ctl->opt_initialize);
541 break;
542 case OPT_CURSOR:
543 ctl->opt_cursor = set_opt_flag(ctl->opt_cursor);
544 ctl->opt_cu_on = parse_switch(optarg, _("argument error"),
545 "on", "off", NULL);
546 break;
547 case OPT_REPEAT:
548 ctl->opt_repeat = set_opt_flag(ctl->opt_repeat);
549 ctl->opt_rep_on = parse_switch(optarg, _("argument error"),
550 "on", "off", NULL);
551 break;
552 case OPT_APPCURSORKEYS:
553 ctl->opt_appcursorkeys = set_opt_flag(ctl->opt_appcursorkeys);
554 ctl->opt_appck_on = parse_switch(optarg, _("argument error"),
555 "on", "off", NULL);
556 break;
557 case OPT_LINEWRAP:
558 ctl->opt_linewrap = set_opt_flag(ctl->opt_linewrap);
559 ctl->opt_li_on = parse_switch(optarg, _("argument error"),
560 "on", "off", NULL);
561 break;
562 case OPT_DEFAULT:
563 ctl->opt_default = set_opt_flag(ctl->opt_default);
564 break;
565 case OPT_FOREGROUND:
566 ctl->opt_foreground = set_opt_flag(ctl->opt_foreground);
567 ctl->opt_fo_color = parse_febg_color(optarg);
568 break;
569 case OPT_BACKGROUND:
570 ctl->opt_background = set_opt_flag(ctl->opt_background);
571 ctl->opt_ba_color = parse_febg_color(optarg);
572 break;
573 case OPT_ULCOLOR:
574 ctl->opt_ulcolor = set_opt_flag(ctl->opt_ulcolor);
575 ctl->opt_ul_color = parse_ulhb_color(av, &optind);
576 break;
577 case OPT_HBCOLOR:
578 ctl->opt_hbcolor = set_opt_flag(ctl->opt_hbcolor);
579 ctl->opt_hb_color = parse_ulhb_color(av, &optind);
580 break;
581 case OPT_INVERSESCREEN:
582 ctl->opt_inversescreen = set_opt_flag(ctl->opt_inversescreen);
583 ctl->opt_invsc_on = parse_switch(optarg, _("argument error"),
584 "on", "off", NULL);
585 break;
586 case OPT_BOLD:
587 ctl->opt_bold = set_opt_flag(ctl->opt_bold);
588 ctl->opt_bo_on = parse_switch(optarg, _("argument error"),
589 "on", "off", NULL);
590 break;
591 case OPT_HALF_BRIGHT:
592 ctl->opt_halfbright = set_opt_flag(ctl->opt_halfbright);
593 ctl->opt_hb_on = parse_switch(optarg, _("argument error"),
594 "on", "off", NULL);
595 break;
596 case OPT_BLINK:
597 ctl->opt_blink = set_opt_flag(ctl->opt_blink);
598 ctl->opt_bl_on = parse_switch(optarg, _("argument error"),
599 "on", "off", NULL);
600 break;
601 case OPT_REVERSE:
602 ctl->opt_reverse = set_opt_flag(ctl->opt_reverse);
603 ctl->opt_re_on = parse_switch(optarg, _("argument error"),
604 "on", "off", NULL);
605 break;
606 case OPT_UNDERLINE:
607 ctl->opt_underline = set_opt_flag(ctl->opt_underline);
608 ctl->opt_un_on = parse_switch(optarg, _("argument error"),
609 "on", "off", NULL);
610 break;
611 case OPT_STORE:
612 ctl->opt_store = set_opt_flag(ctl->opt_store);
613 break;
614 case OPT_CLEAR:
615 ctl->opt_clear = set_opt_flag(ctl->opt_clear);
616 ctl->opt_cl_all = parse_switch(optarg, _("argument error"),
617 "all", "reset", NULL);
618 break;
619 case OPT_TABS:
620 ctl->opt_tabs = set_opt_flag(ctl->opt_tabs);
621 parse_tabs(av, optarg, &optind, ctl->opt_tb_array);
622 break;
623 case OPT_CLRTABS:
624 ctl->opt_clrtabs = set_opt_flag(ctl->opt_clrtabs);
625 parse_tabs(av, optarg, &optind, ctl->opt_tb_array);
626 break;
627 case OPT_REGTABS:
628 ctl->opt_regtabs = set_opt_flag(ctl->opt_regtabs);
629 ctl->opt_rt_len = parse_regtabs(av, optarg, &optind);
630 break;
631 case OPT_BLANK:
632 ctl->opt_blank = set_opt_flag(ctl->opt_blank);
633 ctl->opt_bl_min = parse_blank(av, optarg, &optind);
634 break;
635 case OPT_DUMP:
636 ctl->opt_snap = set_opt_flag(ctl->opt_snap);
637 ctl->opt_sn_num = parse_snap(av, optarg, &optind);
638 break;
639 case OPT_APPEND:
640 ctl->opt_append = set_opt_flag(ctl->opt_append);
641 ctl->opt_sn_num = parse_snap(av, optarg, &optind);
642 break;
643 case OPT_FILE:
644 ctl->opt_snapfile = set_opt_flag(ctl->opt_snapfile);
645 ctl->opt_sn_name = optarg;
646 break;
647 case OPT_MSG:
648 ctl->opt_msg = set_opt_flag(ctl->opt_msg);
649 ctl->opt_msg_on = parse_switch(optarg, _("argument error"),
650 "on", "off", NULL);
651 break;
652 case OPT_MSGLEVEL:
653 ctl->opt_msglevel = set_opt_flag(ctl->opt_msglevel);
654 ctl->opt_msglevel_num = parse_msglevel(optarg);
655 if (ctl->opt_msglevel_num == 0) {
656 ctl->opt_msg = set_opt_flag(ctl->opt_msg);
657 ctl->opt_msg_on |= 1;
658 }
659 break;
660 case OPT_POWERSAVE:
661 ctl->opt_powersave = set_opt_flag(ctl->opt_powersave);
662 ctl->opt_ps_mode = parse_powersave(optarg);
663 break;
664 case OPT_POWERDOWN:
665 ctl->opt_powerdown = set_opt_flag(ctl->opt_powerdown);
666 ctl->opt_pd_min = parse_blank(av, optarg, &optind);
667 break;
668 case OPT_BLENGTH:
669 ctl->opt_blength = set_opt_flag(ctl->opt_blength);
670 ctl->opt_blength_l = parse_blength(av, optarg, &optind);
671 break;
672 case OPT_BFREQ:
673 ctl->opt_bfreq = set_opt_flag(ctl->opt_bfreq);
674 ctl->opt_bfreq_f = parse_bfreq(av, optarg, &optind);
675 break;
676
677 case OPT_VERSION:
678 print_version(EXIT_SUCCESS);
679 case OPT_HELP:
680 usage();
681 default:
682 errtryhelp(EXIT_FAILURE);
683 }
684 }
685 }
686
687 /* Return the specified terminfo string, or an empty string if no such
688 * terminfo capability exists. */
689 static char *ti_entry(const char *name)
690 {
691 char *buf_ptr;
692
693 if ((buf_ptr = tigetstr(name)) == (char *)-1)
694 buf_ptr = NULL;
695 return buf_ptr;
696 }
697
698 static void show_tabs(void)
699 {
700 int i, co = tigetnum("cols");
701
702 if (co > 0) {
703 printf("\r ");
704 for (i = 10; i < co - 2; i += 10)
705 printf("%-10d", i);
706 putchar('\n');
707 for (i = 1; i <= co; i++)
708 putchar(i % 10 + '0');
709 putchar('\n');
710 for (i = 1; i < co; i++)
711 printf("\tT\b");
712 putchar('\n');
713 }
714 }
715
716 static int open_snapshot_device(struct setterm_control *ctl)
717 {
718 int fd;
719
720 if (ctl->opt_sn_num)
721 xasprintf(&ctl->in_device, "/dev/vcsa%d", ctl->opt_sn_num);
722 else
723 xasprintf(&ctl->in_device, "/dev/vcsa");
724 fd = open(ctl->in_device, O_RDONLY);
725 if (fd < 0)
726 err(EXIT_DUMPFILE, _("cannot read %s"), ctl->in_device);
727 return fd;
728 }
729
730 static void set_blanking(struct setterm_control *ctl)
731 {
732 char ioctlarg;
733 int ret;
734
735 if (0 <= ctl->opt_bl_min) {
736 printf("\033[9;%d]", ctl->opt_bl_min);
737 return;
738 }
739 switch (ctl->opt_bl_min) {
740 case BLANKSCREEN:
741 ioctlarg = TIOCL_BLANKSCREEN;
742 if (ioctl(STDIN_FILENO, TIOCLINUX, &ioctlarg))
743 warn(_("cannot force blank"));
744 break;
745 case UNBLANKSCREEN:
746 ioctlarg = TIOCL_UNBLANKSCREEN;
747 if (ioctl(STDIN_FILENO, TIOCLINUX, &ioctlarg))
748 warn(_("cannot force unblank"));
749 break;
750 case BLANKEDSCREEN:
751 ioctlarg = TIOCL_BLANKEDSCREEN;
752 ret = ioctl(STDIN_FILENO, TIOCLINUX, &ioctlarg);
753 if (ret < 0)
754 warn(_("cannot get blank status"));
755 else
756 printf("%d\n", ret);
757 break;
758 default: /* should be impossible to reach */
759 abort();
760 }
761 return;
762 }
763
764 static void screendump(struct setterm_control *ctl)
765 {
766 unsigned char header[4];
767 unsigned int rows, cols;
768 int fd;
769 FILE *out;
770 size_t i, j;
771 ssize_t rc;
772 char *inbuf, *outbuf, *p, *q;
773
774 /* open source and destination files */
775 fd = open_snapshot_device(ctl);
776 if (!ctl->opt_sn_name)
777 ctl->opt_sn_name = "screen.dump";
778 out = fopen(ctl->opt_sn_name, ctl->opt_snap ? "w" : "a");
779 if (!out)
780 err(EXIT_DUMPFILE, _("cannot open dump file %s for output"), ctl->opt_sn_name);
781 /* determine snapshot size */
782 if (read(fd, header, 4) != 4)
783 err(EXIT_DUMPFILE, _("cannot read %s"), ctl->in_device);
784 rows = header[0];
785 cols = header[1];
786 if (rows * cols == 0)
787 err(EXIT_DUMPFILE, _("cannot read %s"), ctl->in_device);
788 /* allocate buffers */
789 inbuf = xmalloc(rows * cols * 2);
790 outbuf = xmalloc(rows * (cols + 1));
791 /* read input */
792 rc = read(fd, inbuf, rows * cols * 2);
793 if (rc < 0 || (size_t)rc != rows * cols * 2)
794 err(EXIT_DUMPFILE, _("cannot read %s"), ctl->in_device);
795 p = inbuf;
796 q = outbuf;
797 /* copy inbuf to outbuf */
798 for (i = 0; i < rows; i++) {
799 for (j = 0; j < cols; j++) {
800 *q++ = *p;
801 p += 2;
802 }
803 while (j-- > 0 && q[-1] == ' ')
804 q--;
805 *q++ = '\n';
806 }
807 fwrite(outbuf, 1, q - outbuf, out);
808 /* clean up allocations */
809 close(fd);
810 free(inbuf);
811 free(outbuf);
812 free(ctl->in_device);
813 if (close_stream(out) != 0)
814 errx(EXIT_FAILURE, _("write error"));
815 return;
816 }
817
818 /* Some options are applicable when terminal is virtual console. */
819 static int vc_only(struct setterm_control *ctl, const char *err)
820 {
821 if (!ctl->vcterm && err)
822 warnx(_("terminal %s does not support %s"),
823 ctl->opt_te_terminal_name, err);
824 return ctl->vcterm;
825 }
826
827 static void tty_raw(struct termios *saved_attributes, int *saved_fl)
828 {
829 struct termios tattr;
830
831 fcntl(STDIN_FILENO, F_GETFL, saved_fl);
832 tcgetattr(STDIN_FILENO, saved_attributes);
833 fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK);
834 memcpy(&tattr, saved_attributes, sizeof(struct termios));
835 tattr.c_lflag &= ~(ICANON | ECHO);
836 tattr.c_cc[VMIN] = 1;
837 tattr.c_cc[VTIME] = 0;
838 tcsetattr(STDIN_FILENO, TCSAFLUSH, &tattr);
839 }
840
841 static void tty_restore(struct termios *saved_attributes, int *saved_fl)
842 {
843 fcntl(STDIN_FILENO, F_SETFL, *saved_fl);
844 tcsetattr(STDIN_FILENO, TCSANOW, saved_attributes);
845 }
846
847 static int select_wait(void)
848 {
849 struct timeval tv;
850 fd_set set;
851 int ret;
852
853 FD_ZERO(&set);
854 FD_SET(STDIN_FILENO, &set);
855 tv.tv_sec = 10;
856 tv.tv_usec = 0;
857 while ((ret = select(1, &set, NULL, NULL, &tv)) < 0) {
858 if (errno == EINTR)
859 continue;
860 err(EXIT_FAILURE, _("select failed"));
861 }
862 return ret;
863 }
864
865 static int resizetty(void)
866 {
867 /*
868 * \e7 Save current state (cursor coordinates, attributes,
869 * character sets pointed at by G0, G1).
870 * \e[r Set scrolling region; parameters are top and bottom row.
871 * \e[32766E Move cursor down 32766 (INT16_MAX - 1) rows.
872 * \e[32766C Move cursor right 32766 columns.
873 * \e[6n Report cursor position.
874 * \e8 Restore state most recently saved by \e7.
875 */
876 static const char *getpos = "\e7\e[r\e[32766E\e[32766C\e[6n\e8";
877 char retstr[32];
878 int row, col;
879 size_t pos;
880 ssize_t rc;
881 struct winsize ws;
882 struct termios saved_attributes;
883 int saved_fl;
884
885 if (!isatty(STDIN_FILENO))
886 errx(EXIT_FAILURE, _("stdin does not refer to a terminal"));
887
888 tty_raw(&saved_attributes, &saved_fl);
889 if (write_all(STDIN_FILENO, getpos, strlen(getpos)) < 0) {
890 warn(_("write failed"));
891 tty_restore(&saved_attributes, &saved_fl);
892 return 1;
893 }
894 for (pos = 0; pos < sizeof(retstr) - 1;) {
895 if (0 == select_wait())
896 break;
897 if ((rc =
898 read(STDIN_FILENO, retstr + pos,
899 sizeof(retstr) - 1 - pos)) < 0) {
900 if (errno == EINTR)
901 continue;
902 warn(_("read failed"));
903 tty_restore(&saved_attributes, &saved_fl);
904 return 1;
905 }
906 pos += rc;
907 if (retstr[pos - 1] == 'R')
908 break;
909 }
910 retstr[pos] = 0;
911 tty_restore(&saved_attributes, &saved_fl);
912 rc = sscanf(retstr, "\033[%d;%dR", &row, &col);
913 if (rc != 2) {
914 warnx(_("invalid cursor position: %s"), retstr);
915 return 1;
916 }
917 memset(&ws, 0, sizeof(struct winsize));
918 ioctl(STDIN_FILENO, TIOCGWINSZ, &ws);
919 ws.ws_row = row;
920 ws.ws_col = col;
921 ioctl(STDIN_FILENO, TIOCSWINSZ, &ws);
922 return 0;
923 }
924
925 static void perform_sequence(struct setterm_control *ctl)
926 {
927 int result;
928
929 /* -reset. */
930 if (ctl->opt_reset)
931 putp(ti_entry("rs1"));
932
933 /* -resize. */
934 if (ctl->opt_resize)
935 if (resizetty())
936 warnx(_("reset failed"));
937
938 /* -initialize. */
939 if (ctl->opt_initialize)
940 putp(ti_entry("is2"));
941
942 /* -cursor [on|off]. */
943 if (ctl->opt_cursor) {
944 if (ctl->opt_cu_on)
945 putp(ti_entry("cnorm"));
946 else
947 putp(ti_entry("civis"));
948 }
949
950 /* -linewrap [on|off]. */
951 if (ctl->opt_linewrap)
952 fputs(ctl->opt_li_on ? "\033[?7h" : "\033[?7l", stdout);
953
954 /* -repeat [on|off]. */
955 if (ctl->opt_repeat && vc_only(ctl, "--repeat"))
956 fputs(ctl->opt_rep_on ? "\033[?8h" : "\033[?8l", stdout);
957
958 /* -appcursorkeys [on|off]. */
959 if (ctl->opt_appcursorkeys && vc_only(ctl, "--appcursorkeys"))
960 fputs(ctl->opt_appck_on ? "\033[?1h" : "\033[?1l", stdout);
961
962 /* -default. Vc sets default rendition, otherwise clears all
963 * attributes. */
964 if (ctl->opt_default) {
965 if (vc_only(ctl, NULL))
966 printf("\033[0m");
967 else
968 putp(ti_entry("sgr0"));
969 }
970
971 /* -foreground black|red|green|yellow|blue|magenta|cyan|white|default. */
972 if (ctl->opt_foreground)
973 printf("\033[3%c%s", '0' + ctl->opt_fo_color, "m");
974
975 /* -background black|red|green|yellow|blue|magenta|cyan|white|default. */
976 if (ctl->opt_background)
977 printf("\033[4%c%s", '0' + ctl->opt_ba_color, "m");
978
979 /* -ulcolor [bright] black|red|green|yellow|blue|magenta|cyan|white. */
980 if (ctl->opt_ulcolor && vc_only(ctl, "--ulcolor"))
981 printf("\033[1;%d]", ctl->opt_ul_color);
982
983 /* -hbcolor [bright] black|red|green|yellow|blue|magenta|cyan|white. */
984 if (ctl->opt_hbcolor)
985 printf("\033[2;%d]", ctl->opt_hb_color);
986
987 /* -inversescreen [on|off]. */
988 if (ctl->opt_inversescreen)
989 fputs(ctl->opt_invsc_on ? "\033[?5h" : "\033[?5l", stdout);
990
991 /* -bold [on|off]. Vc behaves as expected, otherwise off turns off
992 * all attributes. */
993 if (ctl->opt_bold) {
994 if (ctl->opt_bo_on)
995 putp(ti_entry("bold"));
996 else {
997 if (vc_only(ctl, NULL))
998 fputs("\033[22m", stdout);
999 else
1000 putp(ti_entry("sgr0"));
1001 }
1002 }
1003
1004 /* -half-bright [on|off]. Vc behaves as expected, otherwise off
1005 * turns off all attributes. */
1006 if (ctl->opt_halfbright) {
1007 if (ctl->opt_hb_on)
1008 putp(ti_entry("dim"));
1009 else {
1010 if (vc_only(ctl, NULL))
1011 fputs("\033[22m", stdout);
1012 else
1013 putp(ti_entry("sgr0"));
1014 }
1015 }
1016
1017 /* -blink [on|off]. Vc behaves as expected, otherwise off turns off
1018 * all attributes. */
1019 if (ctl->opt_blink) {
1020 if (ctl->opt_bl_on)
1021 putp(ti_entry("blink"));
1022 else {
1023 if (vc_only(ctl, NULL))
1024 fputs("\033[25m", stdout);
1025 else
1026 putp(ti_entry("sgr0"));
1027 }
1028 }
1029
1030 /* -reverse [on|off]. Vc behaves as expected, otherwise off turns
1031 * off all attributes. */
1032 if (ctl->opt_reverse) {
1033 if (ctl->opt_re_on)
1034 putp(ti_entry("rev"));
1035 else {
1036 if (vc_only(ctl, NULL))
1037 fputs("\033[27m", stdout);
1038 else
1039 putp(ti_entry("sgr0"));
1040 }
1041 }
1042
1043 /* -underline [on|off]. */
1044 if (ctl->opt_underline)
1045 putp(ti_entry(ctl->opt_un_on ? "smul" : "rmul"));
1046
1047 /* -store. */
1048 if (ctl->opt_store && vc_only(ctl, "--store"))
1049 fputs("\033[8]", stdout);
1050
1051 /* -clear [all|rest]. */
1052 if (ctl->opt_clear)
1053 putp(ti_entry(ctl->opt_cl_all ? "clear" : "ed"));
1054
1055 /* -tabs. */
1056 if (ctl->opt_tabs) {
1057 if (ctl->opt_tb_array[0] == -1)
1058 show_tabs();
1059 else {
1060 int i;
1061
1062 for (i = 0; ctl->opt_tb_array[i] > 0; i++)
1063 printf("\033[%dG\033H", ctl->opt_tb_array[i]);
1064 putchar('\r');
1065 }
1066 }
1067
1068 /* -clrtabs. */
1069 if (ctl->opt_clrtabs && vc_only(ctl, "--clrtabs")) {
1070 int i;
1071
1072 if (ctl->opt_tb_array[0] == -1)
1073 fputs("\033[3g", stdout);
1074 else
1075 for (i = 0; ctl->opt_tb_array[i] > 0; i++)
1076 printf("\033[%dG\033[g", ctl->opt_tb_array[i]);
1077 putchar('\r');
1078 }
1079
1080 /* -regtabs. */
1081 if (ctl->opt_regtabs && vc_only(ctl, "--regtabs")) {
1082 int i;
1083
1084 fputs("\033[3g\r", stdout);
1085 for (i = ctl->opt_rt_len + 1; i <= TABS_MAX; i += ctl->opt_rt_len)
1086 printf("\033[%dC\033H", ctl->opt_rt_len);
1087 putchar('\r');
1088 }
1089
1090 /* -blank [0-60]. */
1091 if (ctl->opt_blank && vc_only(ctl, "--blank"))
1092 set_blanking(ctl);
1093
1094 /* -powersave [on|vsync|hsync|powerdown|off] (console) */
1095 if (ctl->opt_powersave) {
1096 char ioctlarg[2];
1097 ioctlarg[0] = TIOCL_SETVESABLANK;
1098 ioctlarg[1] = ctl->opt_ps_mode;
1099 if (ioctl(STDIN_FILENO, TIOCLINUX, ioctlarg))
1100 warn(_("cannot (un)set powersave mode"));
1101 }
1102
1103 /* -powerdown [0-60]. */
1104 if (ctl->opt_powerdown)
1105 printf("\033[14;%d]", ctl->opt_pd_min);
1106
1107 /* -snap [1-NR_CONS]. */
1108 if (ctl->opt_snap || ctl->opt_append)
1109 screendump(ctl);
1110
1111 /* -msg [on|off]. Controls printk's to console. */
1112 if (ctl->opt_msg && vc_only(ctl, "--msg")) {
1113 if (ctl->opt_msg_on)
1114 result = klogctl(SYSLOG_ACTION_CONSOLE_ON, NULL, 0);
1115 else
1116 result = klogctl(SYSLOG_ACTION_CONSOLE_OFF, NULL, 0);
1117
1118 if (result != 0)
1119 warn(_("klogctl error"));
1120 }
1121
1122 /* -msglevel [0-8]. Console printk message level. */
1123 if (ctl->opt_msglevel_num && vc_only(ctl, "--msglevel")) {
1124 result =
1125 klogctl(SYSLOG_ACTION_CONSOLE_LEVEL, NULL,
1126 ctl->opt_msglevel_num);
1127 if (result != 0)
1128 warn(_("klogctl error"));
1129 }
1130
1131 /* -blength [0-2000] */
1132 if (ctl->opt_blength && vc_only(ctl, "--blength")) {
1133 printf("\033[11;%d]", ctl->opt_blength_l);
1134 }
1135
1136 /* -bfreq freqnumber */
1137 if (ctl->opt_bfreq && vc_only(ctl, "--bfreq")) {
1138 printf("\033[10;%d]", ctl->opt_bfreq_f);
1139 }
1140 }
1141
1142 static void init_terminal(struct setterm_control *ctl)
1143 {
1144 int term_errno;
1145
1146 if (!ctl->opt_te_terminal_name) {
1147 ctl->opt_te_terminal_name = getenv("TERM");
1148 if (ctl->opt_te_terminal_name == NULL)
1149 errx(EXIT_FAILURE, _("$TERM is not defined."));
1150 }
1151
1152 /* Find terminfo entry. */
1153 if (setupterm(ctl->opt_te_terminal_name, STDOUT_FILENO, &term_errno))
1154 switch (term_errno) {
1155 case -1:
1156 errx(EXIT_FAILURE, _("terminfo database cannot be found"));
1157 case 0:
1158 errx(EXIT_FAILURE, _("%s: unknown terminal type"), ctl->opt_te_terminal_name);
1159 case 1:
1160 errx(EXIT_FAILURE, _("terminal is hardcopy"));
1161 }
1162
1163 /* See if the terminal is a virtual console terminal. */
1164 ctl->vcterm = (!strncmp(ctl->opt_te_terminal_name, "con", 3) ||
1165 !strncmp(ctl->opt_te_terminal_name, "linux", 5));
1166 }
1167
1168
1169 int main(int argc, char **argv)
1170 {
1171 struct setterm_control ctl = { NULL };
1172
1173 setlocale(LC_ALL, "");
1174 bindtextdomain(PACKAGE, LOCALEDIR);
1175 textdomain(PACKAGE);
1176 close_stdout_atexit();
1177
1178 if (argc < 2) {
1179 warnx(_("bad usage"));
1180 errtryhelp(EXIT_FAILURE);
1181 }
1182 parse_option(&ctl, argc, argv);
1183 init_terminal(&ctl);
1184 perform_sequence(&ctl);
1185
1186 return EXIT_SUCCESS;
1187 }
Unnamed repository; edit this file 'description' to name the repository.