/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright (c) 2012 Gary Mills
 */

/*	Copyright (c) 1988 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 *	tput - print terminal attribute
 *
 *  return-codes - command line arguments:
 *	0: ok if boolean capname -> TRUE
 *	1: for boolean capname -> FALSE
 *
 *  return-codes - standard input arguments:
 *	0: ok; tput for all lines was successful
 *
 *  return-codes - both cases:
 *	2	usage error
 *	3	bad terminal type given or no terminfo database
 *	4	unknown capname
 *	-1	capname is a numeric variable that is not specified in the
 *		terminfo database(E.g. tpu -T450 lines).
 *
 *  tput printfs a value if an INT capname was given; e.g. cols.
 *	putp's a string if a STRING capname was given; e.g. clear. and
 *  for BOOLEAN capnames, e.g. hard-copy, just returns the boolean value.
 */

#include <curses.h>
#include <term.h>
#include <fcntl.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <locale.h>

/* externs from libcurses */
extern int tigetnum();

static int outputcap(char *cap, int argc, char **argv);
static int allnumeric(char *string);
static int getpad(char *cap);
static void setdelay();
static void settabs();
static void cat(char *file);
static void initterm();
static void reset_term();

static char *progname;		/* argv[0] */
static int CurrentBaudRate;	/* current baud rate */
static int reset = 0;		/* called as reset_term */
static int fildes = 1;

int
main(int argc, char **argv)
{
	int i, std_argc;
	char *term = getenv("TERM");
	char *cap, std_input = FALSE;
	int setuperr;

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	progname = argv[0];

	while ((i = getopt(argc, argv, "ST:")) != EOF) {
		switch (i) {
		case 'T':
			fildes = -1;
			(void) putenv("LINES=");
			(void) putenv("COLUMNS=");
			term = optarg;
			break;

		case 'S':
			std_input = TRUE;
			break;

		case '?':			/* FALLTHROUGH		*/
		usage:				/* FALLTHROUGH		*/
		default:
			(void) fprintf(stderr, gettext(
			    "usage:\t%s [-T [term]] capname "
			    "[parm argument...]\n"), progname);
			(void) fprintf(stderr, gettext("OR:\t%s -S <<\n"),
			    progname);
			exit(2);
		}
	}

	if (!term || !*term) {
		(void) fprintf(stderr,
		    gettext("%s: No value for $TERM and no -T specified\n"),
		    progname);
		exit(2);
	}

	(void) setupterm(term, fildes, &setuperr);

	switch (setuperr) {
	case -2:
		(void) fprintf(stderr,
		    gettext("%s: unreadable terminal descriptor \"%s\"\n"),
		    progname, term);
		exit(3);
		break;

	case -1:
		(void) fprintf(stderr,
		    gettext("%s: no terminfo database\n"), progname);
		exit(3);
		break;

	case 0:
		(void) fprintf(stderr,
		    gettext("%s: unknown terminal \"%s\"\n"),
		    progname, term);
		exit(3);
	}

	reset_shell_mode();

	/* command line arguments */
	if (!std_input) {
		if (argc == optind)
			goto usage;

		cap = argv[optind++];

		if (strcmp(cap, "init") == 0)
			initterm();
		else if (strcmp(cap, "reset") == 0)
			reset_term();
		else if (strcmp(cap, "longname") == 0)
			(void) printf("%s\n", longname());
		else
			exit(outputcap(cap, argc, argv));
		return (0);
	} else {			/* standard input argumets	*/
		char buff[128];
		char **v;

		/* allocate storage for the 'faked' argv[] array	*/
		v = (char **)malloc(10 * sizeof (char *));
		for (i = 0; i < 10; i++)
			v[i] = (char *)malloc(32 * sizeof (char));

		while (fgets(buff, sizeof (buff), stdin) != NULL) {
			/* read standard input line; skip over empty lines */
			if ((std_argc =
			    sscanf(buff,
			    "%31s %31s %31s %31s %31s %31s %31s %31s "
			    "%31s %31s",
			    v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7],
			    v[8], v[9])) < 1) {
				continue;
			}

			cap = v[0];
			optind = 1;

			if (strcmp(cap, "init") == 0) {
				initterm();
			} else if (strcmp(cap, "reset") == 0) {
				reset_term();
			} else if (strcmp(cap, "longname") == 0) {
				(void) printf("%s\n", longname());
			} else {
				(void) outputcap(cap, std_argc, v);
			}
			(void) fflush(stdout);
		}

		return (0);
	}
}

