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