static config_err_t
k_g_checkout (const char *section_name,
struct config_keyvalue *kv,
void *arg)
{
bmc_config_state_data_t *state_data = (bmc_config_state_data_t *)arg;
uint8_t k_g[IPMI_MAX_K_G_LENGTH];
char k_g_str[IPMI_MAX_K_G_LENGTH*2+3];
config_err_t ret;
memset (k_g, 0, IPMI_MAX_K_G_LENGTH);
if ((ret = _get_key (state_data,
IPMI_CHANNEL_SECURITY_KEYS_KEY_ID_K_G,
k_g,
IPMI_MAX_K_G_LENGTH)) != 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->config_args.action == 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 CONFIG_ERR_FATAL_ERROR;
if (!memcmp (kv_k_g, k_g, IPMI_MAX_K_G_LENGTH))
{
if (config_section_update_keyvalue_output(state_data->pstate,
kv,
kv->value_input) < 0)
return CONFIG_ERR_FATAL_ERROR;
return 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, (unsigned char *)k_g))
return CONFIG_ERR_FATAL_ERROR;
if (config_section_update_keyvalue_output(state_data->pstate,
kv,
(char *)k_g_str) < 0)
return CONFIG_ERR_FATAL_ERROR;
return CONFIG_ERR_SUCCESS;
}
static config_err_t
event_specific_alert_string_checkout (const char *section_name,
struct config_keyvalue *kv,
void *arg)
{
ipmi_pef_config_state_data_t *state_data;
struct alert_policy_table apt;
config_err_t ret;
assert (section_name);
assert (kv);
assert (arg);
state_data = (ipmi_pef_config_state_data_t *)arg;
if ((ret = _get_alert_policy_table (state_data,
section_name,
&apt)) != CONFIG_ERR_SUCCESS)
return (ret);
if (config_section_update_keyvalue_output (state_data->pstate,
kv,
apt.event_specific_alert_string ? "Yes" : "No") < 0)
return (CONFIG_ERR_FATAL_ERROR);
return (CONFIG_ERR_SUCCESS);
}
static config_err_t
k_r_checkout (const char *section_name,
struct config_keyvalue *kv,
void *arg)
{
bmc_config_state_data_t *state_data = (bmc_config_state_data_t *)arg;
uint8_t k_r[IPMI_MAX_K_R_LENGTH + 1];
config_err_t ret;
memset (k_r, 0, IPMI_MAX_K_R_LENGTH + 1);
if ((ret = _get_key (state_data,
IPMI_CHANNEL_SECURITY_KEYS_KEY_ID_K_R,
(uint8_t *)k_r,
IPMI_MAX_K_R_LENGTH)) != CONFIG_ERR_SUCCESS)
return ret;
k_r[IPMI_MAX_K_R_LENGTH] = '\0';
if (config_section_update_keyvalue_output(state_data->pstate,
kv,
(char *)k_r) < 0)
return CONFIG_ERR_FATAL_ERROR;
return CONFIG_ERR_SUCCESS;
}
config_err_t
enable_pef_alert_startup_delay_checkout (pstdout_state_t pstate,
struct config_keyvalue *kv,
ipmi_ctx_t ipmi_ctx,
struct config_arguments *cmd_args)
{
struct pef_control pc;
config_err_t ret;
assert (kv);
assert (ipmi_ctx);
assert (cmd_args);
if ((ret = _get_pef_control (pstate,
ipmi_ctx,
cmd_args,
&pc)) != CONFIG_ERR_SUCCESS)
return (ret);
if (config_section_update_keyvalue_output (pstate,
kv,
pc.enable_pef_alert_startup_delay ? "Yes" : "No") < 0)
return (CONFIG_ERR_FATAL_ERROR);
return (CONFIG_ERR_SUCCESS);
}
config_err_t
enable_diagnostic_interrupt_checkout (pstdout_state_t pstate,
struct config_keyvalue *kv,
ipmi_ctx_t ipmi_ctx,
struct config_arguments *cmd_args)
{
struct pef_action_global_control gc;
config_err_t ret;
assert (kv);
assert (ipmi_ctx);
assert (cmd_args);
if ((ret = _get_pef_action_global_control (pstate,
ipmi_ctx,
cmd_args,
&gc)) != CONFIG_ERR_SUCCESS)
return (ret);
if (config_section_update_keyvalue_output (pstate,
kv,
gc.enable_diagnostic_interrupt ? "Yes" : "No") < 0)
return (CONFIG_ERR_FATAL_ERROR);
return (CONFIG_ERR_SUCCESS);
}
static config_err_t
enable_event_message_when_user_disabled_checkout (const char *section_name,
struct config_keyvalue *kv,
void *arg)
{
bmc_config_state_data_t *state_data;
struct bad_password_threshold bpt;
config_err_t ret;
assert (section_name);
assert (kv);
assert (arg);
state_data = (bmc_config_state_data_t *)arg;
if ((ret = _get_bad_password_threshold (state_data, section_name, &bpt)) != CONFIG_ERR_SUCCESS)
return (ret);
if (config_section_update_keyvalue_output (state_data->pstate,
kv,
bpt.user_disabled_event_message ? "Yes" : "No") < 0)
return (CONFIG_ERR_FATAL_ERROR);
return (CONFIG_ERR_SUCCESS);
}
static config_err_t
volatile_bit_rate_checkout (const char *section_name,
struct config_keyvalue *kv,
void *arg)
{
bmc_config_state_data_t *state_data = (bmc_config_state_data_t *)arg;
fiid_obj_t obj_cmd_rs = NULL;
uint64_t val;
config_err_t rv = CONFIG_ERR_FATAL_ERROR;
config_err_t ret;
uint8_t channel_number;
_FIID_OBJ_CREATE(obj_cmd_rs, tmpl_cmd_get_sol_configuration_parameters_sol_volatile_bit_rate_rs);
if ((ret = get_sol_channel_number (state_data, &channel_number)) != CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (ipmi_cmd_get_sol_configuration_parameters_sol_volatile_bit_rate (state_data->ipmi_ctx,
channel_number,
IPMI_GET_SOL_PARAMETER,
SET_SELECTOR,
BLOCK_SELECTOR,
obj_cmd_rs) < 0)
{
if (state_data->prog_data->args->config_args.common.debug)
pstdout_fprintf(state_data->pstate,
stderr,
"ipmi_cmd_get_sol_configuration_parameters_sol_volatile_bit_rate: %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 (obj_cmd_rs, "bit_rate", &val);
if (config_section_update_keyvalue_output(state_data->pstate,
kv,
sol_bit_rate_string (val)) < 0)
return CONFIG_ERR_FATAL_ERROR;
rv = CONFIG_ERR_SUCCESS;
cleanup:
_FIID_OBJ_DESTROY(obj_cmd_rs);
return (rv);
}
static config_err_t
_authentication_level_checkout (const char *section_name,
struct config_keyvalue *kv,
void *arg)
{
bmc_config_state_data_t *state_data;
struct bmc_authentication_level al;
config_err_t ret;
unsigned int available_flag = 1; /* default is to always allow checkout */
uint8_t *al_ptr;
assert (section_name);
assert (kv);
assert (arg);
state_data = (bmc_config_state_data_t *)arg;
if ((ret = _get_authentication_type_enables (state_data,
section_name,
&al)) != CONFIG_ERR_SUCCESS)
return (ret);
/* non-fatal error is ok here */
ret = _authentication_type_enable_available (state_data,
section_name,
kv->key->key_name,
&available_flag);
if (ret == CONFIG_ERR_FATAL_ERROR)
return (ret);
if (available_flag)
{
if (!(al_ptr = _authentication_level_ptr (state_data,
section_name,
kv->key->key_name,
&al)))
return (CONFIG_ERR_FATAL_ERROR);
if (config_section_update_keyvalue_output (state_data->pstate,
kv,
*al_ptr ? "Yes" : "No") < 0)
return (CONFIG_ERR_FATAL_ERROR);
return (CONFIG_ERR_SUCCESS);
}
return (CONFIG_ERR_NON_FATAL_ERROR);
}
static config_err_t
force_sol_payload_encryption_checkout (const char *section_name,
struct config_keyvalue *kv,
void *arg)
{
bmc_config_state_data_t *state_data = (bmc_config_state_data_t *)arg;
struct sol_authentication sa;
config_err_t ret;
if ((ret = _get_sol_sol_authentication (state_data, &sa)) != CONFIG_ERR_SUCCESS)
return ret;
if (config_section_update_keyvalue_output(state_data->pstate,
kv,
sa.force_sol_payload_encryption ? "Yes" : "No") < 0)
return CONFIG_ERR_FATAL_ERROR;
return CONFIG_ERR_SUCCESS;
}
static config_err_t
sol_privilege_level_checkout (const char *section_name,
struct config_keyvalue *kv,
void *arg)
{
bmc_config_state_data_t *state_data = (bmc_config_state_data_t *)arg;
struct sol_authentication sa;
config_err_t ret;
if ((ret = _get_sol_sol_authentication (state_data, &sa)) != CONFIG_ERR_SUCCESS)
return ret;
if (config_section_update_keyvalue_output(state_data->pstate,
kv,
privilege_level_string (sa.sol_privilege_level)) < 0)
return CONFIG_ERR_FATAL_ERROR;
return CONFIG_ERR_SUCCESS;
}
static config_err_t
policy_enabled_checkout (const char *section_name,
struct config_keyvalue *kv,
void *arg)
{
pef_config_state_data_t *state_data = (pef_config_state_data_t *)arg;
struct alert_policy_table apt;
config_err_t ret;
if ((ret = _get_alert_policy_table (state_data,
section_name,
&apt)) != CONFIG_ERR_SUCCESS)
return ret;
if (config_section_update_keyvalue_output(state_data->pstate,
kv,
apt.policy_enabled ? "Yes" : "No") < 0)
return CONFIG_ERR_FATAL_ERROR;
return CONFIG_ERR_SUCCESS;
}
static config_err_t
community_string_checkout (const char *section_name,
struct config_keyvalue *kv,
void *arg)
{
ipmi_pef_config_state_data_t *state_data;
char community_string[IPMI_MAX_COMMUNITY_STRING_LENGTH+1] = { 0, };
fiid_obj_t obj_cmd_rs = NULL;
config_err_t rv = CONFIG_ERR_FATAL_ERROR;
config_err_t ret;
uint8_t channel_number;
assert (section_name);
assert (kv);
assert (arg);
state_data = (ipmi_pef_config_state_data_t *)arg;
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)) != 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 (state_data->prog_data->args->config_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));
if (config_is_config_param_non_fatal_error (state_data->ipmi_ctx,
obj_cmd_rs,
&ret))
rv = ret;
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: 'obj_cmd_rs': %s\n",
fiid_obj_errormsg (obj_cmd_rs));
goto cleanup;
}
if (config_section_update_keyvalue_output (state_data->pstate,
kv,
community_string) < 0)
return (CONFIG_ERR_FATAL_ERROR);
rv = CONFIG_ERR_SUCCESS;
cleanup:
fiid_obj_destroy (obj_cmd_rs);
return (rv);
}
static config_err_t
id_checkout (const char *section_name,
struct config_keyvalue *kv,
void *arg,
int id)
{
bmc_config_state_data_t *state_data;
config_err_t ret;
uint8_t privilege;
unsigned int i;
int id_found = 0;
assert (section_name);
assert (kv);
assert (arg);
state_data = (bmc_config_state_data_t *)arg;
if ((ret = _rmcpplus_cipher_suite_id_privilege_setup (state_data, section_name)) != CONFIG_ERR_SUCCESS)
return (ret);
for (i = 0; i < state_data->cipher_suite_entry_count; i++)
{
if (state_data->cipher_suite_id_supported[i] == id)
{
/* achu: NOT A BUG.
*
* IPMI spec is_supported does not map to privileges array, you want to index at [id] not [i]
*/
privilege = state_data->cipher_suite_priv[id];
id_found++;
break;
}
}
if (id_found)
{
/* achu: see HP DL145 workaround description above in
* _rmcpplus_cipher_suite_id_privilege_setup()
*/
if (privilege != BMC_CONFIG_PRIVILEGE_LEVEL_SUPPORTED_BUT_NOT_READABLE)
{
if (config_section_update_keyvalue_output (state_data->pstate,
kv,
rmcpplus_priv_string (privilege)) < 0)
return (CONFIG_ERR_FATAL_ERROR);
}
else
{
/* output empty string, will match with
* CONFIG_CHECKOUT_KEY_COMMENTED_OUT_IF_VALUE_EMPTY flag to
* output commented out section.
*/
if (config_section_update_keyvalue_output (state_data->pstate,
kv,
"") < 0)
return (CONFIG_ERR_FATAL_ERROR);
}
return (CONFIG_ERR_SUCCESS);
}
/* if ID not found, return non-fatal error, will not output at all */
return (CONFIG_ERR_NON_FATAL_ERROR);
}
static config_err_t
hysteresis_threshold_checkout (const char *section_name,
struct config_keyvalue *kv,
void *arg)
{
ipmi_sensors_config_state_data_t *state_data;
config_err_t rv = CONFIG_ERR_FATAL_ERROR;
config_err_t ret;
uint8_t positive_going_threshold_hysteresis_value;
uint8_t negative_going_threshold_hysteresis_value;
uint8_t value_raw;
double value_calc;
uint8_t hysteresis_support;
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_capabilities (state_data->sdr_ctx,
NULL,
0,
NULL,
NULL,
&hysteresis_support,
NULL,
NULL) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_sensor_capabilities: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
goto cleanup;
}
/* achu: shouldn't hit this, was calculated during section setup.
* verbose mode should hit 'undefined' checkout
*/
if (hysteresis_support != IPMI_SDR_READABLE_HYSTERESIS_SUPPORT
&& hysteresis_support != IPMI_SDR_READABLE_SETTABLE_HYSTERESIS_SUPPORT)
{
rv = CONFIG_ERR_NON_FATAL_ERROR;
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 ((ret = _get_hysteresis (state_data,
sensor_number,
&positive_going_threshold_hysteresis_value,
&negative_going_threshold_hysteresis_value)) != CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (!strcasecmp (kv->key->key_name, "Positive_Going_Threshold_Hysteresis"))
value_raw = positive_going_threshold_hysteresis_value;
else if (!strcasecmp (kv->key->key_name, "Negative_Going_Threshold_Hysteresis"))
value_raw = negative_going_threshold_hysteresis_value;
else
/* unknown key_name - fatal error */
goto cleanup;
/* 0 means hysteresis is not used, so don't decode */
if (value_raw == 0)
{
if (config_section_update_keyvalue_output (state_data->pstate,
kv,
"None") < 0)
goto cleanup;
}
else
{
if ((ret = _decode_value (state_data,
value_raw,
&value_calc)) != CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (config_section_update_keyvalue_output_double (state_data->pstate,
kv,
value_calc) < 0)
goto cleanup;
}
rv = CONFIG_ERR_SUCCESS;
cleanup:
return (rv);
}
