/* 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) || color == DEFAULT)
		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);

	if (bright)
		color |= 8;

	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 half-bright 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:
			print_version(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 [bright] black|red|green|yellow|blue|magenta|cyan|white. */
	if (ctl->opt_ulcolor && vc_only(ctl, "--ulcolor"))
		printf("\033[1;%d]", ctl->opt_ul_color);

	/* -hbcolor [bright] black|red|green|yellow|blue|magenta|cyan|white. */
	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);
	close_stdout_atexit();

	if (argc < 2) {
		warnx(_("bad usage"));
		errtryhelp(EXIT_FAILURE);
	}
	parse_option(&ctl, argc, argv);
	init_terminal(&ctl);
	perform_sequence(&ctl);

	return EXIT_SUCCESS;
}