/*

 * Copyright (c) 2005 Tyan Computer Corp.  All Rights Reserved.

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 

 * Redistribution of source code must retain the above copyright

 * notice, this list of conditions and the following disclaimer.

 * 

 * Redistribution in binary form must reproduce the above copyright

 * notice, this list of conditions and the following disclaimer in the

 * documentation and/or other materials provided with the distribution.

 * 

 * Neither the name of Sun Microsystems, Inc. or the names of

 * contributors may be used to endorse or promote products derived

 * from this software without specific prior written permission.

 * 

 * This software is provided "AS IS," without a warranty of any kind.

 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,

 * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A

 * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.

 * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE

 * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING

 * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.  IN NO EVENT WILL

 * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,

 * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR

 * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF

 * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,

 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

 */

#define _DEFAULT_SOURCE

#include <sys/types.h>

#include <sys/stat.h>

#include <poll.h>

#include <fcntl.h>

#include <unistd.h>

#include <errno.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <netdb.h>

#include <signal.h>

#include <sys/select.h>

#include <sys/time.h>

#include <sys/ioctl.h>

#if defined(HAVE_CONFIG_H)

# include <config.h>

#endif

#if defined(HAVE_TERMIOS_H)

# include <termios.h>

#elif defined (HAVE_SYS_TERMIOS_H)

# include <sys/termios.h>

#endif

#include <ipmitool/log.h>

#include <ipmitool/helper.h>

#include <ipmitool/ipmi.h>

#include <ipmitool/ipmi_intf.h>

#include <ipmitool/ipmi_tsol.h>

#include <ipmitool/ipmi_strings.h>

#include <ipmitool/bswap.h>

static struct timeval _start_keepalive;

static struct termios _saved_tio;

static struct winsize _saved_winsize;

static int _in_raw_mode = 0;

static int _altterm = 0;

extern int verbose;

static int

ipmi_tsol_command(struct ipmi_intf *intf, char *recvip, int port,

		unsigned char cmd)

