/*

 * 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 _SVID_SOURCE || _BSD_SOURCE || _POSIX_C_SOURCE >= 1 || \

	_XOPEN_SOURCE || _POSIX_SOURCE

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include <time.h>

#include <ipmitool/bswap.h>

#include <ipmitool/helper.h>

#include <ipmitool/ipmi.h>

#include <ipmitool/log.h>

#include <ipmitool/ipmi_intf.h>

#include <ipmitool/ipmi_strings.h>

#include <ipmitool/ipmi_chassis.h>

extern int verbose;

int

ipmi_chassis_power_status(struct ipmi_intf * intf)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

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

	req.msg.netfn = IPMI_NETFN_CHASSIS;

	req.msg.cmd = 0x1;

	req.msg.data_len = 0;

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

	if (rsp == NULL) {

		lprintf(LOG_ERR, "Unable to get Chassis Power Status");

		return -1;

	}

	if (rsp->ccode > 0) {

		lprintf(LOG_ERR, "Get Chassis Power Status failed: %s",

				val2str(rsp->ccode, completion_code_vals));

		return -1;

	}

	return rsp->data[0] & 1;

}

static int

ipmi_chassis_print_power_status(struct ipmi_intf * intf)

{

	int ps = ipmi_chassis_power_status(intf);

	if (ps < 0)

		return -1;

	printf("Chassis Power is %s\n", ps ? "on" : "off");

	return 0;

}

int

ipmi_chassis_power_control(struct ipmi_intf * intf, uint8_t ctl)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

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

	req.msg.netfn = IPMI_NETFN_CHASSIS;

	req.msg.cmd = 0x2;

	req.msg.data = &ctl;

	req.msg.data_len = 1;

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

	if (rsp == NULL) {

		lprintf(LOG_ERR, "Unable to set Chassis Power Control to %s",

				val2str(ctl, ipmi_chassis_power_control_vals));

		return -1;

	}

	if (rsp->ccode > 0) {

		lprintf(LOG_ERR, "Set Chassis Power Control to %s failed: %s",

				val2str(ctl, ipmi_chassis_power_control_vals),

				val2str(rsp->ccode, completion_code_vals));

		return -1;

	}

	printf("Chassis Power Control: %s\n",

			val2str(ctl, ipmi_chassis_power_control_vals));

	return 0;

}

static int

ipmi_chassis_identify(struct ipmi_intf * intf, char * arg)

{

	struct ipmi_rq req;

	struct ipmi_rs * rsp;

	int rc = (-3);

	struct {

		uint8_t interval;

		uint8_t force_on;

	} identify_data = { .interval = 0, .force_on = 0 };

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

	req.msg.netfn = IPMI_NETFN_CHASSIS;

	req.msg.cmd = 0x4;

	if (arg != NULL) {

		if (strncmp(arg, "force", 5) == 0) {

			identify_data.force_on = 1;

		} else {

			if ( (rc = str2uchar(arg, &identify_data.interval)) != 0) {

				if (rc == (-2)) {

					lprintf(LOG_ERR, "Invalid interval given.");

				} else {

					lprintf(LOG_ERR, "Given interval is too big.");

				}

				return (-1);

			}

		}

		req.msg.data = (uint8_t *)&identify_data;

		/* The Force Identify On byte is optional and not

		 * supported by all devices-- if force is not specified,

		 * we pass only one data byte; if specified, we pass two

		 * data bytes and check for an error completion code

		 */

		req.msg.data_len = (identify_data.force_on) ? 2 : 1;

	}

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

	if (rsp == NULL) {

		lprintf(LOG_ERR, "Unable to set Chassis Identify");

		return -1;

	}

	if (rsp->ccode > 0) {

		lprintf(LOG_ERR, "Set Chassis Identify failed: %s",

				val2str(rsp->ccode, completion_code_vals));

		if (identify_data.force_on != 0) {

			/* Intel SE7501WV2 F/W 1.2 returns CC 0xC7, but

			 * the IPMI v1.5 spec does not standardize a CC

			 * if unsupported, so we warn

			 */

			lprintf(LOG_WARNING, "Chassis may not support Force Identify On\n");

		}

		return -1;

	}

	printf("Chassis identify interval: ");

	if (arg == NULL) {

		printf("default (15 seconds)\n");

	} else {

		if (identify_data.force_on != 0) {

			printf("indefinite\n");

		} else {

			if (identify_data.interval == 0)

				printf("off\n");

			else

				printf("%i seconds\n", identify_data.interval);

		}

	}

	return 0;

}