static long parm[9] = {
    0, 0, 0, 0, 0, 0, 0, 0, 0
};

static int
outputcap(char *cap, int argc, char **argv)
{
	int parmset = 0;
	char *thisstr;
	int i;

	if ((i = tigetflag(cap)) >= 0)
		return (1 - i);

	if ((i = tigetnum(cap)) >= -1) {
		(void) printf("%d\n", i);
		return (0);
	}

	if ((thisstr = tigetstr(cap)) != (char *)-1) {
		if (!thisstr) {
			return (1);
		}
		for (parmset = 0; optind < argc; optind++, parmset++)
			if (allnumeric(argv[optind]))
				parm[parmset] = atoi(argv[optind]);
			else
				parm[parmset] = (int)argv[optind];

		if (parmset)
			putp(tparm(thisstr,
			    parm[0], parm[1], parm[2], parm[3],
			    parm[4], parm[5], parm[6], parm[7], parm[8]));
		else
			putp(thisstr);
		return (0);
	}

	(void) fprintf(stderr,
	    gettext("%s: unknown terminfo capability '%s'\n"), progname, cap);

	exit(4);
	/* NOTREACHED */
}

/*
 *  The decision as to whether an argument is a number or not is to simply
 *  look at whether there are any non-digits in the string.
 */
static int
allnumeric(char *string)
{
	if (*string) {
		while (*string) {
			if (!isdigit(*string++)) {
				return (0);
			}
		}
		return (1);
	} else {
		return (0);
	}
}

/*
 *  SYSTEM DEPENDENT TERMINAL DELAY TABLES
 *
 *	These tables maintain the correspondence between the delays
 *	defined in terminfo and the delay algorithms in the tty driver
 *	on the particular systems. For each type of delay, the bits used
 *	for that delay must be specified, in XXbits, and a table
 *	must be defined giving correspondences between delays and
 *	algorithms. Algorithms which are not fixed delays, such
 *	as dependent on current column or line number, must be
 *	kludged in some way at this time.
 *
 *	Some of this was taken from tset(1).
 */

struct delay
{
    int d_delay;
    int d_bits;
};

/* The appropriate speeds for various termio settings. */
static int speeds[] = {
	0,		/* B0		*/
	50,		/* B50		*/
	75,		/* B75		*/
	110,		/* B110		*/
	134,		/* B134		*/
	150,		/* B150		*/
	200,		/* B200		*/
	300,		/* B300		*/
	600,		/* B600		*/
	1200,		/* B1200	*/
	1800,		/* B1800	*/
	2400,		/* B2400	*/
	4800,		/* B4800	*/
	9600,		/* B9600	*/
	19200,		/* B19200	*/
	38400,		/* B38400	*/
	57600,		/* B57600	*/
	76800,		/* B76800	*/
	115200,		/* B115200	*/
	153600,		/* B153600	*/
	230400,		/* B230400	*/
	307200,		/* B307200	*/
	460800,		/* B460800	*/
	921600,		/* B921600	*/
	1000000,	/* B1000000	*/
	1152000,	/* B1152000	*/
	1500000,	/* B1500000	*/
	2000000,	/* B2000000	*/
	2500000,	/* B2500000	*/
	3000000,	/* B3000000	*/
	3500000,	/* B3500000	*/
	4000000,	/* B4000000	*/
	0
};

#if defined(SYSV) || defined(USG)
/*	Unix 3.0 on up */

/*    Carriage Return delays	*/

