static ipmi_config_err_t
_set_bad_password_threshold (ipmi_config_state_data_t *state_data,
const char *section_name,
struct bad_password_threshold *bpt)
{
fiid_obj_t obj_cmd_rs = NULL;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
uint8_t channel_number;
assert (state_data);
assert (section_name);
assert (bpt);
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)) != IPMI_CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (ipmi_cmd_set_lan_configuration_parameters_bad_password_threshold (state_data->ipmi_ctx,
channel_number,
bpt->user_disabled_event_message,
bpt->bad_password_threshold_number,
bpt->attempt_count_reset_interval,
bpt->user_lockout_interval,
obj_cmd_rs) < 0)
{
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_set_lan_configuration_parameters_bad_password_threshold: %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);
}
static ipmi_config_err_t
_set_connection_mode (ipmi_config_state_data_t *state_data,
const char *section_name,
struct connection_mode *cm)
{
fiid_obj_t obj_cmd_rs = NULL;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
uint8_t channel_number;
assert (state_data);
assert (section_name);
assert (cm);
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_set_serial_modem_configuration_rs)))
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_create: %s\n",
strerror (errno));
goto cleanup;
}
if ((ret = get_serial_channel_number (state_data, section_name, &channel_number)) != IPMI_CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (ipmi_cmd_set_serial_modem_configuration_connection_mode (state_data->ipmi_ctx,
channel_number,
cm->basic_mode,
cm->ppp_mode,
cm->terminal_mode,
cm->connect_mode,
obj_cmd_rs) < 0)
{
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_set_serial_modem_configuration_connection_mode: %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);
}
static ipmi_config_err_t
community_string_commit (ipmi_config_state_data_t *state_data,
const char *section_name,
const struct ipmi_config_keyvalue *kv)
{
fiid_obj_t obj_cmd_rs = NULL;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
uint8_t channel_number;
assert (state_data);
assert (section_name);
assert (kv);
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)) != IPMI_CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (ipmi_cmd_set_lan_configuration_parameters_community_string (state_data->ipmi_ctx,
channel_number,
kv->value_input,
strlen (kv->value_input),
obj_cmd_rs) < 0)
{
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_set_lan_configuration_parameters_community_string: %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);
}
static ipmi_config_err_t
community_string_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
char community_string[IPMI_MAX_COMMUNITY_STRING_LENGTH+1] = { 0, };
fiid_obj_t obj_cmd_rs = NULL;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
uint8_t channel_number;
assert (state_data);
assert (section_name);
assert (kv);
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_lan_configuration_parameters_community_string_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)) != IPMI_CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (ipmi_cmd_get_lan_configuration_parameters_community_string (state_data->ipmi_ctx,
channel_number,
IPMI_GET_LAN_PARAMETER,
IPMI_PEF_CONFIGURATION_PARAMETERS_NO_SET_SELECTOR,
IPMI_PEF_CONFIGURATION_PARAMETERS_NO_BLOCK_SELECTOR,
obj_cmd_rs) < 0)
{
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_lan_configuration_parameters_community_string: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
memset (community_string,'\0', IPMI_MAX_COMMUNITY_STRING_LENGTH+1);
if (fiid_obj_get_data (obj_cmd_rs,
"community_string",
community_string,
IPMI_MAX_COMMUNITY_STRING_LENGTH+1) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get_data: 'community_string': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
community_string) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
static ipmi_config_err_t
_get_bad_password_threshold (ipmi_config_state_data_t *state_data,
const char *section_name,
struct bad_password_threshold *bpt)
{
fiid_obj_t obj_cmd_rs = NULL;
uint64_t val;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
uint8_t channel_number;
assert (state_data);
assert (section_name);
assert (bpt);
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_lan_configuration_parameters_bad_password_threshold_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)) != IPMI_CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (ipmi_cmd_get_lan_configuration_parameters_bad_password_threshold (state_data->ipmi_ctx,
channel_number,
IPMI_GET_LAN_PARAMETER,
IPMI_LAN_CONFIGURATION_PARAMETERS_NO_SET_SELECTOR,
IPMI_LAN_CONFIGURATION_PARAMETERS_NO_BLOCK_SELECTOR,
obj_cmd_rs) < 0)
{
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_lan_configuration_parameters_bad_password_threshold: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs, "user_disabled_event_message", &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'user_disabled_event_message': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
bpt->user_disabled_event_message = val;
if (FIID_OBJ_GET (obj_cmd_rs, "bad_password_threshold_number", &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'bad_password_threshold_number': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
bpt->bad_password_threshold_number = val;
if (FIID_OBJ_GET (obj_cmd_rs, "attempt_count_reset_interval", &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'attempt_count_reset_interval': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
bpt->attempt_count_reset_interval = val;
if (FIID_OBJ_GET (obj_cmd_rs, "user_lockout_interval", &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'user_lockout_interval': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
bpt->user_lockout_interval = val;
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
static ipmi_config_err_t
_get_ipmi_messaging_comm_settings (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_messaging_comm_settings *cs)
{
fiid_obj_t obj_cmd_rs = NULL;
uint64_t val;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
uint8_t channel_number;
assert (state_data);
assert (section_name);
assert (cs);
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_serial_modem_configuration_ipmi_messaging_comm_settings_rs)))
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_create: %s\n",
strerror (errno));
goto cleanup;
}
if ((ret = get_serial_channel_number (state_data, section_name, &channel_number)) != IPMI_CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (ipmi_cmd_get_serial_modem_configuration_ipmi_messaging_comm_settings (state_data->ipmi_ctx,
channel_number,
IPMI_GET_SERIAL_MODEM_PARAMETER,
IPMI_SERIAL_MODEM_CONFIGURATION_NO_SET_SELECTOR,
IPMI_SERIAL_MODEM_CONFIGURATION_NO_BLOCK_SELECTOR,
obj_cmd_rs) < 0)
{
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_serial_modem_configuration_ipmi_messaging_comm_settings: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs, "dtr_hangup", &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'dtr_hangup': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
cs->dtr_hangup = val;
if (FIID_OBJ_GET (obj_cmd_rs, "flow_control", &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'flow_control': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
cs->flow_control = val;
if (FIID_OBJ_GET (obj_cmd_rs, "bit_rate", &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'bit_rate': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
cs->bit_rate = val;
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
static ipmi_config_err_t
_get_connection_mode (ipmi_config_state_data_t *state_data,
const char *section_name,
struct connection_mode *cm)
{
fiid_obj_t obj_cmd_rs = NULL;
uint64_t val;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
uint8_t channel_number;
assert (state_data);
assert (section_name);
assert (cm);
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_serial_modem_configuration_connection_mode_rs)))
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_create: %s\n",
strerror (errno));
goto cleanup;
}
if ((ret = get_serial_channel_number (state_data, section_name, &channel_number)) != IPMI_CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (ipmi_cmd_get_serial_modem_configuration_connection_mode (state_data->ipmi_ctx,
channel_number,
IPMI_GET_SERIAL_MODEM_PARAMETER,
IPMI_SERIAL_MODEM_CONFIGURATION_NO_SET_SELECTOR,
IPMI_SERIAL_MODEM_CONFIGURATION_NO_BLOCK_SELECTOR,
obj_cmd_rs) < 0)
{
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_serial_modem_configuration_connection_mode: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs, "basic_mode", &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'basic_mode': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
cm->basic_mode = val;
if (FIID_OBJ_GET (obj_cmd_rs, "ppp_mode", &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'ppp_mode': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
cm->ppp_mode = val;
if (FIID_OBJ_GET (obj_cmd_rs, "terminal_mode", &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'terminal_mode': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
cm->terminal_mode = val;
if (FIID_OBJ_GET (obj_cmd_rs, "connect_mode", &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'connect_mode': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
cm->connect_mode = val;
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
static ipmi_config_err_t
call_retry_interval_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
fiid_obj_t obj_cmd_rs = NULL;
uint8_t call_retry_interval;
uint64_t val;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
uint8_t channel_number;
assert (state_data);
assert (section_name);
assert (kv);
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_serial_modem_configuration_call_retry_interval_rs)))
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_create: %s\n",
strerror (errno));
goto cleanup;
}
if ((ret = get_serial_channel_number (state_data, section_name, &channel_number)) != IPMI_CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (ipmi_cmd_get_serial_modem_configuration_call_retry_interval (state_data->ipmi_ctx,
channel_number,
IPMI_GET_SERIAL_MODEM_PARAMETER,
IPMI_SERIAL_MODEM_CONFIGURATION_NO_SET_SELECTOR,
IPMI_SERIAL_MODEM_CONFIGURATION_NO_BLOCK_SELECTOR,
obj_cmd_rs) < 0)
{
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_serial_modem_configuration_call_retry_interval: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs, "call_retry_interval", &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'call_retry_interval': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
call_retry_interval = val;
if (ipmi_config_section_update_keyvalue_output_unsigned_int (state_data,
kv,
call_retry_interval) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
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);
}
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);
}
static ipmi_config_err_t
asset_tag_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
fiid_obj_t obj_cmd_rs = NULL;
char asset_tag_data[IPMI_DCMI_MAX_ASSET_TAG_LENGTH + 1];
int data_len;
unsigned int offset = 0;
uint8_t total_asset_tag_length = 0;
uint8_t bytes_to_read = IPMI_DCMI_ASSET_TAG_NUMBER_OF_BYTES_TO_READ_MAX;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
assert (state_data);
assert (section_name);
assert (kv);
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_dcmi_get_asset_tag_rs)))
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_create: %s\n",
strerror (errno));
goto cleanup;
}
memset (asset_tag_data, '\0', IPMI_DCMI_MAX_ASSET_TAG_LENGTH + 1);
while (1)
{
uint64_t val;
if (!offset
|| ((total_asset_tag_length - offset) >= IPMI_DCMI_ASSET_TAG_NUMBER_OF_BYTES_TO_READ_MAX))
bytes_to_read = IPMI_DCMI_ASSET_TAG_NUMBER_OF_BYTES_TO_READ_MAX;
else
bytes_to_read = total_asset_tag_length - offset;
if (ipmi_cmd_dcmi_get_asset_tag (state_data->ipmi_ctx,
offset,
bytes_to_read,
obj_cmd_rs) < 0)
{
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_dcmi_get_asset_tag: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs,
"total_asset_tag_length",
&val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'total_asset_tag_length': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
total_asset_tag_length = val;
if (!total_asset_tag_length)
break;
if ((data_len = fiid_obj_get_data (obj_cmd_rs,
"data",
asset_tag_data + offset,
IPMI_DCMI_MAX_ASSET_TAG_LENGTH - offset)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get_data: 'data': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
offset += data_len;
if (offset >= total_asset_tag_length)
break;
}
/* Handle special case UTF-8 encoding w/ BOM prefix */
if (asset_tag_data[0] == IPMI_DCMI_ASSET_TAG_UTF8_BOM_BYTE0
&& asset_tag_data[1] == IPMI_DCMI_ASSET_TAG_UTF8_BOM_BYTE1
&& asset_tag_data[2] == IPMI_DCMI_ASSET_TAG_UTF8_BOM_BYTE2)
{
/* achu: I think this is right for UTF-8 in libc and is
* portable, but I would bet some systems won't like this.
*/
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
&asset_tag_data[3]) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
}
else
{
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
asset_tag_data) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
}
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
static ipmi_config_err_t
management_controller_identifier_string_commit (ipmi_config_state_data_t *state_data,
const char *section_name,
const struct ipmi_config_keyvalue *kv)
{
fiid_obj_t obj_cmd_rs = NULL;
unsigned int offset = 0;
char data_buf[IPMI_DCMI_MAX_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING_LENGTH + 1];
unsigned int data_len;
uint8_t bytes_to_write = IPMI_DCMI_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING_NUMBER_OF_BYTES_TO_WRITE_MAX;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
assert (state_data);
assert (section_name);
assert (kv);
/* achu:
*
* According to DCMI v1.5 draft
*
* "The presence of the null terminator among bytes to shall be
* considered as indicating the last transfer of the Management
* Controller Identifier string"
*
* So I am assuming we don't need to write the entire buffer. But
* we must include the NUL byte at the end.
*/
/* +1 for NUL char */
data_len = strlen (kv->value_input) + 1;
/* Write NUL char */
if (!data_len)
data_len = 1;
memset (data_buf, '\0', IPMI_DCMI_MAX_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING_LENGTH + 1);
memcpy (data_buf, kv->value_input, strlen (kv->value_input));
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_dcmi_set_management_controller_identifier_string_rs)))
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_create: %s\n",
strerror (errno));
goto cleanup;
}
while (1)
{
uint64_t val;
if ((data_len - offset) >= IPMI_DCMI_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING_NUMBER_OF_BYTES_TO_WRITE_MAX)
bytes_to_write = IPMI_DCMI_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING_NUMBER_OF_BYTES_TO_WRITE_MAX;
else
bytes_to_write = data_len - offset;
if (ipmi_cmd_dcmi_set_management_controller_identifier_string (state_data->ipmi_ctx,
offset,
bytes_to_write,
data_buf + offset,
data_len,
obj_cmd_rs) < 0)
{
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_dcmi_set_management_controller_identifier_string: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs,
"total_length_written",
&val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'total_management_controller_identifier_string_length': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
/* DCMI 1.1 spec is unclear on "total_length_written", is it the
* number of bytes just written or total bytes written so far?
*
* DCMI 1.5 spec makes it clear that this is the number of bytes
* written in total. To defend against vendor mistakes, we
* handle both situations.
*/
if (val > bytes_to_write)
offset += bytes_to_write;
else
offset += val;
if (offset >= data_len)
break;
}
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
static ipmi_config_err_t
management_controller_identifier_string_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
fiid_obj_t obj_cmd_rs = NULL;
char management_controller_identifier_string_data[IPMI_DCMI_MAX_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING_LENGTH + 1];
int data_len;
unsigned int offset = 0;
uint8_t total_length = 0;
uint8_t bytes_to_read = IPMI_DCMI_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING_NUMBER_OF_BYTES_TO_READ_MAX;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
assert (state_data);
assert (section_name);
assert (kv);
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_dcmi_get_management_controller_identifier_string_rs)))
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_create: %s\n",
strerror (errno));
goto cleanup;
}
memset (management_controller_identifier_string_data, '\0', IPMI_DCMI_MAX_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING_LENGTH + 1);
while (1)
{
uint64_t val;
if (!offset
|| ((total_length - offset) >= IPMI_DCMI_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING_NUMBER_OF_BYTES_TO_READ_MAX))
bytes_to_read = IPMI_DCMI_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING_NUMBER_OF_BYTES_TO_READ_MAX;
else
bytes_to_read = total_length - offset;
if (ipmi_cmd_dcmi_get_management_controller_identifier_string (state_data->ipmi_ctx,
offset,
bytes_to_read,
obj_cmd_rs) < 0)
{
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_dcmi_get_management_controller_identifier_string: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs,
"total_length",
&val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'total_length': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
total_length = val;
if (!total_length)
break;
if ((data_len = fiid_obj_get_data (obj_cmd_rs,
"data",
management_controller_identifier_string_data + offset,
IPMI_DCMI_MAX_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING_LENGTH - offset)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get_data: 'data': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
offset += data_len;
if (offset >= total_length)
break;
}
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
management_controller_identifier_string_data) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
static ipmi_config_err_t
asset_tag_commit (ipmi_config_state_data_t *state_data,
const char *section_name,
const struct ipmi_config_keyvalue *kv)
{
fiid_obj_t obj_cmd_rs = NULL;
unsigned int offset = 0;
char data_buf[IPMI_DCMI_MAX_ASSET_TAG_LENGTH + 1];
unsigned int data_len;
uint8_t bytes_to_write = IPMI_DCMI_ASSET_TAG_NUMBER_OF_BYTES_TO_WRITE_MAX;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
assert (state_data);
assert (section_name);
assert (kv);
/* achu:
*
* DCMI v1.1 spec is unclear if the entire buffer needs to be
* written or just the amount you desire.
*
* DCMI v1.5 spec strongly suggests you don't write the entire
* buffer due to the results of the "total_asset_tag_length_written"
* field.
*
* "Total Asset Tag Length. This is the length in bytes of the stored
* Asset Tag after the Set operation has completed. The Asset Tag
* length shall be set to the sum of the offset to write plus bytes
* to write. For example, if offset to write is 32 and bytes to
* write is 4, the Total Asset Tag Length returned will be 36."
*/
data_len = strlen (kv->value_input);
/* Write empty buffer */
if (!data_len)
data_len = IPMI_DCMI_MAX_ASSET_TAG_LENGTH;
memset (data_buf, '\0', IPMI_DCMI_MAX_ASSET_TAG_LENGTH + 1);
memcpy (data_buf, kv->value_input, strlen (kv->value_input));
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_dcmi_set_asset_tag_rs)))
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_create: %s\n",
strerror (errno));
goto cleanup;
}
while (1)
{
uint64_t val;
if ((data_len - offset) >= IPMI_DCMI_ASSET_TAG_NUMBER_OF_BYTES_TO_WRITE_MAX)
bytes_to_write = IPMI_DCMI_ASSET_TAG_NUMBER_OF_BYTES_TO_WRITE_MAX;
else
bytes_to_write = data_len - offset;
if (ipmi_cmd_dcmi_set_asset_tag (state_data->ipmi_ctx,
offset,
bytes_to_write,
data_buf + offset,
data_len,
obj_cmd_rs) < 0)
{
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_dcmi_set_asset_tag: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs,
"total_asset_tag_length_written",
&val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'total_asset_tag_length': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
/* DCMI 1.1 spec is unclear on "total_length_written", is it the
* number of bytes just written or total bytes written so far?
*
* DCMI 1.5 spec makes it clear that this is the number of bytes
* written in total. To defend against vendor mistakes, we
* handle both situations.
*/
if (val > bytes_to_write)
offset += bytes_to_write;
else
offset += val;
if (offset >= data_len)
break;
}
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
