/*                                 

 * 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.

 */

#define _XOPEN_SOURCE

#define _BSD_SOURCE || \

	(_XOPEN_SOURCE >= 500 || \

                       _XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED) && \

	!(_POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700)

#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;

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->ssn_params.port);

				params->payload_port = intf->ssn_params.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",