/*

 * Copyright (c) 2009, 2014, Oracle and/or its affiliates. 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

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <strings.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <errno.h>

#include <time.h>

#include <unistd.h>

#include <signal.h>

#include <ctype.h>

#include <sys/time.h>

#include <limits.h>

#include <fcntl.h>

#include <sys/select.h>

#include <termios.h>

#include <ipmitool/ipmi.h>

#include <ipmitool/ipmi_intf.h>

#include <ipmitool/helper.h>

#include <ipmitool/log.h>

#include <ipmitool/ipmi_sel.h>

#include <ipmitool/ipmi_sdr.h>

#include <ipmitool/ipmi_strings.h>

#include <ipmitool/ipmi_channel.h>

#include <ipmitool/ipmi_sunoem.h>

#include <ipmitool/ipmi_raw.h>

static const struct valstr sunoem_led_type_vals[] = {

	{ 0, "OK2RM" },

	{ 1, "SERVICE" },

	{ 2, "ACT" },

	{ 3, "LOCATE" },

	{ 0xFF, NULL },

};

static const struct valstr sunoem_led_mode_vals[] = {

	{ 0, "OFF" },

	{ 1, "ON" },

	{ 2, "STANDBY" },

	{ 3, "SLOW" },

	{ 4, "FAST" },

	{ 0xFF, NULL },

};

static const struct valstr sunoem_led_mode_optvals[] = {

	{ 0, "STEADY_OFF" },

	{ 1, "STEADY_ON" },

	{ 2, "STANDBY_BLINK" },

	{ 3, "SLOW_BLINK" },

	{ 4, "FAST_BLINK" },

	{ 0xFF, NULL },

};

#define SUNOEM_SUCCESS 1

#define IPMI_SUNOEM_GETFILE_VERSION {3,2,0,0}

#define IPMI_SUNOEM_GETBEHAVIOR_VERSION {3,2,0,0}

/*

 * PRINT_NORMAL: print out the LED value as normal

 * PRINT_ERROR: print out "na" for the LED value

 */

typedef enum

{

	PRINT_NORMAL = 0, PRINT_ERROR

} print_status_t;

int ret_get = 0;

int ret_set = 0;

static void

ipmi_sunoem_usage(void)

