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