NetBSD-5.0.2/usr.sbin/envstat/config.c
/* $NetBSD: config.c,v 1.8 2008/08/22 11:27:50 pgoyette Exp $ */
/*-
* Copyright (c) 2007 Juan Romero Pardines.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: config.c,v 1.8 2008/08/22 11:27:50 pgoyette Exp $");
#endif /* not lint */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <err.h>
#include <errno.h>
#include <sys/queue.h>
#include <prop/proplib.h>
#include "envstat.h"
/*
* Singly linked list for dictionaries that store properties
* in a sensor.
*/
static SLIST_HEAD(, sensor_block) sensor_block_list =
SLIST_HEAD_INITIALIZER(&sensor_block_list);
/*
* Singly linked list for devices that store a proplib array
* device with a device name.
*/
static SLIST_HEAD(, device_block) device_block_list =
SLIST_HEAD_INITIALIZER(&device_block_list);
enum {
VALUE_ERR,
PROP_ERR,
SENSOR_ERR,
DEV_ERR
};
static prop_dictionary_t cfdict, sensordict, refreshdict;
static void config_errmsg(int, const char *, const char *);
static void
config_errmsg(int lvl, const char *key, const char *key2)
{
(void)printf("envstat: ");
switch (lvl) {
case VALUE_ERR:
(void)printf("invalid value for '%s' in `%s'\n",
key, key2);
break;
case PROP_ERR:
(void)printf("the '%s' property is not allowed "
"in `%s'\n", key, key2);
break;
case SENSOR_ERR:
(void)printf("'%s' is not a valid sensor in the "
"`%s' device\n", key, key2);
break;
case DEV_ERR:
(void)printf("device `%s' doesn't exist\n", key);
break;
}
(void)printf("envstat: please fix the configuration file!\n");
exit(EXIT_FAILURE);
}
/*
* Adds a property into a temporary dictionary.
*/
void
config_dict_add_prop(const char *key, char *value)
{
if (!key || !value)
return;
if (!sensordict) {
sensordict = prop_dictionary_create();
if (!sensordict)
err(EXIT_FAILURE, "sensordict");
}
if (!prop_dictionary_set_cstring(sensordict, key, value))
err(EXIT_FAILURE, "prop_dict_set_cstring");
}
/*
* Marks sensor's dictionary to say that it's the last property
* and the dictionary should be added into the singly linked list.
*/
void
config_dict_mark(void)
{
struct sensor_block *sb;
sb = calloc(1, sizeof(*sb));
if (!sb)
err(EXIT_FAILURE, "!sb");
sb->dict = prop_dictionary_create();
if (!sb->dict)
err(EXIT_FAILURE, "!sb->dict");
sb->dict = prop_dictionary_copy(sensordict);
SLIST_INSERT_HEAD(&sensor_block_list, sb, sb_head);
config_dict_destroy(sensordict);
}
/*
* Only used for debugging purposses.
*/
void
config_dict_dump(prop_dictionary_t d)
{
char *buf;
buf = prop_dictionary_externalize(d);
(void)printf("%s", buf);
free(buf);
}
/*
* Returns the global dictionary.
*/
prop_dictionary_t
config_dict_parsed(void)
{
return cfdict;
}
/*
* To add device properties into the global array, for now only the
* 'refresh-timeout' property is accepted.
*/
void
config_dict_adddev_prop(const char *key, const char *value, int line)
{
prop_dictionary_t d = NULL;
uint64_t timo;
size_t len;
char *endptr, *tmp, *strval;
bool minutes, hours;
minutes = hours = false;
/*
* Check what was specified: seconds, minutes or hours.
*/
if ((tmp = strchr(value, 's'))) {
/*
* do nothing, by default the value will be sent as seconds.
*/
} else if ((tmp = strchr(value, 'm'))) {
minutes = true;
} else if ((tmp = strchr(value, 'h'))) {
hours = true;
} else
goto bad;
len = strlen(value);
strval = calloc(len, sizeof(*value));
if (!strval)
err(EXIT_FAILURE, "calloc");
(void)strlcpy(strval, value, len);
timo = strtoul(strval, &endptr, 10);
if (*endptr != '\0') {
free(strval);
goto bad;
}
free(strval);
refreshdict = prop_dictionary_create();
if (!refreshdict)
err(EXIT_FAILURE, "prop_dict_create refresh");
d = prop_dictionary_create();
if (!d)
err(EXIT_FAILURE, "prop_dict_create refresh 1");
if (minutes)
timo *= 60;
else if (hours) {
/*
* Make sure the value is not too high...
*/
if (timo > 999)
goto bad;
timo *= 60 * 60;
} else {
/*
* 1 second is the lowest value allowed.
*/
if (timo < 1)
goto bad;
}
if (!prop_dictionary_set_uint64(d, key, timo))
err(EXIT_FAILURE, "%s", key);
if (!prop_dictionary_set(refreshdict, "device-properties", d))
err(EXIT_FAILURE, "device-properties %s", key);
prop_object_release(d);
return;
bad:
(void)printf("envstat: invalid value for the '%s' "
"property at line %d\n", key, line);
(void)printf("envstat: please fix the configuration file!\n");
if (d)
prop_object_release(d);
exit(EXIT_FAILURE);
}
/*
* Destroys all objects from a dictionary.
*/
void
config_dict_destroy(prop_dictionary_t d)
{
prop_object_iterator_t iter;
prop_object_t obj;
iter = prop_dictionary_iterator(d);
if (!iter)
err(EXIT_FAILURE, "!iter");
while ((obj = prop_object_iterator_next(iter)) != NULL) {
prop_dictionary_remove(d,
prop_dictionary_keysym_cstring_nocopy(obj));
prop_object_iterator_reset(iter);
}
prop_object_iterator_release(iter);
}
/*
* Parses all properties on the device and adds the device
* into the singly linked list for devices and the global dictionary.
*/
void
config_devblock_add(const char *key, prop_dictionary_t kdict)
{
struct device_block *db;
struct sensor_block *sb;
prop_array_t array;
prop_object_iterator_t iter;
prop_dictionary_t sdict;
prop_object_t obj;
prop_string_t lindex;
const char *sensor;
bool sensor_found = false;
if (!key)
err(EXIT_FAILURE, "devblock !key");
array = prop_dictionary_get(kdict, key);
if (!array)
config_errmsg(DEV_ERR, key, NULL);
SLIST_FOREACH(sb, &sensor_block_list, sb_head) {
/* get the index object value from configuration */
lindex = prop_dictionary_get(sb->dict, "index");
sensor = prop_string_cstring_nocopy(lindex);
iter = prop_array_iterator(array);
if (!iter)
err(EXIT_FAILURE, "prop_array_iterator devblock");
/*
* Get the correct sensor's dictionary from kernel's
* dictionary.
*/
while ((sdict = prop_object_iterator_next(iter)) != NULL) {
obj = prop_dictionary_get(sdict, "index");
if (prop_string_equals(lindex, obj)) {
sensor_found = true;
break;
}
}
if (!sensor_found) {
prop_object_iterator_release(iter);
config_errmsg(SENSOR_ERR, sensor, key);
}
config_devblock_check_sensorprops(sdict, sb->dict, sensor);
prop_object_iterator_release(iter);
}
db = calloc(1, sizeof(*db));
if (!db)
err(EXIT_FAILURE, "calloc db");
db->array = prop_array_create();
if (!db->array)
err(EXIT_FAILURE, "prop_array_create devblock");
/*
* Add all dictionaries into the array.
*/
SLIST_FOREACH(sb, &sensor_block_list, sb_head)
if (!prop_array_add(db->array, sb->dict))
err(EXIT_FAILURE, "prop_array_add");
/*
* Add the device-properties dictionary into the array.
*/
if (refreshdict) {
if (!prop_array_add(db->array, refreshdict))
err(EXIT_FAILURE, "prop_array_add refreshdict");
prop_object_release(refreshdict);
}
/*
* Add this device block into our list.
*/
db->dev_key = strdup(key);
SLIST_INSERT_HEAD(&device_block_list, db, db_head);
/*
* Remove all items in the list, but just decrement
* the refcnt in the dictionaries... they are in use.
*/
while (!SLIST_EMPTY(&sensor_block_list)) {
sb = SLIST_FIRST(&sensor_block_list);
SLIST_REMOVE_HEAD(&sensor_block_list, sb_head);
prop_object_release(sb->dict);
free(sb);
}
/*
* Now the properties on the array has been parsed,
* add it into the global dict.
*/
if (!cfdict) {
cfdict = prop_dictionary_create();
if (!cfdict)
err(EXIT_FAILURE, "prop_dictionary_create cfdict");
}
if (!prop_dictionary_set(cfdict, key, db->array))
err(EXIT_FAILURE, "prop_dictionary_set db->array");
/*
* refreshdict must be NULLed to avoid false positives in
* next matches.
*/
refreshdict = NULL;
}
/*
* Returns the dictionary that has 'sensor_key' in the 'dvname'
* array.
*/
prop_dictionary_t
config_devblock_getdict(const char *dvname, const char *sensor_key)
{
struct device_block *db;
prop_object_iterator_t iter;
prop_object_t obj, obj2;
if (!dvname || !sensor_key)
return NULL;
SLIST_FOREACH(db, &device_block_list, db_head)
if (strcmp(db->dev_key, dvname) == 0)
break;
if (!db)
return NULL;
iter = prop_array_iterator(db->array);
if (!iter)
return NULL;
while ((obj = prop_object_iterator_next(iter)) != NULL) {
obj2 = prop_dictionary_get(obj, "index");
if (prop_string_equals_cstring(obj2, sensor_key))
break;
}
prop_object_iterator_release(iter);
return obj;
}
/*
* Checks that all properties specified in the configuration file
* are valid and updates the objects with proper values.
*/
void
config_devblock_check_sensorprops(prop_dictionary_t ksdict,
prop_dictionary_t csdict,
const char *sensor)
{
prop_object_t obj, obj2, obj3;
char *strval, *endptr;
double val;
/*
* rfact property set?
*/
obj = prop_dictionary_get(csdict, "rfact");
if (obj) {
obj2 = prop_dictionary_get(ksdict, "allow-rfact");
if (prop_bool_true(obj2)) {
strval = prop_string_cstring(obj);
val = strtod(strval, &endptr);
if (*endptr != '\0')
config_errmsg(VALUE_ERR, "rfact", sensor);
if (!prop_dictionary_set_uint32(csdict, "rfact", val))
err(EXIT_FAILURE, "dict_set rfact");
} else
config_errmsg(PROP_ERR, "rfact", sensor);
}
/*
* critical-capacity property set?
*/
obj = prop_dictionary_get(csdict, "critical-capacity");
if (obj) {
obj2 = prop_dictionary_get(ksdict, "want-percentage");
obj3 = prop_dictionary_get(ksdict, "monitoring-supported");
if (prop_bool_true(obj2) && prop_bool_true(obj3)) {
strval = prop_string_cstring(obj);
val = strtod(strval, &endptr);
if ((*endptr != '\0') || (val < 0 || val > 100))
config_errmsg(VALUE_ERR,
"critical-capacity",
sensor);
/*
* Convert the value to a valid percentage.
*/
obj = prop_dictionary_get(ksdict, "max-value");
val = (val / 100) * prop_number_integer_value(obj);
if (!prop_dictionary_set_uint32(csdict,
"critical-capacity",
val))
err(EXIT_FAILURE, "dict_set critcap");
} else
config_errmsg(PROP_ERR, "critical-capacity", sensor);
}
/*
* warning-capacity property set?
*/
obj = prop_dictionary_get(csdict, "warning-capacity");
if (obj) {
obj2 = prop_dictionary_get(ksdict, "want-percentage");
obj3 = prop_dictionary_get(ksdict, "monitoring-supported");
if (prop_bool_true(obj2) && prop_bool_true(obj3)) {
strval = prop_string_cstring(obj);
val = strtod(strval, &endptr);
if ((*endptr != '\0') || (val < 0 || val > 100))
config_errmsg(VALUE_ERR,
"warning-capacity",
sensor);
/*
* Convert the value to a valid percentage.
*/
obj = prop_dictionary_get(ksdict, "max-value");
val = (val / 100) * prop_number_integer_value(obj);
if (!prop_dictionary_set_uint32(csdict,
"warning-capacity",
val))
err(EXIT_FAILURE, "dict_set warncap");
} else
config_errmsg(PROP_ERR, "warning-capacity", sensor);
}
/*
* critical-max property set?
*/
obj = prop_dictionary_get(csdict, "critical-max");
if (obj) {
obj2 = prop_dictionary_get(ksdict, "monitoring-supported");
if (!prop_bool_true(obj2))
config_errmsg(PROP_ERR, "critical-max", sensor);
strval = prop_string_cstring(obj);
obj = convert_val_to_pnumber(ksdict, "critical-max",
sensor, strval);
if (!prop_dictionary_set(csdict, "critical-max", obj))
err(EXIT_FAILURE, "prop_dict_set cmax");
}
/*
* critical-min property set?
*/
obj = prop_dictionary_get(csdict, "critical-min");
if (obj) {
obj2 = prop_dictionary_get(ksdict, "monitoring-supported");
if (!prop_bool_true(obj2))
config_errmsg(PROP_ERR, "critical-min", sensor);
strval = prop_string_cstring(obj);
obj = convert_val_to_pnumber(ksdict, "critical-min",
sensor, strval);
if (!prop_dictionary_set(csdict, "critical-min", obj))
err(EXIT_FAILURE, "prop_dict_set cmin");
}
/*
* warning-max property set?
*/
obj = prop_dictionary_get(csdict, "warning-max");
if (obj) {
obj2 = prop_dictionary_get(ksdict, "monitoring-supported");
if (!prop_bool_true(obj2))
config_errmsg(PROP_ERR, "warning-max", sensor);
strval = prop_string_cstring(obj);
obj = convert_val_to_pnumber(ksdict, "warning-max",
sensor, strval);
if (!prop_dictionary_set(csdict, "warning-max", obj))
err(EXIT_FAILURE, "prop_dict_set wmax");
}
/*
* warning-min property set?
*/
obj = prop_dictionary_get(csdict, "warning-min");
if (obj) {
obj2 = prop_dictionary_get(ksdict, "monitoring-supported");
if (!prop_bool_true(obj2))
config_errmsg(PROP_ERR, "warning-min", sensor);
strval = prop_string_cstring(obj);
obj = convert_val_to_pnumber(ksdict, "warning-min",
sensor, strval);
if (!prop_dictionary_set(csdict, "warning-min", obj))
err(EXIT_FAILURE, "prop_dict_set wmin");
}
}
/*
* Conversions for critical-max and critical-min properties.
*/
prop_number_t
convert_val_to_pnumber(prop_dictionary_t kdict, const char *prop,
const char *sensor, char *value)
{
prop_object_t obj;
prop_number_t num;
double val, max, min;
char *strval, *tmp, *endptr;
bool celsius;
size_t len;
val = max = min = 0;
/*
* critical-max and critical-min are not allowed in
* battery sensors.
*/
obj = prop_dictionary_get(kdict, "want-percentage");
if (prop_bool_true(obj))
config_errmsg(PROP_ERR, prop, sensor);
/*
* Make the conversion for sensor's type.
*/
obj = prop_dictionary_get(kdict, "type");
if (prop_string_equals_cstring(obj, "Temperature")) {
tmp = strchr(value, 'C');
if (tmp)
celsius = true;
else {
tmp = strchr(value, 'F');
if (!tmp)
config_errmsg(VALUE_ERR, prop, sensor);
celsius = false;
}
len = strlen(value);
strval = calloc(len, sizeof(*value));
if (!strval)
err(EXIT_FAILURE, "calloc");
(void)strlcpy(strval, value, len);
val = strtod(strval, &endptr);
if (*endptr != '\0') {
free(strval);
config_errmsg(VALUE_ERR, prop, sensor);
}
/* convert to fahrenheit */
if (!celsius)
val = (val - 32.0) * (5.0 / 9.0);
/* convert to microKelvin */
val = val * 1000000 + 273150000;
num = prop_number_create_unsigned_integer(val);
free(strval);
} else if (prop_string_equals_cstring(obj, "Fan")) {
/* no conversion */
val = strtod(value, &endptr);
if (*endptr != '\0')
config_errmsg(VALUE_ERR, prop, sensor);
num = prop_number_create_unsigned_integer(val);
} else {
obj = prop_dictionary_get(kdict, "max-value");
if (obj)
max = prop_number_integer_value(obj);
obj = prop_dictionary_get(kdict, "min-value");
if (obj)
min = prop_number_integer_value(obj);
val = strtod(value, &endptr);
if (*endptr != '\0')
config_errmsg(VALUE_ERR, prop, sensor);
/* convert to m[V,W,Ohms] again */
val *= 1000000.0;
/*
* trying to set a value higher than the max
* assigned?
*/
if (max && val > max)
config_errmsg(VALUE_ERR, prop, sensor);
/*
* trying to set a value lower than the min
* assigned?
*/
if (min && val < min)
config_errmsg(VALUE_ERR, prop, sensor);
num = prop_number_create_integer(val);
}
return num;
}