{

	lprintf(LOG_NOTICE, "Usage: sunoem <command> [option...]");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, "Commands:");

	lprintf(LOG_NOTICE, " - cli [<command string> ...]");

	lprintf(LOG_NOTICE, "      Execute SP CLI commands.");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, " - led get [<sensor_id>] [ledtype]");

	lprintf(LOG_NOTICE, "      - Read status of LED found in Generic Device Locator.");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, " - led set <sensor_id> <led_mode> [led_type]");

	lprintf(LOG_NOTICE, "      - Set mode of LED found in Generic Device Locator.");

	lprintf(LOG_NOTICE, "      - You can pass 'all' as the <senso_rid> to change the LED mode of all sensors.");

	lprintf(LOG_NOTICE, "      - Use 'sdr list generic' command to get list of Generic");

	lprintf(LOG_NOTICE, "      - Devices that are controllable LEDs.");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, "      - Required SIS LED Mode:");

	lprintf(LOG_NOTICE, "          OFF          Off");

	lprintf(LOG_NOTICE, "          ON           Steady On");

	lprintf(LOG_NOTICE, "          STANDBY      100ms on 2900ms off blink rate");

	lprintf(LOG_NOTICE, "          SLOW         1HZ blink rate");

	lprintf(LOG_NOTICE, "          FAST         4HZ blink rate");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, "      - Optional SIS LED Type:");

	lprintf(LOG_NOTICE, "          OK2RM        OK to Remove");

	lprintf(LOG_NOTICE, "          SERVICE      Service Required");

	lprintf(LOG_NOTICE, "          ACT          Activity");

	lprintf(LOG_NOTICE, "          LOCATE       Locate");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, " - nacname <ipmi_nac_name>");

	lprintf(LOG_NOTICE, "      - Returns the full nac name");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, " - ping NUMBER <q>");

	lprintf(LOG_NOTICE, "      - Send and Receive NUMBER (64 Byte) packets.");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, "      - q - Quiet. Displays output at start and end");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, " - getval <target_name>");

	lprintf(LOG_NOTICE, "      - Returns the ILOM property value");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, " - setval <property name> <property value> <timeout>");

	lprintf(LOG_NOTICE, "      - Sets the ILOM property value");

	lprintf(LOG_NOTICE, "      - If timeout is not specified, the default is 5 sec.");

	lprintf(LOG_NOTICE, "      - NOTE: must be executed locally on host, not remotely over LAN!");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, " - sshkey del <user_id>");

	lprintf(LOG_NOTICE, "      - Delete ssh key for user id from authorized_keys,");

	lprintf(LOG_NOTICE, "      - view users with 'user list' command.");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, " - sshkey set <user_id> <id_rsa.pub>");

	lprintf(LOG_NOTICE, "      - Set ssh key for a userid into authorized_keys,");

	lprintf(LOG_NOTICE, "      - view users with 'user list' command.");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, " - version");

	lprintf(LOG_NOTICE, "      - Display the software version");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, " - nacname <ipmi_nac_name>");

	lprintf(LOG_NOTICE, "      - Returns the full nac name");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, " - getfile <file_string_id> <destination_file_name>");

	lprintf(LOG_NOTICE, "      - Copy file <file_string_id> to <destination_file_name>");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, "      - File string ids:");

	lprintf(LOG_NOTICE, "          SSH_PUBKEYS");

	lprintf(LOG_NOTICE, "          DIAG_PASSED");

	lprintf(LOG_NOTICE, "          DIAG_FAILED");

	lprintf(LOG_NOTICE, "          DIAG_END_TIME");

	lprintf(LOG_NOTICE, "          DIAG_INVENTORY");

	lprintf(LOG_NOTICE, "          DIAG_TEST_LOG");

	lprintf(LOG_NOTICE, "          DIAG_START_TIME");

	lprintf(LOG_NOTICE, "          DIAG_UEFI_LOG");

	lprintf(LOG_NOTICE, "          DIAG_TEST_LOG");

	lprintf(LOG_NOTICE, "          DIAG_LAST_LOG");

	lprintf(LOG_NOTICE, "          DIAG_LAST_CMD");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, " - getbehavior <behavior_string_id>");

	lprintf(LOG_NOTICE, "      - Test if ILOM behavior is enabled");

	lprintf(LOG_NOTICE, "");

	lprintf(LOG_NOTICE, "      - Behavior string ids:");

	lprintf(LOG_NOTICE, "          SUPPORTS_SIGNED_PACKAGES");

	lprintf(LOG_NOTICE, "          REQUIRES_SIGNED_PACKAGES");

	lprintf(LOG_NOTICE, "");

}

#define SUNOEM_FAN_MODE_AUTO    0x00

#define SUNOEM_FAN_MODE_MANUAL  0x01

static void

__sdr_list_empty(struct sdr_record_list * head)

{

	struct sdr_record_list * e, *f;

	for (e = head; e != NULL; e = f) {

		f = e->next;

		free(e);

	}

	head = NULL;

}

/*

 *  led_print

 *  Print out the led name and the state, if stat is PRINT_NORMAL.

 *  Otherwise, print out the led name and "na".

 *  The state parameter is not referenced if stat is not PRINT_NORMAL.

 */

static void

led_print(const char * name, print_status_t stat, uint8_t state)

{

	const char *theValue;

	if (stat == PRINT_NORMAL) {

		theValue = val2str(state, sunoem_led_mode_vals);

	} else {

		theValue = "na";

	}

	if (csv_output) {

		printf("%s,%s\n", name, theValue);

	} else {

		printf("%-16s | %s\n", name, theValue);

	}

}

#define CC_NORMAL                  0x00

#define CC_PARAM_OUT_OF_RANGE      0xc9

#define CC_DEST_UNAVAILABLE        0xd3

#define CC_UNSPECIFIED_ERR         0xff

#define CC_INSUFFICIENT_PRIVILEGE  0xd4

#define CC_INV_CMD                 0xc1

#define CC_INV_DATA_FIELD          0xcc