static int

ipmi_chassis_poh(struct ipmi_intf * intf)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

	uint8_t mins_per_count;

	uint32_t count;

	float minutes;

	uint32_t days, hours;

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

	req.msg.netfn = IPMI_NETFN_CHASSIS;

	req.msg.cmd = 0xf;

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

	if (rsp == NULL) {

		lprintf(LOG_ERR, "Unable to get Chassis Power-On-Hours");

		return -1;

	}

	if (rsp->ccode > 0) {

		lprintf(LOG_ERR, "Get Chassis Power-On-Hours failed: %s",

				val2str(rsp->ccode, completion_code_vals));

		return -1;

	}

	mins_per_count = rsp->data[0];

	memcpy(&count, rsp->data+1, 4);

#if WORDS_BIGENDIAN

	count = BSWAP_32(count);

#endif

	minutes = (float)count * mins_per_count;

	days = minutes / 1440;

	minutes -= (float)days * 1440;

	hours = minutes / 60;

	minutes -= hours * 60;

	if (mins_per_count < 60) {

		printf("POH Counter  : %i days, %i hours, %li minutes\n",

				days, hours, (long)minutes);

	} else {

		printf("POH Counter  : %i days, %i hours\n", days, hours);

	}

	return 0;

}

static int

ipmi_chassis_restart_cause(struct ipmi_intf * intf)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

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

	req.msg.netfn = IPMI_NETFN_CHASSIS;

	req.msg.cmd = 0x7;

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

	if (rsp == NULL) {

		lprintf(LOG_ERR, "Unable to get Chassis Restart Cause");

		return -1;

	}

	if (rsp->ccode > 0) {

		lprintf(LOG_ERR, "Get Chassis Restart Cause failed: %s",

				val2str(rsp->ccode, completion_code_vals));

		return -1;

	}

	printf("System restart cause: ");

	switch (rsp->data[0] & 0xf) {

	case 0:

		printf("unknown\n");

		break;

	case 1:

		printf("chassis power control command\n");

		break;

	case 2:

		printf("reset via pushbutton\n");

		break;

	case 3:

		printf("power-up via pushbutton\n");

		break;

	case 4:

		printf("watchdog expired\n");

		break;

	case 5:

		printf("OEM\n");

		break;

	case 6:

		printf("power-up due to always-restore power policy\n");

		break;

	case 7:

		printf("power-up due to restore-previous power policy\n");

		break;

	case 8:

		printf("reset via PEF\n");

		break;

	case 9:

		printf("power-cycle via PEF\n");

		break;

	default:

		printf("invalid\n");

	}

	return 0;

}

int

ipmi_chassis_status(struct ipmi_intf * intf)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

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

	req.msg.netfn = IPMI_NETFN_CHASSIS;

	req.msg.cmd = 0x1;

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

	if (rsp == NULL) {

		lprintf(LOG_ERR, "Error sending Chassis Status command");

		return -1;

	}

	if (rsp->ccode > 0) {

		lprintf(LOG_ERR, "Error sending Chassis Status command: %s",

				val2str(rsp->ccode, completion_code_vals));

		return -1;

	}

	/* byte 1 */

	printf("System Power         : %s\n", (rsp->data[0] & 0x1) ? "on" : "off");

	printf("Power Overload       : %s\n", (rsp->data[0] & 0x2) ? "true" : "false");

	printf("Power Interlock      : %s\n", (rsp->data[0] & 0x4) ? "active" : "inactive");

	printf("Main Power Fault     : %s\n", (rsp->data[0] & 0x8) ? "true" : "false");

	printf("Power Control Fault  : %s\n", (rsp->data[0] & 0x10) ? "true" : "false");

	printf("Power Restore Policy : ");

	switch ((rsp->data[0] & 0x60) >> 5) {

	case 0x0:

		printf("always-off\n");

		break;

	case 0x1:

		printf("previous\n");

		break;

	case 0x2:

		printf("always-on\n");

		break;

	case 0x3:

	default:

		printf("unknown\n");

	}

	/* byte 2 */

	printf("Last Power Event     : ");

	if (rsp->data[1] & 0x1)

		printf("ac-failed ");

	if (rsp->data[1] & 0x2)

		printf("overload ");

	if (rsp->data[1] & 0x4)

		printf("interlock ");

	if (rsp->data[1] & 0x8)

		printf("fault ");

	if (rsp->data[1] & 0x10)

		printf("command");

	printf("\n");

	/* byte 3 */

	printf("Chassis Intrusion    : %s\n", (rsp->data[2] & 0x1) ? "active" : "inactive");

	printf("Front-Panel Lockout  : %s\n", (rsp->data[2] & 0x2) ? "active" : "inactive");

	printf("Drive Fault          : %s\n", (rsp->data[2] & 0x4) ? "true" : "false");

	printf("Cooling/Fan Fault    : %s\n", (rsp->data[2] & 0x8) ? "true" : "false");

	if (rsp->data_len > 3) {

		/* optional byte 4 */

		if (rsp->data[3] == 0) {

			printf("Front Panel Control  : none\n");

		} else {

			printf("Sleep Button Disable : %s\n", (rsp->data[3] & 0x80) ? "allowed" : "not allowed");

			printf("Diag Button Disable  : %s\n", (rsp->data[3] & 0x40) ? "allowed" : "not allowed");

			printf("Reset Button Disable : %s\n", (rsp->data[3] & 0x20) ? "allowed" : "not allowed");

			printf("Power Button Disable : %s\n", (rsp->data[3] & 0x10) ? "allowed" : "not allowed");

			printf("Sleep Button Disabled: %s\n", (rsp->data[3] & 0x08) ? "true" : "false");

			printf("Diag Button Disabled : %s\n", (rsp->data[3] & 0x04) ? "true" : "false");

			printf("Reset Button Disabled: %s\n", (rsp->data[3] & 0x02) ? "true" : "false");

			printf("Power Button Disabled: %s\n", (rsp->data[3] & 0x01) ? "true" : "false");

		}

	}

	return 0;

}