{

	struct ipmi_rs *rsp;

	struct ipmi_rq	req;

	unsigned char data[6];

	unsigned ip1, ip2, ip3, ip4;

	if (sscanf(recvip, "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4) != 4) {

		lprintf(LOG_ERR, "Invalid IP address: %s", recvip);

		return (-1);

	}

	memset(&req, 0, sizeof(struct ipmi_rq));

	req.msg.netfn = IPMI_NETFN_TSOL;

	req.msg.cmd = cmd;

	req.msg.data_len = 6;

	req.msg.data = data;

	memset(data, 0, sizeof(data));

	data[0] = ip1;

	data[1] = ip2;

	data[2] = ip3;

	data[3] = ip4;

	data[4] = (port & 0xff00) >> 8;

	data[5] = (port & 0xff);

	rsp = intf->sendrecv(intf, &req;;

	if (rsp == NULL) {

		lprintf(LOG_ERR, "Unable to perform TSOL command");

		return (-1);

	}

	if (rsp->ccode > 0) {

		lprintf(LOG_ERR, "Unable to perform TSOL command: %s",

				val2str(rsp->ccode, completion_code_vals));

		return (-1);

	}

	return 0;

}

static int

ipmi_tsol_start(struct ipmi_intf *intf, char *recvip, int port)

{

	return ipmi_tsol_command(intf, recvip, port, IPMI_TSOL_CMD_START);

}

static int

ipmi_tsol_stop(struct ipmi_intf *intf, char *recvip, int port)

{

	return ipmi_tsol_command(intf, recvip, port, IPMI_TSOL_CMD_STOP);

}

static int

ipmi_tsol_send_keystroke(struct ipmi_intf *intf, char *buff, int length)

{

	struct ipmi_rs *rsp;

	struct ipmi_rq req;

	unsigned char data[16];

	static unsigned char keyseq = 0;

	memset(&req, 0, sizeof(struct ipmi_rq));

	req.msg.netfn = IPMI_NETFN_TSOL;

	req.msg.cmd = IPMI_TSOL_CMD_SENDKEY;

	req.msg.data_len = length + 2;

	req.msg.data = data;

	memset(data, 0, sizeof(data));

	data[0] = length + 1;

	memcpy(data + 1, buff, length);

	data[length + 1] = keyseq++;

	rsp = intf->sendrecv(intf, &req;;

	if (verbose) {

		if (rsp == NULL) {

			lprintf(LOG_ERR, "Unable to send keystroke");

			return -1;

		}

		if (rsp->ccode > 0) {

			lprintf(LOG_ERR, "Unable to send keystroke: %s",

					val2str(rsp->ccode, completion_code_vals));

			return -1;

		}

	}

	return length;

}

static int

tsol_keepalive(struct ipmi_intf *intf)

{

	struct timeval end;

	gettimeofday(&end, 0);

	if (end.tv_sec - _start_keepalive.tv_sec <= 30) {

		return 0;

	}

	intf->keepalive(intf);

	gettimeofday(&_start_keepalive, 0);

	return 0;

}

static void

print_escape_seq(struct ipmi_intf *intf)

{

	lprintf(LOG_NOTICE,

"       %c.  - terminate connection\n"

"       %c^Z - suspend ipmitool\n"

"       %c^X - suspend ipmitool, but don't restore tty on restart\n"

"       %c?  - this message\n"

"       %c%c  - send the escape character by typing it twice\n"

"       (Note that escapes are only recognized immediately after newline.)",

			intf->ssn_params.sol_escape_char,

			intf->ssn_params.sol_escape_char,

			intf->ssn_params.sol_escape_char,

			intf->ssn_params.sol_escape_char,

			intf->ssn_params.sol_escape_char,

			intf->ssn_params.sol_escape_char);

}

static int

leave_raw_mode(void)

{

	if (!_in_raw_mode) {

		return -1;

	} else if (tcsetattr(fileno(stdin), TCSADRAIN, &_saved_tio) == -1) {

		lperror(LOG_ERR, "tcsetattr(stdin)");

	} else if (tcsetattr(fileno(stdout), TCSADRAIN, &_saved_tio) == -1) {

		lperror(LOG_ERR, "tcsetattr(stdout)");

	} else {

		_in_raw_mode = 0;

	}

	return 0;

}

static int

enter_raw_mode(void)

{

	struct termios tio;

	if (tcgetattr(fileno(stdout), &_saved_tio) < 0) {

		lperror(LOG_ERR, "tcgetattr failed");

		return -1;

	}

	tio = _saved_tio;

	if (_altterm) {

		tio.c_iflag &= (ISTRIP | IGNBRK);

		tio.c_cflag &= ~(CSIZE | PARENB | IXON | IXOFF | IXANY);

		tio.c_cflag |= (CS8 |CREAD) | (IXON|IXOFF|IXANY);

		tio.c_lflag &= 0;

		tio.c_cc[VMIN] = 1;

		tio.c_cc[VTIME] = 0;

	} else {

		tio.c_iflag |= IGNPAR;

		tio.c_iflag &= ~(ISTRIP | INLCR | IGNCR | ICRNL | IXON | IXANY | IXOFF);

		tio.c_lflag &= ~(ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHONL | IEXTEN);

		tio.c_oflag &= ~OPOST;

		tio.c_cc[VMIN] = 1;

		tio.c_cc[VTIME] = 0;

	}

	if (tcsetattr(fileno(stdin), TCSADRAIN, &tio) < 0) {

		lperror(LOG_ERR, "tcsetattr(stdin)");

	} else if (tcsetattr(fileno(stdout), TCSADRAIN, &tio) < 0) {

		lperror(LOG_ERR, "tcsetattr(stdout)");

	} else {

		_in_raw_mode = 1;

	}

	return 0;

}

static void

suspend_self(int restore_tty)

{

	leave_raw_mode();

	kill(getpid(), SIGTSTP);

	if (restore_tty) {

		enter_raw_mode();

	}

}

static int

do_inbuf_actions(struct ipmi_intf *intf, char *in_buff, int len)

{

	static int in_esc = 0;

	static int last_was_cr = 1;

	int i;

	for(i = 0; i < len ;) {

		if (!in_esc) {

			if (last_was_cr &&

					(in_buff[i] == intf->ssn_params.sol_escape_char)) {

				in_esc = 1;

				memmove(in_buff, in_buff + 1, len - i - 1);

				len--;

				continue;

			}

		}

		if (in_esc) {

			if (in_buff[i] == intf->ssn_params.sol_escape_char) {

				in_esc = 0;

				i++;

				continue;

			}

			switch (in_buff[i]) {

			case '.':

				printf("%c. [terminated ipmitool]\n",

						intf->ssn_params.sol_escape_char);

				return -1;

			case 'Z' - 64:

				printf("%c^Z [suspend ipmitool]\n",

						intf->ssn_params.sol_escape_char);

				/* Restore tty back to raw */

				suspend_self(1);

				break;

			case 'X' - 64:

				printf("%c^X [suspend ipmitool]\n",

						intf->ssn_params.sol_escape_char);

				/* Don't restore to raw mode */

				suspend_self(0);

				break;

			case '?':

				printf("%c? [ipmitool help]\n",

						intf->ssn_params.sol_escape_char);

				print_escape_seq(intf);

				break;

			}

			memmove(in_buff, (in_buff + 1), (len - i - 1));

			len--;

			in_esc = 0;

			continue;

		}

		last_was_cr = (in_buff[i] == '\r' || in_buff[i] == '\n');

		i++;

	}

	return len;

}

static void

do_terminal_cleanup(void)

{

	if (_saved_winsize.ws_row > 0 && _saved_winsize.ws_col > 0) {

		ioctl(fileno(stdout), TIOCSWINSZ, &_saved_winsize);

	}

	leave_raw_mode();

	if (errno) {

		lprintf(LOG_ERR, "Exiting due to error %d -> %s",

			errno, strerror(errno));

	}

}

static void

set_terminal_size(int rows, int cols)

{

	struct winsize winsize;

	if (rows <= 0 || cols <= 0) {

		return;

	}

	/* save initial winsize */

	ioctl(fileno(stdout), TIOCGWINSZ, &_saved_winsize);

	/* set new winsize */

	winsize.ws_row = rows;

	winsize.ws_col = cols;

	ioctl(fileno(stdout), TIOCSWINSZ, &winsize);

}

static void

print_tsol_usage(void)

{

	struct winsize winsize;

	lprintf(LOG_NOTICE,

"Usage: tsol [recvip] [port=NUM] [ro|rw] [rows=NUM] [cols=NUM] [altterm]");

	lprintf(LOG_NOTICE,

"       recvip       Receiver IP Address             [default=local]");

	lprintf(LOG_NOTICE,

"       port=NUM     Receiver UDP Port               [default=%d]",

			IPMI_TSOL_DEF_PORT);

	lprintf(LOG_NOTICE,

"       ro|rw        Set Read-Only or Read-Write     [default=rw]");

			ioctl(fileno(stdout), TIOCGWINSZ, &winsize);

	lprintf(LOG_NOTICE,

"       rows=NUM     Set terminal rows               [default=%d]",

			winsize.ws_row);

	lprintf(LOG_NOTICE,

"       cols=NUM     Set terminal columns            [default=%d]",

			winsize.ws_col);

	lprintf(LOG_NOTICE,

"       altterm      Alternate terminal setup        [default=off]");

}

int

ipmi_tsol_main(struct ipmi_intf *intf, int argc, char **argv)

{

	struct pollfd fds_wait[3], fds_data_wait[3], *fds;

	struct sockaddr_in sin, myaddr, *sa_in;

	socklen_t mylen;

	char *recvip = NULL;

	char in_buff[IPMI_BUF_SIZE];

	char out_buff[IPMI_BUF_SIZE * 8];

	char buff[IPMI_BUF_SIZE + 4];

	int fd_socket, result, i;

	int out_buff_fill, in_buff_fill;

	int ip1, ip2, ip3, ip4;

	int read_only = 0, rows = 0, cols = 0;

	int port = IPMI_TSOL_DEF_PORT;

	if (strlen(intf->name) < 3 || strncmp(intf->name, "lan", 3) != 0) {

		lprintf(LOG_ERR, "Error: Tyan SOL is only available over lan interface");

		return (-1);

	}

	for (i = 0; i

		if (sscanf(argv[i], "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4) == 4) {

			/* not free'd ...*/

			/* recvip = strdup(argv[i]); */

			recvip = argv[i];

		} else if (sscanf(argv[i], "port=%d", &ip1) == 1) {

			port = ip1;

		} else if (sscanf(argv[i], "rows=%d", &ip1) == 1) {

			rows = ip1;

		} else if (sscanf(argv[i], "cols=%d", &ip1) == 1) {

			cols = ip1;

		} else if (strlen(argv[i]) == 2

				&& strncmp(argv[i], "ro", 2) == 0) {

			read_only = 1;

		} else if (strlen(argv[i]) == 2

				&& strncmp(argv[i], "rw", 2) == 0) {

			read_only = 0;

		} else if (strlen(argv[i]) == 7

				&& strncmp(argv[i], "altterm", 7) == 0) {

			_altterm = 1;

		} else if (strlen(argv[i]) == 4

				&& strncmp(argv[i], "help", 4) == 0) {

			print_tsol_usage();

			return 0;

		} else {

			lprintf(LOG_ERR, "Invalid tsol command: '%s'\n",

					argv[i]);

			print_tsol_usage();

			return (-1);

		}

	}

	/* create udp socket to receive the packet */

	memset(&sin, 0, sizeof(sin));

	sin.sin_family = AF_INET;

	sin.sin_port = htons(port);

	sa_in = (struct sockaddr_in *)&intf->session->addr;

	result = inet_pton(AF_INET, (const char *)intf->ssn_params.hostname,

			&sa_in->sin_addr);

	if (result <= 0) {

		struct hostent *host = gethostbyname((const char *)intf->ssn_params.hostname);

		if (host == NULL ) {

			lprintf(LOG_ERR, "Address lookup for %s failed",

				intf->ssn_params.hostname);

			return -1;

		}

		if (host->h_addrtype != AF_INET) {

			lprintf(LOG_ERR,

					"Address lookup for %s failed. Got %s, expected IPv4 address.",

					intf->ssn_params.hostname,

					(host->h_addrtype == AF_INET6) ? "IPv6" : "Unknown");

			return (-1);

		}

		sa_in->sin_family = host->h_addrtype;

		memcpy(&sa_in->sin_addr, host->h_addr_list[0], host->h_length);

	}

	fd_socket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);

	if (fd_socket < 0) {

		lprintf(LOG_ERR, "Can't open port %d", port);

		return -1;

	}

	if (bind(fd_socket, (struct sockaddr *)&sin, sizeof(sin)) == (-1)) {

		lprintf(LOG_ERR, "Failed to bind socket.");

		close(fd_socket);

		return -1;

	}

	/*

	 * retrieve local IP address if not supplied on command line

	 */

	if (recvip == NULL) {

		/* must connect first */

		result = intf->open(intf);

		if (result < 0) {

			close(fd_socket);

			return -1;

		}

		mylen = sizeof(myaddr);

		if (getsockname(intf->fd, (struct sockaddr *)&myaddr, &mylen) < 0) {

			lperror(LOG_ERR, "getsockname failed");

			close(fd_socket);

			return -1;

		}

		recvip = inet_ntoa(myaddr.sin_addr);

		if (recvip == NULL) {

			lprintf(LOG_ERR, "Unable to find local IP address");

			close(fd_socket);

			return -1;

		}

	}

	printf("[Starting %sSOL with receiving address %s:%d]\n",

			read_only ? "Read-only " : "", recvip, port);

	set_terminal_size(rows, cols);

	enter_raw_mode();

	/*

	 * talk to smdc to start Console redirect - IP address and port as parameter

	 * ipmitool -I lan -H 192.168.168.227 -U Administrator raw 0x30 0x06 0xC0 0xA8 0xA8 0x78 0x1A 0x0A

	 */

	result = ipmi_tsol_start(intf, recvip, port);

	if (result < 0) {

		lprintf(LOG_ERR, "Error starting SOL");

		close(fd_socket);

		return (-1);

	}

	printf("[SOL Session operational.  Use %c? for help]\n",

			intf->ssn_params.sol_escape_char);

	gettimeofday(&_start_keepalive, 0);

	fds_wait[0].fd = fd_socket;

	fds_wait[0].events = POLLIN;

	fds_wait[0].revents = 0;

	fds_wait[1].fd = fileno(stdin);

	fds_wait[1].events = POLLIN;

	fds_wait[1].revents = 0;

	fds_wait[2].fd = -1;

	fds_wait[2].events = 0;

	fds_wait[2].revents = 0;

	fds_data_wait[0].fd = fd_socket;

	fds_data_wait[0].events = POLLIN | POLLOUT;

	fds_data_wait[0].revents = 0;

	fds_data_wait[1].fd = fileno(stdin);

	fds_data_wait[1].events = POLLIN;

	fds_data_wait[1].revents = 0;

	fds_data_wait[2].fd = fileno(stdout);

	fds_data_wait[2].events = POLLOUT;

	fds_data_wait[2].revents = 0;

	out_buff_fill = 0;

	in_buff_fill = 0;

	fds = fds_wait;

	for (;;) {

		result = poll(fds, 3, 15 * 1000);

		if (result < 0) {

			break;

		}

		/* send keepalive packet */

		tsol_keepalive(intf);

		if ((fds[0].revents & POLLIN) && (sizeof(out_buff) > out_buff_fill)) {

			socklen_t sin_len = sizeof(sin);

			int buff_size = sizeof(buff);

			if ((sizeof(out_buff) - out_buff_fill + 4) < buff_size) {

				buff_size = (sizeof(out_buff) - out_buff_fill) + 4;

				if ((buff_size - 4) <= 0) {

					buff_size = 0;

				}

			}

			result = recvfrom(fd_socket, buff,

					buff_size, 0,

					(struct sockaddr *)&sin, &sin_len);

			/* read the data from udp socket,

			 * skip some bytes in the head

			 */

			if ((result - 4) > 0) {

				int length = result - 4;

				memcpy(out_buff + out_buff_fill, buff + 4, length);

				out_buff_fill += length;

			}

		}

		if ((fds[1].revents & POLLIN) && (sizeof(in_buff) > in_buff_fill)) {

			/* Read from keyboard */

			result = read(fileno(stdin), in_buff + in_buff_fill,

					sizeof(in_buff) - in_buff_fill);

			if (result > 0) {

				int bytes;

				bytes = do_inbuf_actions(intf,

						in_buff + in_buff_fill, result);

				if (bytes < 0) {

					result = ipmi_tsol_stop(intf, recvip, port);

					do_terminal_cleanup();

					return result;

				}

				if (read_only) {

					bytes = 0;

				}

				in_buff_fill += bytes;

			}

		}

		if ((fds[2].revents & POLLOUT) && out_buff_fill) {

			/* To screen */

			result = write(fileno(stdout), out_buff, out_buff_fill);

			if (result > 0) {

				out_buff_fill -= result;

				if (out_buff_fill) {

					memmove(out_buff, out_buff + result, out_buff_fill);

				}

			}

		}

		if ((fds[0].revents & POLLOUT) && in_buff_fill) {

			/*

			 * translate key and send that to SMDC using IPMI

			 * ipmitool -I lan -H 192.168.168.227 -U Administrator raw 0x30 0x03 0x04 0x1B 0x5B 0x43

			 */

			result = ipmi_tsol_send_keystroke(intf,

					in_buff, __min(in_buff_fill, 14));

			if (result > 0) {

				gettimeofday(&_start_keepalive, 0);

				in_buff_fill -= result;

				if (in_buff_fill) {

					memmove(in_buff, in_buff + result, in_buff_fill);

				}

			}

		}

		fds = (in_buff_fill || out_buff_fill )?

			fds_data_wait : fds_wait;

	}

	return 0;

}