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); }