static int

ipmi_chassis_selftest(struct ipmi_intf * intf)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

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

	req.msg.netfn = IPMI_NETFN_APP;

	req.msg.cmd = 0x4;

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

	if (rsp == NULL) {

		lprintf(LOG_ERR, "Error sending Get Self Test command");

		return -1;

	}

	if (rsp->ccode > 0) {

		lprintf(LOG_ERR, "Error sending Get Self Test command: %s",

				val2str(rsp->ccode, completion_code_vals));

		return -1;

	}

	printf("Self Test Results    : ");

	switch (rsp->data[0]) {

	case 0x55:

		printf("passed\n");

		break;

	case 0x56:

		printf("not implemented\n");

		break;

	case 0x57:

	{

		int i;

		const struct valstr broken_dev_vals[] = {

			{ 0, "firmware corrupted" },

			{ 1, "boot block corrupted" },

			{ 2, "FRU Internal Use Area corrupted" },

			{ 3, "SDR Repository empty" },

			{ 4, "IPMB not responding" },

			{ 5, "cannot access BMC FRU" },

			{ 6, "cannot access SDR Repository" },

			{ 7, "cannot access SEL Device" },

			{ 0xff, NULL },

		};

		printf("device error\n");

		for (i=0; i<8; i++) {

			if (rsp->data[1] & (1<

				printf("                       [%s]\n",

						val2str(i, broken_dev_vals));

			}

		}

	}

	break;

	case 0x58:

		printf("Fatal hardware error: %02xh\n", rsp->data[1]);

		break;

	default:

		printf("Device-specific failure %02xh:%02xh\n",

				rsp->data[0], rsp->data[1]);

		break;

	}

	return 0;

}

static int

ipmi_chassis_set_bootparam(struct ipmi_intf * intf, uint8_t param, uint8_t * data, int len)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

	uint8_t msg_data[16];

	memset(msg_data, 0, 16);

	msg_data[0] = param & 0x7f;

	memcpy(msg_data+1, data, len);

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

	req.msg.netfn = IPMI_NETFN_CHASSIS;

	req.msg.cmd = 0x8;

	req.msg.data = msg_data;

	req.msg.data_len = len + 1;

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

	if (rsp == NULL) {

		lprintf(LOG_ERR, "Error setting Chassis Boot Parameter %d", param);

		return -1;

	}

	if (rsp->ccode > 0) {

		if (param != 0) {

			lprintf(LOG_ERR, "Set Chassis Boot Parameter %d failed: %s",

					param, val2str(rsp->ccode, completion_code_vals));

		}

		return -1;

	}

	lprintf(LOG_DEBUG, "Chassis Set Boot Parameter %d to %s", param, buf2str(data, len));

	return 0;

}

static int

