/*
* 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<argc; 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;
}