static int	CRbits = CRDLY;
static struct delay	CRdelay[] =
{
	0,	CR0,
	80,	CR1,
	100,	CR2,
	150,	CR3,
	-1
};

/*	New Line delays	*/

static int	NLbits = NLDLY;
static struct delay	NLdelay[] =
{
	0,	NL0,
	100,	NL1,
	-1
};

/*	Back Space delays	*/

static int	BSbits = BSDLY;
static struct delay	BSdelay[] =
{
	0,	BS0,
	50,	BS1,
	-1
};

/*	TaB delays	*/

static int	TBbits = TABDLY;
static struct delay	TBdelay[] =
{
	0,	TAB0,
	11,	TAB1,		/* special M37 delay */
	100,	TAB2,
				/* TAB3 is XTABS and not a delay */
	-1
};

/*	Form Feed delays	*/

static int	FFbits = FFDLY;
static struct delay	FFdelay[] =
{
	0,	FF0,
	2000,	FF1,
	-1
};

#else	/* BSD */

/*	Carriage Return delays	*/

int	CRbits = CRDELAY;
struct delay	CRdelay[] =
{
	0,	CR0,
	9,	CR3,
	80,	CR1,
	160,	CR2,
	-1
};

/*	New Line delays	*/

int	NLbits = NLDELAY;
struct delay	NLdelay[] =
{
	0,	NL0,
	66,	NL1,		/* special M37 delay */
	100,	NL2,
	-1
};

/*	Tab delays	*/

int	TBbits = TBDELAY;
struct delay	TBdelay[] =
{
	0,	TAB0,
	11,	TAB1,		/* special M37 delay */
	-1
};

/*	Form Feed delays	*/

int	FFbits = VTDELAY;
struct delay	FFdelay[] =
{
	0,	FF0,
	2000,	FF1,
	-1
};
#endif	/* BSD */

/*
 *  Initterm, a.k.a. reset_term, does terminal specific initialization. In
 *  particular, the init_strings from terminfo are output and tabs are
 *  set, if they aren't hardwired in. Much of this stuff was done by
 *  the tset(1) program.
 */

/*
 *  Figure out how many milliseconds of padding the capability cap
 *  needs and return that number. Padding is stored in the string as "$<n>",
 *  where n is the number of milliseconds of padding. More than one
 *  padding string is allowed within the string, although this is unlikely.
 */

static int
getpad(char *cap)
{
	int padding = 0;

	/* No padding needed at speeds below padding_baud_rate */
	if (padding_baud_rate > CurrentBaudRate || cap == NULL)
		return (0);

	while (*cap) {
		if ((cap[0] == '$') && (cap[1] == '<')) {
			cap++;
			cap++;
			padding += atoi(cap);
			while (isdigit (*cap))
				cap++;
			while (*cap == '.' || *cap == '/' || *cap == '*' ||
			    isdigit(*cap))
				cap++;
			while (*cap == '>')
				cap++;
		} else {
			cap++;
		}
	}

	return (padding);
}

/*
 *  Set the appropriate delay bits in the termio structure for
 *  the given delay.
 */
static void
setdelay(delay, delaytable, bits, flags)
register int delay;
struct delay delaytable[];
int bits;
#ifdef SYSV
tcflag_t *flags;
#else	/* SYSV */
unsigned short *flags;
#endif	/* SYSV */
{
	register struct delay  *p;
	register struct delay  *lastdelay;

	/* Clear out the bits, replace with new ones */
	*flags &= ~bits;

	/* Scan the delay table for first entry with adequate delay */
	for (lastdelay = p = delaytable;
	    (p -> d_delay >= 0) && (p -> d_delay < delay);
	    p++) {
		lastdelay = p;
	}

	/* use last entry if none will do */
	*flags |= lastdelay -> d_bits;
}

/*
 * Set the hardware tabs on the terminal, using clear_all_tabs,
 * set_tab, and column_address capabilities. Cursor_address and cursor_right
 * may also be used, if necessary.
 * This is done before the init_file and init_3string, so they can patch in
 * case we blow this.
 */