ipmi_chassis_get_bootparam(struct ipmi_intf * intf, char * arg)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

	uint8_t msg_data[3];

	uint8_t param_id = 0;

	if (arg == NULL)

		return -1;

	if (str2uchar(arg, &param_id) != 0) {

		lprintf(LOG_ERR, "Invalid parameter '%s' given instead of bootparam.",

				arg);

		return (-1);

	}

	memset(msg_data, 0, 3);

	msg_data[0] = param_id & 0x7f;

	msg_data[1] = 0;

	msg_data[2] = 0;

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

	req.msg.netfn = IPMI_NETFN_CHASSIS;

	req.msg.cmd = 0x9;

	req.msg.data = msg_data;

	req.msg.data_len = 3;

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

	if (rsp == NULL) {

		lprintf(LOG_ERR, "Error Getting Chassis Boot Parameter %s", arg);

		return -1;

	}

	if (rsp->ccode > 0) {

		lprintf(LOG_ERR, "Get Chassis Boot Parameter %s failed: %s",

				arg, val2str(rsp->ccode, completion_code_vals));

		return -1;

	}

	if (verbose > 2)

		printbuf(rsp->data, rsp->data_len, "Boot Option");

	param_id = 0;

	param_id = (rsp->data[1] & 0x7f);

	printf("Boot parameter version: %d\n", rsp->data[0]);

	printf("Boot parameter %d is %s\n", rsp->data[1] & 0x7f,

			(rsp->data[1] & 0x80) ? "invalid/locked" : "valid/unlocked");

	printf("Boot parameter data: %s\n", buf2str(rsp->data+2, rsp->data_len - 2));

	switch(param_id)

	{

		case 0:

		{

			printf(" Set In Progress : ");

			switch((rsp->data[2]) &0x03)

			{

				case 0: printf("set complete\n"); break;

				case 1: printf("set in progress\n"); break;

				case 2: printf("commit write\n"); break;

				default: printf("error, reserved bit\n"); break;

			}

		}

		break;

		case 1:

		{

			printf(" Service Partition Selector : ");

			if((rsp->data[2]) == 0)

			{

				printf("unspecified\n");

			}

			else

			{

				printf("%d\n",(rsp->data[2]));

			}

		}

		break;

		case 2:

		{

			printf(   " Service Partition Scan :\n");

			if((rsp->data[2]&0x03) != 0)

			{

				if((rsp->data[2]&0x01) == 0x01)

					printf("     - Request BIOS to scan\n");

				if((rsp->data[2]&0x02) == 0x02)

					printf("     - Service Partition Discovered\n");

			}

			else

			{

				printf("     No flag set\n");

			}

		}

		break;

		case 3:

		{

			printf(   " BMC boot flag valid bit clearing :\n");

			if((rsp->data[2]&0x1f) != 0)

			{

				if((rsp->data[2]&0x10) == 0x10)

					printf("     - Don't clear valid bit on reset/power cycle cause by PEF\n");

				if((rsp->data[2]&0x08) == 0x08)

					printf("     - Don't automatically clear boot flag valid bit on timeout\n");

				if((rsp->data[2]&0x04) == 0x04)

					printf("     - Don't clear valid bit on reset/power cycle cause by watchdog\n");

				if((rsp->data[2]&0x02) == 0x02)

					printf("     - Don't clear valid bit on push button reset // soft reset\n");

				if((rsp->data[2]&0x01) == 0x01)

					printf("     - Don't clear valid bit on power up via power push button or wake event\n");

			}

			else

			{

				printf("     No flag set\n");

			}

		}

		break;

		case 4:

		{

			printf(   " Boot Info Acknowledge :\n");

			if((rsp->data[3]&0x1f) != 0)

			{

				if((rsp->data[3]&0x10) == 0x10)

					printf("    - OEM has handled boot info\n");

				if((rsp->data[3]&0x08) == 0x08)

					printf("    - SMS has handled boot info\n");

				if((rsp->data[3]&0x04) == 0x04)

					printf("    - OS // service partition has handled boot info\n");

				if((rsp->data[3]&0x02) == 0x02)

					printf("    - OS Loader has handled boot info\n");

				if((rsp->data[3]&0x01) == 0x01)

					printf("    - BIOS/POST has handled boot info\n");

			}

			else

			{

				printf("     No flag set\n");

			}

		}

		break;

		case 5:

		{

			printf(   " Boot Flags :\n");

			if((rsp->data[2]&0x80) == 0x80)

				printf("   - Boot Flag Valid\n");

			else

				printf("   - Boot Flag Invalid\n");

			if((rsp->data[2]&0x40) == 0x40)

				printf("   - Options apply to all future boots\n");

			else

				printf("   - Options apply to only next boot\n");

			if((rsp->data[2]&0x20) == 0x20)

				printf("   - BIOS EFI boot \n");

			else

				printf("   - BIOS PC Compatible (legacy) boot \n");

			if((rsp->data[3]&0x80) == 0x80)

				printf("   - CMOS Clear\n");

			if((rsp->data[3]&0x40) == 0x40)

				printf("   - Lock Keyboard\n");

			printf("   - Boot Device Selector : ");

			switch( ((rsp->data[3]>>2)&0x0f))

			{

				case 0: printf("No override\n"); break;

				case 1: printf("Force PXE\n"); break;

				case 2: printf("Force Boot from default Hard-Drive\n"); break;

				case 3: printf("Force Boot from default Hard-Drive, request Safe-Mode\n"); break;

				case 4: printf("Force Boot from Diagnostic Partition\n"); break;

				case 5: printf("Force Boot from CD/DVD\n"); break;

				case 6: printf("Force Boot into BIOS Setup\n"); break;

				case 15: printf("Force Boot from Floppy/primary removable media\n"); break;

				default: printf("Flag error\n"); break;

			}

			if((rsp->data[3]&0x02) == 0x02)

				printf("   - Screen blank\n");

			if((rsp->data[3]&0x01) == 0x01)

				printf("   - Lock out Reset buttons\n");

			if((rsp->data[4]&0x80) == 0x80)

				printf("   - Lock out (power off/sleep request) vi Power Button\n");

			printf("   - Console Redirection control : ");

			switch( ((rsp->data[4]>>5)&0x03))

			{

				case 0: printf("System Default\n"); break;

				case 1: printf("Request Quiet Display\n"); break;

				case 2: printf("Request Verbose Display\n"); break;

				default: printf("Flag error\n"); break;

			}

			if((rsp->data[4]&0x10) == 0x10)

				printf("   - Force progress event traps\n");

			if((rsp->data[4]&0x08) == 0x08)

				printf("   - User password bypass\n");

			if((rsp->data[4]&0x04) == 0x04)

				printf("   - Lock Out Sleep Button\n");

			if((rsp->data[4]&0x02) == 0x02)

				printf("   - Lock Out Sleep Button\n");

			printf("   - BIOS verbosity : ");

			switch( ((rsp->data[4]>>0)&0x03))

			{

				case 0: printf("Console redirection occurs per BIOS configuration setting (default)\n"); break;

				case 1: printf("Suppress (skip) console redirection if enabled\n"); break;

				case 2: printf("Request console redirection be enabled\n"); break;

				default: printf("Flag error\n"); break;

			}

			if((rsp->data[5]&0x08) == 0x08)

				printf("   - BIOS Shared Mode Override\n");

			printf("   - BIOS Mux Control Override : ");

			switch( ((rsp->data[5]>>0)&0x07))

			{

				case 0: printf("BIOS uses recommended setting of the mux at the end of POST\n"); break;

				case 1: printf("Requests BIOS to force mux to BMC at conclusion of POST/start of OS boot\n"); break;

				case 2: printf("Requests BIOS to force mux to system at conclusion of POST/start of OS boot\n"); break;

				default: printf("Flag error\n"); break;

			}

		}

		break;

		case 6:

		{

			unsigned long session_id;

			unsigned long timestamp;

			char time_buf[40];

			time_t out_time;

			session_id  = ((unsigned long) rsp->data[3]);

			session_id |= (((unsigned long) rsp->data[4])<<8);

			session_id |= (((unsigned long) rsp->data[5])<<16);

			session_id |= (((unsigned long) rsp->data[6])<<24);

			timestamp  = ((unsigned long) rsp->data[7]);

			timestamp |= (((unsigned long) rsp->data[8])<<8);

			timestamp |= (((unsigned long) rsp->data[9])<<16);

			timestamp |= (((unsigned long) rsp->data[10])<<24);

			memset(time_buf, 0, 40);

			strftime(

					time_buf,

					sizeof(time_buf),

					"%m/%d/%Y %H:%M:%S", localtime(&out_time)

			);

			printf(" Boot Initiator Info :\n");

			printf("    Channel Number : %d\n", (rsp->data[2] & 0x0f));

			printf("    Session Id     : %08lXh\n",session_id);

			if(timestamp != 0)

			{

				printf("    Timestamp      : %08lXh, %s\n",timestamp,time_buf);

			}

			else

			{

				printf("    Timestamp      : %08lXh, undefined\n",timestamp);

			}

		}

		break;

		case 7:

		{

			printf(" Selector   : %d\n", rsp->data[2] );

			printf(" Block Data : %s\n", buf2str(rsp->data+3, rsp->data_len - 2));

		}

		break;

		default:

			printf(" Undefined byte\n");

			break;

	}

	return 0;

}

