summaryrefslogtreecommitdiffstats
path: root/term-utils/setterm.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--term-utils/setterm.c1184
1 files changed, 1184 insertions, 0 deletions
diff --git a/term-utils/setterm.c b/term-utils/setterm.c
new file mode 100644
index 0000000..bb13eb3
--- /dev/null
+++ b/term-utils/setterm.c
@@ -0,0 +1,1184 @@
+/* setterm.c, set terminal attributes.
+ *
+ * Copyright (C) 1990 Gordon Irlam (gordoni@cs.ua.oz.au). Conditions of use,
+ * modification, and redistribution are contained in the file COPYRIGHT that
+ * forms part of this distribution.
+ *
+ * Adaption to Linux by Peter MacDonald.
+ *
+ * Enhancements by Mika Liljeberg (liljeber@cs.Helsinki.FI)
+ *
+ * Beep modifications by Christophe Jolif (cjolif@storm.gatelink.fr.net)
+ *
+ * Sanity increases by Cafeine Addict [sic].
+ *
+ * Powersave features by todd j. derr <tjd@wordsmith.org>
+ *
+ * Converted to terminfo by Kars de Jong (jongk@cs.utwente.nl)
+ *
+ * 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
+ * - added Native Language Support
+ *
+ * Semantics:
+ *
+ * Setterm writes to standard output a character string that will
+ * invoke the specified terminal capabilities. Where possible
+ * terminfo is consulted to find the string to use. Some options
+ * however do not correspond to a terminfo capability. In this case if
+ * the terminal type is "con*", or "linux*" the string that invokes
+ * the specified capabilities on the PC Linux virtual console driver
+ * is output. Options that are not implemented by the terminal are
+ * ignored.
+ *
+ * The following options are non-obvious.
+ *
+ * -term can be used to override the TERM environment variable.
+ *
+ * -reset displays the terminal reset string, which typically resets the
+ * terminal to its power on state.
+ *
+ * -initialize displays the terminal initialization string, which typically
+ * sets the terminal's rendering options, and other attributes to the
+ * default values.
+ *
+ * -default sets the terminal's rendering options to the default values.
+ *
+ * -store stores the terminal's current rendering options as the default
+ * values. */
+
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/klog.h>
+#include <sys/param.h> /* for MAXPATHLEN */
+#include <sys/time.h>
+#include <termios.h>
+#include <unistd.h>
+
+#if defined(HAVE_NCURSESW_TERM_H)
+# include <ncursesw/term.h>
+#elif defined(HAVE_NCURSES_TERM_H)
+# include <ncurses/term.h>
+#elif defined(HAVE_TERM_H)
+# include <term.h>
+#endif
+
+#ifdef HAVE_LINUX_TIOCL_H
+# include <linux/tiocl.h>
+#endif
+
+#include "all-io.h"
+#include "c.h"
+#include "closestream.h"
+#include "nls.h"
+#include "optutils.h"
+#include "strutils.h"
+#include "xalloc.h"
+
+/* Constants. */
+
+/* Non-standard return values. */
+#define EXIT_DUMPFILE -1
+
+/* Colors. */
+enum {
+ BLACK = 0,
+ RED,
+ GREEN,
+ YELLOW,
+ BLUE,
+ MAGENTA,
+ CYAN,
+ WHITE,
+ GREY,
+ DEFAULT
+};
+
+static const char *colornames[] = {
+ [BLACK] = "black",
+ [RED] = "red",
+ [GREEN] = "green",
+ [YELLOW]= "yellow",
+ [BLUE] = "blue",
+ [MAGENTA]="magenta",
+ [CYAN] = "cyan",
+ [WHITE] = "white",
+ [GREY] = "grey",
+ [DEFAULT] = "default"
+};
+
+#define is_valid_color(x) (x >= 0 && (size_t) x < ARRAY_SIZE(colornames))
+
+/* Blank commands */
+enum {
+ BLANKSCREEN = -1,
+ UNBLANKSCREEN = -2,
+ BLANKEDSCREEN = -3
+};
+
+/* <linux/tiocl.h> fallback */
+#ifndef TIOCL_BLANKSCREEN
+enum {
+ TIOCL_UNBLANKSCREEN = 4, /* unblank screen */
+ TIOCL_SETVESABLANK = 10, /* set vesa blanking mode */
+ TIOCL_BLANKSCREEN = 14, /* keep screen blank even if a key is pressed */
+ TIOCL_BLANKEDSCREEN = 15 /* return which vt was blanked */
+};
+#endif
+
+/* Powersave modes */
+enum {
+ VESA_BLANK_MODE_OFF = 0,
+ VESA_BLANK_MODE_SUSPENDV,
+ VESA_BLANK_MODE_SUSPENDH,
+ VESA_BLANK_MODE_POWERDOWN
+};
+
+/* klogctl() actions */
+enum {
+ SYSLOG_ACTION_CONSOLE_OFF = 6,
+ SYSLOG_ACTION_CONSOLE_ON = 7,
+ SYSLOG_ACTION_CONSOLE_LEVEL = 8
+};
+
+/* Console log levels */
+enum {
+ CONSOLE_LEVEL_MIN = 0,
+ CONSOLE_LEVEL_MAX = 8
+};
+
+/* Various numbers */
+#define DEFAULT_TAB_LEN 8
+#define BLANK_MAX 60
+#define TABS_MAX 160
+#define BLENGTH_MAX 2000
+
+/* Command controls. */
+struct setterm_control {
+ char *opt_te_terminal_name; /* terminal name */
+ int opt_bl_min; /* blank screen */
+ int opt_blength_l; /* bell duration in milliseconds */
+ int opt_bfreq_f; /* bell frequency in Hz */
+ int opt_sn_num; /* console number to be snapshot */
+ char *opt_sn_name; /* path to write snap */
+ char *in_device; /* device to snapshot */
+ int opt_msglevel_num; /* printk() logging level */
+ int opt_ps_mode; /* powersave mode */
+ int opt_pd_min; /* powerdown time */
+ int opt_rt_len; /* regular tab length */
+ int opt_tb_array[TABS_MAX + 1]; /* array for tab list */
+ /* colors */
+ unsigned int opt_fo_color:4, opt_ba_color:4, opt_ul_color:4, opt_hb_color:4;
+ /* boolean options */
+ unsigned int opt_cu_on:1, opt_li_on:1, opt_bo_on:1, opt_hb_on:1,
+ opt_bl_on:1, opt_re_on:1, opt_un_on:1, opt_rep_on:1,
+ opt_appck_on:1, opt_invsc_on:1, opt_msg_on:1, opt_cl_all:1,
+ vcterm:1;
+ /* Option flags. Set when an option is invoked. */
+ uint64_t opt_term:1, opt_reset:1, opt_resize:1, opt_initialize:1, opt_cursor:1,
+ opt_linewrap:1, opt_default:1, opt_foreground:1,
+ opt_background:1, opt_bold:1, opt_blink:1, opt_reverse:1,
+ opt_underline:1, opt_store:1, opt_clear:1, opt_blank:1,
+ opt_snap:1, opt_snapfile:1, opt_append:1, opt_ulcolor:1,
+ opt_hbcolor:1, opt_halfbright:1, opt_repeat:1, opt_tabs:1,
+ opt_clrtabs:1, opt_regtabs:1, opt_appcursorkeys:1,
+ opt_inversescreen:1, opt_msg:1, opt_msglevel:1, opt_powersave:1,
+ opt_powerdown:1, opt_blength:1, opt_bfreq:1;
+};
+
+static int parse_color(const char *arg)
+{
+ size_t i;
+
+ for (i = 0; i < ARRAY_SIZE(colornames); i++) {
+ if (strcmp(colornames[i], arg) == 0)
+ return i;
+ }
+
+ return -EINVAL;
+}
+
+static int parse_febg_color(const char *arg)
+{
+ int color = parse_color(arg);
+
+ if (color < 0)
+ color = strtos32_or_err(arg, _("argument error"));
+
+ if (!is_valid_color(color) || color == GREY)
+ errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
+ return color;
+}
+
+static int parse_ulhb_color(char **av, int *oi)
+{
+ char *color_name;
+ int bright = 0;
+ int color = -1;
+
+ if (av[*oi] && strcmp(av[*oi - 1], "bright") == 0) {
+ bright = 1;
+ color_name = av[*oi];
+ (*oi)++;
+ } else
+ color_name = av[*oi - 1];
+
+ color = parse_color(color_name);
+ if (color < 0)
+ color = strtos32_or_err(color_name, _("argument error"));
+ if (!is_valid_color(color))
+ errx(EXIT_FAILURE, "%s: %s", _("argument error"), color_name);
+ if (bright && (color == BLACK || color == GREY))
+ errx(EXIT_FAILURE, _("argument error: bright %s is not supported"), color_name);
+
+ return color;
+}
+
+static char *find_optional_arg(char **av, char *oa, int *oi)
+{
+ char *arg;
+ if (oa)
+ return oa;
+ else {
+ arg = av[*oi];
+ if (!arg || arg[0] == '-')
+ return NULL;
+ }
+ (*oi)++;
+ return arg;
+}
+
+static int parse_blank(char **av, char *oa, int *oi)
+{
+ char *arg;
+
+ arg = find_optional_arg(av, oa, oi);
+ if (!arg)
+ return BLANKEDSCREEN;
+ if (!strcmp(arg, "force"))
+ return BLANKSCREEN;
+ else if (!strcmp(arg, "poke"))
+ return UNBLANKSCREEN;
+ else {
+ int ret;
+
+ ret = strtos32_or_err(arg, _("argument error"));
+ if (ret < 0 || BLANK_MAX < ret)
+ errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
+ return ret;
+ }
+}
+
+static int parse_powersave(const char *arg)
+{
+ if (strcmp(arg, "on") == 0)
+ return VESA_BLANK_MODE_SUSPENDV;
+ else if (strcmp(arg, "vsync") == 0)
+ return VESA_BLANK_MODE_SUSPENDV;
+ else if (strcmp(arg, "hsync") == 0)
+ return VESA_BLANK_MODE_SUSPENDH;
+ else if (strcmp(arg, "powerdown") == 0)
+ return VESA_BLANK_MODE_POWERDOWN;
+ else if (strcmp(arg, "off") == 0)
+ return VESA_BLANK_MODE_OFF;
+ errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
+}
+
+static int parse_msglevel(const char *arg)
+{
+ int ret;
+
+ ret = strtos32_or_err(arg, _("argument error"));
+ if (ret < CONSOLE_LEVEL_MIN || CONSOLE_LEVEL_MAX < ret)
+ errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
+ return ret;
+}
+
+static int parse_snap(char **av, char *oa, int *oi)
+{
+ int ret;
+ char *arg;
+
+ arg = find_optional_arg(av, oa, oi);
+ if (!arg)
+ return 0;
+ ret = strtos32_or_err(arg, _("argument error"));
+ if (ret < 1)
+ errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
+ return ret;
+}
+
+static void parse_tabs(char **av, char *oa, int *oi, int *tab_array)
+{
+ int i = 0;
+
+ if (oa) {
+ tab_array[i] = strtos32_or_err(oa, _("argument error"));
+ i++;
+ }
+ while (av[*oi]) {
+ if (TABS_MAX < i)
+ errx(EXIT_FAILURE, _("too many tabs"));
+ if (av[*oi][0] == '-')
+ break;
+ tab_array[i] = strtos32_or_err(av[*oi], _("argument error"));
+ (*oi)++;
+ i++;
+ }
+ tab_array[i] = -1;
+}
+
+static int parse_regtabs(char **av, char *oa, int *oi)
+{
+ int ret;
+ char *arg;
+
+ arg = find_optional_arg(av, oa, oi);
+ if (!arg)
+ return DEFAULT_TAB_LEN;
+ ret = strtos32_or_err(arg, _("argument error"));
+ if (ret < 1 || TABS_MAX < ret)
+ errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
+ return ret;
+}
+
+static int parse_blength(char **av, char *oa, int *oi)
+{
+ int ret = -1;
+ char *arg;
+
+ arg = find_optional_arg(av, oa, oi);
+ if (!arg)
+ return 0;
+ ret = strtos32_or_err(arg, _("argument error"));
+ if (ret < 0 || BLENGTH_MAX < ret)
+ errx(EXIT_FAILURE, "%s: %s", _("argument error"), arg);
+ return ret;
+}
+
+static int parse_bfreq(char **av, char *oa, int *oi)
+{
+ char *arg;
+
+ arg = find_optional_arg(av, oa, oi);
+ if (!arg)
+ return 0;
+ return strtos32_or_err(arg, _("argument error"));
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+ FILE *out = stdout;
+ fputs(USAGE_HEADER, out);
+ fprintf(out,
+ _(" %s [options]\n"), program_invocation_short_name);
+
+ fputs(USAGE_SEPARATOR, out);
+ fputs(_("Set the attributes of a terminal.\n"), out);
+
+ fputs(USAGE_OPTIONS, out);
+ fputs(_(" --term <terminal_name> override TERM environment variable\n"), out);
+ fputs(_(" --reset reset terminal to power-on state\n"), out);
+ fputs(_(" --resize reset terminal rows and columns\n"), out);
+ fputs(_(" --initialize display init string, and use default settings\n"), out);
+ fputs(_(" --default use default terminal settings\n"), out);
+ fputs(_(" --store save current terminal settings as default\n"), out);
+ fputs(_(" --cursor [on|off] display cursor\n"), out);
+ fputs(_(" --repeat [on|off] keyboard repeat\n"), out);
+ fputs(_(" --appcursorkeys [on|off] cursor key application mode\n"), out);
+ fputs(_(" --linewrap [on|off] continue on a new line when a line is full\n"), out);
+ fputs(_(" --inversescreen [on|off] swap colors for the whole screen\n"), out);
+ fputs(_(" --foreground default|<color> set foreground color\n"), out);
+ fputs(_(" --background default|<color> set background color\n"), out);
+ fputs(_(" --ulcolor [bright] <color> set underlined text color\n"), out);
+ fputs(_(" --hbcolor [bright] <color> set bold text color\n"), out);
+ fputs(_(" <color>: black blue cyan green grey magenta red white yellow\n"), out);
+ fputs(_(" --bold [on|off] bold\n"), out);
+ fputs(_(" --half-bright [on|off] dim\n"), out);
+ fputs(_(" --blink [on|off] blink\n"), out);
+ fputs(_(" --underline [on|off] underline\n"), out);
+ fputs(_(" --reverse [on|off] swap foreground and background colors\n"), out);
+ fputs(_(" --clear [all|rest] clear screen and set cursor position\n"), out);
+ fputs(_(" --tabs [<number>...] set these tab stop positions, or show them\n"), out);
+ fputs(_(" --clrtabs [<number>...] clear these tab stop positions, or all\n"), out);
+ fputs(_(" --regtabs [1-160] set a regular tab stop interval\n"), out);
+ fputs(_(" --blank [0-60|force|poke] set time of inactivity before screen blanks\n"), out);
+ fputs(_(" --dump [<number>] write vcsa<number> console dump to file\n"), out);
+ fputs(_(" --append [<number>] append vcsa<number> console dump to file\n"), out);
+ fputs(_(" --file <filename> name of the dump file\n"), out);
+ fputs(_(" --msg [on|off] send kernel messages to console\n"), out);
+ fputs(_(" --msglevel 0-8 kernel console log level\n"), out);
+ fputs(_(" --powersave [on|vsync|hsync|powerdown|off]\n"), out);
+ fputs(_(" set vesa powersaving features\n"), out);
+ fputs(_(" --powerdown [0-60] set vesa powerdown interval in minutes\n"), out);
+ fputs(_(" --blength [0-2000] duration of the bell in milliseconds\n"), out);
+ fputs(_(" --bfreq <number> bell frequency in Hertz\n"), out);
+ printf( " --help %s\n", USAGE_OPTSTR_HELP);
+ printf( " --version %s\n", USAGE_OPTSTR_VERSION);
+
+ printf(USAGE_MAN_TAIL("setterm(1)"));
+ exit(EXIT_SUCCESS);
+}
+
+static int __attribute__((__pure__)) set_opt_flag(int opt)
+{
+ if (opt)
+ errx(EXIT_FAILURE, _("duplicate use of an option"));
+ return 1;
+}
+
+static void parse_option(struct setterm_control *ctl, int ac, char **av)
+{
+ int c;
+ enum {
+ OPT_TERM = CHAR_MAX + 1,
+ OPT_RESET,
+ OPT_RESIZE,
+ OPT_INITIALIZE,
+ OPT_CURSOR,
+ OPT_REPEAT,
+ OPT_APPCURSORKEYS,
+ OPT_LINEWRAP,
+ OPT_DEFAULT,
+ OPT_FOREGROUND,
+ OPT_BACKGROUND,
+ OPT_ULCOLOR,
+ OPT_HBCOLOR,
+ OPT_INVERSESCREEN,
+ OPT_BOLD,
+ OPT_HALF_BRIGHT,
+ OPT_BLINK,
+ OPT_REVERSE,
+ OPT_UNDERLINE,
+ OPT_STORE,
+ OPT_CLEAR,
+ OPT_TABS,
+ OPT_CLRTABS,
+ OPT_REGTABS,
+ OPT_BLANK,
+ OPT_DUMP,
+ OPT_APPEND,
+ OPT_FILE,
+ OPT_MSG,
+ OPT_MSGLEVEL,
+ OPT_POWERSAVE,
+ OPT_POWERDOWN,
+ OPT_BLENGTH,
+ OPT_BFREQ,
+ OPT_VERSION,
+ OPT_HELP
+ };
+ static const struct option longopts[] = {
+ {"term", required_argument, NULL, OPT_TERM},
+ {"reset", no_argument, NULL, OPT_RESET},
+ {"resize", no_argument, NULL, OPT_RESIZE},
+ {"initialize", no_argument, NULL, OPT_INITIALIZE},
+ {"cursor", required_argument, NULL, OPT_CURSOR},
+ {"repeat", required_argument, NULL, OPT_REPEAT},
+ {"appcursorkeys", required_argument, NULL, OPT_APPCURSORKEYS},
+ {"linewrap", required_argument, NULL, OPT_LINEWRAP},
+ {"default", no_argument, NULL, OPT_DEFAULT},
+ {"foreground", required_argument, NULL, OPT_FOREGROUND},
+ {"background", required_argument, NULL, OPT_BACKGROUND},
+ {"ulcolor", required_argument, NULL, OPT_ULCOLOR},
+ {"hbcolor", required_argument, NULL, OPT_HBCOLOR},
+ {"inversescreen", required_argument, NULL, OPT_INVERSESCREEN},
+ {"bold", required_argument, NULL, OPT_BOLD},
+ {"half-bright", required_argument, NULL, OPT_HALF_BRIGHT},
+ {"blink", required_argument, NULL, OPT_BLINK},
+ {"reverse", required_argument, NULL, OPT_REVERSE},
+ {"underline", required_argument, NULL, OPT_UNDERLINE},
+ {"store", no_argument, NULL, OPT_STORE},
+ {"clear", required_argument, NULL, OPT_CLEAR},
+ {"tabs", optional_argument, NULL, OPT_TABS},
+ {"clrtabs", optional_argument, NULL, OPT_CLRTABS},
+ {"regtabs", optional_argument, NULL, OPT_REGTABS},
+ {"blank", optional_argument, NULL, OPT_BLANK},
+ {"dump", optional_argument, NULL, OPT_DUMP},
+ {"append", required_argument, NULL, OPT_APPEND},
+ {"file", required_argument, NULL, OPT_FILE},
+ {"msg", required_argument, NULL, OPT_MSG},
+ {"msglevel", required_argument, NULL, OPT_MSGLEVEL},
+ {"powersave", required_argument, NULL, OPT_POWERSAVE},
+ {"powerdown", optional_argument, NULL, OPT_POWERDOWN},
+ {"blength", optional_argument, NULL, OPT_BLENGTH},
+ {"bfreq", optional_argument, NULL, OPT_BFREQ},
+ {"version", no_argument, NULL, OPT_VERSION},
+ {"help", no_argument, NULL, OPT_HELP},
+ {NULL, 0, NULL, 0}
+ };
+ static const ul_excl_t excl[] = {
+ { OPT_DEFAULT, OPT_STORE },
+ { OPT_TABS, OPT_CLRTABS, OPT_REGTABS },
+ { OPT_MSG, OPT_MSGLEVEL },
+ { 0 }
+ };
+ int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
+
+ while ((c = getopt_long_only(ac, av, "", longopts, NULL)) != -1) {
+ err_exclusive_options(c, longopts, excl, excl_st);
+ switch (c) {
+ case OPT_TERM:
+ ctl->opt_term = set_opt_flag(ctl->opt_term);
+ ctl->opt_te_terminal_name = optarg;
+ break;
+ case OPT_RESET:
+ ctl->opt_reset = set_opt_flag(ctl->opt_reset);
+ break;
+ case OPT_RESIZE:
+ ctl->opt_resize = set_opt_flag(ctl->opt_resize);
+ break;
+ case OPT_INITIALIZE:
+ ctl->opt_initialize = set_opt_flag(ctl->opt_initialize);
+ break;
+ case OPT_CURSOR:
+ ctl->opt_cursor = set_opt_flag(ctl->opt_cursor);
+ ctl->opt_cu_on = parse_switch(optarg, _("argument error"),
+ "on", "off", NULL);
+ break;
+ case OPT_REPEAT:
+ ctl->opt_repeat = set_opt_flag(ctl->opt_repeat);
+ ctl->opt_rep_on = parse_switch(optarg, _("argument error"),
+ "on", "off", NULL);
+ break;
+ case OPT_APPCURSORKEYS:
+ ctl->opt_appcursorkeys = set_opt_flag(ctl->opt_appcursorkeys);
+ ctl->opt_appck_on = parse_switch(optarg, _("argument error"),
+ "on", "off", NULL);
+ break;
+ case OPT_LINEWRAP:
+ ctl->opt_linewrap = set_opt_flag(ctl->opt_linewrap);
+ ctl->opt_li_on = parse_switch(optarg, _("argument error"),
+ "on", "off", NULL);
+ break;
+ case OPT_DEFAULT:
+ ctl->opt_default = set_opt_flag(ctl->opt_default);
+ break;
+ case OPT_FOREGROUND:
+ ctl->opt_foreground = set_opt_flag(ctl->opt_foreground);
+ ctl->opt_fo_color = parse_febg_color(optarg);
+ break;
+ case OPT_BACKGROUND:
+ ctl->opt_background = set_opt_flag(ctl->opt_background);
+ ctl->opt_ba_color = parse_febg_color(optarg);
+ break;
+ case OPT_ULCOLOR:
+ ctl->opt_ulcolor = set_opt_flag(ctl->opt_ulcolor);
+ ctl->opt_ul_color = parse_ulhb_color(av, &optind);
+ break;
+ case OPT_HBCOLOR:
+ ctl->opt_hbcolor = set_opt_flag(ctl->opt_hbcolor);
+ ctl->opt_hb_color = parse_ulhb_color(av, &optind);
+ break;
+ case OPT_INVERSESCREEN:
+ ctl->opt_inversescreen = set_opt_flag(ctl->opt_inversescreen);
+ ctl->opt_invsc_on = parse_switch(optarg, _("argument error"),
+ "on", "off", NULL);
+ break;
+ case OPT_BOLD:
+ ctl->opt_bold = set_opt_flag(ctl->opt_bold);
+ ctl->opt_bo_on = parse_switch(optarg, _("argument error"),
+ "on", "off", NULL);
+ break;
+ case OPT_HALF_BRIGHT:
+ ctl->opt_halfbright = set_opt_flag(ctl->opt_halfbright);
+ ctl->opt_hb_on = parse_switch(optarg, _("argument error"),
+ "on", "off", NULL);
+ break;
+ case OPT_BLINK:
+ ctl->opt_blink = set_opt_flag(ctl->opt_blink);
+ ctl->opt_bl_on = parse_switch(optarg, _("argument error"),
+ "on", "off", NULL);
+ break;
+ case OPT_REVERSE:
+ ctl->opt_reverse = set_opt_flag(ctl->opt_reverse);
+ ctl->opt_re_on = parse_switch(optarg, _("argument error"),
+ "on", "off", NULL);
+ break;
+ case OPT_UNDERLINE:
+ ctl->opt_underline = set_opt_flag(ctl->opt_underline);
+ ctl->opt_un_on = parse_switch(optarg, _("argument error"),
+ "on", "off", NULL);
+ break;
+ case OPT_STORE:
+ ctl->opt_store = set_opt_flag(ctl->opt_store);
+ break;
+ case OPT_CLEAR:
+ ctl->opt_clear = set_opt_flag(ctl->opt_clear);
+ ctl->opt_cl_all = parse_switch(optarg, _("argument error"),
+ "all", "reset", NULL);
+ break;
+ case OPT_TABS:
+ ctl->opt_tabs = set_opt_flag(ctl->opt_tabs);
+ parse_tabs(av, optarg, &optind, ctl->opt_tb_array);
+ break;
+ case OPT_CLRTABS:
+ ctl->opt_clrtabs = set_opt_flag(ctl->opt_clrtabs);
+ parse_tabs(av, optarg, &optind, ctl->opt_tb_array);
+ break;
+ case OPT_REGTABS:
+ ctl->opt_regtabs = set_opt_flag(ctl->opt_regtabs);
+ ctl->opt_rt_len = parse_regtabs(av, optarg, &optind);
+ break;
+ case OPT_BLANK:
+ ctl->opt_blank = set_opt_flag(ctl->opt_blank);
+ ctl->opt_bl_min = parse_blank(av, optarg, &optind);
+ break;
+ case OPT_DUMP:
+ ctl->opt_snap = set_opt_flag(ctl->opt_snap);
+ ctl->opt_sn_num = parse_snap(av, optarg, &optind);
+ break;
+ case OPT_APPEND:
+ ctl->opt_append = set_opt_flag(ctl->opt_append);
+ ctl->opt_sn_num = parse_snap(av, optarg, &optind);
+ break;
+ case OPT_FILE:
+ ctl->opt_snapfile = set_opt_flag(ctl->opt_snapfile);
+ ctl->opt_sn_name = optarg;
+ break;
+ case OPT_MSG:
+ ctl->opt_msg = set_opt_flag(ctl->opt_msg);
+ ctl->opt_msg_on = parse_switch(optarg, _("argument error"),
+ "on", "off", NULL);
+ break;
+ case OPT_MSGLEVEL:
+ ctl->opt_msglevel = set_opt_flag(ctl->opt_msglevel);
+ ctl->opt_msglevel_num = parse_msglevel(optarg);
+ if (ctl->opt_msglevel_num == 0) {
+ ctl->opt_msg = set_opt_flag(ctl->opt_msg);
+ ctl->opt_msg_on |= 1;
+ }
+ break;
+ case OPT_POWERSAVE:
+ ctl->opt_powersave = set_opt_flag(ctl->opt_powersave);
+ ctl->opt_ps_mode = parse_powersave(optarg);
+ break;
+ case OPT_POWERDOWN:
+ ctl->opt_powerdown = set_opt_flag(ctl->opt_powerdown);
+ ctl->opt_pd_min = parse_blank(av, optarg, &optind);
+ break;
+ case OPT_BLENGTH:
+ ctl->opt_blength = set_opt_flag(ctl->opt_blength);
+ ctl->opt_blength_l = parse_blength(av, optarg, &optind);
+ break;
+ case OPT_BFREQ:
+ ctl->opt_bfreq = set_opt_flag(ctl->opt_bfreq);
+ ctl->opt_bfreq_f = parse_bfreq(av, optarg, &optind);
+ break;
+ case OPT_VERSION:
+ printf(UTIL_LINUX_VERSION);
+ exit(EXIT_SUCCESS);
+ case OPT_HELP:
+ usage();
+ default:
+ errtryhelp(EXIT_FAILURE);
+ }
+ }
+}
+
+/* Return the specified terminfo string, or an empty string if no such
+ * terminfo capability exists. */
+static char *ti_entry(const char *name)
+{
+ char *buf_ptr;
+
+ if ((buf_ptr = tigetstr(name)) == (char *)-1)
+ buf_ptr = NULL;
+ return buf_ptr;
+}
+
+static void show_tabs(void)
+{
+ int i, co = tigetnum("cols");
+
+ if (co > 0) {
+ printf("\r ");
+ for (i = 10; i < co - 2; i += 10)
+ printf("%-10d", i);
+ putchar('\n');
+ for (i = 1; i <= co; i++)
+ putchar(i % 10 + '0');
+ putchar('\n');
+ for (i = 1; i < co; i++)
+ printf("\tT\b");
+ putchar('\n');
+ }
+}
+
+static int open_snapshot_device(struct setterm_control *ctl)
+{
+ int fd;
+
+ if (ctl->opt_sn_num)
+ xasprintf(&ctl->in_device, "/dev/vcsa%d", ctl->opt_sn_num);
+ else
+ xasprintf(&ctl->in_device, "/dev/vcsa");
+ fd = open(ctl->in_device, O_RDONLY);
+ if (fd < 0)
+ err(EXIT_DUMPFILE, _("cannot read %s"), ctl->in_device);
+ return fd;
+}
+
+static void set_blanking(struct setterm_control *ctl)
+{
+ char ioctlarg;
+ int ret;
+
+ if (0 <= ctl->opt_bl_min) {
+ printf("\033[9;%d]", ctl->opt_bl_min);
+ return;
+ }
+ switch (ctl->opt_bl_min) {
+ case BLANKSCREEN:
+ ioctlarg = TIOCL_BLANKSCREEN;
+ if (ioctl(STDIN_FILENO, TIOCLINUX, &ioctlarg))
+ warn(_("cannot force blank"));
+ break;
+ case UNBLANKSCREEN:
+ ioctlarg = TIOCL_UNBLANKSCREEN;
+ if (ioctl(STDIN_FILENO, TIOCLINUX, &ioctlarg))
+ warn(_("cannot force unblank"));
+ break;
+ case BLANKEDSCREEN:
+ ioctlarg = TIOCL_BLANKEDSCREEN;
+ ret = ioctl(STDIN_FILENO, TIOCLINUX, &ioctlarg);
+ if (ret < 0)
+ warn(_("cannot get blank status"));
+ else
+ printf("%d\n", ret);
+ break;
+ default: /* should be impossible to reach */
+ abort();
+ }
+ return;
+}
+
+static void screendump(struct setterm_control *ctl)
+{
+ unsigned char header[4];
+ unsigned int rows, cols;
+ int fd;
+ FILE *out;
+ size_t i, j;
+ ssize_t rc;
+ char *inbuf, *outbuf, *p, *q;
+
+ /* open source and destination files */
+ fd = open_snapshot_device(ctl);
+ if (!ctl->opt_sn_name)
+ ctl->opt_sn_name = "screen.dump";
+ out = fopen(ctl->opt_sn_name, ctl->opt_snap ? "w" : "a");
+ if (!out)
+ err(EXIT_DUMPFILE, _("cannot open dump file %s for output"), ctl->opt_sn_name);
+ /* determine snapshot size */
+ if (read(fd, header, 4) != 4)
+ err(EXIT_DUMPFILE, _("cannot read %s"), ctl->in_device);
+ rows = header[0];
+ cols = header[1];
+ if (rows * cols == 0)
+ err(EXIT_DUMPFILE, _("cannot read %s"), ctl->in_device);
+ /* allocate buffers */
+ inbuf = xmalloc(rows * cols * 2);
+ outbuf = xmalloc(rows * (cols + 1));
+ /* read input */
+ rc = read(fd, inbuf, rows * cols * 2);
+ if (rc < 0 || (size_t)rc != rows * cols * 2)
+ err(EXIT_DUMPFILE, _("cannot read %s"), ctl->in_device);
+ p = inbuf;
+ q = outbuf;
+ /* copy inbuf to outbuf */
+ for (i = 0; i < rows; i++) {
+ for (j = 0; j < cols; j++) {
+ *q++ = *p;
+ p += 2;
+ }
+ while (j-- > 0 && q[-1] == ' ')
+ q--;
+ *q++ = '\n';
+ }
+ fwrite(outbuf, 1, q - outbuf, out);
+ /* clean up allocations */
+ close(fd);
+ free(inbuf);
+ free(outbuf);
+ free(ctl->in_device);
+ if (close_stream(out) != 0)
+ errx(EXIT_FAILURE, _("write error"));
+ return;
+}
+
+/* Some options are applicable when terminal is virtual console. */
+static int vc_only(struct setterm_control *ctl, const char *err)
+{
+ if (!ctl->vcterm && err)
+ warnx(_("terminal %s does not support %s"),
+ ctl->opt_te_terminal_name, err);
+ return ctl->vcterm;
+}
+
+static void tty_raw(struct termios *saved_attributes, int *saved_fl)
+{
+ struct termios tattr;
+
+ fcntl(STDIN_FILENO, F_GETFL, saved_fl);
+ tcgetattr(STDIN_FILENO, saved_attributes);
+ fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK);
+ memcpy(&tattr, saved_attributes, sizeof(struct termios));
+ tattr.c_lflag &= ~(ICANON | ECHO);
+ tattr.c_cc[VMIN] = 1;
+ tattr.c_cc[VTIME] = 0;
+ tcsetattr(STDIN_FILENO, TCSAFLUSH, &tattr);
+}
+
+static void tty_restore(struct termios *saved_attributes, int *saved_fl)
+{
+ fcntl(STDIN_FILENO, F_SETFL, *saved_fl);
+ tcsetattr(STDIN_FILENO, TCSANOW, saved_attributes);
+}
+
+static int select_wait(void)
+{
+ struct timeval tv;
+ fd_set set;
+ int ret;
+
+ FD_ZERO(&set);
+ FD_SET(STDIN_FILENO, &set);
+ tv.tv_sec = 10;
+ tv.tv_usec = 0;
+ while ((ret = select(1, &set, NULL, NULL, &tv)) < 0) {
+ if (errno == EINTR)
+ continue;
+ err(EXIT_FAILURE, _("select failed"));
+ }
+ return ret;
+}
+
+static int resizetty(void)
+{
+ /*
+ * \e7 Save current state (cursor coordinates, attributes,
+ * character sets pointed at by G0, G1).
+ * \e[r Set scrolling region; parameters are top and bottom row.
+ * \e[32766E Move cursor down 32766 (INT16_MAX - 1) rows.
+ * \e[32766C Move cursor right 32766 columns.
+ * \e[6n Report cursor position.
+ * \e8 Restore state most recently saved by \e7.
+ */
+ static const char *getpos = "\e7\e[r\e[32766E\e[32766C\e[6n\e8";
+ char retstr[32];
+ int row, col;
+ size_t pos;
+ ssize_t rc;
+ struct winsize ws;
+ struct termios saved_attributes;
+ int saved_fl;
+
+ if (!isatty(STDIN_FILENO))
+ errx(EXIT_FAILURE, _("stdin does not refer to a terminal"));
+
+ tty_raw(&saved_attributes, &saved_fl);
+ if (write_all(STDIN_FILENO, getpos, strlen(getpos)) < 0) {
+ warn(_("write failed"));
+ tty_restore(&saved_attributes, &saved_fl);
+ return 1;
+ }
+ for (pos = 0; pos < sizeof(retstr) - 1;) {
+ if (0 == select_wait())
+ break;
+ if ((rc =
+ read(STDIN_FILENO, retstr + pos,
+ sizeof(retstr) - 1 - pos)) < 0) {
+ if (errno == EINTR)
+ continue;
+ warn(_("read failed"));
+ tty_restore(&saved_attributes, &saved_fl);
+ return 1;
+ }
+ pos += rc;
+ if (retstr[pos - 1] == 'R')
+ break;
+ }
+ retstr[pos] = 0;
+ tty_restore(&saved_attributes, &saved_fl);
+ rc = sscanf(retstr, "\033[%d;%dR", &row, &col);
+ if (rc != 2) {
+ warnx(_("invalid cursor position: %s"), retstr);
+ return 1;
+ }
+ memset(&ws, 0, sizeof(struct winsize));
+ ioctl(STDIN_FILENO, TIOCGWINSZ, &ws);
+ ws.ws_row = row;
+ ws.ws_col = col;
+ ioctl(STDIN_FILENO, TIOCSWINSZ, &ws);
+ return 0;
+}
+
+static void perform_sequence(struct setterm_control *ctl)
+{
+ int result;
+
+ /* -reset. */
+ if (ctl->opt_reset)
+ putp(ti_entry("rs1"));
+
+ /* -resize. */
+ if (ctl->opt_resize)
+ if (resizetty())
+ warnx(_("reset failed"));
+
+ /* -initialize. */
+ if (ctl->opt_initialize)
+ putp(ti_entry("is2"));
+
+ /* -cursor [on|off]. */
+ if (ctl->opt_cursor) {
+ if (ctl->opt_cu_on)
+ putp(ti_entry("cnorm"));
+ else
+ putp(ti_entry("civis"));
+ }
+
+ /* -linewrap [on|off]. */
+ if (ctl->opt_linewrap)
+ fputs(ctl->opt_li_on ? "\033[?7h" : "\033[?7l", stdout);
+
+ /* -repeat [on|off]. */
+ if (ctl->opt_repeat && vc_only(ctl, "--repeat"))
+ fputs(ctl->opt_rep_on ? "\033[?8h" : "\033[?8l", stdout);
+
+ /* -appcursorkeys [on|off]. */
+ if (ctl->opt_appcursorkeys && vc_only(ctl, "--appcursorkeys"))
+ fputs(ctl->opt_appck_on ? "\033[?1h" : "\033[?1l", stdout);
+
+ /* -default. Vc sets default rendition, otherwise clears all
+ * attributes. */
+ if (ctl->opt_default) {
+ if (vc_only(ctl, NULL))
+ printf("\033[0m");
+ else
+ putp(ti_entry("sgr0"));
+ }
+
+ /* -foreground black|red|green|yellow|blue|magenta|cyan|white|default. */
+ if (ctl->opt_foreground)
+ printf("\033[3%c%s", '0' + ctl->opt_fo_color, "m");
+
+ /* -background black|red|green|yellow|blue|magenta|cyan|white|default. */
+ if (ctl->opt_background)
+ printf("\033[4%c%s", '0' + ctl->opt_ba_color, "m");
+
+ /* -ulcolor black|red|green|yellow|blue|magenta|cyan|white|default. */
+ if (ctl->opt_ulcolor && vc_only(ctl, "--ulcolor"))
+ printf("\033[1;%d]", ctl->opt_ul_color);
+
+ /* -hbcolor black|red|green|yellow|blue|magenta|cyan|white|default. */
+ if (ctl->opt_hbcolor)
+ printf("\033[2;%d]", ctl->opt_hb_color);
+
+ /* -inversescreen [on|off]. */
+ if (ctl->opt_inversescreen)
+ fputs(ctl->opt_invsc_on ? "\033[?5h" : "\033[?5l", stdout);
+
+ /* -bold [on|off]. Vc behaves as expected, otherwise off turns off
+ * all attributes. */
+ if (ctl->opt_bold) {
+ if (ctl->opt_bo_on)
+ putp(ti_entry("bold"));
+ else {
+ if (vc_only(ctl, NULL))
+ fputs("\033[22m", stdout);
+ else
+ putp(ti_entry("sgr0"));
+ }
+ }
+
+ /* -half-bright [on|off]. Vc behaves as expected, otherwise off
+ * turns off all attributes. */
+ if (ctl->opt_halfbright) {
+ if (ctl->opt_hb_on)
+ putp(ti_entry("dim"));
+ else {
+ if (vc_only(ctl, NULL))
+ fputs("\033[22m", stdout);
+ else
+ putp(ti_entry("sgr0"));
+ }
+ }
+
+ /* -blink [on|off]. Vc behaves as expected, otherwise off turns off
+ * all attributes. */
+ if (ctl->opt_blink) {
+ if (ctl->opt_bl_on)
+ putp(ti_entry("blink"));
+ else {
+ if (vc_only(ctl, NULL))
+ fputs("\033[25m", stdout);
+ else
+ putp(ti_entry("sgr0"));
+ }
+ }
+
+ /* -reverse [on|off]. Vc behaves as expected, otherwise off turns
+ * off all attributes. */
+ if (ctl->opt_reverse) {
+ if (ctl->opt_re_on)
+ putp(ti_entry("rev"));
+ else {
+ if (vc_only(ctl, NULL))
+ fputs("\033[27m", stdout);
+ else
+ putp(ti_entry("sgr0"));
+ }
+ }
+
+ /* -underline [on|off]. */
+ if (ctl->opt_underline)
+ putp(ti_entry(ctl->opt_un_on ? "smul" : "rmul"));
+
+ /* -store. */
+ if (ctl->opt_store && vc_only(ctl, "--store"))
+ fputs("\033[8]", stdout);
+
+ /* -clear [all|rest]. */
+ if (ctl->opt_clear)
+ putp(ti_entry(ctl->opt_cl_all ? "clear" : "ed"));
+
+ /* -tabs. */
+ if (ctl->opt_tabs) {
+ if (ctl->opt_tb_array[0] == -1)
+ show_tabs();
+ else {
+ int i;
+
+ for (i = 0; ctl->opt_tb_array[i] > 0; i++)
+ printf("\033[%dG\033H", ctl->opt_tb_array[i]);
+ putchar('\r');
+ }
+ }
+
+ /* -clrtabs. */
+ if (ctl->opt_clrtabs && vc_only(ctl, "--clrtabs")) {
+ int i;
+
+ if (ctl->opt_tb_array[0] == -1)
+ fputs("\033[3g", stdout);
+ else
+ for (i = 0; ctl->opt_tb_array[i] > 0; i++)
+ printf("\033[%dG\033[g", ctl->opt_tb_array[i]);
+ putchar('\r');
+ }
+
+ /* -regtabs. */
+ if (ctl->opt_regtabs && vc_only(ctl, "--regtabs")) {
+ int i;
+
+ fputs("\033[3g\r", stdout);
+ for (i = ctl->opt_rt_len + 1; i <= TABS_MAX; i += ctl->opt_rt_len)
+ printf("\033[%dC\033H", ctl->opt_rt_len);
+ putchar('\r');
+ }
+
+ /* -blank [0-60]. */
+ if (ctl->opt_blank && vc_only(ctl, "--blank"))
+ set_blanking(ctl);
+
+ /* -powersave [on|vsync|hsync|powerdown|off] (console) */
+ if (ctl->opt_powersave) {
+ char ioctlarg[2];
+ ioctlarg[0] = TIOCL_SETVESABLANK;
+ ioctlarg[1] = ctl->opt_ps_mode;
+ if (ioctl(STDIN_FILENO, TIOCLINUX, ioctlarg))
+ warn(_("cannot (un)set powersave mode"));
+ }
+
+ /* -powerdown [0-60]. */
+ if (ctl->opt_powerdown)
+ printf("\033[14;%d]", ctl->opt_pd_min);
+
+ /* -snap [1-NR_CONS]. */
+ if (ctl->opt_snap || ctl->opt_append)
+ screendump(ctl);
+
+ /* -msg [on|off]. Controls printk's to console. */
+ if (ctl->opt_msg && vc_only(ctl, "--msg")) {
+ if (ctl->opt_msg_on)
+ result = klogctl(SYSLOG_ACTION_CONSOLE_ON, NULL, 0);
+ else
+ result = klogctl(SYSLOG_ACTION_CONSOLE_OFF, NULL, 0);
+
+ if (result != 0)
+ warn(_("klogctl error"));
+ }
+
+ /* -msglevel [0-8]. Console printk message level. */
+ if (ctl->opt_msglevel_num && vc_only(ctl, "--msglevel")) {
+ result =
+ klogctl(SYSLOG_ACTION_CONSOLE_LEVEL, NULL,
+ ctl->opt_msglevel_num);
+ if (result != 0)
+ warn(_("klogctl error"));
+ }
+
+ /* -blength [0-2000] */
+ if (ctl->opt_blength && vc_only(ctl, "--blength")) {
+ printf("\033[11;%d]", ctl->opt_blength_l);
+ }
+
+ /* -bfreq freqnumber */
+ if (ctl->opt_bfreq && vc_only(ctl, "--bfreq")) {
+ printf("\033[10;%d]", ctl->opt_bfreq_f);
+ }
+}
+
+static void init_terminal(struct setterm_control *ctl)
+{
+ int term_errno;
+
+ if (!ctl->opt_te_terminal_name) {
+ ctl->opt_te_terminal_name = getenv("TERM");
+ if (ctl->opt_te_terminal_name == NULL)
+ errx(EXIT_FAILURE, _("$TERM is not defined."));
+ }
+
+ /* Find terminfo entry. */
+ if (setupterm(ctl->opt_te_terminal_name, STDOUT_FILENO, &term_errno))
+ switch (term_errno) {
+ case -1:
+ errx(EXIT_FAILURE, _("terminfo database cannot be found"));
+ case 0:
+ errx(EXIT_FAILURE, _("%s: unknown terminal type"), ctl->opt_te_terminal_name);
+ case 1:
+ errx(EXIT_FAILURE, _("terminal is hardcopy"));
+ }
+
+ /* See if the terminal is a virtual console terminal. */
+ ctl->vcterm = (!strncmp(ctl->opt_te_terminal_name, "con", 3) ||
+ !strncmp(ctl->opt_te_terminal_name, "linux", 5));
+}
+
+
+int main(int argc, char **argv)
+{
+ struct setterm_control ctl = { NULL };
+
+ setlocale(LC_ALL, "");
+ bindtextdomain(PACKAGE, LOCALEDIR);
+ textdomain(PACKAGE);
+ atexit(close_stdout);
+
+ if (argc < 2) {
+ warnx(_("bad usage"));
+ errtryhelp(EXIT_FAILURE);
+ }
+ parse_option(&ctl, argc, argv);
+ init_terminal(&ctl);
+ perform_sequence(&ctl);
+
+ return EXIT_SUCCESS;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-27 10:41:33 +0000