static void
settabs()
{
	register int c;

	/* Do not set tabs if they power up properly. */
	if (init_tabs == 8)
		return;

	if (set_tab) {
		/* Force the cursor to be at the left margin. */
		if (carriage_return)
			putp(carriage_return);
		else
			(void) putchar('\r');

		/* Clear any current tab settings. */
		if (clear_all_tabs)
			putp(clear_all_tabs);

		/* Set the tabs. */
		for (c = 8; c < columns; c += 8) {
			/* Get to that column. */
			(void) fputs("        ", stdout);

			/* Set the tab. */
			putp(set_tab);
		}

		/* Get back to the left column. */
		if (carriage_return)
			putp(carriage_return);
		else
			(void) putchar('\r');

	}
}

/*
 *  Copy "file" onto standard output.
 */

static void
cat(file)
char *file;				/* File to copy. */
{
	register int fd;			/* File descriptor. */
	register ssize_t i;			/* Number characters read. */
	char buf[BUFSIZ];			/* Buffer to read into. */

	fd = open(file, O_RDONLY);

	if (fd < 0) {
		perror("Cannot open initialization file");
	} else {
		while ((i = read(fd, buf, BUFSIZ)) > (ssize_t)0)
			(void) write(fileno(stdout), buf, (unsigned)i);
		(int)close(fd);
	}
}

/*
 *  Initialize the terminal.
 *  Send the initialization strings to the terminal.
 */