static int

get_bootparam_options(char *optstring,

		unsigned char *set_flag, unsigned char *clr_flag)

{

	char *token;

	char *saveptr = NULL;

	int optionError = 0;

	*set_flag = 0;

	*clr_flag = 0;

	static struct {

		char *name;

		unsigned char value;

		char *desc;

	} options[] = {

	{"PEF",          0x10,

	    "Clear valid bit on reset/power cycle cause by PEF"},

	{"timeout",      0x08,

	    "Automatically clear boot flag valid bit on timeout"},

	{"watchdog",     0x04,

	    "Clear valid bit on reset/power cycle cause by watchdog"},

	{"reset",        0x02,

	    "Clear valid bit on push button reset/soft reset"},

	{"power", 0x01,

	    "Clear valid bit on power up via power push button or wake event"},

	{NULL}	/* End marker */

	}, *op;

	if (strncmp(optstring, "options=", 8) != 0) {

		lprintf(LOG_ERR, "No options= keyword found \"%s\"", optstring);

		return -1;

	}

	token = strtok_r(optstring + 8, ",", &saveptr);

	while (token != NULL) {

		int setbit = 0;

		if (strcmp(token, "help") == 0) {

			optionError = 1;

			break;

		}

		if (strncmp(token, "no-", 3) == 0) {

			setbit = 1;

			token += 3;

		}

		for (op = options; op->name != NULL; ++op) {

			if (strncmp(token, op->name, strlen(op->name)) == 0) {

				if (setbit) {

				    *set_flag |= op->value;

				} else {

				    *clr_flag |= op->value;

				}

				break;

			}

		}

		if (op->name == NULL) {

			/* Option not found */

			optionError = 1;

			if (setbit) {

				token -=3;

			}

			lprintf(LOG_ERR, "Invalid option: %s", token);

		}

		token = strtok_r(NULL, ",", &saveptr);

	}

	if (optionError) {

		lprintf(LOG_NOTICE, " Legal options are:");

		lprintf(LOG_NOTICE, "  %-8s: print this message", "help");

		for (op = options; op->name != NULL; ++op) {

			lprintf(LOG_NOTICE, "  %-8s: %s", op->name, op->desc);

		}

		lprintf(LOG_NOTICE, " Any Option may be prepended with no-"

				    " to invert sense of operation\n");

		return (-1);

	}

	return (0);

}

