int
ipmi_monitoring_sdr_cache_flush (ipmi_monitoring_ctx_t c,
const char *hostname)
{
char filename[MAXPATHLEN+1];
assert (c);
assert (c->magic == IPMI_MONITORING_MAGIC);
if (_ipmi_monitoring_sdr_cache_filename (c, hostname, filename, MAXPATHLEN + 1) < 0)
goto cleanup;
if (_ipmi_monitoring_sdr_ctx_init (c, hostname) < 0)
goto cleanup;
if (_ipmi_monitoring_sdr_cache_delete (c, hostname, filename) < 0)
goto cleanup;
return (0);
cleanup:
ipmi_sdr_ctx_destroy (c->sdr_ctx);
c->sdr_ctx = NULL;
return (-1);
}
void
ipmi_sensor_read_ctx_destroy (ipmi_sensor_read_ctx_t ctx)
{
if (!ctx || ctx->magic != IPMI_SENSOR_READ_CTX_MAGIC)
return;
ctx->magic = ~IPMI_SENSOR_READ_CTX_MAGIC;
ipmi_sdr_ctx_destroy (ctx->sdr_ctx);
free (ctx);
}
static int
_ipmi_oem (pstdout_state_t pstate,
const char *hostname,
void *arg)
{
ipmi_oem_state_data_t state_data;
ipmi_oem_prog_data_t *prog_data;
int exit_code = EXIT_FAILURE;
assert (pstate);
assert (arg);
prog_data = (ipmi_oem_prog_data_t *)arg;
if (prog_data->args->common_args.flush_cache)
{
if (sdr_cache_flush_cache (pstate,
hostname,
&prog_data->args->common_args) < 0)
return (EXIT_FAILURE);
return (EXIT_SUCCESS);
}
memset (&state_data, '\0', sizeof (ipmi_oem_state_data_t));
state_data.prog_data = prog_data;
state_data.pstate = pstate;
state_data.hostname = (char *)hostname;
/* Special case, we're going to output help info, don't do an IPMI connection */
if (prog_data->args->oem_command)
{
if (!(state_data.ipmi_ctx = ipmi_open (prog_data->progname,
hostname,
&(prog_data->args->common_args),
state_data.pstate)))
goto cleanup;
}
if (!(state_data.sdr_ctx = ipmi_sdr_ctx_create ()))
{
pstdout_perror (pstate, "ipmi_sdr_ctx_create()");
goto cleanup;
}
if (run_cmd_args (&state_data) < 0)
goto cleanup;
exit_code = EXIT_SUCCESS;
cleanup:
ipmi_sdr_ctx_destroy (state_data.sdr_ctx);
ipmi_ctx_close (state_data.ipmi_ctx);
ipmi_ctx_destroy (state_data.ipmi_ctx);
return (exit_code);
}
int
ipmi_monitoring_sdr_cache_unload (ipmi_monitoring_ctx_t c)
{
assert (c);
assert (c->magic == IPMI_MONITORING_MAGIC);
ipmi_sdr_cache_close (c->sdr_ctx);
ipmi_sdr_ctx_destroy (c->sdr_ctx);
c->sdr_ctx = NULL;
return (0);
}
ipmi_sensor_read_ctx_t
ipmi_sensor_read_ctx_create (ipmi_ctx_t ipmi_ctx)
{
struct ipmi_sensor_read_ctx *ctx = NULL;
if (!ipmi_ctx)
{
SET_ERRNO (EINVAL);
return (NULL);
}
/* check that ipmi_ctx is open for use */
if (ipmi_ctx_get_target (ipmi_ctx, NULL, NULL) < 0)
{
SET_ERRNO (EINVAL);
return (NULL);
}
if (!(ctx = (ipmi_sensor_read_ctx_t)malloc (sizeof (struct ipmi_sensor_read_ctx))))
{
ERRNO_TRACE (errno);
return (NULL);
}
ctx->magic = IPMI_SENSOR_READ_CTX_MAGIC;
ctx->flags = IPMI_SENSOR_READ_FLAGS_DEFAULT;
ctx->ipmi_ctx = ipmi_ctx;
ctx->sdr_ctx = NULL;
if (!(ctx->sdr_ctx = ipmi_sdr_ctx_create ()))
{
ERRNO_TRACE (errno);
goto cleanup;
}
return (ctx);
cleanup:
if (ctx)
{
ipmi_sdr_ctx_destroy (ctx->sdr_ctx);
free (ctx);
}
return (NULL);
}
static int
_find_sensor (ipmi_oem_state_data_t *state_data,
uint8_t sensor_number,
char *id_string,
unsigned int id_string_len)
{
struct ipmi_oem_ibm_find_sensor_sdr_callback sdr_callback_arg;
struct common_cmd_args common_args;
ipmi_sdr_ctx_t tmp_sdr_ctx = NULL;
int rv = -1;
assert (state_data);
assert (id_string);
assert (id_string_len);
/* Make temporary sdr cache to search for sensor
*
* Redo loading of SDR cache since this is being called from a loop
* using the state_data sdr_ctx.
*/
if (!(tmp_sdr_ctx = ipmi_sdr_ctx_create ()))
{
pstdout_perror (state_data->pstate, "ipmi_sdr_ctx_create()");
goto cleanup;
}
sdr_callback_arg.state_data = state_data;
sdr_callback_arg.sensor_number = sensor_number;
sdr_callback_arg.id_string = id_string;
sdr_callback_arg.id_string_len = id_string_len;
sdr_callback_arg.found = 0;
/* Should not cause sdr recreation, since this is the second time we're calling it */
memcpy (&common_args, &state_data->prog_data->args->common_args, sizeof (struct common_cmd_args));
common_args.quiet_cache = 1;
common_args.sdr_cache_recreate = 0;
if (sdr_cache_create_and_load (tmp_sdr_ctx,
state_data->pstate,
state_data->ipmi_ctx,
state_data->hostname,
&common_args) < 0)
goto cleanup;
if (ipmi_sdr_cache_iterate (tmp_sdr_ctx,
_find_sensor_sdr_callback,
&sdr_callback_arg) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_cache_iterate: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
goto cleanup;
}
if (!sdr_callback_arg.found)
snprintf (id_string,
id_string_len,
"Sensor Number = %02Xh",
sensor_number);
rv = 0;
cleanup:
ipmi_sdr_ctx_destroy (tmp_sdr_ctx);
return (rv);
}
int
ipmi_monitoring_sdr_cache_load (ipmi_monitoring_ctx_t c,
const char *hostname,
unsigned int sdr_create_flags)
{
char filename[MAXPATHLEN+1];
assert (c);
assert (c->magic == IPMI_MONITORING_MAGIC);
assert (c->ipmi_ctx);
memset (filename, '\0', MAXPATHLEN + 1);
if (_ipmi_monitoring_sdr_cache_filename (c, hostname, filename, MAXPATHLEN + 1) < 0)
goto cleanup;
if (_ipmi_monitoring_sdr_ctx_init (c, hostname) < 0)
goto cleanup;
if (ipmi_sdr_cache_open (c->sdr_ctx,
c->ipmi_ctx,
filename) < 0)
{
if (ipmi_sdr_ctx_errnum (c->sdr_ctx) == IPMI_SDR_ERR_CACHE_READ_CACHE_DOES_NOT_EXIST)
{
if (_ipmi_monitoring_sdr_cache_retrieve (c, hostname, filename, sdr_create_flags) < 0)
goto cleanup;
}
else if (ipmi_sdr_ctx_errnum (c->sdr_ctx) == IPMI_SDR_ERR_CACHE_INVALID
|| ipmi_sdr_ctx_errnum (c->sdr_ctx) == IPMI_SDR_ERR_CACHE_OUT_OF_DATE)
{
if (_ipmi_monitoring_sdr_cache_delete (c, hostname, filename) < 0)
goto cleanup;
if (_ipmi_monitoring_sdr_cache_retrieve (c, hostname, filename, sdr_create_flags) < 0)
goto cleanup;
}
else if (ipmi_sdr_ctx_errnum (c->sdr_ctx) == IPMI_SDR_ERR_FILESYSTEM)
{
c->errnum = IPMI_MONITORING_ERR_SDR_CACHE_FILESYSTEM;
goto cleanup;
}
else if (ipmi_sdr_ctx_errnum (c->sdr_ctx) == IPMI_SDR_ERR_PERMISSION)
{
c->errnum = IPMI_MONITORING_ERR_SDR_CACHE_PERMISSION;
goto cleanup;
}
else
{
IPMI_MONITORING_DEBUG (("ipmi_sdr_cache_open: %s", ipmi_sdr_ctx_errormsg (c->sdr_ctx)));
c->errnum = IPMI_MONITORING_ERR_INTERNAL_ERROR;
goto cleanup;
}
/* 2nd try after the sdr was retrieved*/
if (ipmi_sdr_cache_open (c->sdr_ctx,
c->ipmi_ctx,
filename) < 0)
{
if (ipmi_sdr_ctx_errnum (c->sdr_ctx) == IPMI_SDR_ERR_FILESYSTEM)
{
c->errnum = IPMI_MONITORING_ERR_SDR_CACHE_FILESYSTEM;
goto cleanup;
}
else if (ipmi_sdr_ctx_errnum (c->sdr_ctx) == IPMI_SDR_ERR_PERMISSION)
{
c->errnum = IPMI_MONITORING_ERR_SDR_CACHE_PERMISSION;
goto cleanup;
}
else
{
IPMI_MONITORING_DEBUG (("ipmi_sdr_cache_open: %s", ipmi_sdr_ctx_errormsg (c->sdr_ctx)));
c->errnum = IPMI_MONITORING_ERR_INTERNAL_ERROR;
goto cleanup;
}
}
}
return (0);
cleanup:
if (strlen (filename))
ipmi_sdr_cache_delete (c->sdr_ctx, filename);
ipmi_sdr_ctx_destroy (c->sdr_ctx);
c->sdr_ctx = NULL;
return (-1);
}
static int
_ipmi_sensors_config (pstdout_state_t pstate,
const char *hostname,
void *arg)
{
ipmi_sensors_config_state_data_t state_data;
ipmi_sensors_config_prog_data_t *prog_data;
int exit_code = EXIT_FAILURE;
config_err_t ret = 0;
int file_opened = 0;
FILE *fp = NULL; /* init NULL to remove warnings */
assert (pstate);
assert (arg);
prog_data = (ipmi_sensors_config_prog_data_t *) arg;
if (prog_data->args->config_args.common_args.flush_cache)
{
if (sdr_cache_flush_cache (pstate,
hostname,
&prog_data->args->config_args.common_args) < 0)
return (EXIT_FAILURE);
return (EXIT_SUCCESS);
}
memset (&state_data, '\0', sizeof (ipmi_sensors_config_state_data_t));
state_data.prog_data = prog_data;
state_data.pstate = pstate;
if (!(state_data.ipmi_ctx = ipmi_open (prog_data->progname,
hostname,
&(prog_data->args->config_args.common_args),
state_data.pstate)))
goto cleanup;
if (!(state_data.sdr_ctx = ipmi_sdr_ctx_create ()))
{
pstdout_perror (pstate, "ipmi_sdr_ctx_create()");
goto cleanup;
}
if (sdr_cache_create_and_load (state_data.sdr_ctx,
NULL,
state_data.ipmi_ctx,
hostname,
&state_data.prog_data->args->config_args.common_args) < 0)
goto cleanup;
if (!(state_data.sections = ipmi_sensors_config_sections_create (&state_data)))
goto cleanup;
if (prog_data->args->config_args.action == CONFIG_ACTION_CHECKOUT)
{
if (prog_data->args->config_args.filename)
{
if (prog_data->hosts_count > 1)
{
pstdout_fprintf (pstate,
stderr,
"Cannot output multiple host checkout into a single file\n");
goto cleanup;
}
if (!(fp = fopen (prog_data->args->config_args.filename, "w")))
{
pstdout_perror (pstate, "fopen");
goto cleanup;
}
file_opened++;
}
else
fp = stdout;
}
else if (prog_data->args->config_args.action == CONFIG_ACTION_COMMIT
|| prog_data->args->config_args.action == CONFIG_ACTION_DIFF)
{
if (prog_data->args->config_args.filename
&& strcmp (prog_data->args->config_args.filename, "-"))
{
if (!(fp = fopen (prog_data->args->config_args.filename, "r")))
{
pstdout_perror (pstate, "fopen");
goto cleanup;
}
file_opened++;
}
else
fp = stdin;
}
/* parse if there is an input file or no pairs at all */
if ((prog_data->args->config_args.action == CONFIG_ACTION_COMMIT
&& prog_data->args->config_args.filename)
|| (prog_data->args->config_args.action == CONFIG_ACTION_COMMIT
&& !prog_data->args->config_args.filename
&& !prog_data->args->config_args.keypairs)
|| (prog_data->args->config_args.action == CONFIG_ACTION_DIFF
&& prog_data->args->config_args.filename)
|| (prog_data->args->config_args.action == CONFIG_ACTION_DIFF
&& !prog_data->args->config_args.filename
&& !prog_data->args->config_args.keypairs))
{
if (config_parse (pstate,
state_data.sections,
&(prog_data->args->config_args),
fp) < 0)
{
/* errors printed in function call */
goto cleanup;
}
}
/* note: argp validation catches if user specified keypair and
filename for a diff
*/
if ((prog_data->args->config_args.action == CONFIG_ACTION_CHECKOUT
|| prog_data->args->config_args.action == CONFIG_ACTION_COMMIT
|| prog_data->args->config_args.action == CONFIG_ACTION_DIFF)
&& prog_data->args->config_args.keypairs)
{
if (config_sections_insert_keyvalues (pstate,
state_data.sections,
prog_data->args->config_args.keypairs) < 0)
{
/* errors printed in function call */
goto cleanup;
}
}
if (prog_data->args->config_args.action == CONFIG_ACTION_COMMIT
|| prog_data->args->config_args.action == CONFIG_ACTION_DIFF)
{
int num;
if ((num = config_sections_validate_keyvalue_inputs (pstate,
state_data.sections,
&state_data)) < 0)
goto cleanup;
/* some errors found */
if (num)
goto cleanup;
}
if (prog_data->args->config_args.action == CONFIG_ACTION_CHECKOUT
&& prog_data->args->config_args.section_strs)
{
struct config_section_str *sstr;
sstr = prog_data->args->config_args.section_strs;
while (sstr)
{
if (!config_find_section (state_data.sections,
sstr->section_name))
{
pstdout_fprintf (pstate,
stderr,
"Unknown section `%s'\n",
sstr->section_name);
goto cleanup;
}
sstr = sstr->next;
}
}
switch (prog_data->args->config_args.action)
{
case CONFIG_ACTION_CHECKOUT:
if (prog_data->args->config_args.section_strs)
{
struct config_section_str *sstr;
/* note: argp validation catches if user specified --section
* and --keypair, so all_keys_if_none_specified should be '1'.
*/
sstr = prog_data->args->config_args.section_strs;
while (sstr)
{
struct config_section *s;
config_err_t this_ret;
if (!(s = config_find_section (state_data.sections,
sstr->section_name)))
{
pstdout_fprintf (pstate,
stderr,
"## FATAL: Cannot checkout section '%s'\n",
sstr->section_name);
continue;
}
this_ret = config_checkout_section (pstate,
s,
&(prog_data->args->config_args),
1,
fp,
75,
&state_data);
if (this_ret != CONFIG_ERR_SUCCESS)
ret = this_ret;
if (ret == CONFIG_ERR_FATAL_ERROR)
break;
sstr = sstr->next;
}
}
else
{
int all_keys_if_none_specified = 0;
if (!prog_data->args->config_args.keypairs)
all_keys_if_none_specified++;
ret = config_checkout (pstate,
state_data.sections,
&(prog_data->args->config_args),
all_keys_if_none_specified,
fp,
75,
&state_data);
}
break;
case CONFIG_ACTION_COMMIT:
ret = config_commit (pstate,
state_data.sections,
&(prog_data->args->config_args),
&state_data);
break;
case CONFIG_ACTION_DIFF:
ret = config_diff (pstate,
state_data.sections,
&(prog_data->args->config_args),
&state_data);
break;
case CONFIG_ACTION_LIST_SECTIONS:
ret = config_output_sections_list (pstate, state_data.sections);
break;
}
if (ret == CONFIG_ERR_FATAL_ERROR)
{
exit_code = CONFIG_FATAL_EXIT_VALUE;
goto cleanup;
}
if (ret == CONFIG_ERR_NON_FATAL_ERROR)
{
exit_code = CONFIG_NON_FATAL_EXIT_VALUE;
goto cleanup;
}
exit_code = EXIT_SUCCESS;
cleanup:
ipmi_sdr_ctx_destroy (state_data.sdr_ctx);
ipmi_ctx_close (state_data.ipmi_ctx);
ipmi_ctx_destroy (state_data.ipmi_ctx);
config_sections_destroy (state_data.sections);
if (file_opened)
fclose (fp);
return (exit_code);
}