static void
initterm()
{
	register int filedes;		/* File descriptor for ioctl's. */
#if defined(SYSV) || defined(USG)
	struct termio termmode;		/* To hold terminal settings. */
	struct termios termmodes;	/* To hold terminal settings. */
	int i;
	int istermios = -1;
#define	GTTY(fd, mode)	ioctl(fd, TCGETA, mode)
#define	GTTYS(fd, mode) \
	(istermios = ioctl(fd, TCGETS, mode))
#define	STTY(fd, mode)	ioctl(fd, TCSETAW, mode)
#define	STTYS(fd, mode)	ioctl(fd, TCSETSW, mode)
#define	SPEED(mode)	(mode.c_cflag & CBAUD)
#define	SPEEDS(mode)	(cfgetospeed(&mode))
#define	OFLAG(mode)	mode.c_oflag
#else	/* BSD */
	struct sgttyb termmode;		/* To hold terminal settings. */
#define	GTTY(fd, mode)	gtty(fd, mode)
#define	STTY(fd, mode)	stty(fd, mode)
#define	SPEED(mode)	(mode.sg_ospeed & 017)
#define	OFLAG(mode)	mode.sg_flags
#define	TAB3		XTABS
#endif

	/* Get the terminal settings. */
	/* First try standard output, then standard error, */
	/* then standard input, then /dev/tty. */
#ifdef SYSV
	if ((filedes = 1, GTTYS(filedes, &termmodes) < 0) ||
	    (filedes = 2, GTTYS(filedes, &termmodes) < 0) ||
	    (filedes = 0, GTTYS(filedes, &termmodes) < 0) ||
	    (filedes = open("/dev/tty", O_RDWR),
	    GTTYS(filedes, &termmodes) < 0)) {
#endif	/* SYSV */
		if ((filedes = 1, GTTY(filedes, &termmode) == -1) ||
		    (filedes = 2, GTTY(filedes, &termmode) == -1) ||
		    (filedes = 0, GTTY(filedes, &termmode) == -1) ||
		    (filedes = open("/dev/tty", O_RDWR),
		    GTTY(filedes, &termmode) == -1)) {
			filedes = -1;
			CurrentBaudRate = speeds[B1200];
		} else
			CurrentBaudRate = speeds[SPEED(termmode)];
#ifdef SYSV
		termmodes.c_lflag = termmode.c_lflag;
		termmodes.c_oflag = termmode.c_oflag;
		termmodes.c_iflag = termmode.c_iflag;
		termmodes.c_cflag = termmode.c_cflag;
		for (i = 0; i < NCC; i++)
			termmodes.c_cc[i] = termmode.c_cc[i];
	} else
		CurrentBaudRate = speeds[SPEEDS(termmodes)];
#endif	/* SYSV */

	if (xon_xoff) {
#ifdef SYSV
		OFLAG(termmodes) &=
		    ~(NLbits | CRbits | BSbits | FFbits | TBbits);
#else	/* SYSV */
		OFLAG(termmode) &=
		    ~(NLbits | CRbits | BSbits | FFbits | TBbits);
#endif	/* SYSV */
	} else {
#ifdef SYSV
		setdelay(getpad(carriage_return),
		    CRdelay, CRbits, &OFLAG(termmodes));
		setdelay(getpad(scroll_forward),
		    NLdelay, NLbits, &OFLAG(termmodes));
		setdelay(getpad(cursor_left),
		    BSdelay, BSbits, &OFLAG(termmodes));
		setdelay(getpad(form_feed),
		    FFdelay, FFbits, &OFLAG(termmodes));
		setdelay(getpad(tab),
		    TBdelay, TBbits, &OFLAG(termmodes));
#else	/* SYSV */
		setdelay(getpad(carriage_return),
		    CRdelay, CRbits, &OFLAG(termmode));
		setdelay(getpad(scroll_forward),
		    NLdelay, NLbits, &OFLAG(termmode));
		setdelay(getpad(cursor_left),
		    BSdelay, BSbits, &OFLAG(termmode));
		setdelay(getpad(form_feed),
		    FFdelay, FFbits, &OFLAG(termmode));
		setdelay(getpad(tab),
		    TBdelay, TBbits, &OFLAG(termmode));
#endif	/* SYSV */
	}

	/* If tabs can be sent to the tty, turn off their expansion. */
	if (tab && set_tab || init_tabs == 8) {
#ifdef SYSV
		OFLAG(termmodes) &= ~(TAB3);
#else	/* SYSV */
		OFLAG(termmode) &= ~(TAB3);
#endif	/* SYSV */
	} else {
#ifdef SYSV
		OFLAG(termmodes) |= TAB3;
#else	/* SYSV */
		OFLAG(termmode) |= TAB3;
#endif	/* SYSV */
	}

	/* Do the changes to the terminal settings */
#ifdef SYSV
	if (istermios < 0) {
		int i;

		termmode.c_lflag = termmodes.c_lflag;
		termmode.c_oflag = termmodes.c_oflag;
		termmode.c_iflag = termmodes.c_iflag;
		termmode.c_cflag = termmodes.c_cflag;
		for (i = 0; i < NCC; i++)
			termmode.c_cc[i] = termmodes.c_cc[i];
		(void) STTY(filedes, &termmode);
	} else
		(void) STTYS(filedes, &termmodes);

#else	/* SYSV */
	(void) STTY(filedes, &termmode);
#endif	/* SYSV */

	/* Send first initialization strings. */
	if (init_prog)
	(void) system(init_prog);

	if (reset && reset_1string) {
		putp(reset_1string);
	} else if (init_1string) {
		putp(init_1string);
	}

	if (reset && reset_2string) {
		putp(reset_2string);
	} else if (init_2string) {
		putp(init_2string);
	}

	/* Set up the tabs stops. */
	settabs();

	/* Send out initializing file. */
	if (reset && reset_file) {
		cat(reset_file);
	} else if (init_file) {
		cat(init_file);
	}

	/* Send final initialization strings. */
	if (reset && reset_3string) {
		putp(reset_3string);
	} else if (init_3string) {
		putp(init_3string);
	}

	if (carriage_return) {
		putp(carriage_return);
	} else {
		(void) putchar('\r');
	}

	/* Send color initialization strings */

	if (orig_colors)
		putp(orig_colors);

	if (orig_pair)
	putp(orig_pair);

	/* Let the terminal settle down. */
	(void) fflush(stdout);
	(void) sleep(1);
}

static void
reset_term()
{
	reset++;
	initterm();
}