static int

ipmi_chassis_get_bootvalid(struct ipmi_intf * intf)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

	uint8_t msg_data[3];

	uint8_t param_id = IPMI_CHASSIS_BOOTPARAM_FLAG_VALID;

	memset(msg_data, 0, 3);

	msg_data[0] = param_id & 0x7f;

	msg_data[1] = 0;

	msg_data[2] = 0;

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

	req.msg.netfn = IPMI_NETFN_CHASSIS;

	req.msg.cmd = 0x9;

	req.msg.data = msg_data;

	req.msg.data_len = 3;

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

	if (rsp == NULL) {

		lprintf(LOG_ERR,

			"Error Getting Chassis Boot Parameter %d", param_id);

		return -1;

	}

	if (rsp->ccode > 0) {

		lprintf(LOG_ERR, "Get Chassis Boot Parameter %d failed: %s",

			param_id, val2str(rsp->ccode, completion_code_vals));

		return -1;

	}

	if (verbose > 2)

		printbuf(rsp->data, rsp->data_len, "Boot Option");

	return(rsp->data[2]);

}

static int

ipmi_chassis_set_bootvalid(struct ipmi_intf *intf, uint8_t set_flag, uint8_t clr_flag)

{

	int bootvalid;

	uint8_t flags[5];

	int rc = 0;

	int use_progress = 1;

	uint8_t param_id = IPMI_CHASSIS_BOOTPARAM_FLAG_VALID;

	if (use_progress) {

		/* set set-in-progress flag */

		memset(flags, 0, 5);

		flags[0] = 0x01;

		rc = ipmi_chassis_set_bootparam(intf,

				IPMI_CHASSIS_BOOTPARAM_SET_IN_PROGRESS, flags, 1);