/*

 * sunoem_led_get(....)

 *

 * OUTPUT:

 *   SUNOEM_EC_INVALID_ARG         if dev is NULL,

 *   SUNOEM_EC_BMC_NOT_RESPONDING  if no reply is obtained from BMC,

 *   SUNOEM_EC_BMC_CCODE_NONZERO   if completion code is nonzero,

 *   SUNOEM_EC_SUCCESS             otherwise.

 */

static sunoem_ec_t

sunoem_led_get(struct ipmi_intf * intf,	struct sdr_record_generic_locator * dev,

		int ledtype, struct ipmi_rs **loc_rsp)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

	uint8_t rqdata[7];

	int rqdata_len;

	if (dev == NULL) {

		*loc_rsp = NULL;

		return (SUNOEM_EC_INVALID_ARG);

	}

	rqdata[0] = dev->dev_slave_addr;

	if (ledtype == 0xFF)

		rqdata[1] = dev->oem;

	else

		rqdata[1] = ledtype;

	rqdata[2] = dev->dev_access_addr;

	rqdata[3] = dev->oem;

	rqdata[4] = dev->entity.id;

	rqdata[5] = dev->entity.instance;

	rqdata[6] = 0;

	rqdata_len = 7;

	req.msg.netfn = IPMI_NETFN_SUNOEM;

	req.msg.cmd = IPMI_SUNOEM_LED_GET;

	req.msg.lun = dev->lun;

	req.msg.data = rqdata;

	req.msg.data_len = rqdata_len;

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

	/*

	 * Just return NULL if there was

	 * an error.

	 */

	if (rsp == NULL) {

		*loc_rsp = NULL;

		return (SUNOEM_EC_BMC_NOT_RESPONDING);

	} else if (rsp->ccode > 0) {

		*loc_rsp = rsp;

		return (SUNOEM_EC_BMC_CCODE_NONZERO);

	} else {

		*loc_rsp = rsp;

		return (SUNOEM_EC_SUCCESS);

	}

}

static struct ipmi_rs *

sunoem_led_set(struct ipmi_intf * intf, struct sdr_record_generic_locator * dev,

		int ledtype, int ledmode)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

	uint8_t rqdata[9];

	int rqdata_len;

	if (dev == NULL)

		return NULL;

	rqdata[0] = dev->dev_slave_addr;

	if (ledtype == 0xFF)

		rqdata[1] = dev->oem;

	else

		rqdata[1] = ledtype;

	rqdata[2] = dev->dev_access_addr;

	rqdata[3] = dev->oem;

	rqdata[4] = ledmode;

	rqdata[5] = dev->entity.id;

	rqdata[6] = dev->entity.instance;

	rqdata[7] = 0;

	rqdata[8] = 0;

	rqdata_len = 9;

	req.msg.netfn = IPMI_NETFN_SUNOEM;

	req.msg.cmd = IPMI_SUNOEM_LED_SET;

	req.msg.lun = dev->lun;

	req.msg.data = rqdata;

	req.msg.data_len = rqdata_len;

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

	if (rsp == NULL) {

		lprintf(LOG_ERR, "Sun OEM Set LED command failed.");

		return NULL;

	} else if (rsp->ccode > 0) {

		lprintf(LOG_ERR, "Sun OEM Set LED command failed: %s",

				val2str(rsp->ccode, completion_code_vals));

		return NULL;

	}

	return (rsp);

}

static void

sunoem_led_get_byentity(struct ipmi_intf * intf, uint8_t entity_id,

		uint8_t entity_inst, int ledtype)

