static error_t cmdline_parse (int key, char *arg, struct argp_state *state) { struct ipmi_chassis_config_arguments *cmd_args; error_t ret; assert (state); cmd_args = state->input; switch (key) { case ARGP_KEY_ARG: /* Too many arguments. */ argp_usage (state); break; case ARGP_KEY_END: break; default: ret = config_parse_opt (key, arg, &cmd_args->config_args); if (ret == ARGP_ERR_UNKNOWN) ret = common_parse_opt (key, arg, &(cmd_args->config_args.common_args)); return (ret); } return (0); }
static error_t cmdline_parse (int key, char *arg, struct argp_state *state) { struct ipmi_fru_arguments *cmd_args; char *endptr; int tmp; assert (state); cmd_args = state->input; switch (key) { case DEVICE_ID_KEY: errno = 0; tmp = strtol (arg, &endptr, 0); if (errno || endptr[0] != '\0') { fprintf (stderr, "invalid device id\n"); exit (EXIT_FAILURE); } if (tmp == IPMI_FRU_DEVICE_ID_RESERVED || tmp < IPMI_FRU_DEVICE_ID_MIN || tmp > IPMI_FRU_DEVICE_ID_MAX) { fprintf (stderr, "invalid device id\n"); exit (EXIT_FAILURE); } cmd_args->device_id = tmp; cmd_args->device_id_set++; break; case VERBOSE_KEY: cmd_args->verbose_count++; break; /* legacy */ case SKIP_CHECKS_KEY: cmd_args->skip_checks = 1; break; case BRIDGE_FRU_KEY: cmd_args->bridge_fru = 1; break; case INTERPRET_OEM_DATA: cmd_args->interpret_oem_data = 1; break; case ARGP_KEY_ARG: /* Too many arguments. */ argp_usage (state); break; case ARGP_KEY_END: break; default: return (common_parse_opt (key, arg, &(cmd_args->common_args))); } return (0); }
static error_t cmdline_parse (int key, char *arg, struct argp_state *state) { struct bmc_info_arguments *cmd_args; assert (state); cmd_args = state->input; switch (key) { case GET_DEVICE_ID_KEY: cmd_args->get_device_id++; break; /* legacy */ case GUID_KEY: case GET_DEVICE_GUID_KEY: cmd_args->get_device_guid++; break; case GET_SYSTEM_GUID_KEY: cmd_args->get_system_guid++; break; case GET_SYSTEM_INFO_KEY: cmd_args->get_system_info++; break; case GET_CHANNEL_INFO_KEY: cmd_args->get_channel_info++; break; case INTERPRET_OEM_DATA_KEY: cmd_args->interpret_oem_data = 1; break; case ARGP_KEY_ARG: /* Too many arguments. */ argp_usage (state); break; case ARGP_KEY_END: break; default: return (common_parse_opt (key, arg, &(cmd_args->common_args))); } return (0); }
static error_t cmdline_parse (int key, char *arg, struct argp_state *state) { struct ipmi_fru_arguments *cmd_args = state->input; error_t ret; char *ptr; switch (key) { case DEVICE_ID_KEY: cmd_args->device_id = strtoul(arg, &ptr, 0); if (ptr != (arg + strlen(arg))) { fprintf (stderr, "invalid device id\n"); exit(1); } cmd_args->device_id_set++; break; case VERBOSE_KEY: cmd_args->verbose_count++; break; case SKIP_CHECKS_KEY: cmd_args->skip_checks = 1; break; case ARGP_KEY_ARG: /* Too many arguments. */ argp_usage (state); break; case ARGP_KEY_END: break; default: ret = common_parse_opt (key, arg, state, &(cmd_args->common)); if (ret == ARGP_ERR_UNKNOWN) ret = sdr_parse_opt (key, arg, state, &(cmd_args->sdr)); if (ret == ARGP_ERR_UNKNOWN) ret = hostrange_parse_opt (key, arg, state, &(cmd_args->hostrange)); return ret; } return 0; }
static error_t cmdline_parse (int key, char *arg, struct argp_state *state) { struct ipmi_sensors_arguments *cmd_args = state->input; char *ptr; char *tok; int value; error_t ret; switch (key) { case VERBOSE_KEY: cmd_args->verbose = 1; cmd_args->verbose_count++; break; case QUIET_READINGS_KEY: cmd_args->quiet_readings = 1; break; case SDR_INFO_KEY: cmd_args->sdr_info = 1; break; case LIST_GROUPS_KEY: cmd_args->list_groups = 1; break; /* maintain "group" for backwards compatability */ case GROUP_KEY: cmd_args->groups_wanted = 1; strncpy(cmd_args->groups[cmd_args->groups_length], arg, IPMI_SENSORS_MAX_GROUPS_STRING_LENGTH); cmd_args->groups_length++; break; case GROUPS_KEY: cmd_args->groups_wanted = 1; tok = strtok(arg, " ,"); while (tok && cmd_args->groups_length < IPMI_SENSORS_MAX_GROUPS) { strncpy(cmd_args->groups[cmd_args->groups_length], tok, IPMI_SENSORS_MAX_GROUPS_STRING_LENGTH); cmd_args->groups_length++; tok = strtok(NULL, " ,"); } break; case SENSORS_KEY: cmd_args->sensors_wanted = 1; tok = strtok(arg, " ,"); while (tok && cmd_args->sensors_length < IPMI_SENSORS_MAX_RECORD_IDS) { value = 0; ptr = NULL; errno = 0; value = strtol(tok, &ptr, 10); if (errno || ptr[0] != '\0' || value < 0 || value < IPMI_SDR_RECORD_ID_FIRST || value > IPMI_SDR_RECORD_ID_LAST) { fprintf (stderr, "invalid sensor record id: %d\n", value); exit(1); } cmd_args->sensors[cmd_args->sensors_length] = value; cmd_args->sensors_length++; tok = strtok(NULL, " ,"); } break; case BRIDGE_SENSORS_KEY: cmd_args->bridge_sensors = 1; break; case ARGP_KEY_ARG: /* Too many arguments. */ argp_usage (state); break; case ARGP_KEY_END: break; default: ret = common_parse_opt (key, arg, state, &(cmd_args->common)); if (ret == ARGP_ERR_UNKNOWN) ret = sdr_parse_opt (key, arg, state, &(cmd_args->sdr)); if (ret == ARGP_ERR_UNKNOWN) ret = hostrange_parse_opt (key, arg, state, &(cmd_args->hostrange)); return ret; } return 0; }
static error_t cmdline_parse (int key, char *arg, struct argp_state *state) { struct bmc_device_arguments *cmd_args; char *endptr; int tmp; assert (state); cmd_args = state->input; switch (key) { case COLD_RESET_KEY: cmd_args->cold_reset++; break; case WARM_RESET_KEY: cmd_args->warm_reset++; break; case GET_SELF_TEST_RESULTS_KEY: cmd_args->get_self_test_results++; break; case GET_ACPI_POWER_STATE_KEY: cmd_args->get_acpi_power_state++; break; case SET_ACPI_POWER_STATE_KEY: cmd_args->set_acpi_power_state++; break; case SET_ACPI_SYSTEM_POWER_STATE_KEY: if (!strcasecmp (arg, "S0") /* acceptable here */ || !strcasecmp (arg, "G0") /* acceptable here */ || !strcasecmp (arg, "S0_G0") || !strcasecmp (arg, "S0/G0")) /* just in case */ cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_S0_G0; else if (!strcasecmp (arg, "S1")) cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_S1; else if (!strcasecmp (arg, "S2")) cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_S2; else if (!strcasecmp (arg, "S3")) cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_S3; else if (!strcasecmp (arg, "S4")) cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_S4; else if (!strcasecmp (arg, "G2") /* acceptable here */ || !strcasecmp (arg, "S5_G2") || !strcasecmp (arg, "S5/G2")) /* just in case */ cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_S5_G2; else if (!strcasecmp (arg, "S4_S5") || !strcasecmp (arg, "S4/S5")) /* just in case */ cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_S4_S5; else if (!strcasecmp (arg, "G3")) cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_G3; else if (!strcasecmp (arg, "SLEEPING")) cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_SLEEPING; else if (!strcasecmp (arg, "G1_SLEEPING")) cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_G1_SLEEPING; else if (!strcasecmp (arg, "OVERRIDE")) cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_OVERRIDE; else if (!strcasecmp (arg, "LEGACY_ON")) cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_LEGACY_ON; else if (!strcasecmp (arg, "LEGACY_OFF")) cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_LEGACY_OFF; else if (!strcasecmp (arg, "UNKNOWN")) cmd_args->set_acpi_power_state_args.system_power_state = IPMI_ACPI_SYSTEM_POWER_STATE_UNKNOWN; else { fprintf (stderr, "invalid value for system power state\n"); exit (EXIT_FAILURE); } break; case SET_ACPI_DEVICE_POWER_STATE_KEY: if (!strcasecmp (arg, "D0")) cmd_args->set_acpi_power_state_args.device_power_state = IPMI_ACPI_DEVICE_POWER_STATE_D0; else if (!strcasecmp (arg, "D1")) cmd_args->set_acpi_power_state_args.device_power_state = IPMI_ACPI_DEVICE_POWER_STATE_D1; else if (!strcasecmp (arg, "D2")) cmd_args->set_acpi_power_state_args.device_power_state = IPMI_ACPI_DEVICE_POWER_STATE_D2; else if (!strcasecmp (arg, "D3")) cmd_args->set_acpi_power_state_args.device_power_state = IPMI_ACPI_DEVICE_POWER_STATE_D3; else if (!strcasecmp (arg, "UNKNOWN")) cmd_args->set_acpi_power_state_args.device_power_state = IPMI_ACPI_DEVICE_POWER_STATE_UNKNOWN; else { fprintf (stderr, "invalid value for device power state\n"); exit (EXIT_FAILURE); } break; case GET_LAN_STATISTICS_KEY: cmd_args->get_lan_statistics++; break; case CLEAR_LAN_STATISTICS_KEY: cmd_args->clear_lan_statistics++; break; case REARM_SENSOR_KEY: cmd_args->rearm_sensor = 1; cmd_args->rearm_sensor_arg = arg; break; case GET_SDR_REPOSITORY_TIME_KEY: cmd_args->get_sdr_repository_time = 1; break; case SET_SDR_REPOSITORY_TIME_KEY: cmd_args->set_sdr_repository_time = 1; cmd_args->set_sdr_repository_time_arg = arg; break; case GET_SEL_TIME_KEY: cmd_args->get_sel_time = 1; break; case SET_SEL_TIME_KEY: cmd_args->set_sel_time = 1; cmd_args->set_sel_time_arg = arg; break; case GET_SEL_TIME_UTC_OFFSET_KEY: cmd_args->get_sel_time_utc_offset = 1; break; case SET_SEL_TIME_UTC_OFFSET_KEY: cmd_args->set_sel_time_utc_offset = 1; cmd_args->set_sel_time_utc_offset_arg = arg; break; case PLATFORM_EVENT_KEY: cmd_args->platform_event = 1; cmd_args->platform_event_arg = arg; break; case SET_SENSOR_READING_AND_EVENT_STATUS_KEY: cmd_args->set_sensor_reading_and_event_status = 1; cmd_args->set_sensor_reading_and_event_status_arg = arg; break; case GET_MCA_AUXILIARY_LOG_STATUS_KEY: cmd_args->get_mca_auxiliary_log_status = 1; break; case GET_SSIF_INTERFACE_CAPABILITIES_KEY: cmd_args->get_ssif_interface_capabilities = 1; break; case GET_KCS_INTERFACE_CAPABILITIES_KEY: cmd_args->get_kcs_interface_capabilities = 1; break; case GET_BT_INTERFACE_CAPABILITIES_KEY: cmd_args->get_bt_interface_capabilities = 1; break; case GET_BMC_GLOBAL_ENABLES_KEY: cmd_args->get_bmc_global_enables = 1; break; case SET_SYSTEM_FIRMWARE_VERSION_KEY: cmd_args->set_system_firmware_version = 1; cmd_args->set_system_firmware_version_arg = arg; break; case SET_SYSTEM_NAME_KEY: cmd_args->set_system_name = 1; cmd_args->set_system_name_arg = arg; break; case SET_PRIMARY_OPERATING_SYSTEM_NAME_KEY: cmd_args->set_primary_operating_system_name = 1; cmd_args->set_primary_operating_system_name_arg = arg; break; case SET_OPERATING_SYSTEM_NAME_KEY: cmd_args->set_operating_system_name = 1; cmd_args->set_operating_system_name_arg = arg; break; case SET_PRESENT_OS_VERSION_NUMBER_KEY: cmd_args->set_present_os_version_number = 1; cmd_args->set_present_os_version_number_arg = arg; break; case SET_BMC_URL_KEY: cmd_args->set_bmc_url = 1; cmd_args->set_bmc_url_arg = arg; break; case SET_BASE_OS_HYPERVISOR_URL_KEY: cmd_args->set_base_os_hypervisor_url = 1; cmd_args->set_base_os_hypervisor_url_arg = arg; break; case READ_FRU_KEY: cmd_args->read_fru = 1; cmd_args->read_fru_filename = arg; break; case WRITE_FRU_KEY: cmd_args->write_fru = 1; cmd_args->write_fru_filename = arg; break; case DEVICE_ID_KEY: errno = 0; tmp = strtol (arg, &endptr, 0); if (errno || endptr[0] != '\0') { fprintf (stderr, "invalid device id\n"); exit (EXIT_FAILURE); } if (tmp == IPMI_FRU_DEVICE_ID_RESERVED || tmp < IPMI_FRU_DEVICE_ID_MIN || tmp > IPMI_FRU_DEVICE_ID_MAX) { fprintf (stderr, "invalid device id\n"); exit (EXIT_FAILURE); } cmd_args->device_id = tmp; cmd_args->device_id_set = 1; break; case VERBOSE_KEY: cmd_args->verbose++; break; case ARGP_KEY_ARG: /* Too many arguments. */ argp_usage (state); break; case ARGP_KEY_END: break; default: return (common_parse_opt (key, arg, &(cmd_args->common_args))); } return (0); }
static error_t cmdline_parse (int key, char *arg, struct argp_state *state) { struct ipmiconsole_arguments *cmd_args; char *endptr; int tmp; assert (state); cmd_args = state->input; switch (key) { case ESCAPE_CHAR_KEY: /* --escape-char */ cmd_args->escape_char = *arg; break; case DONT_STEAL_KEY: /* --dont-steal */ cmd_args->dont_steal++; break; case DEACTIVATE_KEY: /* --deactivate */ cmd_args->deactivate++; break; case SERIAL_KEEPALIVE_KEY: /* --serial-keepalive */ cmd_args->serial_keepalive++; break; case SERIAL_KEEPALIVE_EMPTY_KEY: /* --serial-keepalive-empty */ cmd_args->serial_keepalive_empty++; break; case SOL_PAYLOAD_INSTANCE_KEY: /* --sol-payload-instance */ errno = 0; tmp = strtol (arg, &endptr, 0); if (errno || endptr[0] != '\0' || !IPMI_PAYLOAD_INSTANCE_VALID (tmp)) { fprintf (stderr, "invalid sol payload instance\n"); exit (EXIT_FAILURE); } cmd_args->sol_payload_instance = tmp; break; case DEACTIVATE_ALL_INSTANCES_KEY: /* --deactivate-all-instances */ cmd_args->deactivate_all_instances++; break; case LOCK_MEMORY_KEY: /* --lock-memory */ cmd_args->lock_memory++; break; #ifndef NDEBUG case DEBUGFILE_KEY: /* --debugfile */ cmd_args->debugfile++; break; case NORAW_KEY: /* --noraw */ cmd_args->noraw++; break; #endif /* NDEBUG */ case ARGP_KEY_ARG: /* Too many arguments. */ argp_usage (state); break; case ARGP_KEY_END: break; default: return (common_parse_opt (key, arg, &(cmd_args->common_args))); } return (0); }
static error_t cmdline_parse (int key, char *arg, struct argp_state *state) { struct ipmi_oem_arguments *cmd_args; assert (state); cmd_args = state->input; switch (key) { case LIST_KEY: cmd_args->list = 1; break; case VERBOSE_KEY: cmd_args->verbose_count++; break; case ARGP_KEY_ARG: { if (!cmd_args->oem_id) { if (!(cmd_args->oem_id = strdup (arg))) { perror ("strdup"); exit (EXIT_FAILURE); } break; } else if (!cmd_args->oem_command) { if (!(cmd_args->oem_command = strdup (arg))) { perror ("strdup"); exit (EXIT_FAILURE); } break; } else { if (cmd_args->oem_options_count < IPMI_OEM_MAX_ARGS) { if (!(cmd_args->oem_options[cmd_args->oem_options_count] = strdup (arg))) { perror ("strdup"); exit (EXIT_FAILURE); } cmd_args->oem_options_count++; break; } else { fprintf (stderr, "Too many arguments specified\n"); exit (EXIT_FAILURE); } } break; } case ARGP_KEY_END: break; default: return (common_parse_opt (key, arg, &(cmd_args->common_args))); } return (0); }
static error_t cmdline_parse (int key, char *arg, struct argp_state *state) { error_t ret; char *endptr = NULL; struct ipmi_chassis_arguments *cmd_args; int tmp; assert (state); cmd_args = state->input; switch (key) { case GET_CHASSIS_CAPABILITIES_KEY: cmd_args->get_chassis_capabilities++; break; case GET_CHASSIS_STATUS_KEY: cmd_args->get_chassis_status++; break; case CHASSIS_CONTROL_KEY: if (!strcasecmp (arg, "power-down")) cmd_args->chassis_control_arg = IPMI_CHASSIS_CONTROL_POWER_DOWN; else if (!strcasecmp (arg, "power-up")) cmd_args->chassis_control_arg = IPMI_CHASSIS_CONTROL_POWER_UP; else if (!strcasecmp (arg, "power-cycle")) cmd_args->chassis_control_arg = IPMI_CHASSIS_CONTROL_POWER_CYCLE; else if (!strcasecmp (arg, "hard-reset")) cmd_args->chassis_control_arg = IPMI_CHASSIS_CONTROL_HARD_RESET; else if (!strcasecmp (arg, "diagnostic-interrupt")) cmd_args->chassis_control_arg = IPMI_CHASSIS_CONTROL_PULSE_DIAGNOSTIC_INTERRUPT; else if (!strcasecmp (arg, "soft-shutdown")) cmd_args->chassis_control_arg = IPMI_CHASSIS_CONTROL_INITIATE_SOFT_SHUTDOWN; else { fprintf (stderr, "invalid value for chassis control\n"); exit (EXIT_FAILURE); } cmd_args->chassis_control++; break; case CHASSIS_IDENTIFY_KEY: if (!strcasecmp (arg, "turn-off")) { cmd_args->chassis_identify_args.identify_interval = 1; cmd_args->chassis_identify_args.identify_interval_arg = 0; cmd_args->chassis_identify_args.force_identify = 0; } else if (!strcasecmp (arg, "force")) { cmd_args->chassis_identify_args.force_identify = 1; cmd_args->chassis_identify_args.force_identify_arg = IPMI_CHASSIS_FORCE_IDENTIFY_ON; /* Need to have identify_interval set if force_identify is set */ cmd_args->chassis_identify_args.identify_interval = 1; cmd_args->chassis_identify_args.identify_interval_arg = 0xFF; } else { errno = 0; tmp = strtol (arg, &endptr, 10); if (errno || endptr[0] != '\0') { fprintf (stderr, "invalid value for chassis-identify\n"); exit (EXIT_FAILURE); } if (tmp < IPMI_CHASSIS_IDENTIFY_INTERVAL_MIN || tmp > IPMI_CHASSIS_IDENTIFY_INTERVAL_MAX) { fprintf (stderr, "chassis-identify interval out of range\n"); exit (EXIT_FAILURE); } cmd_args->chassis_identify_args.identify_interval = 1; cmd_args->chassis_identify_args.identify_interval_arg = tmp; cmd_args->chassis_identify_args.force_identify = 0; } cmd_args->chassis_identify++; break; case SET_POWER_RESTORE_POLICY_KEY: if (!strcasecmp (arg, "always-on")) cmd_args->set_power_restore_policy_arg = IPMI_POWER_RESTORE_POLICY_ALWAYS_POWER_UP_AFTER_AC_IS_LOST; else if (!strcasecmp (arg, "always-off")) cmd_args->set_power_restore_policy_arg = IPMI_POWER_RESTORE_POLICY_ALWAYS_STAY_POWERED_OFF; else if (!strcasecmp (arg, "restore")) cmd_args->set_power_restore_policy_arg = IPMI_POWER_RESTORE_POLICY_RESTORE_POWER_TO_STATE_WHEN_AC_WAS_LOST; else if (!strcasecmp (arg, "list-supported-policies")) cmd_args->set_power_restore_policy_arg = IPMI_POWER_RESTORE_POLICY_NO_CHANGE; else { fprintf (stderr, "invalid value for power restore policy\n"); exit (EXIT_FAILURE); } cmd_args->set_power_restore_policy++; break; case SET_POWER_CYCLE_INTERVAL_KEY: errno = 0; tmp = strtol (arg, &endptr, 10); if (errno || endptr[0] != '\0') { fprintf (stderr, "invalid value for power cycle interval\n"); exit (EXIT_FAILURE); } if (tmp < IPMI_CHASSIS_POWER_CYCLE_INTERVAL_MIN || tmp > IPMI_CHASSIS_POWER_CYCLE_INTERVAL_MAX) { fprintf (stderr, "power-cycle interval out of range\n"); exit (EXIT_FAILURE); } cmd_args->set_power_cycle_interval_arg = tmp; cmd_args->set_power_cycle_interval++; break; case GET_SYSTEM_RESTART_CAUSE_KEY: cmd_args->get_system_restart_cause++; break; case SET_BOOT_FLAGS_KEY: cmd_args->set_system_boot_options++; break; case GET_BOOT_FLAGS_KEY: cmd_args->get_system_boot_options++; break; case GET_POWER_ON_HOURS_COUNTER_KEY: cmd_args->get_power_on_hours_counter++; break; case ARGP_KEY_ARG: /* Too many arguments. */ argp_usage (state); break; case ARGP_KEY_END: break; default: ret = boot_flag_parse (key, arg, state); if (ret == ARGP_ERR_UNKNOWN) ret = common_parse_opt (key, arg, &(cmd_args->common_args)); return (ret); } return (0); }
static error_t cmdline_parse (int key, char *arg, struct argp_state *state) { struct ipmi_raw_arguments *cmd_args; error_t ret; char *endptr; assert (state); cmd_args = state->input; switch (key) { case CHANNEL_NUMBER_KEY: ret = common_parse_opt (ARGP_TARGET_CHANNEL_NUMBER_KEY, arg, &(cmd_args->common_args)); if (ret == ARGP_ERR_UNKNOWN) return (ret); break; case SLAVE_ADDRESS_KEY: ret = common_parse_opt (ARGP_TARGET_SLAVE_ADDRESS_KEY, arg, &(cmd_args->common_args)); if (ret == ARGP_ERR_UNKNOWN) return (ret); break; case CMD_FILE_KEY: if (!(cmd_args->cmd_file = strdup (arg))) { perror ("strdup"); exit (EXIT_FAILURE); } break; case ARGP_KEY_ARG: { unsigned int i; long value; if (strlen (arg) >= 2) { if (!strncmp (arg, "0x", 2)) arg+=2; } if (*arg == '\0') { fprintf (stderr, "invalid hex byte argument\n"); exit (EXIT_FAILURE); } for (i = 0; arg[i] != '\0'; i++) { if (i >= 2) { fprintf (stderr, "invalid hex byte argument\n"); exit (EXIT_FAILURE); } if (!isxdigit (arg[i])) { fprintf (stderr, "invalid hex byte argument\n"); exit (EXIT_FAILURE); } } if (cmd_args->cmd_length < IPMI_RAW_MAX_ARGS) { errno = 0; value = strtol (arg, &endptr, 16); if (errno || endptr[0] != '\0') { fprintf (stderr, "invalid hex byte argument\n"); exit (EXIT_FAILURE); } cmd_args->cmd[cmd_args->cmd_length++] = (uint8_t) value; } else { fprintf (stderr, "Too many arguments specified\n"); exit (EXIT_FAILURE); } break; } case ARGP_KEY_END: break; default: return (common_parse_opt (key, arg, &(cmd_args->common_args))); } return (0); }
static error_t cmdline_parse (int key, char *arg, struct argp_state *state) { struct ipmi_dcmi_arguments *cmd_args; char *endptr = NULL; int tmp; long long lltmp; assert (state); cmd_args = state->input; switch (key) { case GET_DCMI_CAPABILITY_INFO: cmd_args->get_dcmi_capability_info++; break; case GET_ASSET_TAG: cmd_args->get_asset_tag++; break; case SET_ASSET_TAG: cmd_args->set_asset_tag++; cmd_args->set_asset_tag_arg = arg; /* achu: note that the check for the max asset tag length and * the management controller identifier string are different. * The spec is written such that the max length of the asset tag * is 63, while the max length of the management controller * identifier string is 64 w/ a NUL byte included. That's the * literal wording. Because that's what they're writing, that's * what I'm programming. */ if (strlen (cmd_args->set_asset_tag_arg) > IPMI_DCMI_MAX_ASSET_TAG_LENGTH) { fprintf (stderr, "asset tag invalid length\n"); exit (EXIT_FAILURE); } break; case GET_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING: cmd_args->get_management_controller_identifier_string++; break; case SET_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING: cmd_args->set_management_controller_identifier_string++; cmd_args->set_management_controller_identifier_string_arg = arg; /* IPMI_DCMI_MAX_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING_LENGTH includes NUL char, so subtract 1 in check */ if (strlen (cmd_args->set_management_controller_identifier_string_arg) > (IPMI_DCMI_MAX_MANAGEMENT_CONTROLLER_IDENTIFIER_STRING_LENGTH - 1)) { fprintf (stderr, "management controller identifier string invalid length\n"); exit (EXIT_FAILURE); } break; case GET_DCMI_SENSOR_INFO: cmd_args->get_dcmi_sensor_info++; break; case GET_SYSTEM_POWER_STATISTICS: cmd_args->get_system_power_statistics++; break; case GET_ENHANCED_SYSTEM_POWER_STATISTICS: cmd_args->get_enhanced_system_power_statistics++; break; case GET_POWER_LIMIT: cmd_args->get_power_limit++; break; case SET_POWER_LIMIT: cmd_args->set_power_limit++; break; case EXCEPTION_ACTIONS: /* special case */ if (!strcasecmp (arg, "NO_ACTION")) { cmd_args->exception_actions_arg = IPMI_DCMI_EXCEPTION_ACTION_NO_ACTION; break; } else if (!strcasecmp (arg, "HARD_POWER_OFF_SYSTEM")) { cmd_args->exception_actions_arg = IPMI_DCMI_EXCEPTION_ACTION_HARD_POWER_OFF_SYSTEM; break; } else if (!strcasecmp (arg, "LOG_EVENT_TO_SEL_ONLY")) { cmd_args->exception_actions_arg = IPMI_DCMI_EXCEPTION_ACTION_LOG_EVENT_TO_SEL_ONLY; break; } errno = 0; tmp = strtol (arg, &endptr, 0); if (errno || endptr[0] != '\0') { fprintf (stderr, "invalid value for exception actions\n"); exit (EXIT_FAILURE); } if (tmp < IPMI_DCMI_EXCEPTION_ACTIONS_MIN || tmp > IPMI_DCMI_EXCEPTION_ACTIONS_MAX) { fprintf (stderr, "exception actions out of range\n"); exit (EXIT_FAILURE); } cmd_args->exception_actions_arg = tmp; cmd_args->exception_actions++; break; case POWER_LIMIT_REQUESTED: errno = 0; tmp = strtol (arg, &endptr, 10); if (errno || endptr[0] != '\0') { fprintf (stderr, "invalid value for power limit requested\n"); exit (EXIT_FAILURE); } if (tmp < IPMI_DCMI_POWER_LIMIT_REQUESTED_MIN || tmp > IPMI_DCMI_POWER_LIMIT_REQUESTED_MAX) { fprintf (stderr, "power limit requested out of range\n"); exit (EXIT_FAILURE); } cmd_args->power_limit_requested_arg = tmp; cmd_args->power_limit_requested++; break; case CORRECTION_TIME_LIMIT: errno = 0; lltmp = strtoll (arg, &endptr, 10); if (errno || endptr[0] != '\0') { fprintf (stderr, "invalid value for correction time limit\n"); exit (EXIT_FAILURE); } if (lltmp < IPMI_DCMI_CORRECTION_TIME_LIMIT_MIN || lltmp > IPMI_DCMI_CORRECTION_TIME_LIMIT_MAX) { fprintf (stderr, "correction time limit out of range\n"); exit (EXIT_FAILURE); } cmd_args->correction_time_limit_arg = lltmp; cmd_args->correction_time_limit++; break; case STATISTICS_SAMPLING_PERIOD: errno = 0; tmp = strtol (arg, &endptr, 10); if (errno || endptr[0] != '\0') { fprintf (stderr, "invalid value for statistics sampling period\n"); exit (EXIT_FAILURE); } if (tmp < IPMI_DCMI_MANAGEMENT_APPLICATION_STATISTICS_SAMPLING_PERIOD_MIN || tmp > IPMI_DCMI_MANAGEMENT_APPLICATION_STATISTICS_SAMPLING_PERIOD_MAX) { fprintf (stderr, "statistics sampling period out of range\n"); exit (EXIT_FAILURE); } cmd_args->statistics_sampling_period_arg = tmp; cmd_args->statistics_sampling_period++; break; case ACTIVATE_DEACTIVATE_POWER_LIMIT: if (!strcasecmp (arg, "ACTIVATE")) cmd_args->activate_deactivate_power_limit_arg = IPMI_DCMI_POWER_LIMIT_ACTIVATION_ACTIVATE_POWER_LIMIT; else if (!strcasecmp (arg, "DEACTIVATE")) cmd_args->activate_deactivate_power_limit_arg = IPMI_DCMI_POWER_LIMIT_ACTIVATION_DEACTIVATE_POWER_LIMIT; else { fprintf (stderr, "invalid value for activate/deactivate power limit\n"); exit (EXIT_FAILURE); } cmd_args->activate_deactivate_power_limit++; break; case INTERPRET_OEM_DATA_KEY: cmd_args->interpret_oem_data = 1; break; case ARGP_KEY_ARG: /* Too many arguments. */ argp_usage (state); break; case ARGP_KEY_END: break; default: return (common_parse_opt (key, arg, &(cmd_args->common_args))); } return (0); }
/* Parse a single option. */ static error_t cmdline_parse (int key, char *arg, struct argp_state *state) { struct ipmi_config_arguments *cmd_args; struct ipmi_config_keypair *kp = NULL; struct ipmi_config_section_str *sstr = NULL; char *section_name = NULL; char *key_name = NULL; char *value = NULL; assert (state); cmd_args = state->input; switch (key) { case IPMI_CONFIG_ARGP_CATEGORY_KEY: if (_ipmi_config_category (arg, &(cmd_args->category_mask)) < 0) exit (EXIT_FAILURE); break; case IPMI_CONFIG_ARGP_CHECKOUT_KEY: if (!cmd_args->action) cmd_args->action = IPMI_CONFIG_ACTION_CHECKOUT; else cmd_args->action = -1; break; case IPMI_CONFIG_ARGP_COMMIT_KEY: if (!cmd_args->action) cmd_args->action = IPMI_CONFIG_ACTION_COMMIT; else cmd_args->action = -1; break; case IPMI_CONFIG_ARGP_DIFF_KEY: if (!cmd_args->action) cmd_args->action = IPMI_CONFIG_ACTION_DIFF; else cmd_args->action = -1; break; case IPMI_CONFIG_ARGP_FILENAME_KEY: case IPMI_CONFIG_ARGP_FILENAME_KEY_LEGACY: free (cmd_args->filename); if (!(cmd_args->filename = strdup (arg))) { perror ("strdup"); exit (EXIT_FAILURE); } break; case IPMI_CONFIG_ARGP_KEYPAIR_KEY: if (_ipmi_config_keypair_parse_string (arg, §ion_name, &key_name, &value) < 0) exit (EXIT_FAILURE); if (!(kp = _ipmi_config_keypair_create (section_name, key_name, value))) exit (EXIT_FAILURE); if (_ipmi_config_keypair_append (&(cmd_args->keypairs), kp) < 0) exit (EXIT_FAILURE); free (section_name); free (key_name); free (value); break; case IPMI_CONFIG_ARGP_SECTIONS_KEY: if (!(sstr = _ipmi_config_section_str_create (arg))) exit (EXIT_FAILURE); if (_ipmi_config_section_str_append (&(cmd_args->section_strs), sstr) < 0) exit (EXIT_FAILURE); sstr = NULL; break; case IPMI_CONFIG_ARGP_LIST_SECTIONS_KEY: if (!cmd_args->action) cmd_args->action = IPMI_CONFIG_ACTION_LIST_SECTIONS; else cmd_args->action = -1; break; case IPMI_CONFIG_ARGP_VERBOSE_KEY: cmd_args->verbose_count++; break; case IPMI_CONFIG_ARGP_LAN_CHANNEL_NUMBER_KEY: if (_ipmi_config_parse_channel_number (arg, &(cmd_args->lan_channel_number), &(cmd_args->lan_channel_number_set)) < 0) exit (EXIT_FAILURE); break; case IPMI_CONFIG_ARGP_SERIAL_CHANNEL_NUMBER_KEY: if (_ipmi_config_parse_channel_number (arg, &(cmd_args->serial_channel_number), &(cmd_args->serial_channel_number_set)) < 0) exit (EXIT_FAILURE); break; case IPMI_CONFIG_ARGP_SOL_CHANNEL_NUMBER_KEY: if (_ipmi_config_parse_channel_number (arg, &(cmd_args->sol_channel_number), &(cmd_args->sol_channel_number_set)) < 0) exit (EXIT_FAILURE); break; case IPMI_CONFIG_ARGP_PEF_INFO_KEY: /* legacy */ cmd_args->info++; break; case ARGP_KEY_ARG: /* Too many arguments. */ argp_usage (state); break; case ARGP_KEY_END: break; default: return (common_parse_opt (key, arg, &cmd_args->common_args)); } return (0); }