static ipmi_config_err_t
k_g_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
uint8_t k_g[IPMI_MAX_K_G_LENGTH];
char k_g_str[IPMI_MAX_K_G_LENGTH*2+3];
ipmi_config_err_t ret;
assert (state_data);
assert (section_name);
assert (kv);
memset (k_g, 0, IPMI_MAX_K_G_LENGTH);
if ((ret = _get_key (state_data,
section_name,
IPMI_CHANNEL_SECURITY_KEYS_KEY_ID_K_G,
k_g,
IPMI_MAX_K_G_LENGTH)) != IPMI_CONFIG_ERR_SUCCESS)
return (ret);
/* a printable k_g key can have two representations, so compare the
* binary keys and return what the user passed in if they are the
* same.
*/
if (state_data->prog_data->args->action == IPMI_CONFIG_ACTION_DIFF)
{
uint8_t kv_k_g[IPMI_MAX_K_G_LENGTH+1];
memset (kv_k_g, '\0', IPMI_MAX_K_G_LENGTH);
if (parse_kg (kv_k_g, IPMI_MAX_K_G_LENGTH + 1, kv->value_input) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
if (!memcmp (kv_k_g, k_g, IPMI_MAX_K_G_LENGTH))
{
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
kv->value_input) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
return (IPMI_CONFIG_ERR_SUCCESS);
}
/* else, fall through and return the default checked out value */
}
memset (k_g_str, '\0', IPMI_MAX_K_G_LENGTH*2+3);
if (!format_kg (k_g_str, IPMI_MAX_K_G_LENGTH*2+3, k_g))
return (IPMI_CONFIG_ERR_FATAL_ERROR);
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
k_g_str) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
return (IPMI_CONFIG_ERR_SUCCESS);
}
static ipmi_config_err_t
k_r_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
uint8_t k_r[IPMI_MAX_K_R_LENGTH + 1];
ipmi_config_err_t ret;
assert (state_data);
assert (section_name);
assert (kv);
memset (k_r, 0, IPMI_MAX_K_R_LENGTH + 1);
if ((ret = _get_key (state_data,
section_name,
IPMI_CHANNEL_SECURITY_KEYS_KEY_ID_K_R,
k_r,
IPMI_MAX_K_R_LENGTH)) != IPMI_CONFIG_ERR_SUCCESS)
return (ret);
k_r[IPMI_MAX_K_R_LENGTH] = '\0';
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
(char *)k_r) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
return (IPMI_CONFIG_ERR_SUCCESS);
}
static ipmi_config_err_t
front_panel_buttons_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
struct front_panel_buttons data;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
uint8_t enabled = 0;
char *enabled_str = NULL;
assert (state_data);
assert (section_name);
assert (kv);
memset (&data, '\0', sizeof (struct front_panel_buttons));
if ((ret = _get_front_panel_buttons (state_data, &data)) != IPMI_CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (!strcasecmp (kv->key->key_name, "Enable_Standby_Button_For_Entering_Standby"))
enabled = data.standby;
else if (!strcasecmp (kv->key->key_name, "Enable_Diagnostic_Interrupt_Button"))
enabled = data.diagnostic_interrupt;
else if (!strcasecmp (kv->key->key_name, "Enable_Reset_Button"))
enabled = data.reset;
else if (!strcasecmp (kv->key->key_name, "Enable_Power_Off_Button_For_Power_Off_Only"))
enabled = data.power_off;
else
{
if (state_data->prog_data->args->verbose_count)
pstdout_printf (state_data->pstate,
"## Unrecognized section:key_name: %s:%s\n",
section_name,
kv->key->key_name);
rv = IPMI_CONFIG_ERR_NON_FATAL_ERROR;
goto cleanup;
}
if (enabled == BUTTON_ENABLED)
enabled_str = "Yes";
else if (enabled == BUTTON_DISABLED)
enabled_str = "No";
else
enabled_str = "";
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
enabled_str) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
return (rv);
}
static ipmi_config_err_t
power_cycle_interval_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
assert (state_data);
assert (section_name);
assert (kv);
/* achu: value cannot be checked out */
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
"") < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
return (IPMI_CONFIG_ERR_SUCCESS);
}
static ipmi_config_err_t
enable_event_message_when_user_disabled_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
struct bad_password_threshold bpt;
ipmi_config_err_t ret;
assert (state_data);
assert (section_name);
assert (kv);
if ((ret = _get_bad_password_threshold (state_data, section_name, &bpt)) != IPMI_CONFIG_ERR_SUCCESS)
return (ret);
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
bpt.user_disabled_event_message ? "Yes" : "No") < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
return (IPMI_CONFIG_ERR_SUCCESS);
}
static ipmi_config_err_t
bit_rate_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
struct ipmi_messaging_comm_settings cs;
ipmi_config_err_t ret;
assert (state_data);
assert (section_name);
assert (kv);
if ((ret = _get_ipmi_messaging_comm_settings (state_data, section_name, &cs)) != IPMI_CONFIG_ERR_SUCCESS)
return (ret);
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
bit_rate_string (cs.bit_rate)) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
return (IPMI_CONFIG_ERR_SUCCESS);
}
static ipmi_config_err_t
connect_mode_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
struct connection_mode cm;
ipmi_config_err_t ret;
assert (state_data);
assert (section_name);
assert (kv);
if ((ret = _get_connection_mode (state_data, section_name, &cm)) != IPMI_CONFIG_ERR_SUCCESS)
return (ret);
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
connect_mode_string (cm.connect_mode)) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
return (IPMI_CONFIG_ERR_SUCCESS);
}
static ipmi_config_err_t
exception_actions_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
ipmi_config_err_t ret;
struct get_power_limit_data gpld;
char *str;
assert (state_data);
assert (section_name);
assert (kv);
if ((ret = _get_power_limit (state_data,
&gpld,
NULL)) != IPMI_CONFIG_ERR_SUCCESS)
return (ret);
str = exception_actions_string (gpld.exception_actions);
if (str && strlen (str))
{
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
str) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
}
else
{
if (ipmi_config_section_update_keyvalue_output_hex (state_data,
kv,
gpld.exception_actions) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
}
return (IPMI_CONFIG_ERR_SUCCESS);
}
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);
}
ipmi_config_err_t
ipmi_config_checkout_section (ipmi_config_state_data_t *state_data,
struct ipmi_config_section *section,
int all_keys_if_none_specified,
FILE *fp)
{
struct ipmi_config_keyvalue *kv;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret = IPMI_CONFIG_ERR_SUCCESS;
ipmi_config_err_t this_ret;
unsigned int line_length;
assert (state_data);
assert (section);
assert (fp);
/* if no keyvalues specified by user, we want to checkout all keys,
* so build keyvalues list appropriately
*/
if (all_keys_if_none_specified && !section->keyvalues)
{
struct ipmi_config_key *k;
k = section->keys;
while (k)
{
if (!(k->flags & IPMI_CONFIG_DO_NOT_CHECKOUT))
{
if (ipmi_config_section_add_keyvalue (state_data,
section,
k,
NULL,
NULL) < 0)
goto cleanup;
}
k = k->next;
}
}
if (!section->keyvalues)
return (IPMI_CONFIG_ERR_SUCCESS);
/* no need to output if fp NULL, for example if 'diff' is calling
* us.
*/
if (section->section_comment_section_name
&& section->section_comment
&& all_keys_if_none_specified)
{
if (ipmi_config_section_comments (state_data,
section->section_comment_section_name,
section->section_comment,
fp) < 0)
{
if (state_data->prog_data->args->common_args.debug)
pstdout_fprintf (state_data->pstate,
stderr,
"## Error: Comment output error\n");
ret = IPMI_CONFIG_ERR_NON_FATAL_ERROR;
}
}
if (!section->line_length)
line_length = IPMI_CONFIG_CHECKOUT_LINE_LEN;
else
line_length = section->line_length;
ipmi_config_pstdout_fprintf (state_data,
fp,
"Section %s\n",
section->section_name);
kv = section->keyvalues;
while (kv)
{
int key_len = 0;
if (kv->key->flags & IPMI_CONFIG_UNDEFINED)
{
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
"Undefined") < 0)
this_ret = IPMI_CONFIG_ERR_FATAL_ERROR;
else
this_ret = IPMI_CONFIG_ERR_SUCCESS;
}
else
{
if ((this_ret = kv->key->checkout (state_data,
section->section_name,
kv)) == IPMI_CONFIG_ERR_FATAL_ERROR)
goto cleanup;
}
if (IPMI_CONFIG_IS_NON_FATAL_ERROR (this_ret))
{
if (state_data->prog_data->args->verbose_count > 1)
{
if (this_ret == IPMI_CONFIG_ERR_NON_FATAL_ERROR_NOT_SUPPORTED)
ipmi_config_pstdout_fprintf (state_data,
fp,
"\t## Unable to checkout %s:%s : Not Supported\n",
section->section_name,
kv->key->key_name);
else
ipmi_config_pstdout_fprintf (state_data,
fp,
"\t## Unable to checkout %s:%s\n",
section->section_name,
kv->key->key_name);
}
ret = IPMI_CONFIG_ERR_NON_FATAL_ERROR;
}
else
{
char obuf[IPMI_CONFIG_OUTPUT_BUFLEN];
assert (kv->value_output);
if (strchr (kv->key->description, '\n'))
{
char *cptr;
cptr = kv->key->description;
ipmi_config_pstdout_fprintf (state_data,
fp,
"\t## ");
while (*cptr)
{
if (*cptr == '\n')
ipmi_config_pstdout_fprintf (state_data,
fp,
"\n\t## ");
else
ipmi_config_pstdout_fprintf (state_data,
fp,
"%c",
*cptr);
cptr++;
}
ipmi_config_pstdout_fprintf (state_data,
fp,
"\n");
}
else
ipmi_config_pstdout_fprintf (state_data,
fp,
"\t## %s\n",
kv->key->description);
/* achu: Certain keys should have their checked out
* value automatically commented out. Sometimes (in the
* case of passwords) they cannot be checked out, so the
* default is for value to be empty. We do not want the
* user accidently commiting this checked out file,
* which (in this example) clears the password.
*
* Some other keys may or may not have a value, depending on
* the IPMI version or the implementation.
*/
/* achu:
*
* The pstdout library does not return string lengths like
* printf/fprintf do. So we have to calculate it via
* snprintf.
*/
if (kv->key->flags & IPMI_CONFIG_CHECKOUT_KEY_COMMENTED_OUT
|| kv->key->flags & IPMI_CONFIG_UNDEFINED
|| (kv->key->flags & IPMI_CONFIG_CHECKOUT_KEY_COMMENTED_OUT_IF_VALUE_EMPTY
&& !strlen (kv->value_output))
|| (kv->key->flags & IPMI_CONFIG_USERNAME_NOT_SET_YET
&& !strcasecmp (kv->value_output, IPMI_CONFIG_USERNAME_NOT_SET_YET_STR)))
key_len = snprintf (obuf,
IPMI_CONFIG_OUTPUT_BUFLEN,
"\t## %s",
kv->key->key_name);
else
key_len = snprintf (obuf,
IPMI_CONFIG_OUTPUT_BUFLEN,
"\t%s",
kv->key->key_name);
ipmi_config_pstdout_fprintf (state_data,
fp,
"%s",
obuf);
while (key_len <= line_length)
{
ipmi_config_pstdout_fprintf (state_data,
fp,
" ");
key_len++;
}
ipmi_config_pstdout_fprintf (state_data,
fp,
" %s\n",
kv->value_output);
}
kv = kv->next;
}
ipmi_config_pstdout_fprintf (state_data,
fp,
"EndSection\n");
rv = ret;
cleanup:
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_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
power_restore_policy_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
fiid_obj_t obj_cmd_rs = NULL;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
uint8_t power_restore_policy;
uint64_t val;
assert (state_data);
assert (section_name);
assert (kv);
if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_chassis_status_rs)))
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_create: %s\n",
strerror (errno));
goto cleanup;
}
if (ipmi_cmd_get_chassis_status (state_data->ipmi_ctx, obj_cmd_rs) < 0)
{
ipmi_config_err_t ret;
if (state_data->prog_data->args->common_args.debug)
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_get_chassis_status: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
if (ipmi_errnum_is_non_fatal (state_data,
obj_cmd_rs,
&ret))
rv = ret;
goto cleanup;
}
if (FIID_OBJ_GET (obj_cmd_rs, "current_power_state.power_restore_policy", &val) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"fiid_obj_get: 'current_power_state.power_restore_policy': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
power_restore_policy = val;
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
power_restore_policy_string (power_restore_policy)) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