{

	struct ipmi_rs * rsp;

	struct sdr_record_list *elist, *e;

	struct entity_id entity;

	sunoem_ec_t res;

	if (entity_id == 0)

		return;

	/* lookup sdrs with this entity */

	memset(&entity, 0, sizeof(struct entity_id));

	entity.id = entity_id;

	entity.instance = entity_inst;

	elist = ipmi_sdr_find_sdr_byentity(intf, &entity);

	if (elist == NULL)

		ret_get = -1;

	/* for each generic sensor get its led state */

	for (e = elist; e != NULL; e = e->next) {

		if (e->type != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR)

			continue;

		res = sunoem_led_get(intf, e->record.genloc, ledtype, &rsp;;

		if (res == SUNOEM_EC_SUCCESS && rsp && rsp->data_len == 1) {

			led_print((const char *) e->record.genloc->id_string, PRINT_NORMAL,

					rsp->data[0]);

		} else {

			led_print((const char *) e->record.genloc->id_string, PRINT_ERROR,

					0);

			if (res != SUNOEM_EC_BMC_CCODE_NONZERO|| !rsp

			|| rsp->ccode != CC_DEST_UNAVAILABLE) {

				ret_get = -1;

			}

		}

	}

	__sdr_list_empty(elist);

}

static void

sunoem_led_set_byentity(struct ipmi_intf * intf, uint8_t entity_id,

		uint8_t entity_inst, int ledtype, int ledmode)

{

	struct ipmi_rs * rsp;

	struct sdr_record_list *elist, *e;

	struct entity_id entity;

	if (entity_id == 0)

		return;

	/* lookup sdrs with this entity */

	memset(&entity, 0, sizeof(struct entity_id));

	entity.id = entity_id;

	entity.instance = entity_inst;

	elist = ipmi_sdr_find_sdr_byentity(intf, &entity);

	if (elist == NULL)

		ret_set = -1;

	/* for each generic sensor set its led state */

	for (e = elist; e != NULL; e = e->next) {

		if (e->type != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR)

			continue;

		rsp = sunoem_led_set(intf, e->record.genloc, ledtype, ledmode);

		if (rsp && rsp->data_len == 0) {

			led_print((const char *) e->record.genloc->id_string, PRINT_NORMAL,

					ledmode);

		} else if (rsp == NULL) {

			ret_set = -1;

		}

	}

	__sdr_list_empty(elist);

}

/*

 * IPMI Request Data: 5 bytes

 *

 * [byte 0]  devAddr     Value from the "Device Slave Address" field in

 *                       LED's Generic Device Locator record in the SDR

 * [byte 1]  led         LED Type: OK2RM, ACT, LOCATE, SERVICE

 * [byte 2]  ctrlrAddr   Controller address; value from the "Device

 *                       Access Address" field, 0x20 if the LED is local

 * [byte 3]  hwInfo      The OEM field from the SDR record

 * [byte 4]  force       1 = directly access the device

 *                       0 = go thru its controller

 *                       Ignored if LED is local

 *

 * The format below is for Sun Blade Modular systems only

 * [byte 4]  entityID    The entityID field from the SDR record

 * [byte 5]  entityIns   The entityIns field from the SDR record

 * [byte 6]  force       1 = directly access the device

 *                       0 = go thru its controller

 *                       Ignored if LED is local

 */

static int

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

{

	struct ipmi_rs * rsp;

	struct sdr_record_list *sdr;

	struct sdr_record_list *alist, *a;

	struct sdr_record_entity_assoc *assoc;

	int ledtype = 0xFF;

	int i;

	sunoem_ec_t res;

	/*

	 * sunoem led/sbled get <id> [type]

	 */

	if (argc < 1 || strncmp(argv[0], "help", 4) == 0) {

		ipmi_sunoem_usage();

		return (0);

	}

	if (argc > 1) {

		ledtype = str2val(argv[1], sunoem_led_type_vals);

		if (ledtype == 0xFF)

			lprintf(LOG_ERR,

					"Unknown ledtype, will use data from the SDR oem field");

	}

	if (strncasecmp(argv[0], "all", 3) == 0) {

		/* do all generic sensors */

		alist = ipmi_sdr_find_sdr_bytype(intf,

		SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR);

		if (alist == NULL)

			return (-1);

		for (a = alist; a != NULL; a = a->next) {

			if (a->type != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR)

				continue;

			if (a->record.genloc->entity.logical)

				continue;

			res = sunoem_led_get(intf, a->record.genloc, ledtype, &rsp;;

			if (res == SUNOEM_EC_SUCCESS && rsp && rsp->data_len == 1) {

				led_print((const char *) a->record.genloc->id_string,

						PRINT_NORMAL, rsp->data[0]);

			} else {

				led_print((const char *) a->record.genloc->id_string,

						PRINT_ERROR, 0);

				if (res != SUNOEM_EC_BMC_CCODE_NONZERO|| !rsp ||

				rsp->ccode != CC_DEST_UNAVAILABLE) {

					ret_get = -1;

				}

			}

		}

		__sdr_list_empty(alist);

		if (ret_get == -1)

			return (-1);

		return (0);

	}

	/* look up generic device locator record in SDR */

	sdr = ipmi_sdr_find_sdr_byid(intf, argv[0]);

	if (sdr == NULL) {

		lprintf(LOG_ERR, "No Sensor Data Record found for %s", argv[0]);

		return (-1);

	}

	if (sdr->type != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR) {

		lprintf(LOG_ERR, "Invalid SDR type %d", sdr->type);

		return (-1);

	}

	if (!sdr->record.genloc->entity.logical) {

		/*

		 * handle physical entity

		 */

		res = sunoem_led_get(intf, sdr->record.genloc, ledtype, &rsp;;

		if (res == SUNOEM_EC_SUCCESS && rsp && rsp->data_len == 1) {

			led_print((const char *) sdr->record.genloc->id_string,

					PRINT_NORMAL, rsp->data[0]);

		} else {

			led_print((const char *) sdr->record.genloc->id_string, PRINT_ERROR,

					0);

			if (res != SUNOEM_EC_BMC_CCODE_NONZERO|| !rsp

			|| rsp->ccode != CC_DEST_UNAVAILABLE) {

				ret_get = -1;

			}

		}

		if (ret_get == -1)

			return (-1);

		return (0);

	}

	/*

	 * handle logical entity for LED grouping

	 */

	lprintf(LOG_INFO, "LED %s is logical device", argv[0]);

	/* get entity assoc records */

	alist = ipmi_sdr_find_sdr_bytype(intf, SDR_RECORD_TYPE_ENTITY_ASSOC);

	if (alist == NULL)

		return (-1);

	for (a = alist; a != NULL; a = a->next) {

		if (a->type != SDR_RECORD_TYPE_ENTITY_ASSOC)

			continue;

		assoc = a->record.entassoc;

		if (assoc == NULL)

			continue;

		/* check that the entity id/instance matches our generic record */

		if (assoc->entity.id != sdr->record.genloc->entity.id

				|| assoc->entity.instance

						!= sdr->record.genloc->entity.instance)

			continue;

		if (assoc->flags.isrange) {

			/*

			 * handle ranged entity associations

			 *

			 * the test for non-zero entity id is handled in

			 * sunoem_led_get_byentity()

			 */

			/* first range set - id 1 and 2 must be equal */

			if (assoc->entity_id_1 == assoc->entity_id_2)

				for (i = assoc->entity_inst_1; i <= assoc->entity_inst_2; i++)

					sunoem_led_get_byentity(intf, assoc->entity_id_1, i,

							ledtype);

			/* second range set - id 3 and 4 must be equal */

			if (assoc->entity_id_3 == assoc->entity_id_4)

				for (i = assoc->entity_inst_3; i <= assoc->entity_inst_4; i++)

					sunoem_led_get_byentity(intf, assoc->entity_id_3, i,

							ledtype);

		} else {

			/*

			 * handle entity list

			 */

			sunoem_led_get_byentity(intf, assoc->entity_id_1,

					assoc->entity_inst_1, ledtype);

			sunoem_led_get_byentity(intf, assoc->entity_id_2,

					assoc->entity_inst_2, ledtype);

			sunoem_led_get_byentity(intf, assoc->entity_id_3,

					assoc->entity_inst_3, ledtype);

			sunoem_led_get_byentity(intf, assoc->entity_id_4,

					assoc->entity_inst_4, ledtype);

		}

	}

	__sdr_list_empty(alist);

	if (ret_get == -1)

		return (-1);

	return (0);

}

/*

 * IPMI Request Data: 7 bytes

 *

 * [byte 0]  devAddr     Value from the "Device Slave Address" field in

 *                       LED's Generic Device Locator record in the SDR

 * [byte 1]  led         LED Type: OK2RM, ACT, LOCATE, SERVICE

 * [byte 2]  ctrlrAddr   Controller address; value from the "Device

 *                       Access Address" field, 0x20 if the LED is local

 * [byte 3]  hwInfo      The OEM field from the SDR record

 * [byte 4]  mode        LED Mode: OFF, ON, STANDBY, SLOW, FAST

 * [byte 5]  force       TRUE - directly access the device

 *                       FALSE - go thru its controller

 *                       Ignored if LED is local

 * [byte 6]  role        Used by BMC for authorization purposes

 *

 * The format below is for Sun Blade Modular systems only

 * [byte 5]  entityID    The entityID field from the SDR record

 * [byte 6]  entityIns   The entityIns field from the SDR record

 * [byte 7]  force       TRUE - directly access the device

 *                       FALSE - go thru its controller

 *                       Ignored if LED is local

 * [byte 8]  role        Used by BMC for authorization purposes

 *

 *

 * IPMI Response Data: 1 byte

 *

 * [byte 0]  mode     LED Mode: OFF, ON, STANDBY, SLOW, FAST

 */

static int

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

{

	struct ipmi_rs * rsp;

	struct sdr_record_list *sdr;

	struct sdr_record_list *alist, *a;

	struct sdr_record_entity_assoc *assoc;

	int ledmode;

	int ledtype = 0xFF;

	int i;

	/*

	 * sunoem led/sbled set <id> <mode> [type]

	 */

	if (argc < 2 || strncmp(argv[0], "help", 4) == 0) {

		ipmi_sunoem_usage();

		return (0);

	}

	ledmode = str2val(argv[1], sunoem_led_mode_vals);

	if (ledmode == 0xFF) {

		ledmode = str2val(argv[1], sunoem_led_mode_optvals);

		if (ledmode == 0xFF) {

			lprintf(LOG_NOTICE, "Invalid LED Mode: %s", argv[1]);

			return (-1);

		}

	}

	if (argc > 3) {

		ledtype = str2val(argv[2], sunoem_led_type_vals);

		if (ledtype == 0xFF)

			lprintf(LOG_ERR,

					"Unknown ledtype, will use data from the SDR oem field");

	}

	if (strncasecmp(argv[0], "all", 3) == 0) {

		/* do all generic sensors */

		alist = ipmi_sdr_find_sdr_bytype(intf,

		SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR);

		if (alist == NULL)

			return (-1);

		for (a = alist; a != NULL; a = a->next) {

			if (a->type != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR)

				continue;

			if (a->record.genloc->entity.logical)

				continue;

			rsp = sunoem_led_set(intf, a->record.genloc, ledtype, ledmode);

			if (rsp && rsp->ccode == 0)

				led_print((const char *) a->record.genloc->id_string,

						PRINT_NORMAL, ledmode);

			else

				ret_set = -1;

		}

		__sdr_list_empty(alist);

		if (ret_set == -1)

			return (-1);

		return (0);

	}

	/* look up generic device locator records in SDR */

	sdr = ipmi_sdr_find_sdr_byid(intf, argv[0]);

	if (sdr == NULL) {

		lprintf(LOG_ERR, "No Sensor Data Record found for %s", argv[0]);

		return (-1);

	}

	if (sdr->type != SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR) {

		lprintf(LOG_ERR, "Invalid SDR type %d", sdr->type);

		return (-1);

	}

	if (!sdr->record.genloc->entity.logical) {

		/*

		 * handle physical entity

		 */

		rsp = sunoem_led_set(intf, sdr->record.genloc, ledtype, ledmode);

		if (rsp && rsp->ccode == 0)

			led_print(argv[0], PRINT_NORMAL, ledmode);

		else

			return (-1);

		return (0);

	}

	/*

	 * handle logical entity for LED grouping

	 */

	lprintf(LOG_INFO, "LED %s is logical device", argv[0]);

	/* get entity assoc records */

	alist = ipmi_sdr_find_sdr_bytype(intf, SDR_RECORD_TYPE_ENTITY_ASSOC);

	if (alist == NULL)

		return (-1);

	for (a = alist; a != NULL; a = a->next) {

		if (a->type != SDR_RECORD_TYPE_ENTITY_ASSOC)

			continue;

		assoc = a->record.entassoc;

		if (assoc == NULL)

			continue;

		/* check that the entity id/instance matches our generic record */

		if (assoc->entity.id != sdr->record.genloc->entity.id

				|| assoc->entity.instance

						!= sdr->record.genloc->entity.instance)

			continue;

		if (assoc->flags.isrange) {

			/*

			 * handle ranged entity associations

			 *

			 * the test for non-zero entity id is handled in

			 * sunoem_led_get_byentity()

			 */

			/* first range set - id 1 and 2 must be equal */

			if (assoc->entity_id_1 == assoc->entity_id_2)

				for (i = assoc->entity_inst_1; i <= assoc->entity_inst_2; i++)

					sunoem_led_set_byentity(intf, assoc->entity_id_1, i,

							ledtype, ledmode);

			/* second range set - id 3 and 4 must be equal */

			if (assoc->entity_id_3 == assoc->entity_id_4)

				for (i = assoc->entity_inst_3; i <= assoc->entity_inst_4; i++)

					sunoem_led_set_byentity(intf, assoc->entity_id_3, i,

							ledtype, ledmode);

		} else {

			/*

			 * handle entity list

			 */

			sunoem_led_set_byentity(intf, assoc->entity_id_1,

					assoc->entity_inst_1, ledtype, ledmode);

			sunoem_led_set_byentity(intf, assoc->entity_id_2,

					assoc->entity_inst_2, ledtype, ledmode);

			sunoem_led_set_byentity(intf, assoc->entity_id_3,

					assoc->entity_inst_3, ledtype, ledmode);

			sunoem_led_set_byentity(intf, assoc->entity_id_4,

					assoc->entity_inst_4, ledtype, ledmode);

		}

	}

	__sdr_list_empty(alist);

	if (ret_set == -1)

		return (-1);

	return (0);

}

static int

ipmi_sunoem_sshkey_del(struct ipmi_intf * intf, uint8_t uid)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

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

	req.msg.netfn = IPMI_NETFN_SUNOEM;

	req.msg.cmd = IPMI_SUNOEM_DEL_SSH_KEY;

	req.msg.data = &ui;;

	req.msg.data_len = 1;

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

	if (rsp == NULL) {

		lprintf(LOG_ERR, "Unable to delete ssh key for UID %d", uid);

		return (-1);

	} else if (rsp->ccode > 0) {

		lprintf(LOG_ERR, "Unable to delete ssh key for UID %d: %s", uid,

				val2str(rsp->ccode, completion_code_vals));

		return (-1);

	}

	printf("Deleted SSH key for user id %d\n", uid);

	return (0);

}

#define SSHKEY_BLOCK_SIZE	64

static int

ipmi_sunoem_sshkey_set(struct ipmi_intf * intf, uint8_t uid, char * ifile)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

	FILE * fp;

	int count = 0;

	uint8_t wbuf[SSHKEY_BLOCK_SIZE + 3];

	int32_t i_size = 0;

	int32_t r = 0;

	int32_t size = 0;

	if (ifile == NULL) {

		lprintf(LOG_ERR, "Invalid or misisng input filename.");

		return (-1);

	}

	fp = ipmi_open_file_read(ifile);

	if (fp == NULL) {

		lprintf(LOG_ERR, "Unable to open file '%s' for reading.", ifile);

		return (-1);

	}

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

	req.msg.netfn = IPMI_NETFN_SUNOEM;

	req.msg.cmd = IPMI_SUNOEM_SET_SSH_KEY;

	req.msg.data = wbuf;

	if (fseek(fp, 0, SEEK_END) == (-1)) {

		lprintf(LOG_ERR, "Failed to seek in file '%s'.", ifile);

		if (fp != NULL)

			fclose(fp);

		return (-1);

	}

	size = (int32_t) ftell(fp);

	if (size < 0) {

		lprintf(LOG_ERR, "Failed to seek in file '%s'.", ifile);

		if (fp != NULL)

			fclose(fp);

		return (-1);

	} else if (size == 0) {

		lprintf(LOG_ERR, "File '%s' is empty.", ifile);

		if (fp != NULL)

			fclose(fp);

		return (-1);

	}