/*
* 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 = &uid;
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);
}
if (fseek(fp, 0, SEEK_SET) == (-1)) {
lprintf(LOG_ERR, "Failed to seek in file '%s'.", ifile);
if (fp != NULL)
fclose(fp);
return (-1);
}
printf("Setting SSH key for user id %d...", uid);
for (r = 0; r < size; r += i_size) {
i_size = size - r;
if (i_size > SSHKEY_BLOCK_SIZE)
i_size = SSHKEY_BLOCK_SIZE;
memset(wbuf, 0, SSHKEY_BLOCK_SIZE);
fseek(fp, r, SEEK_SET);
count = fread(wbuf + 3, 1, i_size, fp);
if (count != i_size) {
printf("failed\n");
lprintf(LOG_ERR, "Unable to read %ld bytes from file '%s'.", i_size,
ifile);
if (fp != NULL)
fclose(fp);
return (-1);
}
printf(".");
fflush(stdout);
wbuf[0] = uid;
if ((r + SSHKEY_BLOCK_SIZE) >= size)
wbuf[1] = 0xff;
else {
if ((r / SSHKEY_BLOCK_SIZE) > UINT8_MAX) {
printf("failed\n");
lprintf(LOG_ERR, "Unable to pack byte %ld from file '%s'.", r,
ifile);
if (fp != NULL)
fclose(fp);
return (-1);
}
wbuf[1] = (uint8_t) (r / SSHKEY_BLOCK_SIZE);
}
wbuf[2] = (uint8_t) i_size;
req.msg.data_len = i_size + 3;
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
printf("failed\n");
lprintf(LOG_ERR, "Unable to set ssh key for UID %d.", uid);
if (fp != NULL)
fclose(fp);
return (-1);
} /* if (rsp == NULL) */
if (rsp->ccode != 0) {
printf("failed\n");
lprintf(LOG_ERR, "Unable to set ssh key for UID %d, %s.", uid,
val2str(rsp->ccode, completion_code_vals));
if (fp != NULL)
fclose(fp);
return (-1);
} /* if (rsp->ccode != 0) */
}
printf("done\n");
fclose(fp);
return (0);
}
/*
* This structure is used in both the request to and response from the BMC.
*/
#define SUNOEM_CLI_LEGACY_VERSION 1
#define SUNOEM_CLI_SEQNUM_VERSION 2
#define SUNOEM_CLI_VERSION SUNOEM_CLI_SEQNUM_VERSION
#define SUNOEM_CLI_HEADER 8 /* command + spare + handle */
#define SUNOEM_CLI_BUF_SIZE (80 - SUNOEM_CLI_HEADER) /* Total 80 bytes */
#define SUNOEM_CLI_MSG_SIZE(msg) (SUNOEM_CLI_HEADER + strlen((msg).buf) + 1)
#ifdef HAVE_PRAGMA_PACK
#pragma pack(push, 1)
#endif
typedef struct
{
/*
* Set version to SUNOEM_CLI_VERSION.
*/
uint8_t version;
/*
* The command in a request, or in a response indicates an error if
* non-zero.
*/
uint8_t command_response;
uint8_t seqnum;
uint8_t spare;
/*
* Opaque 4-byte handle, supplied in the response to an OPEN request,
* and used in all subsequent POLL and CLOSE requests.
*/
uint8_t handle[4];
/*
* The client data in a request, or the server data in a response. Must
* by null terminated, i.e., it must be at least one byte, but can be
* smaller if there's less data.
*/
char buf[SUNOEM_CLI_BUF_SIZE];
}__attribute__((packed)) sunoem_cli_msg_t;
#ifdef HAVE_PRAGMA_PACK
#pragma pack(pop)
#endif
/*
* Command codes for the command_request field in each request.
*/
#define SUNOEM_CLI_CMD_OPEN 0 /* Open a new connection */
#define SUNOEM_CLI_CMD_FORCE 1 /* Close any existing connection, then open */
#define SUNOEM_CLI_CMD_CLOSE 2 /* Close the current connection */
#define SUNOEM_CLI_CMD_POLL 3 /* Poll for new data to/from the server */
#define SUNOEM_CLI_CMD_EOF 4 /* Poll, client is out of data */
#define SUNOEM_CLI_MAX_RETRY 3 /* Maximum number of retries */
#define SUNOEM_CLI_INVALID_VER_ERR "Invalid version"
#define SUNOEM_CLI_BUSY_ERR "Busy"
typedef enum
{
C_CTL_B = 0x02, /* same as left arrow */
C_CTL_C = 0x03,
C_CTL_D = 0x04,
C_CTL_F = 0x06, /* same as right arrow */
C_CTL_N = 0x0E, /* same as down arrow */
C_CTL_P = 0x10, /* same as up arrow */
C_DEL = 0x7f
} canon_char_t;
static int
sunoem_cli_unbufmode_start(FILE *f, struct termios *orig_ts)
{
struct termios ts;
int rc;
if ((rc = tcgetattr(fileno(f), &ts))) {
return (rc);
}
*orig_ts = ts;
ts.c_lflag &= ~(ICANON | ECHO | ISIG);
ts.c_cc[VMIN] = 1;
if ((rc = tcsetattr(fileno(f), TCSAFLUSH, &ts))) {
return (rc);
}
return (0);
}
static int
sunoem_cli_unbufmode_stop(FILE *f, struct termios *ts)
{
int rc;
if ((rc = tcsetattr(fileno(f), TCSAFLUSH, ts))) {
return (rc);
}
return (0);
}
static int
ipmi_sunoem_cli(struct ipmi_intf * intf, int argc, char *argv[])
{
struct ipmi_rs *rsp;
struct ipmi_rq req;
sunoem_cli_msg_t cli_req;
sunoem_cli_msg_t *cli_rsp;
int arg_num = 0;
int arg_pos = 0;
time_t wait_time = 0;
int retries;
static uint8_t SunOemCliActingVersion = SUNOEM_CLI_VERSION;
unsigned short first_char = 0; /*first char on the line*/
struct termios orig_ts;
int error = 0;
time_t now = 0;
int delay = 0;
/* Prepare to open an SP shell session */
memset(&cli_req, 0, sizeof(cli_req));
cli_req.version = SunOemCliActingVersion;
cli_req.command_response = SUNOEM_CLI_CMD_OPEN;
if (argc > 0 && strcmp(argv[0], "force") == 0) {
cli_req.command_response = SUNOEM_CLI_CMD_FORCE;
argc--;
argv++;
}
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_SUNOEM;
req.msg.cmd = IPMI_SUNOEM_CLI;
req.msg.data = (uint8_t *) &cli_req;
req.msg.data_len = SUNOEM_CLI_HEADER + 1;
retries = 0;
while (1) {
cli_req.version = SunOemCliActingVersion;
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR, "Sun OEM cli command failed");
return (-1);
}
cli_rsp = (sunoem_cli_msg_t *) rsp->data;
if ((cli_rsp->command_response != 0) || (rsp->ccode != 0)) {
if (strncmp(cli_rsp->buf, SUNOEM_CLI_INVALID_VER_ERR,
sizeof(SUNOEM_CLI_INVALID_VER_ERR) - 1) == 0
|| strncmp(&(cli_rsp->buf[1]), SUNOEM_CLI_INVALID_VER_ERR,
sizeof(SUNOEM_CLI_INVALID_VER_ERR) - 1) == 0) {
if (SunOemCliActingVersion == SUNOEM_CLI_VERSION) {
/* Server doesn't support version SUNOEM_CLI_VERSION
Fall back to legacy version, and try again*/
SunOemCliActingVersion = SUNOEM_CLI_LEGACY_VERSION;
continue;
}
/* Server doesn't support legacy version either */
lprintf(LOG_ERR, "Failed to connect: %s", cli_rsp->buf);
return (-1);
} else if (strncmp(cli_rsp->buf, SUNOEM_CLI_BUSY_ERR,
sizeof(SUNOEM_CLI_BUSY_ERR) - 1) == 0) {
if (retries++ < SUNOEM_CLI_MAX_RETRY) {
lprintf(LOG_INFO, "Failed to connect: %s, retrying",
cli_rsp->buf);
sleep(2);
continue;
}
lprintf(LOG_ERR, "Failed to connect: %s", cli_rsp->buf);
return (-1);
} else {
lprintf(LOG_ERR, "Failed to connect: %s", cli_rsp->buf);
return (-1);
}
}
break;
}
if (SunOemCliActingVersion == SUNOEM_CLI_SEQNUM_VERSION) {
/*
* Bit 1 of seqnum is used as an alternating sequence number
* to allow a server that supports it to detect when a retry is being sent from the host IPMI driver.
* Typically when this occurs, the server's last response message would have been dropped.
* Once the server detects this condition, it will know that it should retry sending the response.
*/
cli_req.seqnum ^= 0x1;
}
printf("Connected. Use ^D to exit.\n");
fflush(NULL);
/*
* Remember the handle provided in the response, and issue a
* series of "poll" commands to send and get data
*/
memcpy(cli_req.handle, cli_rsp->handle, 4);
cli_req.command_response = SUNOEM_CLI_CMD_POLL;
/*
* If no arguments make input unbuffered and so interactive
*/
if (argc == 0) {
if (sunoem_cli_unbufmode_start(stdin, &orig_ts)) {
lprintf(LOG_ERR, "Failed to set interactive mode: %s",
strerror(errno));
return (-1);
}
}
while (rsp->ccode == 0 && cli_rsp->command_response == 0) {
int rc = 0;
int count = 0;
cli_req.buf[0] = '\0';
if (argc == 0) {
/*
* Accept input from stdin. Use select so we don't hang if
* there's no input to read. Select timeout is 500 msec.
*/
struct timeval tv = { 0, 500000 }; /* 500 msec */
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(0, &rfds);
rc = select(1, &rfds, NULL, NULL, &tv);
if (rc < 0) {
/* Select returned an error so close and exit */
printf("Broken pipe\n");
cli_req.command_response = SUNOEM_CLI_CMD_CLOSE;
} else if (rc > 0) {
/* Read data from stdin */
count = read(0, cli_req.buf, 1 /* sizeof (cli_req.buf) - 1 */);
/*
* If select said there was data but there was nothing to
* read. This implies user hit ^D.
* Also handle ^D input when pressed as first char at a new line.
*/
if (count <= 0 || (first_char && cli_req.buf[0] == C_CTL_D)) {
cli_req.command_response = SUNOEM_CLI_CMD_EOF;
count = 0;
}
first_char = cli_req.buf[0] == '\n' || cli_req.buf[0] == '\r';
}
} else {
/*
* Get data from command line arguments
*/
now = time(NULL);
if (now < wait_time) {
/* Do nothing; we're waiting */
} else if (arg_num >= argc) {
/* Last arg was sent. Set EOF */
cli_req.command_response = SUNOEM_CLI_CMD_EOF;
} else if (strncmp(argv[arg_num], "@wait=", 6) == 0) {
/* This is a wait command */
char *s = &argv[arg_num][6];
delay = 0;
if (*s != '\0') {
if (str2int(s, &delay)) {
delay = 0;
}
if (delay < 0) {
delay = 0;
}
}
wait_time = now + delay;
arg_num++;
} else {
/*
* Take data from args. It may be that the argument is larger
* than the request buffer can hold. So pull off BUF_SIZE
* number of characters at a time. When we've consumed the
* entire arg, append a newline and advance to the next arg.
*/
int i;
char *s = argv[arg_num];
for (i = arg_pos;
s[i] != '\0' && count < (SUNOEM_CLI_BUF_SIZE - 2);
i++, count++) {
cli_req.buf[count] = s[i];
}
if (s[i] == '\0') {
/* Reached end of the arg string, so append a newline */
cli_req.buf[count++] = '\n';
/* Reset pos to 0 and advance to the next arg next time */
arg_pos = 0;
arg_num++;
} else {
/*
* Otherwise, there's still more characters in the arg
* to send, so remember where we left off
*/
arg_pos = i;
}
}
}
/*
* Now send the clients's data (if any) and get data back from the
* server. Loop while the server is giving us data until we suck
* it dry.
*/
do {
cli_req.buf[count++] = '\0'; /* Terminate the string */
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_SUNOEM;
req.msg.cmd = 0x19;
req.msg.data = (uint8_t *) &cli_req;
req.msg.data_len = SUNOEM_CLI_HEADER + count;
for (retries = 0; retries <= SUNOEM_CLI_MAX_RETRY; retries++) {
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR, "Communication error.");
error = 1;
goto cleanup;
}
if (rsp->ccode == IPMI_CC_TIMEOUT) { /* Retry if timed out. */
if (retries == SUNOEM_CLI_MAX_RETRY) { /* If it's the last retry. */
lprintf(LOG_ERR, "Excessive timeout.");
error = 1;
goto cleanup;
}
continue;
}
break;
} /* for (retries = 0; retries <= SUNOEM_CLI_MAX_RETRY; retries++) */
if (SunOemCliActingVersion == SUNOEM_CLI_SEQNUM_VERSION) {
cli_req.seqnum ^= 0x1; /* Toggle sequence number after request is sent */
}
cli_rsp = (sunoem_cli_msg_t *) rsp->data;
/* Make sure response string is null terminated */
cli_rsp->buf[sizeof(cli_rsp->buf) - 1] = '\0';
printf("%s", cli_rsp->buf);
fflush(NULL); /* Flush partial lines to stdout */
count = 0; /* Don't re-send the client's data */
if (cli_req.command_response == SUNOEM_CLI_CMD_EOF
&& cli_rsp->command_response != 0 && rsp->ccode == 0) {
cli_rsp->command_response = 1;
}
} while (cli_rsp->command_response == 0 && cli_rsp->buf[0] != '\0');
}
cleanup:
/* Restore original input mode if cli was running interactively */
if (argc == 0) {
if (sunoem_cli_unbufmode_stop(stdin, &orig_ts)) {
lprintf(LOG_ERR, "Failed to restore interactive mode: %s",
strerror(errno));
return (-1);
}
}
return ((error == 0 && cli_rsp->command_response == SUNOEM_SUCCESS) ? 0 : -1);
}
#define ECHO_DATA_SIZE 64
#ifdef HAVE_PRAGMA_PACK
#pragma pack(push, 1)
#endif
typedef struct
{
uint16_t seq_num;
unsigned char data[ECHO_DATA_SIZE];
}__attribute__((packed)) sunoem_echo_msg_t;
#ifdef HAVE_PRAGMA_PACK
#pragma pack(pop)
#endif
/*
* Send and receive X packets to the BMC. Each packet has a
* payload size of (sunoem_echo_msg_t) bytes. Each packet is tagged with a
* sequence number
*/
static int
ipmi_sunoem_echo(struct ipmi_intf * intf, int argc, char *argv[])
{
struct ipmi_rs *rsp;
struct ipmi_rq req;
sunoem_echo_msg_t echo_req;
sunoem_echo_msg_t *echo_rsp;
struct timeval start_time;
struct timeval end_time;
int rc = 0;
int received = 0;
int transmitted = 0;
int quiet_mode = 0;
uint16_t num, i, j;
uint32_t total_time, resp_time, min_time, max_time;
if (argc < 1) {
return (1);
}
if (argc == 2) {
if (*(argv[1]) == 'q') {
quiet_mode = 1;
} else {
lprintf(LOG_ERR, "Unknown option '%s' given.", argv[1]);
return (-1);
}
} else if (argc > 2) {
lprintf(LOG_ERR,
"Too many parameters given. See help for more information.");
return (-1);
}
/* The number of packets to send/receive */
if (str2ushort(argv[0], &num) != 0) {
lprintf(LOG_ERR,
"Given number of packets is either invalid or out of range.");
return (-1);
}
/* Fill in data packet */
for (i = 0; i < ECHO_DATA_SIZE; i++) {
echo_req.data[i] = (uint8_t) i;
}
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_SUNOEM;
req.msg.cmd = IPMI_SUNOEM_ECHO;
req.msg.data = (uint8_t *) &echo_req;
req.msg.data_len = sizeof(sunoem_echo_msg_t);
echo_req.seq_num = i;
min_time = INT_MAX;
max_time = 0;
total_time = 0;
for (i = 0; i < num; i++) {
echo_req.seq_num = i;
transmitted++;
gettimeofday(&start_time, NULL);
rsp = intf->sendrecv(intf, &req);
gettimeofday(&end_time, NULL);
resp_time = ((end_time.tv_sec - start_time.tv_sec) * 1000)
+ ((end_time.tv_usec - start_time.tv_usec) / 1000);
if ((rsp == NULL) || (rsp->ccode != 0)) {
lprintf(LOG_ERR, "Sun OEM echo command failed. Seq # %d",
echo_req.seq_num);
rc = (-2);
break;
}
echo_rsp = (sunoem_echo_msg_t *) rsp->data;
/* Test if sequence # is valid */
if (echo_rsp->seq_num != echo_req.seq_num) {
printf("Invalid Seq # Expecting %d Received %d\n", echo_req.seq_num,
echo_rsp->seq_num);
rc = (-2);
break;
}
/* Test if response length is valid */
if (rsp->session.msglen == req.msg.data_len) {
printf("Invalid payload size for seq # %d. "
"Expecting %d Received %d\n", echo_rsp->seq_num,
req.msg.data_len, rsp->session.msglen);
rc = (-2);
break;
}
/* Test if the data is valid */
for (j = 0; j < ECHO_DATA_SIZE; j++) {
if (echo_rsp->data[j] != j) {
printf("Corrupt data packet. Seq # %d Offset %d\n",
echo_rsp->seq_num, j);
break;
}
} /* for (j = 0; j < ECHO_DATA_SIZE; j++) */
/* If the for loop terminated early - data is corrupt */
if (j != ECHO_DATA_SIZE) {
rc = (-2);
break;
}
/* cumalative time */
total_time += resp_time;
/* min time */
if (resp_time < min_time) {
min_time = resp_time;
}
/* max time */
if (resp_time > max_time) {
max_time = resp_time;
}
received++;
if (!quiet_mode) {
printf("Receive %lu Bytes - Seq. # %d time=%d ms\n",
sizeof(sunoem_echo_msg_t), echo_rsp->seq_num, resp_time);
}
} /* for (i = 0; i < num; i++) */
printf("%d packets transmitted, %d packets received\n", transmitted,
received);
if (received) {
printf("round-trip min/avg/max = %d/%d/%d ms\n", min_time,
total_time / received, max_time);
}
return (rc);
} /* ipmi_sunoem_echo(...) */
#ifdef HAVE_PRAGMA_PACK
#pragma pack(push, 1)
#endif
typedef struct
{
unsigned char oem_record_ver_num;
unsigned char major;
unsigned char minor;
unsigned char update;
unsigned char micro;
char nano[10];
char revision[10];
char version[40];
/*
* When adding new fields (using the spare bytes),
* add it immediately after the spare field to
* ensure backward compatability.
*
* e.g. char version[40];
* unsigned char spare[11];
* int new_item;
* } sunoem_version_response_t;
*/
unsigned char spare[15];
}__attribute__((packed)) sunoem_version_response_t;
#ifdef HAVE_PRAGMA_PACK
#pragma pack(pop)
#endif
typedef struct
{
unsigned char major;
unsigned char minor;
unsigned char update;
unsigned char micro;
} supported_version_t;
static int
ipmi_sunoem_getversion(struct ipmi_intf * intf,
sunoem_version_response_t **version_rsp)
{
struct ipmi_rs *rsp;
struct ipmi_rq req;
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_SUNOEM;
req.msg.cmd = IPMI_SUNOEM_VERSION;
req.msg.data = NULL;
req.msg.data_len = 0;
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR, "Sun OEM Get SP Version Failed.");
return (-1);
}
if (rsp->ccode != 0) {
lprintf(LOG_ERR, "Sun OEM Get SP Version Failed: %d", rsp->ccode);
return (-1);
}
*version_rsp = (sunoem_version_response_t *) rsp->data;
return (0);
}
static void
ipmi_sunoem_print_required_version(const supported_version_t* supp_ver)
{
lprintf(LOG_ERR, "Command is not supported by this version of ILOM,"
" required at least: %d.%d.%d.%d", supp_ver->major, supp_ver->minor,
supp_ver->update, supp_ver->micro);
}
/*
* Function checks current version result against required version.
* Returns:
* - negative value if current ILOM version is smaller than required or
* in case of error
* - positive value if current ILOM version is greater than required
* - 0 if there is an exact ILOM version match
*/
static int
ipmi_sunoem_checkversion(struct ipmi_intf * intf, supported_version_t* supp_ver)
{
sunoem_version_response_t *version_rsp;
int i = 1;
if (ipmi_sunoem_getversion(intf, &version_rsp)) {
lprintf(LOG_ERR, "Unable to get ILOM version");
return (-1);
}
if (version_rsp->major < supp_ver->major) return (-i);
if (version_rsp->major > supp_ver->major) return (i);
/*version_rsp->major == supp_ver->major*/
++i;
if (version_rsp->minor < supp_ver->minor) return (-i);
if (version_rsp->minor > supp_ver->minor) return (i);
/*version_rsp->minor == supp_ver->minor*/
++i;
if (version_rsp->update < supp_ver->update) return (-i);
if (version_rsp->update > supp_ver->update) return (i);
/*version_rsp->update == supp_ver->update*/
++i;
if (version_rsp->micro < supp_ver->micro) return (-i);
if (version_rsp->micro > supp_ver->micro) return (i);
/*version_rsp->micro == supp_ver->micro*/
return (0);
}
/*
* Extract the SP version data including
* - major #
* - minor #
* - update #
* - micro #
* - nano #
* - Revision/Build #
*/
static int
ipmi_sunoem_version(struct ipmi_intf * intf)
{
sunoem_version_response_t *version_rsp;
int rc = ipmi_sunoem_getversion(intf, &version_rsp);
if (!rc) {
printf("Version: %s\n", version_rsp->version);
}
return (rc);
}
/*
* IPMI Max string length is 16 bytes
* define in usr/src/common/include/ami/IPMI_SDRRecord.h
*/
#define MAX_ID_STR_LEN 16
#define MAX_SUNOEM_NAC_SIZE 64
#define LUAPI_MAX_OBJ_PATH_LEN 256
#define LUAPI_MAX_OBJ_VAL_LEN 1024
#ifdef HAVE_PRAGMA_PACK
#pragma pack(push, 1)
#endif
typedef struct
{
unsigned char seq_num;
char nac_name[MAX_SUNOEM_NAC_SIZE];
}__attribute__((packed)) sunoem_nacname_t;
#ifdef HAVE_PRAGMA_PACK
#pragma pack(pop)
#endif
/*
* Retrieve the full NAC name of the IPMI target.
*
* The returned nac name may be larger than the payload size.
* In which case, it make take several request/payload to retrieve
* the entire full path name
*
* The initial seq_num is set to 0. If the return seq_num is incremented,
* only the 1st 72 bytes of the nac name is returned and the caller
* needs to get the next set of string data.
* If the returned seq_num is identical to the input seq_num, all data
* has been returned.
*/
static int
ipmi_sunoem_nacname(struct ipmi_intf * intf, int argc, char *argv[])
{
struct ipmi_rs *rsp;
struct ipmi_rq req;
sunoem_nacname_t nacname_req;
sunoem_nacname_t *nacname_rsp;
char full_nac_name[LUAPI_MAX_OBJ_PATH_LEN];
if (argc < 1) {
return (1);
}
if (strlen(argv[0]) > MAX_ID_STR_LEN) {
lprintf(LOG_ERR,
"Sun OEM nacname command failed: Max size on IPMI name");
return (-1);
}
nacname_req.seq_num = 0;
strcpy(nacname_req.nac_name, argv[0]);
full_nac_name[0] = '\0';
while (1) {
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_SUNOEM;
req.msg.cmd = IPMI_SUNOEM_NACNAME;
req.msg.data = (uint8_t *) &nacname_req;
req.msg.data_len = sizeof(sunoem_nacname_t);
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR, "Sun OEM nacname command failed.");
return (-1);
}
if (rsp->ccode != 0) {
lprintf(LOG_ERR, "Sun OEM nacname command failed: %d", rsp->ccode);
return (-1);
}
nacname_rsp = (sunoem_nacname_t *) rsp->data;
strncat(full_nac_name, nacname_rsp->nac_name, MAX_SUNOEM_NAC_SIZE);
/*
* break out of the loop if there is no more data
* In most cases, if not all, the NAC name fits into a
* single payload
*/
if (nacname_req.seq_num == nacname_rsp->seq_num) {
break;
}
/* Get the next seq of string bytes */
nacname_req.seq_num = nacname_rsp->seq_num;
/* Check if we exceeded the size of the full nac name */
if ((nacname_req.seq_num * MAX_SUNOEM_NAC_SIZE) > LUAPI_MAX_OBJ_PATH_LEN) {
lprintf(LOG_ERR,
"Sun OEM nacname command failed: invalid path length");
return (-1);
}
}
printf("NAC Name: %s\n", full_nac_name);
return (0);
}
/* Constants used by ipmi_sunoem_getval */
#define MAX_SUNOEM_VAL_PAYLOAD 79
#define MAX_SUNOEM_VAL_COMPACT_PAYLOAD 56
/*
* SUNOEM GET/SET LUAPI Commands
*
* SUNOEM_REQ_VAL - Request LUAPI Property Value
* SUNOEM_GET_VAL - Return the value from SUNOEM_REQ_VAL
* SUNOEM_SET_VAL - Set the LUAPI Property value
* SUNOEM_GET_STATUS - Return the Status from SUNOEM_SET_VAL
*/
#define SUNOEM_REQ_VAL 1
#define SUNOEM_GET_VAL 2
#define SUNOEM_SET_VAL 3
#define SUNOEM_GET_STATUS 4
/* Status Code */
#define SUNOEM_REQ_RECV 1
#define SUNOEM_REQ_FAILED 2
#define SUNOEM_DATA_READY 3
#define SUNOEM_DATA_NOT_READY 4
#define SUNOEM_DATA_NOT_FOUND 5
#define GETVAL_MAX_RETRIES 5
/* Parameter type Codes */
#define SUNOEM_LUAPI_TARGET 0
#define SUNOEM_LUAPI_VALUE 1
#ifdef HAVE_PRAGMA_PACK
#pragma pack(push, 1)
#endif
typedef struct
{
unsigned char cmd_code;
unsigned char luapi_value[MAX_SUNOEM_VAL_PAYLOAD];
}__attribute__((packed)) sunoem_getval_t;
#ifdef HAVE_PRAGMA_PACK
#pragma pack(pop)
#endif
/*
* REQUEST PAYLOAD
*
* cmd_code - SUNOEM GET/SET LUAPI Cmds - see above
* param_type: 0: luapi_data contains the luapi property name
* 1: luapi_data contains the luapi value
* luapi_data: Either luapi property name or value
* tid: Transaction ID. If 0. This is the initial request for the
* param_type. If tid > 0, this luapi_data string is a concatenation
* of the previous request. Handle cases where the LUAPI target name
* or value is > MAX_SUNOEM_VAL_COMPACT_PAYLOAD
* eof: If non zero, this is the last payload for the request
*/
#ifdef HAVE_PRAGMA_PACK
#pragma pack(push, 1)
#endif
typedef struct
{
unsigned char cmd_code;
unsigned char param_type;
unsigned char tid;
unsigned char eof;
char luapi_data[MAX_SUNOEM_VAL_COMPACT_PAYLOAD];
}__attribute__((packed)) sunoem_setval_t;
#ifdef HAVE_PRAGMA_PACK
#pragma pack(pop)
#endif
/*
* RESPONSE PAYLOAD
*
* status_code - see above for code definitions
* tid - transaction ID - assigned ny the ILOM stack
*/
#ifdef HAVE_PRAGMA_PACK
#pragma pack(push, 1)
#endif
typedef struct
{
unsigned char status_code;
unsigned char tid;
}__attribute__((packed)) sunoem_setval_resp_t;
#ifdef HAVE_PRAGMA_PACK
#pragma pack(pop)
#endif
/*
* Return the ILOM target property value
*/
static int
ipmi_sunoem_getval(struct ipmi_intf * intf, int argc, char *argv[])
{
struct ipmi_rs *rsp;
struct ipmi_rq req;
sunoem_getval_t getval_req;
sunoem_getval_t *getval_rsp;
int i;
const char* sp_path = "/SP";
supported_version_t supp_ver = { 3, 2, 0, 0 };
if (argc < 1) {
return (1);
}
if (strlen(argv[0]) > MAX_SUNOEM_VAL_PAYLOAD) {
lprintf(LOG_ERR,
"Sun OEM get value command failed: Max size on IPMI name");
return (-1);
}
if ((ipmi_sunoem_checkversion(intf, &supp_ver) < 0)
&& (!strncmp(argv[0], sp_path, strlen(sp_path)))) {
argv[0][1] = 'X'; /*replace SP by X to gain access to hidden properties*/
memmove(&argv[0][2], &argv[0][3], strlen(argv[0]) - 2);
}
/*
* Setup the initial request to fetch the data.
* Upon function return, the next cmd (SUNOEM_GET_VAL)
* can be requested.
*/
memset(&getval_req, 0, sizeof(getval_req));
strncpy((char*) getval_req.luapi_value, argv[0], MAX_SUNOEM_VAL_PAYLOAD);
getval_req.cmd_code = SUNOEM_REQ_VAL;
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_SUNOEM;
req.msg.cmd = IPMI_SUNOEM_GETVAL;
req.msg.data = (uint8_t *) &getval_req;
req.msg.data_len = sizeof(sunoem_getval_t);
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR, "Sun OEM getval1 command failed.");
return (-1);
}
if (rsp->ccode != 0) {
lprintf(LOG_ERR, "Sun OEM getval1 command failed: %d", rsp->ccode);
return (-1);
}
/*
* Fetch the data value - if it is not ready,
* retry the request up to GETVAL_MAX_RETRIES
*/
for (i = 0; i < GETVAL_MAX_RETRIES; i++) {
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_SUNOEM;
req.msg.cmd = IPMI_SUNOEM_GETVAL;
getval_req.cmd_code = SUNOEM_GET_VAL;
req.msg.data = (uint8_t *) &getval_req;
req.msg.data_len = sizeof(sunoem_getval_t);
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR, "Sun OEM getval2 command failed.");
return (-1);
}
if (rsp->ccode != 0) {
lprintf(LOG_ERR, "Sun OEM getval2 command failed: %d", rsp->ccode);
return (-1);
}
getval_rsp = (sunoem_getval_t *) rsp->data;
if (getval_rsp->cmd_code == SUNOEM_DATA_READY) {
printf("Target Value: %s\n", getval_rsp->luapi_value);
return (0);
} else if (getval_rsp->cmd_code == SUNOEM_DATA_NOT_FOUND) {
lprintf(LOG_ERR, "Target: %s not found", getval_req.luapi_value);
return (-1);
}
sleep(1);
}
lprintf(LOG_ERR, "Unable to retrieve target value.");
return (-1);
}
static int
send_luapi_prop_name(struct ipmi_intf * intf, int len, char *prop_name,
unsigned char *tid_num)
{
int i = 0;
struct ipmi_rs *rsp;
struct ipmi_rq req;
sunoem_setval_t setval_req;
sunoem_setval_resp_t *setval_rsp;
*tid_num = 0;
while (i < len) {
/*
* Setup the request,
* Upon function return, the next cmd (SUNOEM_SET_VAL)
* can be requested.
*/
memset(&req, 0, sizeof(req));
memset(&setval_req, 0, sizeof(sunoem_setval_t));
req.msg.netfn = IPMI_NETFN_SUNOEM;
req.msg.cmd = IPMI_SUNOEM_SETVAL;
setval_req.cmd_code = SUNOEM_SET_VAL;
setval_req.param_type = SUNOEM_LUAPI_TARGET;
setval_req.tid = *tid_num;
setval_req.eof = 0;
/*
* If the property name is > payload, only copy
* the payload size and increment the string offset (i)
* for the next payload
*/
if (strlen(&(prop_name[i])) > MAX_SUNOEM_VAL_COMPACT_PAYLOAD) {
strncpy(setval_req.luapi_data, &(prop_name[i]),
MAX_SUNOEM_VAL_COMPACT_PAYLOAD);
} else {
strncpy(setval_req.luapi_data, &(prop_name[i]),
strlen(&(prop_name[i])));
}
req.msg.data = (uint8_t *) &setval_req;
req.msg.data_len = sizeof(sunoem_setval_t);
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR, "Sun OEM setval prop name: response is NULL");
return (-1);
}
if (rsp->ccode != 0) {
lprintf(LOG_ERR, "Sun OEM setval prop name: request failed: %d",
rsp->ccode);
return (-1);
}
setval_rsp = (sunoem_setval_resp_t *) rsp->data;
/*
* If the return code is other than data received, the
* request failed
*/
if (setval_rsp->status_code != SUNOEM_REQ_RECV) {
lprintf(LOG_ERR,
"Sun OEM setval prop name: invalid status code: %d",
setval_rsp->status_code);
return (-1);
}
/* Use the tid returned by ILOM */
*tid_num = setval_rsp->tid;
/* Increment the string offset */
i += MAX_SUNOEM_VAL_COMPACT_PAYLOAD;
}
return (0);
}
static int
send_luapi_prop_value(struct ipmi_intf * intf, int len, char *prop_value,
unsigned char tid_num)
{
int i = 0;
struct ipmi_rs *rsp;
struct ipmi_rq req;
sunoem_setval_t setval_req;
sunoem_setval_resp_t *setval_rsp;
while (i < len) {
/*
* Setup the request,
* Upon function return, the next cmd (SUNOEM_GET_VAL)
* can be requested.
*/
memset(&req, 0, sizeof(req));
memset(&setval_req, 0, sizeof(sunoem_setval_t));
req.msg.netfn = IPMI_NETFN_SUNOEM;
req.msg.cmd = IPMI_SUNOEM_SETVAL;
setval_req.cmd_code = SUNOEM_SET_VAL;
setval_req.param_type = SUNOEM_LUAPI_VALUE;
setval_req.tid = tid_num;
/*
* If the property name is > payload, only copy the
* the payload size and increment the string offset
* for the next payload
*/
if (strlen(&(prop_value[i])) > MAX_SUNOEM_VAL_COMPACT_PAYLOAD) {
strncpy(setval_req.luapi_data, &(prop_value[i]),
MAX_SUNOEM_VAL_COMPACT_PAYLOAD);
} else {
/* Captured the entire string, mark this as the last payload */
strncpy(setval_req.luapi_data, &(prop_value[i]),
strlen(&(prop_value[i])));
setval_req.eof = 1;
}
req.msg.data = (uint8_t *) &setval_req;
req.msg.data_len = sizeof(sunoem_setval_t);
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR, "Sun OEM setval prop value: response is NULL");
return (-1);
}
if (rsp->ccode != 0) {
lprintf(LOG_ERR, "Sun OEM setval prop value: request failed: %d",
rsp->ccode);
return (-1);
}
setval_rsp = (sunoem_setval_resp_t *) rsp->data;
/*
* If the return code is other than data received, the
* request failed
*/
if (setval_rsp->status_code != SUNOEM_REQ_RECV) {
lprintf(LOG_ERR,
"Sun OEM setval prop value: invalid status code: %d",
setval_rsp->status_code);
return (-1);
}
/* Increment the string offset */
i += MAX_SUNOEM_VAL_COMPACT_PAYLOAD;
}
return (0);
}
static int
ipmi_sunoem_setval(struct ipmi_intf * intf, int argc, char *argv[])
{
struct ipmi_rs *rsp;
struct ipmi_rq req;
sunoem_setval_t setval_req;
sunoem_setval_resp_t *setval_rsp;
int prop_len;
int value_len;
int i;
unsigned char tid_num;
int retries;
prop_len = strlen(argv[0]);
value_len = strlen(argv[1]);
if (prop_len > LUAPI_MAX_OBJ_PATH_LEN) {
lprintf(LOG_ERR,
"Sun OEM set value command failed: Max size on property name");
return (-1);
}
if (value_len > LUAPI_MAX_OBJ_VAL_LEN) {
lprintf(LOG_ERR,
"Sun OEM set value command failed: Max size on property value");
return (-1);
}
/* Test if there is a timeout specified */
if (argc == 3) {
if ((str2int(argv[2], &retries) != 0) || retries < 0) {
lprintf(LOG_ERR,
"Invalid input given or out of range for time-out parameter.");
return (-1);
}
} else {
retries = GETVAL_MAX_RETRIES;
}
/* Send the property name 1st */
if (send_luapi_prop_name(intf, prop_len, argv[0], &tid_num) != 0) {
/* return if there is an error */
return (-1);
}
if (send_luapi_prop_value(intf, value_len, argv[1], tid_num) != 0) {
/* return if there is an error */
return (-1);
}
/*
* Get The status of the command.
* if it is not ready, retry the request up to
* GETVAL_MAX_RETRIES
*/
for (i = 0; i < retries; i++) {
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_SUNOEM;
req.msg.cmd = IPMI_SUNOEM_SETVAL;
setval_req.cmd_code = SUNOEM_GET_STATUS;
setval_req.tid = tid_num;
req.msg.data = (uint8_t *) &setval_req;
req.msg.data_len = sizeof(sunoem_setval_t);
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR, "Sun OEM setval command failed.");
return (-1);
}
if (rsp->ccode != 0) {
lprintf(LOG_ERR, "Sun OEM setval command failed: %d", rsp->ccode);
return (-1);
}
setval_rsp = (sunoem_setval_resp_t *) rsp->data;
if (setval_rsp->status_code == SUNOEM_DATA_READY) {
printf("Sun OEM setval command successful.\n");
return (0);
} else if (setval_rsp->status_code != SUNOEM_DATA_NOT_READY) {
lprintf(LOG_ERR, "Sun OEM setval command failed.");
return (-1);
}
sleep(1);
}
/* If we reached here, retries exceeded */
lprintf(LOG_ERR, "Sun OEM setval command failed: Command Timed Out");
return (-1);
}
#define MAX_FILE_DATA_SIZE 1024
#define MAX_FILEID_LEN 16
#define CORE_TUNNEL_SUBCMD_GET_FILE 11
#ifdef HAVE_PRAGMA_PACK
#pragma pack(push, 1)
#endif
typedef struct
{
unsigned char cmd_code;
unsigned char file_id[MAX_FILEID_LEN];
unsigned int block_num;
}__attribute__((packed)) getfile_req_t;
typedef struct
{
unsigned int block_num;
unsigned int data_size;
unsigned char eof;
unsigned char data[MAX_FILE_DATA_SIZE];
}__attribute__((packed)) getfile_rsp_t;
#ifdef HAVE_PRAGMA_PACK
#pragma pack(pop)
#endif
static int
ipmi_sunoem_getfile(struct ipmi_intf * intf, int argc, char *argv[])
{
struct ipmi_rs *rsp;
struct ipmi_rq req;
getfile_req_t getfile_req;
getfile_rsp_t *getfile_rsp;
int block_num = 0;
int nbo_blk_num; /* Network Byte Order Block Num */
FILE *fp;
unsigned data_size;
supported_version_t supp_ver = IPMI_SUNOEM_GETFILE_VERSION;
if (argc < 1) {
return (-1);
}
/*check if command is supported by this version of ilom*/
if (ipmi_sunoem_checkversion(intf, &supp_ver) < 0) {
ipmi_sunoem_print_required_version(&supp_ver);
return (-1);
}
/*
* File ID is < MAX_FILEID_LEN
* Save 1 byte for null Terminated string
*/
if (strlen(argv[0]) >= MAX_FILE_DATA_SIZE) {
lprintf(LOG_ERR, "File ID >= %d characters", MAX_FILEID_LEN);
return (-1);
}
memset(&getfile_req, 0, sizeof(getfile_req));
strncpy((char*) getfile_req.file_id, argv[0], MAX_FILEID_LEN - 1);
/* Create the destination file */
fp = ipmi_open_file_write(argv[1]);
if (fp == NULL) {
lprintf(LOG_ERR, "Unable to open file: %s", argv[1]);
return (-1);
}
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_SUNOEM;
req.msg.cmd = IPMI_SUNOEM_CORE_TUNNEL;
req.msg.data = (uint8_t *) &getfile_req;
req.msg.data_len = sizeof(getfile_req_t);
getfile_req.cmd_code = CORE_TUNNEL_SUBCMD_GET_FILE;
do {
nbo_blk_num = htonl(block_num);
/* Block Num must be in network byte order */
memcpy(&(getfile_req.block_num), &nbo_blk_num,
sizeof(getfile_req.block_num));
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR, "Sun OEM getfile command failed.");
fclose(fp);
return (-1);
}
if (rsp->ccode != 0) {
lprintf(LOG_ERR, "Sun OEM getfile command failed: %d", rsp->ccode);
fclose(fp);
return (-1);
}
getfile_rsp = (getfile_rsp_t *) rsp->data;
memcpy(&data_size, &(getfile_rsp->data_size),
sizeof(getfile_rsp->data_size));
data_size = ntohl(data_size);
if (data_size > MAX_FILE_DATA_SIZE) {
lprintf(LOG_ERR, "Sun OEM getfile invalid data size: %d",
data_size);
fclose(fp);
return (-1);
}
/* Check if Block Num matches */
if (memcmp(&(getfile_req.block_num), &(getfile_rsp->block_num),
sizeof(getfile_req.block_num)) != 0) {
lprintf(LOG_ERR, "Sun OEM getfile Incorrect Block Num Returned");
lprintf(LOG_ERR, "Expecting: %x Received: %x",
getfile_req.block_num, getfile_rsp->block_num);
fclose(fp);
return (-1);
}
if (fwrite(getfile_rsp->data, 1, data_size, fp) != data_size) {
lprintf(LOG_ERR, "Sun OEM getfile write failed: %d", rsp->ccode);
fclose(fp);
return (-1);
}
block_num++;
} while (getfile_rsp->eof == 0);
fclose(fp);
return (0);
}
/*
* Query BMC for capability/behavior.
*/
#define CORE_TUNNEL_SUBCMD_GET_BEHAVIOR 15
#define SUNOEM_BEHAVIORID_SIZE 32
#ifdef HAVE_PRAGMA_PACK
#pragma pack(push, 1)
#endif
typedef struct
{
unsigned char cmd_code;
unsigned char behavior_id[SUNOEM_BEHAVIORID_SIZE];
}__attribute__((packed)) getbehavior_req_t;
typedef struct
{
unsigned char enabled;
}__attribute__((packed)) getbehavior_rsp_t;
#ifdef HAVE_PRAGMA_PACK
#pragma pack(pop)
#endif
static int
ipmi_sunoem_getbehavior(struct ipmi_intf * intf, int argc, char *argv[])
{
struct ipmi_rq req;
struct ipmi_rs *rsp;
getbehavior_req_t getbehavior_req;
getbehavior_rsp_t *getbehavior_rsp;
supported_version_t supp_ver = IPMI_SUNOEM_GETBEHAVIOR_VERSION;
if (argc < 1) {
return (-1);
}
/*check if command is supported by this version of ilom*/
if (ipmi_sunoem_checkversion(intf, &supp_ver) < 0) {
ipmi_sunoem_print_required_version(&supp_ver);
return (-1);
}
/*
* Behavior ID is < SUNOEM_BEHAVIORID_SIZE.
* Save 1 byte for null terminated string
*/
if (strlen(argv[0]) >= SUNOEM_BEHAVIORID_SIZE) {
lprintf(LOG_ERR, "Behavior ID >= %d characters",
SUNOEM_BEHAVIORID_SIZE);
return (-1);
}
memset(&getbehavior_req, 0, sizeof(getbehavior_req));
strncpy(getbehavior_req.behavior_id, argv[0], SUNOEM_BEHAVIORID_SIZE - 1);
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_SUNOEM;
req.msg.cmd = IPMI_SUNOEM_CORE_TUNNEL;
req.msg.data = (uint8_t *) &getbehavior_req;
req.msg.data_len = sizeof(getbehavior_req_t);
getbehavior_req.cmd_code = CORE_TUNNEL_SUBCMD_GET_BEHAVIOR;
rsp = intf->sendrecv(intf, &req);
if (rsp == NULL) {
lprintf(LOG_ERR, "Sun OEM getbehavior command failed.");
return (-1);
}
if (rsp->ccode != 0) {
lprintf(LOG_ERR, "Sun OEM getbehavior command failed: %d", rsp->ccode);
return (-1);
}
getbehavior_rsp = (getbehavior_rsp_t *) rsp->data;
printf("ILOM behavior %s %s enabled\n", getbehavior_req.behavior_id,
getbehavior_rsp->enabled ? "is" : "is not");
return (0);
}
int
ipmi_sunoem_main(struct ipmi_intf * intf, int argc, char ** argv)
{
int rc = 0;
if (argc == 0 || strcmp(argv[0], "help") == 0) {
ipmi_sunoem_usage();
return (0);
} /* if (argc == 0 || strcmp(argv[0], "help") == 0) */
if (strcmp(argv[0], "cli") == 0) {
rc = ipmi_sunoem_cli(intf, argc - 1, &argv[1]);
} else if ((strcmp(argv[0], "led") == 0) || (strcmp(argv[0], "sbled") == 0)) {
if (argc < 2) {
ipmi_sunoem_usage();
return (-1);
}
if (strcmp(argv[1], "get") == 0) {
if (argc < 3) {
char * arg[] = { "all" };
rc = ipmi_sunoem_led_get(intf, 1, arg);
} else {
rc = ipmi_sunoem_led_get(intf, argc - 2, &(argv[2]));
}
} else if (strcmp(argv[1], "set") == 0) {
if (argc < 4) {
ipmi_sunoem_usage();
return (-1);
}
rc = ipmi_sunoem_led_set(intf, argc - 2, &(argv[2]));
} else {
ipmi_sunoem_usage();
return (-1);
}
} else if (strcmp(argv[0], "sshkey") == 0) {
uint8_t uid = 0;
if (argc < 3) {
ipmi_sunoem_usage();
return (-1);
}
rc = str2uchar(argv[2], &uid);
if (rc == 0) {
/* conversion should be OK. */
} else if (rc == 2) {
lprintf(LOG_NOTICE, "Invalid interval given.");
return (-1);
} else {
/* defaults to rc = 3 */
lprintf(LOG_NOTICE, "Given interval is too big.");
return (-1);
}
if (strcmp(argv[1], "del") == 0) {
/* number of arguments, three, is already checked at this point */
rc = ipmi_sunoem_sshkey_del(intf, uid);
} else if (strcmp(argv[1], "set") == 0) {
if (argc < 4) {
ipmi_sunoem_usage();
return (-1);
}
rc = ipmi_sunoem_sshkey_set(intf, uid, argv[3]);
} else {
ipmi_sunoem_usage();
return (-1);
}
} else if (strcmp(argv[0], "ping") == 0) {
if (argc < 2) {
ipmi_sunoem_usage();
return (-1);
}
rc = ipmi_sunoem_echo(intf, argc - 1, &(argv[1]));
} else if (strcmp(argv[0], "version") == 0) {
rc = ipmi_sunoem_version(intf);
} else if (strcmp(argv[0], "nacname") == 0) {
if (argc < 2) {
ipmi_sunoem_usage();
return (-1);
}
rc = ipmi_sunoem_nacname(intf, argc - 1, &(argv[1]));
} else if (strcmp(argv[0], "getval") == 0) {
if (argc < 2) {
ipmi_sunoem_usage();
return (-1);
}
rc = ipmi_sunoem_getval(intf, argc - 1, &(argv[1]));
} else if (strcmp(argv[0], "setval") == 0) {
if (argc < 3) {
ipmi_sunoem_usage();
return (-1);
}
rc = ipmi_sunoem_setval(intf, argc - 1, &(argv[1]));
} else if (strcmp(argv[0], "getfile") == 0) {
if (argc < 3) {
ipmi_sunoem_usage();
return (-1);
}
rc = ipmi_sunoem_getfile(intf, argc - 1, &(argv[1]));
} else if (strcmp(argv[0], "getbehavior") == 0) {
if (argc < 2) {
ipmi_sunoem_usage();
return (-1);
}
rc = ipmi_sunoem_getbehavior(intf, argc - 1, &(argv[1]));
} else {
lprintf(LOG_ERR, "Invalid sunoem command: %s", argv[0]);
return (-1);
} /* if (strcmp(argv[0], "cli") == 0) */
return (rc);
}