int
ipmi_cmd_dcmi_set_power_limit (ipmi_ctx_t ctx,
uint8_t exception_actions,
uint16_t power_limit_requested,
uint32_t correction_time_limit,
uint16_t management_application_statistics_sampling_period,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_dcmi_set_power_limit_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_dcmi_set_power_limit_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_dcmi_set_power_limit (exception_actions,
power_limit_requested,
correction_time_limit,
management_application_statistics_sampling_period,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_GROUP_EXTENSION_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
static config_err_t
_set_authentication_type_enables (bmc_config_state_data_t *state_data,
const char *section_name,
struct bmc_authentication_level *al)
{
fiid_obj_t obj_cmd_rs = NULL;
config_err_t rv = CONFIG_ERR_FATAL_ERROR;
config_err_t ret;
uint8_t channel_number;
assert (state_data);
assert (section_name);
assert (al);
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_set_lan_configuration_parameters_rs)))
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_create: %s\n",
strerror (errno));
goto cleanup;
}
if ((ret = get_lan_channel_number (state_data, section_name, &channel_number)) != CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (ipmi_cmd_set_lan_configuration_parameters_authentication_type_enables (state_data->ipmi_ctx,
channel_number,
al->callback_level_none,
al->callback_level_md2,
al->callback_level_md5,
al->callback_level_straight_password,
al->callback_level_oem_proprietary,
al->user_level_none,
al->user_level_md2,
al->user_level_md5,
al->user_level_straight_password,
al->user_level_oem_proprietary,
al->operator_level_none,
al->operator_level_md2,
al->operator_level_md5,
al->operator_level_straight_password,
al->operator_level_oem_proprietary,
al->admin_level_none,
al->admin_level_md2,
al->admin_level_md5,
al->admin_level_straight_password,
al->admin_level_oem_proprietary,
al->oem_level_none,
al->oem_level_md2,
al->oem_level_md5,
al->oem_level_straight_password,
al->oem_level_oem_proprietary,
obj_cmd_rs) < 0)
{
if (state_data->prog_data->args->config_args.common_args.debug)
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_set_lan_configuration_parameters_authentication_type_enables: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
/*
* IPMI Workaround
*
* Dell Poweredge R610
*
* Nodes come default w/ OEM authentication enables turned
* on, but you cannot configure them on. So this always
* leads to invalid data errors (0xCC) b/c we are
* configuring one field at a time. So we will "absorb" the
* OEM configuration of later fields and try again, hoping
* that the user has tried to "right" the badness already
* sitting on the motherboard.
*/
if (ipmi_ctx_errnum (state_data->ipmi_ctx) == IPMI_ERR_COMMAND_INVALID_OR_UNSUPPORTED
&& (ipmi_check_completion_code (obj_cmd_rs,
IPMI_COMP_CODE_INVALID_DATA_FIELD_IN_REQUEST) == 1))
{
struct config_section *section;
struct config_keyvalue *kv;
section = state_data->sections;
while (section)
{
if (!strcasecmp (section->section_name, "Lan_Conf_Auth"))
break;
section = section->next;
}
/* shouldn't be possible */
if (!section)
goto cleanup;
if ((kv = config_find_keyvalue (section,
"Callback_Enable_Auth_Type_OEM_Proprietary")))
al->callback_level_oem_proprietary = same (kv->value_input, "yes");
if ((kv = config_find_keyvalue (section,
"User_Enable_Auth_Type_OEM_Proprietary")))
al->user_level_oem_proprietary = same (kv->value_input, "yes");
if ((kv = config_find_keyvalue (section,
"Operator_Enable_Auth_Type_OEM_Proprietary")))
al->operator_level_oem_proprietary = same (kv->value_input, "yes");
if ((kv = config_find_keyvalue (section,
"Admin_Enable_Auth_Type_OEM_Proprietary")))
al->admin_level_oem_proprietary = same (kv->value_input, "yes");
if ((kv = config_find_keyvalue (section,
"OEM_Enable_Auth_Type_None")))
al->oem_level_none = same (kv->value_input, "yes");
if ((kv = config_find_keyvalue (section,
"OEM_Enable_Auth_Type_MD2")))
al->oem_level_md2 = same (kv->value_input, "yes");
if ((kv = config_find_keyvalue (section,
"OEM_Enable_Auth_Type_MD5")))
al->oem_level_md5 = same (kv->value_input, "yes");
if ((kv = config_find_keyvalue (section,
"OEM_Enable_Auth_Type_Straight_Password")))
al->oem_level_straight_password = same (kv->value_input, "yes");
if ((kv = config_find_keyvalue (section,
"OEM_Enable_Auth_Type_OEM_Proprietary")))
al->oem_level_oem_proprietary = same (kv->value_input, "yes");
if (ipmi_cmd_set_lan_configuration_parameters_authentication_type_enables (state_data->ipmi_ctx,
channel_number,
al->callback_level_none,
al->callback_level_md2,
al->callback_level_md5,
al->callback_level_straight_password,
al->callback_level_oem_proprietary,
al->user_level_none,
al->user_level_md2,
al->user_level_md5,
al->user_level_straight_password,
al->user_level_oem_proprietary,
al->operator_level_none,
al->operator_level_md2,
al->operator_level_md5,
al->operator_level_straight_password,
al->operator_level_oem_proprietary,
al->admin_level_none,
al->admin_level_md2,
al->admin_level_md5,
al->admin_level_straight_password,
al->admin_level_oem_proprietary,
al->oem_level_none,
al->oem_level_md2,
al->oem_level_md5,
al->oem_level_straight_password,
al->oem_level_oem_proprietary,
obj_cmd_rs) < 0)
{
if (state_data->prog_data->args->config_args.common_args.debug)
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_set_lan_configuration_parameters_authentication_type_enables: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
if (config_is_config_param_non_fatal_error (state_data->ipmi_ctx,
obj_cmd_rs,
&ret))
rv = ret;
goto cleanup;
}
/* success!! */
goto out;
}
else if (config_is_config_param_non_fatal_error (state_data->ipmi_ctx,
obj_cmd_rs,
&ret))
rv = ret;
goto cleanup;
}
out:
rv = CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
static int
_sdr_cache_get_record (ipmi_sdr_ctx_t ctx,
ipmi_ctx_t ipmi_ctx,
uint16_t record_id,
void *record_buf,
unsigned int record_buf_len,
uint16_t *reservation_id,
uint16_t *next_record_id)
{
fiid_obj_t obj_cmd_rs = NULL;
fiid_obj_t obj_sdr_record_header = NULL;
int sdr_record_header_length = 0;
int sdr_record_len = 0;
unsigned int record_length = 0;
int rv = -1;
unsigned int bytes_to_read = IPMI_SDR_CACHE_BYTES_TO_READ_START;
unsigned int offset_into_record = 0;
unsigned int reservation_id_retry_count = 0;
uint8_t temp_record_buf[IPMI_SDR_MAX_RECORD_LENGTH];
uint64_t val;
assert (ctx);
assert (ctx->magic == IPMI_SDR_CTX_MAGIC);
assert (ipmi_ctx);
assert (record_buf);
assert (record_buf_len);
assert (reservation_id);
assert (next_record_id);
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_sdr_rs)))
{
SDR_ERRNO_TO_SDR_ERRNUM (ctx, errno);
goto cleanup;
}
if (!(obj_sdr_record_header = fiid_obj_create (tmpl_sdr_record_header)))
{
SDR_ERRNO_TO_SDR_ERRNUM (ctx, errno);
goto cleanup;
}
if ((sdr_record_header_length = fiid_template_len_bytes (tmpl_sdr_record_header)) < 0)
{
SDR_ERRNO_TO_SDR_ERRNUM (ctx, errno);
goto cleanup;
}
/* achu:
*
* Many motherboards now allow you to read the full SDR record, try
* that first. If it fails for any reason, bail and try to read via
* partial reads.
*/
reservation_id_retry_count = 0;
while (!offset_into_record)
{
if (ipmi_cmd_get_sdr (ipmi_ctx,
*reservation_id,
record_id,
0,
IPMI_SDR_READ_ENTIRE_RECORD_BYTES_TO_READ,
obj_cmd_rs) < 0)
{
if (ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_BAD_COMPLETION_CODE)
{
uint8_t comp_code;
if (FIID_OBJ_GET (obj_cmd_rs,
"comp_code",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
comp_code = val;
if (comp_code == IPMI_COMP_CODE_RESERVATION_CANCELLED
&& (reservation_id_retry_count < IPMI_SDR_CACHE_MAX_RESERVATION_ID_RETRY))
{
if (_sdr_cache_reservation_id (ctx,
ipmi_ctx,
reservation_id) < 0)
goto cleanup;
reservation_id_retry_count++;
continue;
}
}
goto partial_read;
}
if ((sdr_record_len = fiid_obj_get_data (obj_cmd_rs,
"record_data",
temp_record_buf,
IPMI_SDR_MAX_RECORD_LENGTH)) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
/* Assume this is an "IPMI Error", fall through to partial reads */
if (sdr_record_len < sdr_record_header_length)
goto partial_read;
/*
* IPMI Workaround (achu)
*
* Discovered on Xyratex HB-F8-SRAY
*
* For some reason reading the entire SDR record (with
* IPMI_SDR_READ_ENTIRE_RECORD_BYTES_TO_READ) the response
* returns fewer bytes than the actual length of the record.
* However, when reading with partial reads things ultimately
* succeed. If we notice the length is off, we fall out and do
* a partial read.
*/
if ((((uint8_t)temp_record_buf[IPMI_SDR_RECORD_LENGTH_INDEX]) + IPMI_SDR_RECORD_HEADER_LENGTH) > sdr_record_len)
goto partial_read;
if (sdr_record_len > record_buf_len)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_INTERNAL_ERROR);
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs,
"next_record_id",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
*next_record_id = val;
memcpy (record_buf, temp_record_buf, sdr_record_len);
offset_into_record += sdr_record_len;
goto out;
}
partial_read:
reservation_id_retry_count = 0;
while (!record_length)
{
uint8_t record_header_buf[IPMI_SDR_MAX_RECORD_LENGTH];
int sdr_record_header_len;
if (ipmi_cmd_get_sdr (ipmi_ctx,
*reservation_id,
record_id,
0,
sdr_record_header_length,
obj_cmd_rs) < 0)
{
if (ipmi_ctx_errnum (ipmi_ctx) != IPMI_ERR_BAD_COMPLETION_CODE)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_IPMI_ERROR);
goto cleanup;
}
else
{
uint8_t comp_code;
if (FIID_OBJ_GET (obj_cmd_rs,
"comp_code",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
comp_code = val;
if (comp_code == IPMI_COMP_CODE_RESERVATION_CANCELLED
&& (reservation_id_retry_count < IPMI_SDR_CACHE_MAX_RESERVATION_ID_RETRY))
{
if (_sdr_cache_reservation_id (ctx,
ipmi_ctx,
reservation_id) < 0)
goto cleanup;
reservation_id_retry_count++;
continue;
}
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_IPMI_ERROR);
goto cleanup;
}
}
if ((sdr_record_header_len = fiid_obj_get_data (obj_cmd_rs,
"record_data",
record_header_buf,
IPMI_SDR_MAX_RECORD_LENGTH)) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
if (sdr_record_header_len < sdr_record_header_length)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_IPMI_ERROR);
goto cleanup;
}
if (fiid_obj_set_all (obj_sdr_record_header,
record_header_buf,
sdr_record_header_len) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_sdr_record_header);
goto cleanup;
}
if (FIID_OBJ_GET (obj_sdr_record_header,
"record_length",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_sdr_record_header);
goto cleanup;
}
if (sdr_record_header_len > record_buf_len)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_INTERNAL_ERROR);
goto cleanup;
}
/* copy header into buf */
memcpy (record_buf, record_header_buf, sdr_record_header_len);
offset_into_record += sdr_record_header_len;
record_length = val + sdr_record_header_length;
}
if (record_length > record_buf_len)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_INTERNAL_ERROR);
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs,
"next_record_id",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
*next_record_id = val;
reservation_id_retry_count = 0;
while (offset_into_record < record_length)
{
int record_data_len;
if ((record_length - offset_into_record) < bytes_to_read)
bytes_to_read = record_length - offset_into_record;
if (ipmi_cmd_get_sdr (ipmi_ctx,
*reservation_id,
record_id,
offset_into_record,
bytes_to_read,
obj_cmd_rs) < 0)
{
if (ipmi_ctx_errnum (ipmi_ctx) != IPMI_ERR_BAD_COMPLETION_CODE)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_IPMI_ERROR);
goto cleanup;
}
else
{
uint8_t comp_code;
if (FIID_OBJ_GET (obj_cmd_rs,
"comp_code",
&val) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
comp_code = val;
if (comp_code == IPMI_COMP_CODE_RESERVATION_CANCELLED
&& (reservation_id_retry_count < IPMI_SDR_CACHE_MAX_RESERVATION_ID_RETRY))
{
if (_sdr_cache_reservation_id (ctx,
ipmi_ctx,
reservation_id) < 0)
goto cleanup;
reservation_id_retry_count++;
continue;
}
else if ((comp_code == IPMI_COMP_CODE_CANNOT_RETURN_REQUESTED_NUMBER_OF_BYTES
|| comp_code == IPMI_COMP_CODE_UNSPECIFIED_ERROR)
&& bytes_to_read > sdr_record_header_length)
{
bytes_to_read -= IPMI_SDR_CACHE_BYTES_TO_READ_DECREMENT;
if (bytes_to_read < sdr_record_header_length)
bytes_to_read = sdr_record_header_length;
continue;
}
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_IPMI_ERROR);
goto cleanup;
}
}
if ((record_data_len = fiid_obj_get_data (obj_cmd_rs,
"record_data",
record_buf + offset_into_record,
record_buf_len - offset_into_record)) < 0)
{
SDR_FIID_OBJECT_ERROR_TO_SDR_ERRNUM (ctx, obj_cmd_rs);
goto cleanup;
}
offset_into_record += record_data_len;
}
out:
rv = offset_into_record;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
fiid_obj_destroy (obj_sdr_record_header);
return (rv);
}
static ipmi_config_err_t
_get_power_limit (ipmi_config_state_data_t *state_data,
struct get_power_limit_data *gpld,
int *no_set_power_limit_flag)
{
fiid_obj_t obj_cmd_rs = NULL;
uint64_t val;
int no_set_power_limit_error_flag = 0;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
assert (state_data);
assert (gpld);
if (no_set_power_limit_flag)
(*no_set_power_limit_flag) = 0;
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_dcmi_get_power_limit_rs)))
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_create: %s",
strerror (errno));
goto cleanup;
}
/* IPMI Workaround/Interpretation
*
* The DCMI spec indicates a potential completion code for the "Get
* Power Limit" command as "No Set Power Limit" (0x80). FreeIPMI
* originally interpreted this to mean the "Set Power Limit" command
* was not available. Atleast one vendor interpreted this to mean
* "No Power Limit Set". One can consider this an English
* interpretation issue of 'No set POWER LIMIT' vs. 'No SET POWER
* LIMIT' (i.e. is "set" a verb or part of a proper noun referencing
* the DCMI command). Confounding this issue is the fact that the
* example implementation in Intel's DCMItool implements the former,
* while the DCMI Conformance test suite implements the latter. In
* addition to this, with the latter interpretation, it need not be
* an indication of an error, but rather a flag. So the rest of the
* packet can be completely full of legitimate data.
*
* So how do we handle this?
*
* If we hit "No Set Power Limit", try to read data. If we can't
* read data (b/c it's not set), fail out, but preserve the "No Set
* Power Limit" error message.
*/
if (ipmi_cmd_dcmi_get_power_limit (state_data->ipmi_ctx,
obj_cmd_rs) < 0)
{
ipmi_config_err_t ret;
if (ipmi_ctx_errnum (state_data->ipmi_ctx) == IPMI_ERR_BAD_COMPLETION_CODE
&& ipmi_check_completion_code (obj_cmd_rs,
IPMI_COMP_CODE_DCMI_NO_SET_POWER_LIMIT) == 1)
{
if (state_data->prog_data->args->common_args.debug)
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_dcmi_get_power_limit: %s",
IPMI_COMP_CODE_DCMI_NO_SET_POWER_LIMIT_STR);
if (no_set_power_limit_flag)
(*no_set_power_limit_flag) = 1;
no_set_power_limit_error_flag++;
goto read_data;
}
if (ipmi_config_param_errnum_is_non_fatal (state_data,
obj_cmd_rs,
&ret))
rv = ret;
if (rv == IPMI_CONFIG_ERR_FATAL_ERROR
|| state_data->prog_data->args->common_args.debug)
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_get_pef_configuration_parameters_event_filter_table: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
read_data:
if (FIID_OBJ_GET (obj_cmd_rs,
"exception_actions",
&val) < 0)
{
if (!no_set_power_limit_error_flag
|| fiid_obj_errnum (obj_cmd_rs) != FIID_ERR_DATA_NOT_AVAILABLE)
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'exception_actions': %s",
fiid_obj_errormsg (obj_cmd_rs));
if (no_set_power_limit_error_flag)
rv = IPMI_CONFIG_ERR_NON_FATAL_ERROR;
goto cleanup;
}
gpld->exception_actions = val;
if (FIID_OBJ_GET (obj_cmd_rs,
"power_limit_requested",
&val) < 0)
{
if (!no_set_power_limit_error_flag
|| fiid_obj_errnum (obj_cmd_rs) != FIID_ERR_DATA_NOT_AVAILABLE)
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'power_limit_requested': %s",
fiid_obj_errormsg (obj_cmd_rs));
if (no_set_power_limit_error_flag)
rv = IPMI_CONFIG_ERR_NON_FATAL_ERROR;
goto cleanup;
}
gpld->power_limit_requested = val;
if (FIID_OBJ_GET (obj_cmd_rs,
"correction_time_limit",
&val) < 0)
{
if (!no_set_power_limit_error_flag
|| fiid_obj_errnum (obj_cmd_rs) != FIID_ERR_DATA_NOT_AVAILABLE)
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'correction_time_limit': %s",
fiid_obj_errormsg (obj_cmd_rs));
if (no_set_power_limit_error_flag)
rv = IPMI_CONFIG_ERR_NON_FATAL_ERROR;
goto cleanup;
}
gpld->correction_time_limit = val;
if (FIID_OBJ_GET (obj_cmd_rs,
"management_application_statistics_sampling_period",
&val) < 0)
{
if (!no_set_power_limit_error_flag
|| fiid_obj_errnum (obj_cmd_rs) != FIID_ERR_DATA_NOT_AVAILABLE)
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'management_application_statistics_sampling_period': %s",
fiid_obj_errormsg (obj_cmd_rs));
if (no_set_power_limit_error_flag)
rv = IPMI_CONFIG_ERR_NON_FATAL_ERROR;
goto cleanup;
}
gpld->management_application_statistics_sampling_period = val;
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
int
ipmi_cmd_set_acpi_power_state (ipmi_ctx_t ctx,
uint8_t system_power_state_enumeration,
uint8_t set_system_power_state,
uint8_t device_power_state_enumeration,
uint8_t set_device_power_state,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_set_acpi_power_state_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_set_acpi_power_state_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_set_acpi_power_state (system_power_state_enumeration,
set_system_power_state,
device_power_state_enumeration,
set_device_power_state,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_APP_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
int
ipmi_cmd_set_sol_configuration_parameters_sol_authentication (ipmi_ctx_t ctx,
uint8_t channel_number,
uint8_t sol_privilege_level,
uint8_t force_sol_payload_authentication,
uint8_t force_sol_payload_encryption,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_set_sol_configuration_parameters_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_set_sol_configuration_parameters_sol_authentication_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_set_sol_configuration_parameters_sol_authentication (channel_number,
sol_privilege_level,
force_sol_payload_authentication,
force_sol_payload_encryption,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_TRANSPORT_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
static int
_ipmi_cmd_get_sol_configuration_parameters_common (ipmi_ctx_t ctx,
uint8_t channel_number,
uint8_t get_parameter,
uint8_t set_selector,
uint8_t block_selector,
fiid_obj_t obj_cmd_rs,
fiid_field_t *tmpl_cmd_rs_expected,
uint8_t parameter_selector)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
assert (tmpl_cmd_rs_expected);
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs, tmpl_cmd_rs_expected) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_get_sol_configuration_parameters_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_get_sol_configuration_parameters (channel_number,
get_parameter,
parameter_selector,
set_selector,
block_selector,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_TRANSPORT_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
int
ipmi_cmd_set_system_boot_options_boot_initiator_mailbox (ipmi_ctx_t ctx,
uint8_t parameter_valid,
uint8_t set_selector,
const void *block_data,
unsigned int block_data_length,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_set_system_boot_options_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_set_system_boot_options_boot_initiator_mailbox_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_set_system_boot_options_boot_initiator_mailbox (parameter_valid,
set_selector,
block_data,
block_data_length,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_CHASSIS_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
static int
_ipmi_cmd_get_system_boot_options_common (ipmi_ctx_t ctx,
uint8_t set_selector,
uint8_t block_selector,
fiid_obj_t obj_cmd_rs,
fiid_field_t *tmpl_cmd_rs_expected,
uint8_t parameter_selector)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
assert (tmpl_cmd_rs_expected);
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs, tmpl_cmd_rs_expected) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_get_system_boot_options_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_get_system_boot_options (parameter_selector,
set_selector,
block_selector,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_CHASSIS_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
int
ipmi_cmd_dcmi_set_asset_tag (ipmi_ctx_t ctx,
uint8_t offset_to_write,
uint8_t number_of_bytes_to_write,
const void *data,
unsigned int data_len,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_dcmi_set_asset_tag_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_dcmi_set_asset_tag_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_dcmi_set_asset_tag (offset_to_write,
number_of_bytes_to_write,
data,
data_len,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_GROUP_EXTENSION_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
static int
_cmd (const char *str,
uint8_t netfn,
uint8_t cmd,
fiid_obj_t obj_cmd_rq,
fiid_obj_t obj_cmd_rs)
{
int retry_count = 0;
int ret = 0;
assert (str
&& (netfn == IPMI_NET_FN_APP_RQ || netfn == IPMI_NET_FN_TRANSPORT_RQ)
&& obj_cmd_rq
&& obj_cmd_rs);
last_ipmi_ctx_errnum = -1;
last_cmd = cmd;
last_netfn = netfn;
last_comp_code = 0;
while (1)
{
if ((ret = ipmi_cmd (ipmi_ctx,
IPMI_BMC_IPMB_LUN_BMC,
netfn,
obj_cmd_rq,
obj_cmd_rs)) < 0)
{
last_ipmi_ctx_errnum = ipmi_ctx_errnum (ipmi_ctx);
if (ipmi_ctx_errnum (ipmi_ctx) != IPMI_ERR_DRIVER_BUSY
&& ipmi_ctx_errnum (ipmi_ctx) != IPMI_ERR_BMC_BUSY
&& ipmi_ctx_errnum (ipmi_ctx) != IPMI_ERR_IPMI_ERROR)
{
if (cmd_args.verbose_logging)
err_output ("%s: ipmi_cmd: %s", str, ipmi_ctx_errormsg (ipmi_ctx));
if (ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_BAD_COMPLETION_CODE)
{
if (ipmi_completion_code_strerror_cmd_r (obj_cmd_rs,
netfn,
comp_code_errbuf,
BMC_WATCHDOG_ERR_BUFLEN) < 0)
{
uint64_t val;
_fiid_obj_get (obj_cmd_rs, "comp_code", &val);
last_comp_code = val;
snprintf (comp_code_errbuf,
BMC_WATCHDOG_ERR_BUFLEN,
"Comp Code 0x%X",
last_comp_code);
}
}
return (-1);
}
}
if (ret < 0)
{
if (retry_count >= retry_attempts)
{
err_output ("%s: BMC Timeout: %s", str, ipmi_ctx_errormsg (ipmi_ctx));
return (-1);
}
daemon_sleep (retry_wait_time);
retry_count++;
}
else
break;
}
return (0);
}
int
ipmi_cmd_dcmi_set_dcmi_configuration_parameters_discovery_configuration (ipmi_ctx_t ctx,
uint8_t set_selector,
uint8_t option_12,
uint8_t option_60_with_option_43,
uint8_t random_back_off,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* technically, user can input anything for activate, but only 0x01 will do anything */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_dcmi_set_dcmi_configuration_parameters_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_dcmi_set_dcmi_configuration_parameters_discovery_configuration_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_dcmi_set_dcmi_configuration_parameters_discovery_configuration (set_selector,
option_12,
option_60_with_option_43,
random_back_off,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_GROUP_EXTENSION_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
int
ipmi_cmd_dcmi_get_temperature_reading (ipmi_ctx_t ctx,
uint8_t sensor_type,
uint8_t entity_id,
uint8_t entity_instance,
uint8_t entity_instance_start,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_dcmi_get_temperature_reading_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_dcmi_get_temperature_reading_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_dcmi_get_temperature_reading (sensor_type,
entity_id,
entity_instance,
entity_instance_start,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_GROUP_EXTENSION_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
int
ipmi_cmd_dcmi_set_thermal_limit (ipmi_ctx_t ctx,
uint8_t entity_id,
uint8_t entity_instance,
uint8_t temperature_limit,
uint8_t exception_actions_log_event_to_sel_only,
uint8_t exception_actions_hard_power_off_system_and_log_event,
uint16_t exception_time,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_dcmi_set_thermal_limit_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_dcmi_set_thermal_limit_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_dcmi_set_thermal_limit (entity_id,
entity_instance,
temperature_limit,
exception_actions_log_event_to_sel_only,
exception_actions_hard_power_off_system_and_log_event,
exception_time,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_GROUP_EXTENSION_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
static int ipmi_free_open(struct ipmi_intf * intf)
{
int kcs_ret = -1, ssif_ret = -1;
if (getuid() != 0) {
fprintf(stderr, "Permission denied, must be root\n");
return -1;
}
#if IPMI_INTF_FREE_0_3_0
if (!(dev = ipmi_open_inband (IPMI_DEVICE_KCS,
0,
0,
0,
NULL,
IPMI_FLAGS_DEFAULT))) {
if (!(dev = ipmi_open_inband (IPMI_DEVICE_SSIF,
0,
0,
0,
NULL,
IPMI_FLAGS_DEFAULT))) {
perror("ipmi_open_inband()");
goto cleanup;
}
}
#elif IPMI_INTF_FREE_0_4_0
if (!(dev = ipmi_device_create())) {
perror("ipmi_device_create");
goto cleanup;
}
if (ipmi_open_inband (dev,
IPMI_DEVICE_KCS,
0,
0,
0,
NULL,
IPMI_FLAGS_DEFAULT) < 0) {
if (ipmi_open_inband (dev,
IPMI_DEVICE_SSIF,
0,
0,
0,
NULL,
IPMI_FLAGS_DEFAULT) < 0) {
fprintf(stderr,
"ipmi_open_inband(): %s\n",
ipmi_device_strerror(ipmi_device_errnum(dev)));
goto cleanup;
}
}
#elif IPMI_INTF_FREE_0_5_0
if (!(dev = ipmi_device_create())) {
perror("ipmi_device_create");
goto cleanup;
}
if (ipmi_open_inband (dev,
IPMI_DEVICE_KCS,
0,
0,
0,
NULL,
0,
IPMI_FLAGS_DEFAULT) < 0) {
if (ipmi_open_inband (dev,
IPMI_DEVICE_SSIF,
0,
0,
0,
NULL,
0,
IPMI_FLAGS_DEFAULT) < 0) {
fprintf(stderr,
"ipmi_open_inband(): %s\n",
ipmi_device_strerror(ipmi_device_errnum(dev)));
goto cleanup;
}
}
#elif IPMI_INTF_FREE_0_6_0
if (!(dev = ipmi_ctx_create())) {
perror("ipmi_ctx_create");
goto cleanup;
}
if (ipmi_ctx_open_inband (dev,
IPMI_DEVICE_KCS,
0,
0,
0,
NULL,
0,
IPMI_FLAGS_DEFAULT) < 0) {
if (ipmi_ctx_open_inband (dev,
IPMI_DEVICE_SSIF,
0,
0,
0,
NULL,
0,
IPMI_FLAGS_DEFAULT) < 0) {
fprintf(stderr,
"ipmi_open_inband(): %s\n",
ipmi_ctx_strerror(ipmi_ctx_errnum(dev)));
goto cleanup;
}
}
#endif
intf->opened = 1;
intf->manufacturer_id = ipmi_get_oem(intf);
return 0;
cleanup:
if (dev) {
#if IPMI_INTF_FREE_0_3_0
ipmi_close_device(dev);
#elif IPMI_INTF_FREE_0_4_0 || IPMI_INTF_FREE_0_5_0
ipmi_close_device(dev);
ipmi_device_destroy(dev);
#elif IPMI_INTF_FREE_0_6_0
ipmi_ctx_close(dev);
ipmi_ctx_destroy(dev);
#endif
}
return -1;
}
int
ipmi_cmd_set_front_panel_enables (ipmi_ctx_t ctx,
uint8_t disable_power_off_button_for_power_off_only,
uint8_t disable_reset_button,
uint8_t disable_diagnostic_interrupt_button,
uint8_t disable_standby_button_for_entering_standby,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_set_front_panel_enables_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_set_front_panel_enables_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_set_front_panel_enables (disable_power_off_button_for_power_off_only,
disable_reset_button,
disable_diagnostic_interrupt_button,
disable_standby_button_for_entering_standby,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_CHASSIS_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
int
ipmi_sensors_get_thresholds (ipmi_sensors_state_data_t *state_data,
uint8_t *sdr_record,
unsigned int sdr_record_len,
double **lower_non_critical_threshold,
double **lower_critical_threshold,
double **lower_non_recoverable_threshold,
double **upper_non_critical_threshold,
double **upper_critical_threshold,
double **upper_non_recoverable_threshold)
{
int8_t r_exponent, b_exponent;
int16_t m, b;
uint8_t linearization, analog_data_format;
uint8_t sensor_number;
fiid_obj_t obj_cmd_rs = NULL;
double *tmp_lower_non_critical_threshold = NULL;
double *tmp_lower_critical_threshold = NULL;
double *tmp_lower_non_recoverable_threshold = NULL;
double *tmp_upper_non_critical_threshold = NULL;
double *tmp_upper_critical_threshold = NULL;
double *tmp_upper_non_recoverable_threshold = NULL;
double threshold;
uint8_t threshold_access_support;
uint64_t val;
int rv = -1;
assert(state_data);
assert(sdr_record);
assert(sdr_record_len);
if (lower_non_critical_threshold)
*lower_non_critical_threshold = NULL;
if (lower_critical_threshold)
*lower_critical_threshold = NULL;
if (lower_non_recoverable_threshold)
*lower_non_recoverable_threshold = NULL;
if (upper_non_critical_threshold)
*upper_non_critical_threshold = NULL;
if (upper_critical_threshold)
*upper_critical_threshold = NULL;
if (upper_non_recoverable_threshold)
*upper_non_recoverable_threshold = NULL;
/* achu: first lets check if we have anything to output */
if (sdr_cache_get_sensor_capabilities (state_data->pstate,
sdr_record,
sdr_record_len,
NULL,
&threshold_access_support,
NULL,
NULL,
NULL) < 0)
goto cleanup;
if (threshold_access_support == IPMI_SDR_NO_THRESHOLDS_SUPPORT
|| threshold_access_support == IPMI_SDR_FIXED_UNREADABLE_THRESHOLDS_SUPPORT)
{
rv = 0;
goto cleanup;
}
/* achu:
*
* I will admit I'm not entirely sure what the best way is
* to get thresholds. It seems the information is
* stored/retrievable in the SDR and through an IPMI command.
*
* Since the readable_threshold_mask in the SDR record indicates the
* mask is for the "Get Sensor Thresholds" command, it suggests the
* best/right way is to get the values via that command. Sounds
* good to me. Also, I suppose its possible that changes to the
* thresholds may not be written to the SDR.
*
* Also, because the results from the get_sensor_thresholds include
* readability flags, we can ignore the readability flags in the
* SDR.
*
*/
if (sdr_cache_get_sensor_number (state_data->pstate,
sdr_record,
sdr_record_len,
&sensor_number) < 0)
goto cleanup;
if (sdr_cache_get_sensor_decoding_data(state_data->pstate,
sdr_record,
sdr_record_len,
&r_exponent,
&b_exponent,
&m,
&b,
&linearization,
&analog_data_format) < 0)
goto cleanup;
/* if the sensor is not analog, this is most likely a bug in the
* SDR, since we shouldn't be decoding a non-threshold sensor.
*
* Don't return an error. Allow code to output "NA" or something.
*/
if (!IPMI_SDR_ANALOG_DATA_FORMAT_VALID(analog_data_format))
{
if (state_data->prog_data->args->common.debug)
pstdout_fprintf(state_data->pstate,
stderr,
"Attempting to decode non-analog sensor\n");
rv = 0;
goto cleanup;
}
/* if the sensor is non-linear, I just don't know what to do
*
* Don't return an error. Allow code to output "NA" or something.
*/
if (!IPMI_SDR_LINEARIZATION_IS_LINEAR(linearization))
{
if (state_data->prog_data->args->common.debug)
pstdout_fprintf(state_data->pstate,
stderr,
"Cannot decode non-linear sensor\n");
rv = 0;
goto cleanup;
}
_FIID_OBJ_CREATE(obj_cmd_rs, tmpl_cmd_get_sensor_thresholds_rs);
if (ipmi_cmd_get_sensor_thresholds (state_data->ipmi_ctx,
sensor_number,
obj_cmd_rs) < 0)
{
if (state_data->prog_data->args->common.debug)
pstdout_fprintf(state_data->pstate,
stderr,
"ipmi_cmd_get_sensor_thresholds: %s\n",
ipmi_ctx_strerror(ipmi_ctx_errnum(state_data->ipmi_ctx)));
if ((ipmi_ctx_errnum(state_data->ipmi_ctx) == IPMI_ERR_BAD_COMPLETION_CODE_REQUEST_DATA_INVALID)
&& (ipmi_check_completion_code(obj_cmd_rs,
IPMI_COMP_CODE_COMMAND_ILLEGAL_FOR_SENSOR_OR_RECORD_TYPE) == 1
|| ipmi_check_completion_code(obj_cmd_rs,
IPMI_COMP_CODE_REQUEST_SENSOR_DATA_OR_RECORD_NOT_PRESENT) == 1))
{
/* The thresholds cannot be gathered for one reason or
* another, maybe b/c its a OEM sensor or something. We can
* return 0 gracefully.
*/
rv = 0;
goto cleanup;
}
/*
* IPMI Workaround (achu)
*
* Discovered on HP DL585
*
* Seems that the HP machine doesn't support the "Get Sensor
* Thresholds" command. When this occurs, we assume the
* information in the SDR is legit and up to date. Go get it
* and fill in the object respectively.
*/
if ((ipmi_ctx_errnum(state_data->ipmi_ctx) == IPMI_ERR_BAD_COMPLETION_CODE_INVALID_COMMAND)
&& (ipmi_check_completion_code(obj_cmd_rs, IPMI_COMP_CODE_COMMAND_INVALID) == 1))
{
if (state_data->prog_data->args->common.debug)
pstdout_fprintf(state_data->pstate,
stderr,
"Get Sensor Thresholds failed, using SDR information\n");
if (_get_sdr_sensor_thresholds (state_data,
sdr_record,
sdr_record_len,
obj_cmd_rs) < 0)
goto cleanup;
goto continue_get_sensor_thresholds;
}
goto cleanup;
}
continue_get_sensor_thresholds:
if (lower_non_critical_threshold)
{
_FIID_OBJ_GET (obj_cmd_rs,
"readable_thresholds.lower_non_critical_threshold",
&val);
if (val)
{
_FIID_OBJ_GET(obj_cmd_rs,
"lower_non_critical_threshold",
&val);
if (ipmi_sensor_decode_value (r_exponent,
b_exponent,
m,
b,
linearization,
analog_data_format,
val,
&threshold) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sensor_decode_value: %s\n",
strerror(errno));
goto cleanup;
}
if (!(tmp_lower_non_critical_threshold = (double *)malloc(sizeof(double))))
{
pstdout_perror(state_data->pstate, "malloc");
goto cleanup;
}
*tmp_lower_non_critical_threshold = threshold;
}
}
if (lower_critical_threshold)
{
_FIID_OBJ_GET (obj_cmd_rs,
"readable_thresholds.lower_critical_threshold",
&val);
if (val)
{
_FIID_OBJ_GET(obj_cmd_rs,
"lower_critical_threshold",
&val);
if (ipmi_sensor_decode_value (r_exponent,
b_exponent,
m,
b,
linearization,
analog_data_format,
val,
&threshold) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sensor_decode_value: %s\n",
strerror(errno));
goto cleanup;
}
if (!(tmp_lower_critical_threshold = (double *)malloc(sizeof(double))))
{
pstdout_perror(state_data->pstate, "malloc");
goto cleanup;
}
*tmp_lower_critical_threshold = threshold;
}
}
if (lower_non_recoverable_threshold)
{
_FIID_OBJ_GET (obj_cmd_rs,
"readable_thresholds.lower_non_recoverable_threshold",
&val);
if (val)
{
_FIID_OBJ_GET(obj_cmd_rs,
"lower_non_recoverable_threshold",
&val);
if (ipmi_sensor_decode_value (r_exponent,
b_exponent,
m,
b,
linearization,
analog_data_format,
val,
&threshold) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sensor_decode_value: %s\n",
strerror(errno));
goto cleanup;
}
if (!(tmp_lower_non_recoverable_threshold = (double *)malloc(sizeof(double))))
{
pstdout_perror(state_data->pstate, "malloc");
goto cleanup;
}
*tmp_lower_non_recoverable_threshold = threshold;
}
}
if (upper_non_critical_threshold)
{
_FIID_OBJ_GET (obj_cmd_rs,
"readable_thresholds.upper_non_critical_threshold",
&val);
if (val)
{
_FIID_OBJ_GET(obj_cmd_rs,
"upper_non_critical_threshold",
&val);
if (ipmi_sensor_decode_value (r_exponent,
b_exponent,
m,
b,
linearization,
analog_data_format,
val,
&threshold) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sensor_decode_value: %s\n",
strerror(errno));
goto cleanup;
}
if (!(tmp_upper_non_critical_threshold = (double *)malloc(sizeof(double))))
{
pstdout_perror(state_data->pstate, "malloc");
goto cleanup;
}
*tmp_upper_non_critical_threshold = threshold;
}
}
if (upper_critical_threshold)
{
_FIID_OBJ_GET (obj_cmd_rs,
"readable_thresholds.upper_critical_threshold",
&val);
if (val)
{
_FIID_OBJ_GET(obj_cmd_rs,
"upper_critical_threshold",
&val);
if (ipmi_sensor_decode_value (r_exponent,
b_exponent,
m,
b,
linearization,
analog_data_format,
val,
&threshold) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sensor_decode_value: %s\n",
strerror(errno));
goto cleanup;
}
if (!(tmp_upper_critical_threshold = (double *)malloc(sizeof(double))))
{
pstdout_perror(state_data->pstate, "malloc");
goto cleanup;
}
*tmp_upper_critical_threshold = threshold;
}
}
if (upper_non_recoverable_threshold)
{
_FIID_OBJ_GET (obj_cmd_rs,
"readable_thresholds.upper_non_recoverable_threshold",
&val);
if (val)
{
_FIID_OBJ_GET(obj_cmd_rs,
"upper_non_recoverable_threshold",
&val);
if (ipmi_sensor_decode_value (r_exponent,
b_exponent,
m,
b,
linearization,
analog_data_format,
val,
&threshold) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sensor_decode_value: %s\n",
strerror(errno));
goto cleanup;
}
if (!(tmp_upper_non_recoverable_threshold = (double *)malloc(sizeof(double))))
{
pstdout_perror(state_data->pstate, "malloc");
goto cleanup;
}
*tmp_upper_non_recoverable_threshold = threshold;
}
}
if (lower_non_critical_threshold)
*lower_non_critical_threshold = tmp_lower_non_critical_threshold;
if (lower_critical_threshold)
*lower_critical_threshold = tmp_lower_critical_threshold;
if (lower_non_recoverable_threshold)
*lower_non_recoverable_threshold = tmp_lower_non_recoverable_threshold;
if (upper_non_critical_threshold)
*upper_non_critical_threshold = tmp_upper_non_critical_threshold;
if (upper_critical_threshold)
*upper_critical_threshold = tmp_upper_critical_threshold;
if (upper_non_recoverable_threshold)
*upper_non_recoverable_threshold = tmp_upper_non_recoverable_threshold;
rv = 0;
cleanup:
_FIID_OBJ_DESTROY(obj_cmd_rs);
if (rv < 0)
{
if (tmp_lower_non_critical_threshold)
free(tmp_lower_non_critical_threshold);
if (tmp_lower_critical_threshold)
free(tmp_lower_critical_threshold);
if (tmp_lower_non_recoverable_threshold)
free(tmp_lower_non_recoverable_threshold);
if (tmp_upper_non_critical_threshold)
free(tmp_upper_non_critical_threshold);
if (tmp_upper_critical_threshold)
free(tmp_upper_critical_threshold);
if (tmp_upper_non_recoverable_threshold)
free(tmp_upper_non_recoverable_threshold);
}
return rv;
}
int
ipmi_cmd_set_system_boot_options_BMC_boot_flag_valid_bit_clearing (ipmi_ctx_t ctx,
uint8_t parameter_valid,
uint8_t dont_clear_on_power_up,
uint8_t dont_clear_on_pushbutton_rest_soft_reset,
uint8_t dont_clear_on_watchdog_timeout,
uint8_t dont_clear_on_chassis_control,
uint8_t dont_clear_on_PEF,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_set_system_boot_options_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_set_system_boot_options_BMC_boot_flag_valid_bit_clearing_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_set_system_boot_options_BMC_boot_flag_valid_bit_clearing (parameter_valid,
dont_clear_on_power_up,
dont_clear_on_pushbutton_rest_soft_reset,
dont_clear_on_watchdog_timeout,
dont_clear_on_chassis_control,
dont_clear_on_PEF,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_CHASSIS_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
int
ipmi_cmd_set_sol_configuration_parameters (ipmi_ctx_t ctx,
uint8_t channel_number,
uint8_t parameter_selector,
const void *configuration_parameter_data,
unsigned int configuration_parameter_data_len,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_set_sol_configuration_parameters_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_set_sol_configuration_parameters_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_set_sol_configuration_parameters (channel_number,
parameter_selector,
configuration_parameter_data,
configuration_parameter_data_len,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_TRANSPORT_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
int
ipmi_cmd_set_system_boot_options_boot_info_acknowledge (ipmi_ctx_t ctx,
uint8_t parameter_valid,
const uint8_t *bios_or_post_handled_boot_info,
const uint8_t *os_loader_handled_boot_info,
const uint8_t *os_or_service_partition_handled_boot_info,
const uint8_t *sms_handled_boot_info,
const uint8_t *oem_handled_boot_info,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_set_system_boot_options_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_set_system_boot_options_boot_info_acknowledge_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_set_system_boot_options_boot_info_acknowledge (parameter_valid,
bios_or_post_handled_boot_info,
os_loader_handled_boot_info,
os_or_service_partition_handled_boot_info,
sms_handled_boot_info,
oem_handled_boot_info,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_CHASSIS_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
static config_err_t
_get_key(bmc_config_state_data_t *state_data,
uint8_t key_type,
uint8_t *key,
uint32_t key_len)
{
fiid_obj_t obj_cmd_rs = NULL;
uint8_t buf[CONFIG_PARSE_BUFLEN];
int32_t buf_len;
config_err_t rv = CONFIG_ERR_FATAL_ERROR;
config_err_t ret;
uint8_t channel_number;
assert(key_type == IPMI_CHANNEL_SECURITY_KEYS_KEY_ID_K_R
|| key_type == IPMI_CHANNEL_SECURITY_KEYS_KEY_ID_K_G);
_FIID_OBJ_CREATE(obj_cmd_rs, tmpl_cmd_set_channel_security_keys_rs);
if ((ret = get_lan_channel_number (state_data, &channel_number)) != CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (ipmi_cmd_set_channel_security_keys (state_data->ipmi_ctx,
channel_number,
IPMI_CHANNEL_SECURITY_KEYS_OPERATION_READ_KEY,
key_type,
NULL,
0,
obj_cmd_rs) < 0)
{
if (state_data->prog_data->args->config_args.common.debug)
pstdout_fprintf(state_data->pstate,
stderr,
"ipmi_cmd_set_channel_security_keys: %s\n",
ipmi_ctx_strerror(ipmi_ctx_errnum(state_data->ipmi_ctx)));
if (!IPMI_CTX_ERRNUM_IS_FATAL_ERROR(state_data->ipmi_ctx))
rv = CONFIG_ERR_NON_FATAL_ERROR;
goto cleanup;
}
_FIID_OBJ_GET_DATA_LEN (buf_len,
obj_cmd_rs,
"key_value",
buf,
CONFIG_PARSE_BUFLEN);
if (key_len < buf_len)
{
pstdout_fprintf(state_data->pstate,
stderr,
"ipmi_cmd_set_channel_security_keys: short buffer\n");
goto cleanup;
}
memcpy(key, buf, buf_len);
rv = CONFIG_ERR_SUCCESS;
cleanup:
_FIID_OBJ_DESTROY(obj_cmd_rs);
return (rv);
}
int
ipmi_cmd_set_system_boot_options_boot_flags (ipmi_ctx_t ctx,
uint8_t parameter_valid,
uint8_t bios_boot_type,
uint8_t boot_flags_persistent,
uint8_t boot_flags_valid,
uint8_t lock_out_reset_button,
uint8_t screen_blank,
uint8_t boot_device,
uint8_t lock_keyboard,
uint8_t cmos_clear,
uint8_t console_redirection,
uint8_t lock_out_sleep_button,
uint8_t user_password_bypass,
uint8_t force_progress_event_traps,
uint8_t firmware_bios_verbosity,
uint8_t lock_out_via_power_button,
uint8_t bios_mux_control_override,
uint8_t bios_shared_mode_override,
uint8_t device_instance_selector,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_set_system_boot_options_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_set_system_boot_options_boot_flags_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_set_system_boot_options_boot_flags (parameter_valid,
bios_boot_type,
boot_flags_persistent,
boot_flags_valid,
lock_out_reset_button,
screen_blank,
boot_device,
lock_keyboard,
cmos_clear,
console_redirection,
lock_out_sleep_button,
user_password_bypass,
force_progress_event_traps,
firmware_bios_verbosity,
lock_out_via_power_button,
bios_mux_control_override,
bios_shared_mode_override,
device_instance_selector,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_CHASSIS_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
static ipmi_config_err_t
_set_power_limit (ipmi_config_state_data_t *state_data,
const char *section_name,
struct get_power_limit_data *gpld,
int no_set_power_limit_flag)
{
fiid_obj_t obj_cmd_rs = NULL;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
assert (state_data);
assert (section_name);
assert (gpld);
/* IPMI Workaround/Interpretation
*
* The DCMI spec indicates a potential completion code for the
* "Get Power Limit" command as "No Set Power Limit" (0x80).
* FreeIPMI originally interpreted this to mean the "Set Power
* Limit" command was not available. Atleast one vendor
* interpreted this to mean "No Power Limit Set". One can
* consider this an English interpretation issue of 'No set
* POWER LIMIT' vs. 'No SET POWER LIMIT' (i.e. is "set" a verb
* or part of a proper noun referencing the DCMI command).
* Confounding this issue is the fact that the example
* implementation in Intel's DCMItool implements the former,
* while the DCMI Conformance test suite implements the latter.
* In addition to this, with the latter interpretation, it need
* not be an indication of an error, but rather a flag. So the
* rest of the packet can be completely full of legitimate data.
*
* So we will do the following.
*
* If the "No Set Power Limit" completion code is returned and
* we were able to read all of the fields, _get_power_limit() will
* return normally, so we don't need to worry about this case.
*
* If the "No Set Power Limit", completion code is returned and
* we were *not* able to read all of the fields, we won't have
* values from "Get Power Limit" and won't know how to do the
* configuration properly in "Set Power Limit". So we will
* require that the user input all fields for "Set Power Limit".
*/
if (no_set_power_limit_flag)
{
struct ipmi_config_section *section;
struct ipmi_config_keyvalue *kv;
section = state_data->sections;
while (section)
{
if (!strcasecmp (section_name, section->section_name))
break;
section = section->next;
}
/* shouldn't be possible */
if (!section)
goto cleanup;
if ((kv = ipmi_config_find_keyvalue (section, "Policy_Type")))
gpld->power_limit_requested = atoi (kv->value_input);
if ((kv = ipmi_config_find_keyvalue (section, "Policy_Enabled")))
gpld->correction_time_limit = strtoul (kv->value_input, NULL, 0);
if ((kv = ipmi_config_find_keyvalue (section, "Management_Application_Statistics_Sampling_Period")))
gpld->management_application_statistics_sampling_period = atoi (kv->value_input);
if ((kv = ipmi_config_find_keyvalue (section, "Exception_Actions")))
{
int num = exception_actions_number (kv->value_input);
if (num < 0)
/* previously checked for correctness, so no error check */
gpld->exception_actions = strtol (kv->value_input, NULL, 0);
else
gpld->exception_actions = num;
}
}
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_dcmi_set_power_limit_rs)))
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_create: %s\n",
strerror (errno));
goto cleanup;
}
if (ipmi_cmd_dcmi_set_power_limit (state_data->ipmi_ctx,
gpld->exception_actions,
gpld->power_limit_requested,
gpld->correction_time_limit,
gpld->management_application_statistics_sampling_period,
obj_cmd_rs) < 0)
{
ipmi_config_err_t ret;
if ((ipmi_check_completion_code (obj_cmd_rs,
IPMI_COMP_CODE_DCMI_POWER_LIMIT_OUT_OF_RANGE) == 1)
|| (ipmi_check_completion_code (obj_cmd_rs,
IPMI_COMP_CODE_DCMI_CORRECTION_TIME_OUT_OF_RANGE) == 1)
|| (ipmi_check_completion_code (obj_cmd_rs,
IPMI_COMP_CODE_DCMI_STATISTICS_REPORTING_PERIOD_OUT_OF_RANGE) == 1))
rv = IPMI_CONFIG_ERR_NON_FATAL_ERROR;
else
{
if (ipmi_config_param_errnum_is_non_fatal (state_data,
obj_cmd_rs,
&ret))
rv = ret;
}
if (rv == IPMI_CONFIG_ERR_FATAL_ERROR
|| state_data->prog_data->args->common_args.debug)
{
if (ipmi_ctx_errnum (state_data->ipmi_ctx) == IPMI_ERR_BAD_COMPLETION_CODE
&& ipmi_check_completion_code (obj_cmd_rs,
IPMI_COMP_CODE_DCMI_POWER_LIMIT_OUT_OF_RANGE) == 1)
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_dcmi_set_power_limit: %s\n",
IPMI_COMP_CODE_DCMI_POWER_LIMIT_OUT_OF_RANGE_STR);
else if (ipmi_ctx_errnum (state_data->ipmi_ctx) == IPMI_ERR_BAD_COMPLETION_CODE
&& ipmi_check_completion_code (obj_cmd_rs,
IPMI_COMP_CODE_DCMI_CORRECTION_TIME_OUT_OF_RANGE) == 1)
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_dcmi_set_power_limit: %s\n",
IPMI_COMP_CODE_DCMI_CORRECTION_TIME_OUT_OF_RANGE_STR);
else if (ipmi_ctx_errnum (state_data->ipmi_ctx) == IPMI_ERR_BAD_COMPLETION_CODE
&& ipmi_check_completion_code (obj_cmd_rs,
IPMI_COMP_CODE_DCMI_STATISTICS_REPORTING_PERIOD_OUT_OF_RANGE) == 1)
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_dcmi_set_power_limit: %s\n",
IPMI_COMP_CODE_DCMI_STATISTICS_REPORTING_PERIOD_OUT_OF_RANGE_STR);
else
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_dcmi_set_power_limit: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
}
goto cleanup;
}
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
int
ipmi_cmd_set_system_boot_options_boot_initiator_info (ipmi_ctx_t ctx,
uint8_t parameter_valid,
uint8_t boot_source_channel_number,
uint32_t session_id,
uint32_t boot_info_timestamp,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_set_system_boot_options_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_set_system_boot_options_boot_initiator_info_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_set_system_boot_options_boot_initiator_info (parameter_valid,
boot_source_channel_number,
session_id,
boot_info_timestamp,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_CHASSIS_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
int
ipmi_cmd_set_user_payload_access (ipmi_ctx_t ctx,
uint8_t channel_number,
uint8_t user_id,
uint8_t operation,
uint8_t standard_payload_1,
uint8_t standard_payload_2,
uint8_t standard_payload_3,
uint8_t standard_payload_4,
uint8_t standard_payload_5,
uint8_t standard_payload_6,
uint8_t standard_payload_7,
uint8_t oem_payload_0,
uint8_t oem_payload_1,
uint8_t oem_payload_2,
uint8_t oem_payload_3,
uint8_t oem_payload_4,
uint8_t oem_payload_5,
uint8_t oem_payload_6,
uint8_t oem_payload_7,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_set_user_payload_access_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_set_user_payload_access_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_set_user_payload_access (channel_number,
user_id,
operation,
standard_payload_1,
standard_payload_2,
standard_payload_3,
standard_payload_4,
standard_payload_5,
standard_payload_6,
standard_payload_7,
oem_payload_0,
oem_payload_1,
oem_payload_2,
oem_payload_3,
oem_payload_4,
oem_payload_5,
oem_payload_6,
oem_payload_7,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_APP_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
static config_err_t
threshold_checkout (const char *section_name,
struct config_keyvalue *kv,
void *arg)
{
ipmi_sensors_config_state_data_t *state_data;
fiid_obj_t obj_cmd_rs = NULL;
config_err_t rv = CONFIG_ERR_FATAL_ERROR;
config_err_t ret;
char *readable_str;
char *threshold_str;
uint8_t readable;
uint8_t threshold_raw;
uint64_t val;
double threshold_calc;
uint8_t sensor_number;
assert (section_name);
assert (kv);
assert (arg);
state_data = (ipmi_sensors_config_state_data_t *)arg;
if ((ret = seek_to_sdr_record (state_data,
section_name)) != CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (ipmi_sdr_parse_sensor_number (state_data->sdr_ctx,
NULL,
0,
&sensor_number) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_sensor_number: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
goto cleanup;
}
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_sensor_thresholds_rs)))
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_create: %s\n",
strerror (errno));
goto cleanup;
}
if (ipmi_cmd_get_sensor_thresholds (state_data->ipmi_ctx,
sensor_number,
obj_cmd_rs) < 0)
{
if (state_data->prog_data->args->config_args.common_args.debug)
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_get_sensor_thresholds: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
if (config_is_non_fatal_error (state_data->ipmi_ctx,
obj_cmd_rs,
&ret))
rv = ret;
/*
* IPMI Workaround (achu)
*
* Discovered on HP DL585
*
* Seems that the HP machine doesn't support the "Get Sensor
* Thresholds" command. 99% of the time if a command is invalid
* on a remote machine, that's a fatal error and we should exit.
* I suppose this is an exception though. We can continue on
* even if this command isn't supported. The user just doesn't
* get to configure these thresholds.
*/
if (ipmi_ctx_errnum (state_data->ipmi_ctx) == IPMI_ERR_BAD_COMPLETION_CODE
&& ipmi_check_completion_code (obj_cmd_rs, IPMI_COMP_CODE_INVALID_COMMAND) == 1)
rv = CONFIG_ERR_NON_FATAL_ERROR;
goto cleanup;
}
if (!strcasecmp (kv->key->key_name, "Lower_Non_Critical_Threshold"))
{
readable_str = "readable_thresholds.lower_non_critical_threshold";
threshold_str = "lower_non_critical_threshold";
}
else if (!strcasecmp (kv->key->key_name, "Lower_Critical_Threshold"))
{
readable_str = "readable_thresholds.lower_critical_threshold";
threshold_str = "lower_critical_threshold";
}
else if (!strcasecmp (kv->key->key_name, "Lower_Non_Recoverable_Threshold"))
{
readable_str = "readable_thresholds.lower_non_recoverable_threshold";
threshold_str = "lower_non_recoverable_threshold";
}
else if (!strcasecmp (kv->key->key_name, "Upper_Non_Critical_Threshold"))
{
readable_str = "readable_thresholds.upper_non_critical_threshold";
threshold_str = "upper_non_critical_threshold";
}
else if (!strcasecmp (kv->key->key_name, "Upper_Critical_Threshold"))
{
readable_str = "readable_thresholds.upper_critical_threshold";
threshold_str = "upper_critical_threshold";
}
else if (!strcasecmp (kv->key->key_name, "Upper_Non_Recoverable_Threshold"))
{
readable_str = "readable_thresholds.upper_non_recoverable_threshold";
threshold_str = "upper_non_recoverable_threshold";
}
else
/* unknown key_name - fatal error */
goto cleanup;
if (FIID_OBJ_GET (obj_cmd_rs, readable_str, &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: '%s': %s\n",
readable_str,
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
readable = val;
if (!readable)
{
/* Inconsistency w/ the SDR, should be readable */
if (state_data->prog_data->args->config_args.common_args.debug)
pstdout_fprintf (state_data->pstate,
stderr,
"%s:%s - threshold not readable\n",
section_name,
kv->key->key_name);
rv = CONFIG_ERR_NON_FATAL_ERROR;
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs, threshold_str, &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: '%s': %s\n",
threshold_str,
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
threshold_raw = val;
if ((ret = _decode_value (state_data,
threshold_raw,
&threshold_calc)) != CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (config_section_update_keyvalue_output_double (state_data->pstate,
kv,
threshold_calc) < 0)
goto cleanup;
rv = CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
ipmi_ctx_t
ipmi_open (const char *progname,
const char *hostname,
struct common_cmd_args *common_args,
pstdout_state_t pstate)
{
ipmi_ctx_t ipmi_ctx = NULL;
unsigned int workaround_flags = 0;
assert (progname);
assert (common_args);
if (!(ipmi_ctx = ipmi_ctx_create ()))
{
PSTDOUT_FPRINTF (pstate,
stderr,
"ipmi_ctx_create: %s",
strerror (errno));
goto cleanup;
}
if (hostname
&& strcasecmp (hostname, "localhost") != 0
&& strcmp (hostname, "127.0.0.1") != 0)
{
if (common_args->driver_type == IPMI_DEVICE_LAN_2_0)
{
parse_get_freeipmi_outofband_2_0_flags (common_args->workaround_flags_outofband_2_0,
&workaround_flags);
if (ipmi_ctx_open_outofband_2_0 (ipmi_ctx,
hostname,
common_args->username,
common_args->password,
(common_args->k_g_len) ? common_args->k_g : NULL,
(common_args->k_g_len) ? common_args->k_g_len : 0,
common_args->privilege_level,
common_args->cipher_suite_id,
common_args->session_timeout,
common_args->retransmission_timeout,
workaround_flags,
(common_args->debug) ? IPMI_FLAGS_DEBUG_DUMP : IPMI_FLAGS_DEFAULT) < 0)
{
if (ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_USERNAME_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PASSWORD_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_K_G_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PRIVILEGE_LEVEL_INSUFFICIENT
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PRIVILEGE_LEVEL_CANNOT_BE_OBTAINED
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_AUTHENTICATION_TYPE_UNAVAILABLE
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_CIPHER_SUITE_ID_UNAVAILABLE
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PASSWORD_VERIFICATION_TIMEOUT
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_HOSTNAME_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_IPMI_2_0_UNAVAILABLE
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_CONNECTION_TIMEOUT)
PSTDOUT_FPRINTF (pstate,
stderr,
"%s: %s\n",
progname,
ipmi_ctx_errormsg (ipmi_ctx));
else
PSTDOUT_FPRINTF (pstate,
stderr,
"ipmi_ctx_open_outofband_2_0: %s\n",
ipmi_ctx_errormsg (ipmi_ctx));
goto cleanup;
}
}
else
{
parse_get_freeipmi_outofband_flags (common_args->workaround_flags_outofband,
&workaround_flags);
if (ipmi_ctx_open_outofband (ipmi_ctx,
hostname,
common_args->username,
common_args->password,
common_args->authentication_type,
common_args->privilege_level,
common_args->session_timeout,
common_args->retransmission_timeout,
workaround_flags,
(common_args->debug) ? IPMI_FLAGS_DEBUG_DUMP : IPMI_FLAGS_DEFAULT) < 0)
{
if (ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_USERNAME_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PASSWORD_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PRIVILEGE_LEVEL_INSUFFICIENT
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PRIVILEGE_LEVEL_CANNOT_BE_OBTAINED
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_AUTHENTICATION_TYPE_UNAVAILABLE
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PASSWORD_VERIFICATION_TIMEOUT
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_HOSTNAME_INVALID
|| ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_CONNECTION_TIMEOUT)
PSTDOUT_FPRINTF (pstate,
stderr,
"%s: %s\n",
progname,
ipmi_ctx_errormsg (ipmi_ctx));
else
PSTDOUT_FPRINTF (pstate,
stderr,
"ipmi_ctx_open_outofband: %s\n",
ipmi_ctx_errormsg (ipmi_ctx));
goto cleanup;
}
}
}
else
{
if (!ipmi_is_root ())
{
PSTDOUT_FPRINTF (pstate,
stderr,
"%s: %s\n",
progname,
ipmi_ctx_strerror (IPMI_ERR_PERMISSION));
goto cleanup;
}
parse_get_freeipmi_inband_flags (common_args->workaround_flags_inband,
&workaround_flags);
if (common_args->driver_type == IPMI_DEVICE_UNKNOWN)
{
int ret;
if ((ret = ipmi_ctx_find_inband (ipmi_ctx,
NULL,
common_args->disable_auto_probe,
common_args->driver_address,
common_args->register_spacing,
common_args->driver_device,
workaround_flags,
(common_args->debug) ? IPMI_FLAGS_DEBUG_DUMP : IPMI_FLAGS_DEFAULT)) < 0)
{
PSTDOUT_FPRINTF (pstate,
stderr,
"ipmi_ctx_find_inband: %s\n",
ipmi_ctx_errormsg (ipmi_ctx));
goto cleanup;
}
if (!ret)
{
PSTDOUT_FPRINTF (pstate,
stderr,
"could not find inband device");
goto cleanup;
}
}
else
{
if (ipmi_ctx_open_inband (ipmi_ctx,
common_args->driver_type,
common_args->disable_auto_probe,
common_args->driver_address,
common_args->register_spacing,
common_args->driver_device,
workaround_flags,
(common_args->debug) ? IPMI_FLAGS_DEBUG_DUMP : IPMI_FLAGS_DEFAULT) < 0)
{
if (ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_DEVICE_NOT_FOUND)
PSTDOUT_FPRINTF (pstate,
stderr,
"%s: %s\n",
progname,
ipmi_ctx_errormsg (ipmi_ctx));
else
PSTDOUT_FPRINTF (pstate,
stderr,
"ipmi_ctx_open_inband: %s\n",
ipmi_ctx_errormsg (ipmi_ctx));
goto cleanup;
}
}
}
if (common_args->target_channel_number_is_set
|| common_args->target_slave_address_is_set)
{
if (ipmi_ctx_set_target (ipmi_ctx,
common_args->target_channel_number_is_set ? &common_args->target_channel_number : NULL,
common_args->target_slave_address_is_set ? &common_args->target_slave_address : NULL) < 0)
{
PSTDOUT_FPRINTF (pstate,
stderr,
"ipmi_ctx_set_target: %s\n",
ipmi_ctx_errormsg (ipmi_ctx));
goto cleanup;
}
}
return (ipmi_ctx);
cleanup:
ipmi_ctx_close (ipmi_ctx);
ipmi_ctx_destroy (ipmi_ctx);
return (NULL);
}
static struct ipmi_rs * ipmi_free_send_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
{
u_int8_t lun = req->msg.lun;
u_int8_t cmd = req->msg.cmd;
u_int8_t netfn = req->msg.netfn;
u_int8_t rq_buf[IPMI_BUF_SIZE];
u_int8_t rs_buf[IPMI_BUF_SIZE];
u_int32_t rs_buf_len = IPMI_BUF_SIZE;
int32_t rs_len;
static struct ipmi_rs rsp;
/* achu: FreeIPMI requests have the cmd as the first byte of
* the data. Responses have cmd as the first byte and
* completion code as the second byte. This differs from some
* other APIs, so it must be compensated for within the ipmitool
* interface.
*/
if (!intf || !req)
return NULL;
if (!intf->opened && intf->open && intf->open(intf) < 0)
return NULL;
if (req->msg.data_len > IPMI_BUF_SIZE)
return NULL;
memset(rq_buf, '\0', IPMI_BUF_SIZE);
memset(rs_buf, '\0', IPMI_BUF_SIZE);
memcpy(rq_buf, &cmd, 1);
if (req->msg.data)
memcpy(rq_buf + 1, req->msg.data, req->msg.data_len);
if (intf->target_addr != 0
&& intf->target_addr != IPMI_BMC_SLAVE_ADDR) {
#if IPMI_INTF_FREE_BRIDGING
if ((rs_len = ipmi_cmd_raw_ipmb(dev,
intf->target_channel,
intf->target_addr,
lun,
netfn,
rq_buf,
req->msg.data_len + 1,
rs_buf,
rs_buf_len)) < 0) {
if (verbose > 3)
fprintf(stderr,
"ipmi_cmd_raw_ipmb: %s\n",
ipmi_ctx_strerror(ipmi_ctx_errnum(dev)));
/* Compared to FreeIPMI, user is expected to input
* the target channel on the command line, it is not automatically
* discovered. So that is the likely cause of an error.
*
* Instead of returning an error, return a bad response so output
* of ipmitool commands looks like other interfaces
*/
rs_len = 2;
rs_buf[0] = 0;
rs_buf[1] = 0xC1; /* invalid command */
}
#else /* !IPMI_INTF_FREE_BRIDGING */
if (verbose > 3)
fprintf(stderr, "sensor bridging not supported in this driver version");
/* instead of returning an error, return a bad response so output
* of ipmitool commands looks like other interfaces
*/
rs_len = 2;
rs_buf[0] = 0;
rs_buf[1] = 0xC1; /* invalid command */
#endif /* !IPMI_INTF_FREE_BRIDGING */
}
else {
if ((rs_len = ipmi_cmd_raw(dev,
lun,
netfn,
rq_buf,
req->msg.data_len + 1,
rs_buf,
rs_buf_len)) < 0) {
#if IPMI_INTF_FREE_0_3_0
perror("ipmi_cmd_raw");
#elif IPMI_INTF_FREE_0_4_0 || IPMI_INTF_FREE_0_5_0
fprintf(stderr,
"ipmi_cmd_raw: %s\n",
ipmi_device_strerror(ipmi_device_errnum(dev)));
#elif IPMI_INTF_FREE_0_6_0
fprintf(stderr,
"ipmi_cmd_raw: %s\n",
ipmi_ctx_strerror(ipmi_ctx_errnum(dev)));
#endif
return NULL;
}
}
memset(&rsp, 0, sizeof(struct ipmi_rs));
rsp.ccode = (unsigned char)rs_buf[1];
rsp.data_len = (int)rs_len - 2;
if (!rsp.ccode && rsp.data_len)
memcpy(rsp.data, rs_buf + 2, rsp.data_len);
return &rsp;
}
int
ipmi_cmd_set_serial_modem_configuration_connection_mode (ipmi_ctx_t ctx,
uint8_t channel_number,
uint8_t basic_mode,
uint8_t ppp_mode,
uint8_t terminal_mode,
uint8_t connect_mode,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_set_serial_modem_configuration_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_set_serial_modem_configuration_connection_mode_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_set_serial_modem_configuration_connection_mode (channel_number,
basic_mode,
ppp_mode,
terminal_mode,
connect_mode,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_TRANSPORT_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
int
ipmi_cmd_get_command_sub_function_enables (ipmi_ctx_t ctx,
uint8_t channel_number,
uint8_t net_fn,
uint8_t lun,
uint8_t command,
uint32_t net_fn_data,
fiid_obj_t obj_cmd_rs)
{
fiid_obj_t obj_cmd_rq = NULL;
int rv = -1;
if (!ctx || ctx->magic != IPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
return (-1);
}
/* remaining parameter checks in fill function */
if (!fiid_obj_valid (obj_cmd_rs))
{
API_SET_ERRNUM (ctx, IPMI_ERR_PARAMETERS);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rs,
tmpl_cmd_get_command_sub_function_enables_rs) < 0)
{
API_FIID_OBJECT_ERROR_TO_API_ERRNUM (ctx, obj_cmd_rs);
return (-1);
}
if (!(obj_cmd_rq = fiid_obj_create (tmpl_cmd_get_command_sub_function_enables_rq)))
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (fill_cmd_get_command_sub_function_enables (channel_number,
net_fn,
lun,
command,
net_fn_data,
obj_cmd_rq) < 0)
{
API_ERRNO_TO_API_ERRNUM (ctx, errno);
goto cleanup;
}
if (api_ipmi_cmd (ctx,
IPMI_BMC_IPMB_LUN_BMC,
IPMI_NET_FN_APP_RQ,
obj_cmd_rq,
obj_cmd_rs) < 0)
{
ERR_TRACE (ipmi_ctx_errormsg (ctx), ipmi_ctx_errnum (ctx));
goto cleanup;
}
rv = 0;
cleanup:
fiid_obj_destroy (obj_cmd_rq);
return (rv);
}
