summaryrefslogtreecommitdiff
path: root/lib/ipmi_sol.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/ipmi_sol.c')
-rw-r--r--lib/ipmi_sol.c2098
1 files changed, 2098 insertions, 0 deletions
diff --git a/lib/ipmi_sol.c b/lib/ipmi_sol.c
new file mode 100644
index 0000000..a5b962f
--- /dev/null
+++ b/lib/ipmi_sol.c
@@ -0,0 +1,2098 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. 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.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/select.h>
+#include <sys/time.h>
+#include <time.h>
+#include <signal.h>
+#include <unistd.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/helper.h>
+#include <ipmitool/log.h>
+#include <ipmitool/ipmi.h>
+#include <ipmitool/ipmi_intf.h>
+#include <ipmitool/ipmi_sol.h>
+#include <ipmitool/ipmi_strings.h>
+#include <ipmitool/bswap.h>
+
+
+#define SOL_PARAMETER_SET_IN_PROGRESS 0x00
+#define SOL_PARAMETER_SOL_ENABLE 0x01
+#define SOL_PARAMETER_SOL_AUTHENTICATION 0x02
+#define SOL_PARAMETER_CHARACTER_INTERVAL 0x03
+#define SOL_PARAMETER_SOL_RETRY 0x04
+#define SOL_PARAMETER_SOL_NON_VOLATILE_BIT_RATE 0x05
+#define SOL_PARAMETER_SOL_VOLATILE_BIT_RATE 0x06
+#define SOL_PARAMETER_SOL_PAYLOAD_CHANNEL 0x07
+#define SOL_PARAMETER_SOL_PAYLOAD_PORT 0x08
+
+#define MAX_SOL_RETRY 6
+
+const struct valstr sol_parameter_vals[] = {
+ { SOL_PARAMETER_SET_IN_PROGRESS, "Set In Progress (0)" },
+ { SOL_PARAMETER_SOL_ENABLE, "Enable (1)" },
+ { SOL_PARAMETER_SOL_AUTHENTICATION, "Authentication (2)" },
+ { SOL_PARAMETER_CHARACTER_INTERVAL, "Character Interval (3)" },
+ { SOL_PARAMETER_SOL_RETRY, "Retry (4)" },
+ { SOL_PARAMETER_SOL_NON_VOLATILE_BIT_RATE, "Nonvolatile Bitrate (5)" },
+ { SOL_PARAMETER_SOL_VOLATILE_BIT_RATE, "Volatile Bitrate (6)" },
+ { SOL_PARAMETER_SOL_PAYLOAD_CHANNEL, "Payload Channel (7)" },
+ { SOL_PARAMETER_SOL_PAYLOAD_PORT, "Payload Port (8)" },
+ { 0x00, NULL },
+};
+
+
+static struct timeval _start_keepalive;
+static struct termios _saved_tio;
+static int _in_raw_mode = 0;
+static int _disable_keepalive = 0;
+static int _use_sol_for_keepalive = 0;
+static int _keepalive_retries = 0;
+
+extern int verbose;
+
+/*
+ * ipmi_sol_payload_access
+ */
+int
+ipmi_sol_payload_access(struct ipmi_intf * intf, uint8_t channel,
+ uint8_t userid, int enable)
+{
+ struct ipmi_rq req;
+ struct ipmi_rs *rsp;
+ int rc = (-1);
+ uint8_t data[6];
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = IPMI_SET_USER_PAYLOAD_ACCESS;
+ req.msg.data = data;
+ req.msg.data_len = 6;
+
+ memset(data, 0, 6);
+ /* channel */
+ data[0] = channel & 0xf;
+ /* user id */
+ data[1] = userid & 0x3f;
+ if (!enable) {
+ /* disable */
+ data[1] |= 0x40;
+ }
+ /* payload 1 is SOL */
+ data[2] = 0x02;
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error %sabling SOL payload for user %d on channel %d",
+ enable ? "en" : "dis", userid, channel);
+ rc = (-1);
+ } else if (rsp->ccode != 0) {
+ lprintf(LOG_ERR, "Error %sabling SOL payload for user %d on channel %d: %s",
+ enable ? "en" : "dis", userid, channel,
+ val2str(rsp->ccode, completion_code_vals));
+ rc = (-1);
+ } else {
+ rc = 0;
+ }
+ return rc;
+}
+
+int
+ipmi_sol_payload_access_status(struct ipmi_intf * intf,
+ uint8_t channel,
+ uint8_t userid)
+{
+ struct ipmi_rq req;
+ struct ipmi_rs *rsp;
+ uint8_t data[2];
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = IPMI_GET_USER_PAYLOAD_ACCESS;
+ req.msg.data = data;
+ req.msg.data_len = sizeof(data);
+
+ data[0] = channel & 0xf; /* channel */
+ data[1] = userid & 0x3f; /* user id */
+ rsp = intf->sendrecv(intf, &req);
+
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error. No valid response received.");
+ return -1;
+ }
+
+ switch(rsp->ccode) {
+ case 0x00:
+ if (rsp->data_len != 4) {
+ lprintf(LOG_ERR, "Error parsing SOL payload status for user %d on channel %d",
+ userid, channel);
+ return -1;
+ }
+
+ printf("User %d on channel %d is %sabled\n",
+ userid, channel, (rsp->data[0] & 0x02) ? "en":"dis");
+ return 0;
+
+ default:
+ lprintf(LOG_ERR, "Error getting SOL payload status for user %d on channel %d: %s",
+ userid, channel,
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+}
+
+
+/*
+ * ipmi_get_sol_info
+ */
+int
+ipmi_get_sol_info(
+ struct ipmi_intf * intf,
+ uint8_t channel,
+ struct sol_config_parameters * params)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint8_t data[4];
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_TRANSPORT;
+ req.msg.cmd = IPMI_GET_SOL_CONFIG_PARAMETERS;
+ req.msg.data_len = 4;
+ req.msg.data = data;
+
+ /*
+ * set in progress
+ */
+ memset(data, 0, sizeof(data));
+ data[0] = channel; /* channel number */
+ data[1] = SOL_PARAMETER_SET_IN_PROGRESS; /* parameter selector */
+ data[2] = 0x00; /* set selector */
+ data[3] = 0x00; /* block selector */
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error: No response requesting SOL parameter '%s'",
+ val2str(data[1], sol_parameter_vals));
+ return (-1);
+ }
+
+ switch (rsp->ccode) {
+ case 0x00:
+ if (rsp->data_len == 2) {
+ params->set_in_progress = rsp->data[1];
+ } else {
+ lprintf(LOG_ERR, "Error: Unexpected data length (%d) received "
+ "for SOL parameter '%s'",
+ rsp->data_len,
+ val2str(data[1], sol_parameter_vals));
+ }
+ break;
+ case 0x80:
+ lprintf(LOG_ERR, "Info: SOL parameter '%s' not supported",
+ val2str(data[1], sol_parameter_vals));
+ break;
+ default:
+ lprintf(LOG_ERR, "Error requesting SOL parameter '%s': %s",
+ val2str(data[1], sol_parameter_vals),
+ val2str(rsp->ccode, completion_code_vals));
+ return (-1);
+ }
+
+ /*
+ * SOL enable
+ */
+ memset(data, 0, sizeof(data));
+ data[0] = channel; /* channel number */
+ data[1] = SOL_PARAMETER_SOL_ENABLE; /* parameter selector */
+ data[2] = 0x00; /* set selector */
+ data[3] = 0x00; /* block selector */
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error: No response requesting SOL parameter '%s'",
+ val2str(data[1], sol_parameter_vals));
+ return (-1);
+ }
+
+ switch (rsp->ccode) {
+ case 0x00:
+ if (rsp->data_len == 2) {
+ params->enabled = rsp->data[1];
+ } else {
+ lprintf(LOG_ERR, "Error: Unexpected data length (%d) received "
+ "for SOL parameter '%s'",
+ rsp->data_len,
+ val2str(data[1], sol_parameter_vals));
+ }
+ break;
+ case 0x80:
+ lprintf(LOG_ERR, "Info: SOL parameter '%s' not supported",
+ val2str(data[1], sol_parameter_vals));
+ break;
+ default:
+ lprintf(LOG_ERR, "Error requesting SOL parameter '%s': %s",
+ val2str(data[1], sol_parameter_vals),
+ val2str(rsp->ccode, completion_code_vals));
+ return (-1);
+ }
+
+ /*
+ * SOL authentication
+ */
+ memset(data, 0, sizeof(data));
+ data[0] = channel; /* channel number */
+ data[1] = SOL_PARAMETER_SOL_AUTHENTICATION; /* parameter selector */
+ data[2] = 0x00; /* set selector */
+ data[3] = 0x00; /* block selector */
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error: No response requesting SOL parameter '%s'",
+ val2str(data[1], sol_parameter_vals));
+ return (-1);
+ }
+
+ switch (rsp->ccode) {
+ case 0x00:
+ if (rsp->data_len == 2) {
+ params->force_encryption = ((rsp->data[1] & 0x80)? 1 : 0);
+ params->force_authentication = ((rsp->data[1] & 0x40)? 1 : 0);
+ params->privilege_level = rsp->data[1] & 0x0F;
+ } else {
+ lprintf(LOG_ERR, "Error: Unexpected data length (%d) received "
+ "for SOL parameter '%s'",
+ rsp->data_len,
+ val2str(data[1], sol_parameter_vals));
+ }
+ break;
+ case 0x80:
+ lprintf(LOG_ERR, "Info: SOL parameter '%s' not supported",
+ val2str(data[1], sol_parameter_vals));
+ break;
+ default:
+ lprintf(LOG_ERR, "Error requesting SOL parameter '%s': %s",
+ val2str(data[1], sol_parameter_vals),
+ val2str(rsp->ccode, completion_code_vals));
+ return (-1);
+ }
+
+ /*
+ * Character accumulate interval and character send interval
+ */
+ memset(data, 0, sizeof(data));
+ data[0] = channel; /* channel number */
+ data[1] = SOL_PARAMETER_CHARACTER_INTERVAL; /* parameter selector */
+ data[2] = 0x00; /* set selector */
+ data[3] = 0x00; /* block selector */
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error: No response requesting SOL parameter '%s'",
+ val2str(data[1], sol_parameter_vals));
+ return (-1);
+ }
+
+ switch (rsp->ccode) {
+ case 0x00:
+ if (rsp->data_len == 3) {
+ params->character_accumulate_level = rsp->data[1];
+ params->character_send_threshold = rsp->data[2];
+ } else {
+ lprintf(LOG_ERR, "Error: Unexpected data length (%d) received "
+ "for SOL parameter '%s'",
+ rsp->data_len,
+ val2str(data[1], sol_parameter_vals));
+ }
+ break;
+ case 0x80:
+ lprintf(LOG_ERR, "Info: SOL parameter '%s' not supported",
+ val2str(data[1], sol_parameter_vals));
+ break;
+ default:
+ lprintf(LOG_ERR, "Error requesting SOL parameter '%s': %s",
+ val2str(data[1], sol_parameter_vals),
+ val2str(rsp->ccode, completion_code_vals));
+ return (-1);
+ }
+
+ /*
+ * SOL retry
+ */
+ memset(data, 0, sizeof(data));
+ data[0] = channel; /* channel number */
+ data[1] = SOL_PARAMETER_SOL_RETRY; /* parameter selector */
+ data[2] = 0x00; /* set selector */
+ data[3] = 0x00; /* block selector */
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error: No response requesting SOL parameter '%s'",
+ val2str(data[1], sol_parameter_vals));
+ return (-1);
+ }
+
+ switch (rsp->ccode) {
+ case 0x00:
+ if (rsp->data_len == 3) {
+ params->retry_count = rsp->data[1];
+ params->retry_interval = rsp->data[2];
+ } else {
+ lprintf(LOG_ERR, "Error: Unexpected data length (%d) received "
+ "for SOL parameter '%s'",
+ rsp->data_len,
+ val2str(data[1], sol_parameter_vals));
+ }
+ break;
+ case 0x80:
+ lprintf(LOG_ERR, "Info: SOL parameter '%s' not supported",
+ val2str(data[1], sol_parameter_vals));
+ break;
+ default:
+ lprintf(LOG_ERR, "Error requesting SOL parameter '%s': %s",
+ val2str(data[1], sol_parameter_vals),
+ val2str(rsp->ccode, completion_code_vals));
+ return (-1);
+ }
+
+ /*
+ * SOL non-volatile bit rate
+ */
+ memset(data, 0, sizeof(data));
+ data[0] = channel; /* channel number */
+ data[1] = SOL_PARAMETER_SOL_NON_VOLATILE_BIT_RATE; /* parameter selector */
+ data[2] = 0x00; /* set selector */
+ data[3] = 0x00; /* block selector */
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error: No response requesting SOL parameter '%s'",
+ val2str(data[1], sol_parameter_vals));
+ return (-1);
+ }
+
+ switch (rsp->ccode) {
+ case 0x00:
+ if (rsp->data_len == 2) {
+ params->non_volatile_bit_rate = rsp->data[1] & 0x0F;
+ } else {
+ lprintf(LOG_ERR, "Error: Unexpected data length (%d) received "
+ "for SOL parameter '%s'",
+ rsp->data_len,
+ val2str(data[1], sol_parameter_vals));
+ }
+ break;
+ case 0x80:
+ lprintf(LOG_ERR, "Info: SOL parameter '%s' not supported",
+ val2str(data[1], sol_parameter_vals));
+ break;
+ default:
+ lprintf(LOG_ERR, "Error requesting SOL parameter '%s': %s",
+ val2str(data[1], sol_parameter_vals),
+ val2str(rsp->ccode, completion_code_vals));
+ return (-1);
+ }
+
+ /*
+ * SOL volatile bit rate
+ */
+ memset(data, 0, sizeof(data));
+ data[0] = channel; /* channel number */
+ data[1] = SOL_PARAMETER_SOL_VOLATILE_BIT_RATE; /* parameter selector */
+ data[2] = 0x00; /* set selector */
+ data[3] = 0x00; /* block selector */
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error: No response requesting SOL parameter '%s'",
+ val2str(data[1], sol_parameter_vals));
+ return (-1);
+ }
+
+ switch (rsp->ccode) {
+ case 0x00:
+ if (rsp->data_len == 2) {
+ params->volatile_bit_rate = rsp->data[1] & 0x0F;
+ } else {
+ lprintf(LOG_ERR, "Error: Unexpected data length (%d) received "
+ "for SOL parameter '%s'",
+ rsp->data_len,
+ val2str(data[1], sol_parameter_vals));
+ }
+ break;
+ case 0x80:
+ lprintf(LOG_ERR, "Info: SOL parameter '%s' not supported",
+ val2str(data[1], sol_parameter_vals));
+ break;
+ default:
+ lprintf(LOG_ERR, "Error requesting SOL parameter '%s': %s",
+ val2str(data[1], sol_parameter_vals),
+ val2str(rsp->ccode, completion_code_vals));
+ return (-1);
+ }
+
+ /*
+ * SOL payload channel
+ */
+ memset(data, 0, sizeof(data));
+ data[0] = channel; /* channel number */
+ data[1] = SOL_PARAMETER_SOL_PAYLOAD_CHANNEL; /* parameter selector */
+ data[2] = 0x00; /* set selector */
+ data[3] = 0x00; /* block selector */
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error: No response requesting SOL parameter '%s'",
+ val2str(data[1], sol_parameter_vals));
+ return (-1);
+ }
+
+ switch (rsp->ccode) {
+ case 0x00:
+ if (rsp->data_len == 2) {
+ params->payload_channel = rsp->data[1];
+ } else {
+ lprintf(LOG_ERR, "Error: Unexpected data length (%d) received "
+ "for SOL parameter '%s'",
+ rsp->data_len,
+ val2str(data[1], sol_parameter_vals));
+ }
+ break;
+ case 0x80:
+ lprintf(LOG_ERR, "Info: SOL parameter '%s' not supported - defaulting to 0x%02x",
+ val2str(data[1], sol_parameter_vals), channel);
+ params->payload_channel = channel;
+ break;
+ default:
+ lprintf(LOG_ERR, "Error requesting SOL parameter '%s': %s",
+ val2str(data[1], sol_parameter_vals),
+ val2str(rsp->ccode, completion_code_vals));
+ return (-1);
+ }
+
+ /*
+ * SOL payload port
+ */
+ memset(data, 0, sizeof(data));
+ data[0] = channel; /* channel number */
+ data[1] = SOL_PARAMETER_SOL_PAYLOAD_PORT; /* parameter selector */
+ data[2] = 0x00; /* set selector */
+ data[3] = 0x00; /* block selector */
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error: No response requesting SOL parameter '%s'",
+ val2str(data[1], sol_parameter_vals));
+ return (-1);
+ }
+
+ switch (rsp->ccode) {
+ case 0x00:
+ if (rsp->data_len == 3) {
+ params->payload_port = (rsp->data[1]) | (rsp->data[2] << 8);
+ } else {
+ lprintf(LOG_ERR, "Error: Unexpected data length (%d) received "
+ "for SOL parameter '%s'",
+ rsp->data_len,
+ val2str(data[1], sol_parameter_vals));
+ }
+ break;
+ case 0x80:
+ if( intf->session != NULL ) {
+ lprintf(LOG_ERR, "Info: SOL parameter '%s' not supported - defaulting to %d",
+ val2str(data[1], sol_parameter_vals), intf->session->port);
+ params->payload_port = intf->session->port;
+ } else {
+ lprintf(LOG_ERR,
+ "Info: SOL parameter '%s' not supported - can't determine which "
+ "payload port to use on NULL session",
+ val2str(data[1], sol_parameter_vals));
+ return (-1);
+ }
+ break;
+ default:
+ lprintf(LOG_ERR, "Error requesting SOL parameter '%s': %s",
+ val2str(data[1], sol_parameter_vals),
+ val2str(rsp->ccode, completion_code_vals));
+ return (-1);
+ }
+
+ return 0;
+}
+
+
+
+/*
+ * ipmi_print_sol_info
+ */
+static int
+ipmi_print_sol_info(struct ipmi_intf * intf, uint8_t channel)
+{
+ struct sol_config_parameters params = {0};
+ if (ipmi_get_sol_info(intf, channel, &params))
+ return -1;
+
+ if (csv_output)
+ {
+ printf("%s,",
+ val2str(params.set_in_progress & 0x03,
+ ipmi_set_in_progress_vals));
+ printf("%s,", params.enabled?"true": "false");
+ printf("%s,", params.force_encryption?"true":"false");
+ printf("%s,", params.force_encryption?"true":"false");
+ printf("%s,",
+ val2str(params.privilege_level, ipmi_privlvl_vals));
+ printf("%d,", params.character_accumulate_level * 5);
+ printf("%d,", params.character_send_threshold);
+ printf("%d,", params.retry_count);
+ printf("%d,", params.retry_interval * 10);
+
+ printf("%s,",
+ val2str(params.volatile_bit_rate, ipmi_bit_rate_vals));
+
+ printf("%s,",
+ val2str(params.non_volatile_bit_rate, ipmi_bit_rate_vals));
+
+ printf("%d,", params.payload_channel);
+ printf("%d\n", params.payload_port);
+ }
+ else
+ {
+ printf("Set in progress : %s\n",
+ val2str(params.set_in_progress & 0x03,
+ ipmi_set_in_progress_vals));
+ printf("Enabled : %s\n",
+ params.enabled?"true": "false");
+ printf("Force Encryption : %s\n",
+ params.force_encryption?"true":"false");
+ printf("Force Authentication : %s\n",
+ params.force_authentication?"true":"false");
+ printf("Privilege Level : %s\n",
+ val2str(params.privilege_level, ipmi_privlvl_vals));
+ printf("Character Accumulate Level (ms) : %d\n",
+ params.character_accumulate_level * 5);
+ printf("Character Send Threshold : %d\n",
+ params.character_send_threshold);
+ printf("Retry Count : %d\n",
+ params.retry_count);
+ printf("Retry Interval (ms) : %d\n",
+ params.retry_interval * 10);
+
+ printf("Volatile Bit Rate (kbps) : %s\n",
+ val2str(params.volatile_bit_rate, ipmi_bit_rate_vals));
+
+ printf("Non-Volatile Bit Rate (kbps) : %s\n",
+ val2str(params.non_volatile_bit_rate, ipmi_bit_rate_vals));
+
+ printf("Payload Channel : %d (0x%02x)\n",
+ params.payload_channel, params.payload_channel);
+ printf("Payload Port : %d\n",
+ params.payload_port);
+ }
+
+ return 0;
+}
+
+
+
+/*
+ * Small function to validate that user-supplied SOL
+ * configuration parameter values we store in uint8_t
+ * data type falls within valid range. With minval
+ * and maxval parameters we can use the same function
+ * to validate parameters that have different ranges
+ * of values.
+ *
+ * function will return -1 if value is not valid, or
+ * will return 0 if valid.
+ */
+int ipmi_sol_set_param_isvalid_uint8_t( const char *strval,
+ const char *name,
+ int base,
+ uint8_t minval,
+ uint8_t maxval,
+ uint8_t *out_value)
+{
+ if (str2uchar(strval, out_value) != 0 || (*out_value < minval)
+ || (*out_value > maxval)) {
+ lprintf(LOG_ERR, "Invalid value %s for parameter %s",
+ strval, name);
+ lprintf(LOG_ERR, "Valid values are %d-%d", minval, maxval);
+ return -1;
+ }
+ return 0;
+}
+
+
+/*
+ * ipmi_sol_set_param
+ *
+ * Set the specified Serial Over LAN value to the specified
+ * value
+ *
+ * return 0 on success,
+ * -1 on failure
+ */
+static int
+ipmi_sol_set_param(struct ipmi_intf * intf,
+ uint8_t channel,
+ const char * param,
+ const char * value,
+ uint8_t guarded)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint8_t data[4];
+ int bGuarded = guarded; /* Use set-in-progress indicator? */
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_TRANSPORT; /* 0x0c */
+ req.msg.cmd = IPMI_SET_SOL_CONFIG_PARAMETERS; /* 0x21 */
+ req.msg.data = data;
+
+ data[0] = channel;
+
+ /*
+ * set-in-progress
+ */
+ if (! strcmp(param, "set-in-progress"))
+ {
+ bGuarded = 0; /* We _ARE_ the set-in-progress indicator */
+ req.msg.data_len = 3;
+ data[1] = SOL_PARAMETER_SET_IN_PROGRESS;
+
+ if (! strcmp(value, "set-complete"))
+ data[2] = 0x00;
+ else if (! strcmp(value, "set-in-progress"))
+ data[2] = 0x01;
+ else if (! strcmp(value, "commit-write"))
+ data[2] = 0x02;
+ else
+ {
+ lprintf(LOG_ERR, "Invalid value %s for parameter %s",
+ value, param);
+ lprintf(LOG_ERR, "Valid values are set-complete, set-in-progress "
+ "and commit-write");
+ return -1;
+ }
+ }
+
+
+ /*
+ * enabled
+ */
+ else if (! strcmp(param, "enabled"))
+ {
+ req.msg.data_len = 3;
+ data[1] = SOL_PARAMETER_SOL_ENABLE;
+
+ if (! strcmp(value, "true"))
+ data[2] = 0x01;
+ else if (! strcmp(value, "false"))
+ data[2] = 0x00;
+ else
+ {
+ lprintf(LOG_ERR, "Invalid value %s for parameter %s",
+ value, param);
+ lprintf(LOG_ERR, "Valid values are true and false");
+ return -1;
+ }
+ }
+
+
+ /*
+ * force-payload-encryption
+ */
+ else if (! strcmp(param, "force-encryption"))
+ {
+ struct sol_config_parameters params;
+
+ req.msg.data_len = 3;
+ data[1] = SOL_PARAMETER_SOL_AUTHENTICATION;
+
+ if (! strcmp(value, "true"))
+ data[2] = 0x80;
+ else if (! strcmp(value, "false"))
+ data[2] = 0x00;
+ else
+ {
+ lprintf(LOG_ERR, "Invalid value %s for parameter %s",
+ value, param);
+ lprintf(LOG_ERR, "Valid values are true and false");
+ return -1;
+ }
+
+
+ /* We need other values to complete the request */
+ if (ipmi_get_sol_info(intf, channel, &params))
+ {
+ lprintf(LOG_ERR, "Error fetching SOL parameters for %s update",
+ param);
+ return -1;
+ }
+
+ data[2] |= params.force_authentication? 0x40 : 0x00;
+ data[2] |= params.privilege_level;
+ }
+
+
+ /*
+ * force-payload-authentication
+ */
+ else if (! strcmp(param, "force-authentication"))
+ {
+ struct sol_config_parameters params;
+
+ req.msg.data_len = 3;
+ data[1] = SOL_PARAMETER_SOL_AUTHENTICATION;
+
+ if (! strcmp(value, "true"))
+ data[2] = 0x40;
+ else if (! strcmp(value, "false"))
+ data[2] = 0x00;
+ else
+ {
+ lprintf(LOG_ERR, "Invalid value %s for parameter %s",
+ value, param);
+ lprintf(LOG_ERR, "Valid values are true and false");
+ return -1;
+ }
+
+
+ /* We need other values to complete the request */
+ if (ipmi_get_sol_info(intf, channel, &params))
+ {
+ lprintf(LOG_ERR, "Error fetching SOL parameters for %s update",
+ param);
+ return -1;
+ }
+
+ data[2] |= params.force_encryption? 0x80 : 0x00;
+ data[2] |= params.privilege_level;
+ }
+
+
+ /*
+ * privilege-level
+ */
+ else if (! strcmp(param, "privilege-level"))
+ {
+ struct sol_config_parameters params;
+
+ req.msg.data_len = 3;
+ data[1] = SOL_PARAMETER_SOL_AUTHENTICATION;
+
+ if (! strcmp(value, "user"))
+ data[2] = 0x02;
+ else if (! strcmp(value, "operator"))
+ data[2] = 0x03;
+ else if (! strcmp(value, "admin"))
+ data[2] = 0x04;
+ else if (! strcmp(value, "oem"))
+ data[2] = 0x05;
+ else
+ {
+ lprintf(LOG_ERR, "Invalid value %s for parameter %s",
+ value, param);
+ lprintf(LOG_ERR, "Valid values are user, operator, admin, and oem");
+ return -1;
+ }
+
+
+ /* We need other values to complete the request */
+ if (ipmi_get_sol_info(intf, channel, &params))
+ {
+ lprintf(LOG_ERR, "Error fetching SOL parameters for %s update",
+ param);
+ return -1;
+ }
+
+ data[2] |= params.force_encryption? 0x80 : 0x00;
+ data[2] |= params.force_authentication? 0x40 : 0x00;
+ }
+
+
+ /*
+ * character-accumulate-level
+ */
+ else if (! strcmp(param, "character-accumulate-level"))
+ {
+ struct sol_config_parameters params;
+
+ req.msg.data_len = 4;
+ data[1] = SOL_PARAMETER_CHARACTER_INTERVAL;
+
+ /* validate user-supplied input */
+ if (ipmi_sol_set_param_isvalid_uint8_t(value, param, 0, 1, 255, &data[2]))
+ return -1;
+
+ /* We need other values to complete the request */
+ if (ipmi_get_sol_info(intf, channel, &params))
+ {
+ lprintf(LOG_ERR, "Error fetching SOL parameters for %s update",
+ param);
+ return -1;
+ }
+
+ data[3] = params.character_send_threshold;
+ }
+
+
+ /*
+ * character-send-threshold
+ */
+ else if (! strcmp(param, "character-send-threshold"))
+ {
+ struct sol_config_parameters params;
+
+ req.msg.data_len = 4;
+ data[1] = SOL_PARAMETER_CHARACTER_INTERVAL;
+
+ /* validate user-supplied input */
+ if (ipmi_sol_set_param_isvalid_uint8_t(value, param, 0, 0, 255, &data[3]))
+ return -1;
+
+ /* We need other values to complete the request */
+ if (ipmi_get_sol_info(intf, channel, &params))
+ {
+ lprintf(LOG_ERR, "Error fetching SOL parameters for %s update",
+ param);
+ return -1;
+ }
+
+ data[2] = params.character_accumulate_level;
+ }
+
+
+ /*
+ * retry-count
+ */
+ else if (! strcmp(param, "retry-count"))
+ {
+ struct sol_config_parameters params;
+
+ req.msg.data_len = 4;
+ data[1] = SOL_PARAMETER_SOL_RETRY;
+
+ /* validate user input, 7 is max value */
+ if (ipmi_sol_set_param_isvalid_uint8_t(value, param, 0, 0, 7, &data[2]))
+ return -1;
+
+ /* We need other values to complete the request */
+ if (ipmi_get_sol_info(intf, channel, &params))
+ {
+ lprintf(LOG_ERR, "Error fetching SOL parameters for %s update",
+ param);
+ return -1;
+ }
+
+ data[3] = params.retry_interval;
+ }
+
+
+ /*
+ * retry-interval
+ */
+ else if (! strcmp(param, "retry-interval"))
+ {
+ struct sol_config_parameters params;
+
+ req.msg.data_len = 4;
+ data[1] = SOL_PARAMETER_SOL_RETRY;
+
+ /* validate user-supplied input */
+ if (ipmi_sol_set_param_isvalid_uint8_t(value, param, 0, 0, 255, &data[3]))
+ return -1;
+
+ /* We need other values to complete the request */
+ if (ipmi_get_sol_info(intf, channel, &params))
+ {
+ lprintf(LOG_ERR, "Error fetching SOL parameters for %s update",
+ param);
+ return -1;
+ }
+
+ data[2] = params.retry_count;
+ }
+
+
+ /*
+ * non-volatile-bit-rate
+ */
+ else if (! strcmp(param, "non-volatile-bit-rate"))
+ {
+ req.msg.data_len = 3;
+ data[1] = SOL_PARAMETER_SOL_NON_VOLATILE_BIT_RATE;
+
+ if (!strcmp(value, "serial"))
+ {
+ data[2] = 0x00;
+ }
+ else if (!strcmp(value, "9.6"))
+ {
+ data[2] = 0x06;
+ }
+ else if (!strcmp(value, "19.2"))
+ {
+ data[2] = 0x07;
+ }
+ else if (!strcmp(value, "38.4"))
+ {
+ data[2] = 0x08;
+ }
+ else if (!strcmp(value, "57.6"))
+ {
+ data[2] = 0x09;
+ }
+ else if (!strcmp(value, "115.2"))
+ {
+ data[2] = 0x0A;
+ }
+ else
+ {
+ lprintf(LOG_ERR, "Invalid value \"%s\" for parameter \"%s\"",
+ value,
+ param);
+ lprintf(LOG_ERR, "Valid values are serial, 9.6 19.2, 38.4, 57.6 and 115.2");
+ return -1;
+ }
+ }
+
+
+ /*
+ * volatile-bit-rate
+ */
+ else if (! strcmp(param, "volatile-bit-rate"))
+ {
+ req.msg.data_len = 3;
+ data[1] = SOL_PARAMETER_SOL_VOLATILE_BIT_RATE;
+
+ if (!strcmp(value, "serial"))
+ {
+ data[2] = 0x00;
+ }
+ else if (!strcmp(value, "9.6"))
+ {
+ data[2] = 0x06;
+ }
+ else if (!strcmp(value, "19.2"))
+ {
+ data[2] = 0x07;
+ }
+ else if (!strcmp(value, "38.4"))
+ {
+ data[2] = 0x08;
+ }
+ else if (!strcmp(value, "57.6"))
+ {
+ data[2] = 0x09;
+ }
+ else if (!strcmp(value, "115.2"))
+ {
+ data[2] = 0x0A;
+ }
+ else
+ {
+ lprintf(LOG_ERR, "Invalid value \"%s\" for parameter \"%s\"",
+ value,
+ param);
+ lprintf(LOG_ERR, "Valid values are serial, 9.6 19.2, 38.4, 57.6 and 115.2");
+ return -1;
+ }
+ }
+ else
+ {
+ lprintf(LOG_ERR, "Error: invalid SOL parameter %s", param);
+ return -1;
+ }
+
+
+ /*
+ * Execute the request
+ */
+ if (bGuarded &&
+ (ipmi_sol_set_param(intf,
+ channel,
+ "set-in-progress",
+ "set-in-progress",
+ bGuarded)))
+ {
+ lprintf(LOG_ERR, "Error: set of parameter \"%s\" failed", param);
+ return -1;
+ }
+
+
+ /* The command proper */
+ rsp = intf->sendrecv(intf, &req);
+
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error setting SOL parameter '%s'", param);
+ return -1;
+ }
+
+ if (!(!strncmp(param, "set-in-progress", 15) && !strncmp(value, "commit-write", 12)) &&
+ rsp->ccode > 0) {
+ switch (rsp->ccode) {
+ case 0x80:
+ lprintf(LOG_ERR, "Error setting SOL parameter '%s': "
+ "Parameter not supported", param);
+ break;
+ case 0x81:
+ lprintf(LOG_ERR, "Error setting SOL parameter '%s': "
+ "Attempt to set set-in-progress when not in set-complete state",
+ param);
+ break;
+ case 0x82:
+ lprintf(LOG_ERR, "Error setting SOL parameter '%s': "
+ "Attempt to write read-only parameter", param);
+ break;
+ case 0x83:
+ lprintf(LOG_ERR, "Error setting SOL parameter '%s': "
+ "Attempt to read write-only parameter", param);
+ break;
+ default:
+ lprintf(LOG_ERR, "Error setting SOL parameter '%s' to '%s': %s",
+ param, value, val2str(rsp->ccode, completion_code_vals));
+ break;
+ }
+
+ if (bGuarded &&
+ (ipmi_sol_set_param(intf,
+ channel,
+ "set-in-progress",
+ "set-complete",
+ bGuarded)))
+ {
+ lprintf(LOG_ERR, "Error could not set \"set-in-progress\" "
+ "to \"set-complete\"");
+ }
+
+ return -1;
+ }
+
+
+ /*
+ * The commit write could very well fail, but that's ok.
+ * It may not be implemented.
+ */
+ if (bGuarded)
+ ipmi_sol_set_param(intf,
+ channel,
+ "set-in-progress",
+ "commit-write",
+ bGuarded);
+
+
+ if (bGuarded &&
+ ipmi_sol_set_param(intf,
+ channel,
+ "set-in-progress",
+ "set-complete",
+ bGuarded))
+ {
+ lprintf(LOG_ERR, "Error could not set \"set-in-progress\" "
+ "to \"set-complete\"");
+ return -1;
+ }
+
+ return 0;
+}
+
+
+
+void
+leave_raw_mode(void)
+{
+ if (!_in_raw_mode)
+ return;
+ if (tcsetattr(fileno(stdin), TCSADRAIN, &_saved_tio) == -1)
+ perror("tcsetattr");
+ else
+ _in_raw_mode = 0;
+}
+
+
+
+void
+enter_raw_mode(void)
+{
+ struct termios tio;
+ if (tcgetattr(fileno(stdin), &tio) == -1) {
+ perror("tcgetattr");
+ return;
+ }
+ _saved_tio = tio;
+ tio.c_iflag |= IGNPAR;
+ tio.c_iflag &= ~(ISTRIP | INLCR | IGNCR | ICRNL | IXON | IXANY | IXOFF);
+ tio.c_lflag &= ~(ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHONL);
+ // #ifdef IEXTEN
+ tio.c_lflag &= ~IEXTEN;
+ // #endif
+ tio.c_oflag &= ~OPOST;
+ tio.c_cc[VMIN] = 1;
+ tio.c_cc[VTIME] = 0;
+ if (tcsetattr(fileno(stdin), TCSADRAIN, &tio) == -1)
+ perror("tcsetattr");
+ else
+ _in_raw_mode = 1;
+}
+
+
+static void
+sendBreak(struct ipmi_intf * intf)
+{
+ struct ipmi_v2_payload v2_payload;
+
+ memset(&v2_payload, 0, sizeof(v2_payload));
+
+ v2_payload.payload.sol_packet.character_count = 0;
+ v2_payload.payload.sol_packet.generate_break = 1;
+
+ intf->send_sol(intf, &v2_payload);
+}
+
+
+
+/*
+ * suspendSelf
+ *
+ * Put ourself in the background
+ *
+ * param bRestoreTty specifies whether we will put our self back
+ * in raw mode when we resume
+ */
+static void
+suspendSelf(int bRestoreTty)
+{
+ leave_raw_mode();
+ kill(getpid(), SIGTSTP);
+
+ if (bRestoreTty)
+ enter_raw_mode();
+}
+
+
+
+/*
+ * printSolEscapeSequences
+ *
+ * Send some useful documentation to the user
+ */
+static void
+printSolEscapeSequences(struct ipmi_intf * intf)
+{
+ printf(
+ "%c?\n\
+ Supported escape sequences:\n\
+ %c. - terminate connection\n\
+ %c^Z - suspend ipmitool\n\
+ %c^X - suspend ipmitool, but don't restore tty on restart\n\
+ %cB - send break\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.)\n",
+ intf->session->sol_escape_char,
+ intf->session->sol_escape_char,
+ intf->session->sol_escape_char,
+ intf->session->sol_escape_char,
+ intf->session->sol_escape_char,
+ intf->session->sol_escape_char,
+ intf->session->sol_escape_char,
+ intf->session->sol_escape_char);
+}
+
+
+
+/*
+ * output
+ *
+ * Send the specified data to stdout
+ */
+static void
+output(struct ipmi_rs * rsp)
+{
+ /* Add checks to make sure it is actually SOL data, in general I see
+ * outside code mostly trying to guard against this happening, but
+ * some places fail to do so, so I do so here to make sure nothing gets
+ * through. If non-sol data comes through here, there is probably
+ * a packet that won't get processed somewhere else, but the alternative
+ * of outputting corrupt data is worse. Generally I see the get device
+ * id response make it here somehow. I assume it is a heartbeat and the
+ * other code will retry if it cares about the response and misses it.
+ */
+ if (rsp &&
+ (rsp->session.authtype == IPMI_SESSION_AUTHTYPE_RMCP_PLUS) &&
+ (rsp->session.payloadtype == IPMI_PAYLOAD_TYPE_SOL))
+ {
+ int i;
+
+ for (i = 0; i < rsp->data_len; ++i)
+ putc(rsp->data[i], stdout);
+
+ fflush(stdout);
+ }
+}
+
+
+
+/*
+ * ipmi_sol_deactivate
+ */
+static int
+ipmi_sol_deactivate(struct ipmi_intf * intf, int instance)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint8_t data[6];
+
+ if ((instance <= 0) || (instance > 15)) {
+ lprintf(LOG_ERR, "Error: Instance must range from 1 to 15");
+ return -1;
+ }
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = IPMI_DEACTIVATE_PAYLOAD;
+ req.msg.data_len = 6;
+ req.msg.data = data;
+
+ bzero(data, sizeof(data));
+ data[0] = IPMI_PAYLOAD_TYPE_SOL; /* payload type */
+ data[1] = instance; /* payload instance. */
+
+ /* Lots of important data */
+ data[2] = 0;
+ data[3] = 0;
+ data[4] = 0;
+ data[5] = 0;
+
+ rsp = intf->sendrecv(intf, &req);
+
+ if (NULL != rsp) {
+ switch (rsp->ccode) {
+ case 0x00:
+ return 0;
+ case 0x80:
+ lprintf(LOG_ERR, "Info: SOL payload already de-activated");
+ break;
+ case 0x81:
+ lprintf(LOG_ERR, "Info: SOL payload type disabled");
+ break;
+ default:
+ lprintf(LOG_ERR, "Error de-activating SOL payload: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ break;
+ }
+ } else {
+ lprintf(LOG_ERR, "Error: No response de-activating SOL payload");
+ }
+
+ return -1;
+}
+
+
+
+/*
+ * processSolUserInput
+ *
+ * Act on user input into the SOL session. The only reason this
+ * is complicated is that we have to process escape sequences.
+ *
+ * return 0 on success
+ * 1 if we should exit
+ * < 0 on error (BMC probably closed the session)
+ */
+static int
+processSolUserInput(
+ struct ipmi_intf * intf,
+ uint8_t * input,
+ uint16_t buffer_length)
+{
+ static int escape_pending = 0;
+ static int last_was_cr = 1;
+ struct ipmi_v2_payload v2_payload;
+ int length = 0;
+ int retval = 0;
+ char ch;
+ int i;
+
+ memset(&v2_payload, 0, sizeof(v2_payload));
+
+ /*
+ * Our first order of business is to check the input for escape
+ * sequences to act on.
+ */
+ for (i = 0; i < buffer_length; ++i)
+ {
+ ch = input[i];
+
+ if (escape_pending){
+ escape_pending = 0;
+
+ /*
+ * Process a possible escape sequence.
+ */
+ switch (ch) {
+ case '.':
+ printf("%c. [terminated ipmitool]\n",
+ intf->session->sol_escape_char);
+ retval = 1;
+ break;
+
+ case 'Z' - 64:
+ printf("%c^Z [suspend ipmitool]\n",
+ intf->session->sol_escape_char);
+ suspendSelf(1); /* Restore tty back to raw */
+ continue;
+
+ case 'X' - 64:
+ printf("%c^Z [suspend ipmitool]\n",
+ intf->session->sol_escape_char);
+ suspendSelf(0); /* Don't restore to raw mode */
+ continue;
+
+ case 'B':
+ printf("%cB [send break]\n",
+ intf->session->sol_escape_char);
+ sendBreak(intf);
+ continue;
+
+ case '?':
+ printSolEscapeSequences(intf);
+ continue;
+
+ default:
+ if (ch != intf->session->sol_escape_char)
+ v2_payload.payload.sol_packet.data[length++] =
+ intf->session->sol_escape_char;
+ v2_payload.payload.sol_packet.data[length++] = ch;
+ }
+ }
+
+ else
+ {
+ if (last_was_cr && (ch == intf->session->sol_escape_char)) {
+ escape_pending = 1;
+ continue;
+ }
+
+ v2_payload.payload.sol_packet.data[length++] = ch;
+ }
+
+
+ /*
+ * Normal character. Record whether it was a newline.
+ */
+ last_was_cr = (ch == '\r' || ch == '\n');
+ }
+
+
+ /*
+ * If there is anything left to process we dispatch it to the BMC,
+ * send intf->session->sol_data.max_outbound_payload_size bytes
+ * at a time.
+ */
+ if (length)
+ {
+ struct ipmi_rs * rsp = NULL;
+ int try = 0;
+
+ while (try < intf->session->retry) {
+
+ v2_payload.payload.sol_packet.character_count = length;
+
+ rsp = intf->send_sol(intf, &v2_payload);
+
+ if (rsp)
+ {
+ break;
+ }
+
+ usleep(5000);
+ try++;
+ }
+
+ if (! rsp)
+ {
+ lprintf(LOG_ERR, "Error sending SOL data: FAIL");
+ retval = -1;
+ }
+
+ /* If the sequence number is set we know we have new data */
+ if (retval == 0)
+ if ((rsp->session.authtype == IPMI_SESSION_AUTHTYPE_RMCP_PLUS) &&
+ (rsp->session.payloadtype == IPMI_PAYLOAD_TYPE_SOL) &&
+ (rsp->payload.sol_packet.packet_sequence_number))
+ output(rsp);
+ }
+
+ return retval;
+}
+
+static int
+ipmi_sol_keepalive_using_sol(struct ipmi_intf * intf)
+{
+ struct ipmi_v2_payload v2_payload;
+ struct ipmi_rs * rsp = NULL;
+ struct timeval end;
+
+ int ret = 0;
+
+ if (_disable_keepalive)
+ return 0;
+
+ gettimeofday(&end, 0);
+
+ if (end.tv_sec - _start_keepalive.tv_sec > SOL_KEEPALIVE_TIMEOUT) {
+ memset(&v2_payload, 0, sizeof(v2_payload));
+
+ v2_payload.payload.sol_packet.character_count = 0;
+
+ rsp = intf->send_sol(intf, &v2_payload);
+
+ gettimeofday(&_start_keepalive, 0);
+ }
+ return ret;
+}
+
+static int
+ipmi_sol_keepalive_using_getdeviceid(struct ipmi_intf * intf)
+{
+ struct timeval end;
+ static int ret = 0;
+
+ if (_disable_keepalive)
+ return 0;
+
+ gettimeofday(&end, 0);
+
+ if (end.tv_sec - _start_keepalive.tv_sec > SOL_KEEPALIVE_TIMEOUT) {
+ ret = intf->keepalive(intf);
+ if ( (ret!=0) && (_keepalive_retries < SOL_KEEPALIVE_RETRIES) ) {
+ ret = 0;
+ _keepalive_retries++;
+ }
+ else if ((ret==0) && (_keepalive_retries > 0))
+ _keepalive_retries = 0;
+ gettimeofday(&_start_keepalive, 0);
+ }
+ return ret;
+}
+
+
+
+/*
+ * ipmi_sol_red_pill
+ */
+static int
+ipmi_sol_red_pill(struct ipmi_intf * intf, int instance)
+{
+ char * buffer;
+ int numRead;
+ int bShouldExit = 0;
+ int bBmcClosedSession = 0;
+ fd_set read_fds;
+ struct timeval tv;
+ int retval;
+ int buffer_size = intf->session->sol_data.max_inbound_payload_size;
+ int keepAliveRet = 0;
+ int retrySol = 0;
+
+ /* Subtract SOL header from max_inbound_payload_size */
+ if (buffer_size > 4)
+ buffer_size -= 4;
+
+ buffer = (char*)malloc(buffer_size);
+ if (buffer == NULL) {
+ lprintf(LOG_ERR, "ipmitool: malloc failure");
+ return -1;
+ }
+
+ /* Initialize keepalive start time */
+ gettimeofday(&_start_keepalive, 0);
+
+ enter_raw_mode();
+
+ while (! bShouldExit)
+ {
+ FD_ZERO(&read_fds);
+ FD_SET(0, &read_fds);
+ FD_SET(intf->fd, &read_fds);
+
+ if (!ipmi_oem_active(intf,"i82571spt"))
+ {
+ /* Send periodic keepalive packet */
+ if(_use_sol_for_keepalive == 0)
+ {
+ keepAliveRet = ipmi_sol_keepalive_using_getdeviceid(intf);
+ }
+ else
+ {
+ keepAliveRet = ipmi_sol_keepalive_using_sol(intf);
+ }
+
+ if (keepAliveRet != 0)
+ {
+ /*
+ * Retrying the keep Alive before declaring a communication
+ * lost state with the IPMC. Helpful when the payload is
+ * reset and brings down the connection temporarily. Otherwise,
+ * if we send getDevice Id to check the status of IPMC during
+ * this down time when the connection is restarting, SOL will
+ * exit even though the IPMC is available and the session is open.
+ */
+ if (retrySol == MAX_SOL_RETRY)
+ {
+ /* no response to Get Device ID keepalive message */
+ bShouldExit = 1;
+ continue;
+ }
+ else
+ {
+ retrySol++;
+ }
+ }
+ else
+ {
+ /* if the keep Alive is successful reset retries to zero */
+ retrySol = 0;
+ }
+ } /* !oem="i82571spt" */
+ /* Wait up to half a second */
+ tv.tv_sec = 0;
+ tv.tv_usec = 500000;
+
+ retval = select(intf->fd + 1, &read_fds, NULL, NULL, &tv);
+
+ if (retval)
+ {
+ if (retval == -1)
+ {
+ /* ERROR */
+ perror("select");
+ return -1;
+ }
+
+
+ /*
+ * Process input from the user
+ */
+ if (FD_ISSET(0, &read_fds))
+ {
+ memset(buffer, 0, buffer_size);
+ numRead = read(fileno(stdin),
+ buffer,
+ buffer_size);
+
+ if (numRead > 0)
+ {
+ int rc = processSolUserInput(intf, (uint8_t *)buffer, numRead);
+
+ if (rc)
+ {
+ if (rc < 0)
+ bShouldExit = bBmcClosedSession = 1;
+ else
+ bShouldExit = 1;
+ }
+ }
+ else
+ {
+ bShouldExit = 1;
+ }
+ }
+
+
+ /*
+ * Process input from the BMC
+ */
+ else if (FD_ISSET(intf->fd, &read_fds))
+ {
+ struct ipmi_rs * rs =intf->recv_sol(intf);
+ if (! rs)
+ {
+ bShouldExit = bBmcClosedSession = 1;
+ }
+ else
+ {
+ output(rs);
+ }
+ }
+
+
+ /*
+ * ERROR in select
+ */
+ else
+ {
+ lprintf(LOG_ERR, "Error: Select returned with nothing to read");
+ bShouldExit = 1;
+ }
+ }
+ }
+
+ leave_raw_mode();
+
+ if (keepAliveRet != 0)
+ {
+ lprintf(LOG_ERR, "Error: No response to keepalive - Terminating session");
+ /* attempt to clean up anyway */
+ ipmi_sol_deactivate(intf, instance);
+ exit(1);
+ }
+
+ if (bBmcClosedSession)
+ {
+ lprintf(LOG_ERR, "SOL session closed by BMC");
+ exit(1);
+ }
+ else
+ ipmi_sol_deactivate(intf, instance);
+
+ return 0;
+}
+
+
+
+
+/*
+ * ipmi_sol_activate
+ */
+static int
+ipmi_sol_activate(struct ipmi_intf * intf, int looptest, int interval,
+ int instance)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ struct activate_payload_rsp ap_rsp;
+ uint8_t data[6];
+ uint8_t bSolEncryption = 1;
+ uint8_t bSolAuthentication = 1;
+
+ /*
+ * This command is only available over RMCP+ (the lanplus
+ * interface).
+ */
+ if (strncmp(intf->name, "lanplus", 7) != 0)
+ {
+ lprintf(LOG_ERR, "Error: This command is only available over the "
+ "lanplus interface");
+ return -1;
+ }
+
+ if ((instance <= 0) || (instance > 15)) {
+ lprintf(LOG_ERR, "Error: Instance must range from 1 to 15");
+ return -1;
+ }
+
+
+ /*
+ * Setup a callback so that the lanplus processing knows what
+ * to do with packets that come unexpectedly (while waiting for
+ * an ACK, perhaps.
+ */
+ intf->session->sol_data.sol_input_handler = output;
+
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = IPMI_ACTIVATE_PAYLOAD;
+ req.msg.data_len = 6;
+ req.msg.data = data;
+
+ data[0] = IPMI_PAYLOAD_TYPE_SOL; /* payload type */
+ data[1] = instance; /* payload instance */
+
+ /* Lots of important data. Most is default */
+ data[2] = bSolEncryption? 0x80 : 0;
+ data[2] |= bSolAuthentication? 0x40 : 0;
+ data[2] |= IPMI_SOL_SERIAL_ALERT_MASK_DEFERRED;
+
+ if (ipmi_oem_active(intf, "intelplus")) {
+ data[2] |= IPMI_SOL_BMC_ASSERTS_CTS_MASK_TRUE;
+ } else if (ipmi_oem_active(intf, "i82571spt")) {
+ /*
+ * A quote from Intel: "Engineering believes the problem
+ * lies within the Auxiliary data being sent with the
+ * 'Activate Payload' command from IPMITool. IPMITool
+ * sends a C6h which sets some bits having to do with
+ * encryption and some behavior dealing with CTS DCD/DSR.
+ * I recommend that the customer modify this request
+ * to send 08h instead. This is what our internal utility
+ * sends and it works without issue. I will work with
+ * engineering to ensure the settings that IPMITool uses
+ * (C6h) are supported in the future.
+ */
+ data[2] = 0x08;
+ } else {
+ data[2] |= IPMI_SOL_BMC_ASSERTS_CTS_MASK_FALSE;
+ }
+
+ data[3] = 0x00; /* reserved */
+ data[4] = 0x00; /* reserved */
+ data[5] = 0x00; /* reserved */
+
+ rsp = intf->sendrecv(intf, &req);
+
+ if (NULL != rsp) {
+ switch (rsp->ccode) {
+ case 0x00:
+ if (rsp->data_len == 12) {
+ break;
+ } else {
+ lprintf(LOG_ERR, "Error: Unexpected data length (%d) received "
+ "in payload activation response",
+ rsp->data_len);
+ return -1;
+ }
+ break;
+ case 0x80:
+ lprintf(LOG_ERR, "Info: SOL payload already active on another session");
+ return -1;
+ case 0x81:
+ lprintf(LOG_ERR, "Info: SOL payload disabled");
+ return -1;
+ case 0x82:
+ lprintf(LOG_ERR, "Info: SOL payload activation limit reached");
+ return -1;
+ case 0x83:
+ lprintf(LOG_ERR, "Info: cannot activate SOL payload with encryption");
+ return -1;
+ case 0x84:
+ lprintf(LOG_ERR, "Info: cannot activate SOL payload without encryption");
+ return -1;
+ default:
+ lprintf(LOG_ERR, "Error activating SOL payload: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ } else {
+ lprintf(LOG_ERR, "Error: No response activating SOL payload");
+ return -1;
+ }
+
+
+ memcpy(&ap_rsp, rsp->data, sizeof(struct activate_payload_rsp));
+
+ intf->session->sol_data.max_inbound_payload_size =
+ (ap_rsp.inbound_payload_size[1] << 8) |
+ ap_rsp.inbound_payload_size[0];
+
+ intf->session->sol_data.max_outbound_payload_size =
+ (ap_rsp.outbound_payload_size[1] << 8) |
+ ap_rsp.outbound_payload_size[0];
+
+ intf->session->sol_data.port =
+ (ap_rsp.payload_udp_port[1] << 8) |
+ ap_rsp.payload_udp_port[0];
+
+ intf->session->timeout = 1;
+
+
+ /* NOTE: the spec does allow for SOL traffic to be sent on
+ * a different port. we do not yet support that feature. */
+ if (intf->session->sol_data.port != intf->session->port)
+ {
+ /* try byteswapping port in case BMC sent it incorrectly */
+ uint16_t portswap = BSWAP_16(intf->session->sol_data.port);
+
+ if (portswap == intf->session->port) {
+ intf->session->sol_data.port = portswap;
+ }
+ else {
+ lprintf(LOG_ERR, "Error: BMC requests SOL session on different port");
+ return -1;
+ }
+ }
+
+ printf("[SOL Session operational. Use %c? for help]\n",
+ intf->session->sol_escape_char);
+
+ if(looptest == 1)
+ {
+ ipmi_sol_deactivate(intf, instance);
+ usleep(interval*1000);
+ return 0;
+ }
+
+ /*
+ * At this point we are good to go with our SOL session. We
+ * need to listen to
+ * 1) STDIN for user input
+ * 2) The FD for incoming SOL packets
+ */
+ if (ipmi_sol_red_pill(intf, instance))
+ {
+ lprintf(LOG_ERR, "Error in SOL session");
+ return -1;
+ }
+
+ return 0;
+}
+
+
+
+/*
+ * print_sol_usage
+ */
+static void
+print_sol_usage(void)
+{
+ lprintf(LOG_NOTICE, "SOL Commands: info [<channel number>]");
+ lprintf(LOG_NOTICE, " set <parameter> <value> [channel]");
+ lprintf(LOG_NOTICE, " payload <enable|disable|status> [channel] [userid]");
+ lprintf(LOG_NOTICE, " activate [<usesolkeepalive|nokeepalive>] [instance=<number>]");
+ lprintf(LOG_NOTICE, " deactivate [instance=<number>]");
+ lprintf(LOG_NOTICE, " looptest [<loop times> [<loop interval(in ms)> [<instance>]]]");
+}
+
+
+
+/*
+ * print_sol_set_usage
+ */
+static void
+print_sol_set_usage(void)
+{
+ lprintf(LOG_NOTICE, "\nSOL set parameters and values: \n");
+ lprintf(LOG_NOTICE, " set-in-progress set-complete | "
+ "set-in-progress | commit-write");
+ lprintf(LOG_NOTICE, " enabled true | false");
+ lprintf(LOG_NOTICE, " force-encryption true | false");
+ lprintf(LOG_NOTICE, " force-authentication true | false");
+ lprintf(LOG_NOTICE, " privilege-level user | operator | admin | oem");
+ lprintf(LOG_NOTICE, " character-accumulate-level <in 5 ms increments>");
+ lprintf(LOG_NOTICE, " character-send-threshold N");
+ lprintf(LOG_NOTICE, " retry-count N");
+ lprintf(LOG_NOTICE, " retry-interval <in 10 ms increments>");
+ lprintf(LOG_NOTICE, " non-volatile-bit-rate "
+ "serial | 9.6 | 19.2 | 38.4 | 57.6 | 115.2");
+ lprintf(LOG_NOTICE, " volatile-bit-rate "
+ "serial | 9.6 | 19.2 | 38.4 | 57.6 | 115.2");
+ lprintf(LOG_NOTICE, "");
+}
+
+
+
+/* ipmi_sol_main */
+int
+ipmi_sol_main(struct ipmi_intf * intf, int argc, char ** argv)
+{
+ int retval = 0;
+ if (!argc || !strncmp(argv[0], "help", 4)) {
+ /* Help */
+ print_sol_usage();
+ } else if (!strncmp(argv[0], "info", 4)) {
+ /* Info */
+ uint8_t channel;
+ if (argc == 1) {
+ /* Ask about the current channel */
+ channel = 0x0E;
+ } else if (argc == 2) {
+ if (is_ipmi_channel_num(argv[1], &channel) != 0) {
+ return (-1);
+ }
+ } else {
+ print_sol_usage();
+ return -1;
+ }
+ retval = ipmi_print_sol_info(intf, channel);
+ } else if (!strncmp(argv[0], "payload", 7)) {
+ /* Payload enable or disable */
+ uint8_t channel = 0xe;
+ uint8_t userid = 1;
+ int enable = -1;
+ if (argc == 1 || argc > 4) {
+ print_sol_usage();
+ return -1;
+ }
+ if (argc == 1 || argc > 4) {
+ print_sol_usage();
+ return -1;
+ }
+ if (argc >= 3) {
+ if (is_ipmi_channel_num(argv[2], &channel) != 0) {
+ return (-1);
+ }
+ }
+ if (argc == 4) {
+ if (is_ipmi_user_id(argv[3], &userid) != 0) {
+ return (-1);
+ }
+ }
+ if (!strncmp(argv[1], "enable", 6)) {
+ enable = 1;
+ } else if (!strncmp(argv[1], "disable", 7)) {
+ enable = 0;
+ } else if (!strncmp(argv[1], "status", 6)) {
+ return ipmi_sol_payload_access_status(intf, channel, userid);
+ } else {
+ print_sol_usage();
+ return -1;
+ }
+ retval = ipmi_sol_payload_access(intf, channel, userid, enable);
+ } else if (!strncmp(argv[0], "set", 3)) {
+ /* Set a parameter value */
+ uint8_t channel = 0xe;
+ uint8_t guard = 1;
+ if (argc == 3) {
+ channel = 0xe;
+ } else if (argc == 4) {
+ if (!strncmp(argv[3], "noguard", 7)) {
+ guard = 0;
+ } else {
+ if (is_ipmi_channel_num(argv[3], &channel) != 0) {
+ return (-1);
+ }
+ }
+ } else if (argc == 5) {
+ if (is_ipmi_channel_num(argv[3], &channel) != 0) {
+ return (-1);
+ }
+ if (!strncmp(argv[4], "noguard", 7)) {
+ guard = 0;
+ }
+ } else {
+ print_sol_set_usage();
+ return -1;
+ }
+ retval = ipmi_sol_set_param(intf, channel, argv[1], argv[2], guard);
+ } else if (!strncmp(argv[0], "activate", 8)) {
+ /* Activate */
+ int i;
+ uint8_t instance = 1;
+ for (i = 1; i < argc; i++) {
+ if (!strncmp(argv[i], "usesolkeepalive", 15)) {
+ _use_sol_for_keepalive = 1;
+ } else if (!strncmp(argv[i], "nokeepalive", 11)) {
+ _disable_keepalive = 1;
+ } else if (!strncmp(argv[i], "instance=", 9)) {
+ if (str2uchar(argv[i] + 9, &instance) != 0) {
+ lprintf(LOG_ERR, "Given instance '%s' is invalid.", argv[i] + 9);
+ print_sol_usage();
+ return -1;
+ }
+ } else {
+ print_sol_usage();
+ return -1;
+ }
+ }
+ retval = ipmi_sol_activate(intf, 0, 0, instance);
+ } else if (!strncmp(argv[0], "deactivate", 10)) {
+ /* Dectivate */
+ int i;
+ uint8_t instance = 1;
+ for (i = 1; i < argc; i++) {
+ if (!strncmp(argv[i], "instance=", 9)) {
+ if (str2uchar(argv[i] + 9, &instance) != 0) {
+ lprintf(LOG_ERR,
+ "Given instance '%s' is invalid.",
+ argv[i] + 9);
+ print_sol_usage();
+ return -1;
+ }
+ } else {
+ print_sol_usage();
+ return -1;
+ }
+ }
+ retval = ipmi_sol_deactivate(intf, instance);
+ } else if (!strncmp(argv[0], "looptest", 8)) {
+ /* SOL loop test: Activate and then Dectivate */
+ int cnt = 200;
+ int interval = 100; /* Unit is: ms */
+ uint8_t instance = 1;
+ if (argc > 4) {
+ print_sol_usage();
+ return -1;
+ }
+ if (argc != 1) {
+ /* at least 2 */
+ if (str2int(argv[1], &cnt) != 0) {
+ lprintf(LOG_ERR, "Given cnt '%s' is invalid.",
+ argv[1]);
+ return (-1);
+ }
+ if (cnt <= 0) {
+ cnt = 200;
+ }
+ }
+ if (argc >= 3) {
+ if (str2int(argv[2], &interval) != 0) {
+ lprintf(LOG_ERR, "Given interval '%s' is invalid.",
+ argv[2]);
+ return (-1);
+ }
+ if (interval < 0) {
+ interval = 0;
+ }
+ }
+ if (argc >= 4) {
+ if (str2uchar(argv[3], &instance) != 0) {
+ lprintf(LOG_ERR, "Given instance '%s' is invalid.",
+ argv[3]);
+ print_sol_usage();
+ return -1;
+ }
+ }
+
+ while (cnt > 0) {
+ printf("remain loop test counter: %d\n", cnt);
+ retval = ipmi_sol_activate(intf, 1, interval, instance);
+ if (retval) {
+ printf("SOL looptest failed: %d\n",
+ retval);
+ break;
+ }
+ cnt -= 1;
+ }
+ } else {
+ print_sol_usage();
+ retval = -1;
+ }
+ return retval;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-01 09:14:15 +0000