* Copyright (c) 2007, 2008 Juan Romero Pardines.

/* $NetBSD: envstat.c,v 1.105 2025/04/01 11:39:19 brad Exp $ */

/*-
* Copyright (c) 2007, 2008 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: envstat.c,v 1.105 2025/04/01 11:39:19 brad Exp $");
#endif /* not lint */

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdarg.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <err.h>
#include <errno.h>
#include <mj.h>
#include <paths.h>
#include <syslog.h>
#include <time.h>
#include <sys/envsys.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/queue.h>
#include <prop/proplib.h>

#include "envstat.h"
#include "prog_ops.h"

#define ENVSYS_DFLAG 0x00000001 /* list registered devices */
#define ENVSYS_FFLAG 0x00000002 /* show temp in fahrenheit */
#define ENVSYS_LFLAG 0x00000004 /* list sensors */
#define ENVSYS_XFLAG 0x00000008 /* externalize dictionary */
#define ENVSYS_IFLAG 0x00000010 /* skip invalid sensors */
#define ENVSYS_SFLAG 0x00000020 /* remove all properties set */
#define ENVSYS_TFLAG 0x00000040 /* make statistics */
#define ENVSYS_NFLAG 0x00000080 /* print value only */
#define ENVSYS_KFLAG 0x00000100 /* show temp in kelvin */
#define ENVSYS_JFLAG 0x00000200 /* print the output in JSON */
#define ENVSYS_tFLAG 0x00000400 /* print a timestamp */

/* Sensors */
typedef struct envsys_sensor {
SIMPLEQ_ENTRY(envsys_sensor) entries;
int32_t cur_value;
int32_t max_value;
int32_t min_value;
int32_t critmin_value;
int32_t critmax_value;
int32_t warnmin_value;
int32_t warnmax_value;
char desc[ENVSYS_DESCLEN];
char type[ENVSYS_DESCLEN];
char index[ENVSYS_DESCLEN];
char drvstate[ENVSYS_DESCLEN];
char battcap[ENVSYS_DESCLEN];
char dvname[ENVSYS_DESCLEN];
bool invalid;
bool visible;
bool percentage;
} *sensor_t;

/* Sensor statistics */
typedef struct envsys_sensor_stats {
SIMPLEQ_ENTRY(envsys_sensor_stats) entries;
int32_t max;
int32_t min;
int32_t avg;
char desc[ENVSYS_DESCLEN];
} *sensor_stats_t;

/* Device properties */
typedef struct envsys_dvprops {
uint64_t refresh_timo;
/* more members could be added in the future */
} *dvprops_t;

/* A simple queue to manage all sensors */
static SIMPLEQ_HEAD(, envsys_sensor) sensors_list =
SIMPLEQ_HEAD_INITIALIZER(sensors_list);

/* A simple queue to manage statistics for all sensors */
static SIMPLEQ_HEAD(, envsys_sensor_stats) sensor_stats_list =
SIMPLEQ_HEAD_INITIALIZER(sensor_stats_list);

static unsigned int interval, flags, width;
static char *mydevname, *sensors;
static bool statistics;
static u_int header_passes;
static time_t timestamp;

static int parse_dictionary(int);
static int add_sensors(prop_dictionary_t, prop_dictionary_t, const char *, const char *);
static int send_dictionary(FILE *);
static int find_sensors(prop_array_t, const char *, dvprops_t);
static void print_sensors(void);
static void print_sensors_json(void);
static int check_sensors(const char *);
static int usage(void);

static int sysmonfd; /* fd of /dev/sysmon */

int main(int argc, char **argv)
{
prop_dictionary_t dict;
int c, rval = 0;
char *endptr, *configfile = NULL;
FILE *cf;

if (prog_init && prog_init() == -1)
err(1, "init failed");

setprogname(argv[0]);

while ((c = getopt(argc, argv, "c:Dd:fIi:jklnrSs:Ttw:Wx")) != -1) {
switch (c) {
case 'c': /* configuration file */
configfile = optarg;
break;
case 'D': /* list registered devices */
flags |= ENVSYS_DFLAG;
break;
case 'd': /* show sensors of a specific device */
mydevname = optarg;
break;
case 'f': /* display temperature in Fahrenheit */
flags |= ENVSYS_FFLAG;
break;
case 'I': /* Skips invalid sensors */
flags |= ENVSYS_IFLAG;
break;
case 'i': /* wait time between intervals */
interval = (unsigned int)strtoul(optarg, &endptr, 10);
if (*endptr != '\0')
errx(EXIT_FAILURE, "bad interval '%s'", optarg);
break;
case 'j':
flags |= ENVSYS_JFLAG;
break;
case 'k': /* display temperature in Kelvin */
flags |= ENVSYS_KFLAG;
break;
case 'l': /* list sensors */
flags |= ENVSYS_LFLAG;
break;
case 'n': /* print value only */
flags |= ENVSYS_NFLAG;
break;
case 'r':
/*
* This flag is noop.. it's only here for
* compatibility with the old implementation.
*/
break;
case 'S':
flags |= ENVSYS_SFLAG;
break;
case 's': /* only show specified sensors */
sensors = optarg;
break;
case 'T': /* make statistics */
flags |= ENVSYS_TFLAG;
break;
case 't': /* produce a timestamp */
flags |= ENVSYS_tFLAG;
break;
case 'w': /* width value for the lines */
width = (unsigned int)strtoul(optarg, &endptr, 10);
if (*endptr != '\0')
errx(EXIT_FAILURE, "bad width '%s'", optarg);
break;
case 'x': /* print the dictionary in raw format */
flags |= ENVSYS_XFLAG;
break;
case 'W': /* No longer used, retained for compatibility */
break;
case '?':
default:
usage();
/* NOTREACHED */
}
}

argc -= optind;
argv += optind;

if (argc > 0 && (flags & ENVSYS_XFLAG) == 0)
usage();

/* Check if we want to make statistics */
if (flags & ENVSYS_TFLAG) {
if (!interval)
errx(EXIT_FAILURE,
"-T cannot be used without an interval (-i)");
else
statistics = true;
}

if (mydevname && sensors)
errx(EXIT_FAILURE, "-d flag cannot be used with -s");

/* Open the device in ro mode */
if ((sysmonfd = prog_open(_PATH_SYSMON, O_RDONLY)) == -1)
err(EXIT_FAILURE, "%s", _PATH_SYSMON);

/* Print dictionary in raw mode */
if (flags & ENVSYS_XFLAG) {
rval = prop_dictionary_recv_ioctl(sysmonfd,
ENVSYS_GETDICTIONARY,
&dict);
if (rval)
errx(EXIT_FAILURE, "%s", strerror(rval));

if (mydevname || sensors) {
prop_dictionary_t ndict;

ndict = prop_dictionary_create();
if (ndict == NULL)
err(EXIT_FAILURE, "prop_dictionary_create");

if (mydevname) {
if (add_sensors(ndict, dict, mydevname, NULL))
err(EXIT_FAILURE, "add_sensors");
}
if (sensors) {
char *sstring, *p, *last, *s;
char *dvstring = NULL; /* XXXGCC */
unsigned count = 0;

s = strdup(sensors);
if (s == NULL)
err(EXIT_FAILURE, "strdup");

for ((p = strtok_r(s, ",", &last)); p;
(p = strtok_r(NULL, ",", &last))) {
/* get device name */
dvstring = strtok(p, ":");
if (dvstring == NULL)
errx(EXIT_FAILURE, "missing device name");

/* get sensor description */
sstring = strtok(NULL, ":");
if (sstring == NULL)
errx(EXIT_FAILURE, "missing sensor description");

if (add_sensors(ndict, dict, dvstring, sstring))
err(EXIT_FAILURE, "add_sensors");

++count;
}
free(s);

/* in case we asked for a single sensor
* show only the sensor dictionary
*/
if (count == 1) {
prop_object_t obj, obj2;

obj = prop_dictionary_get(ndict, dvstring);
obj2 = prop_array_get(obj, 0);
prop_object_release(ndict);
ndict = obj2;
}
}

prop_object_release(dict);
dict = ndict;
}

if (argc > 0) {
for (; argc > 0; ++argv, --argc)
config_dict_extract(dict, *argv, true);
} else
config_dict_dump(dict);

/* Remove all properties set in dictionary */
} else if (flags & ENVSYS_SFLAG) {
/* Close the ro descriptor */
(void)prog_close(sysmonfd);

/* open the fd in rw mode */
if ((sysmonfd = prog_open(_PATH_SYSMON, O_RDWR)) == -1)
err(EXIT_FAILURE, "%s", _PATH_SYSMON);

dict = prop_dictionary_create();
if (!dict)
err(EXIT_FAILURE, "prop_dictionary_create");

rval = prop_dictionary_set_bool(dict,
"envsys-remove-props",
true);
if (!rval)
err(EXIT_FAILURE, "prop_dict_set_bool");

/* send the dictionary to the kernel now */
rval = prop_dictionary_send_ioctl(dict, sysmonfd,
ENVSYS_REMOVEPROPS);
if (rval)
warnx("%s", strerror(rval));

/* Set properties in dictionary */
} else if (configfile) {
/*
* Parse the configuration file.
*/
if ((cf = fopen(configfile, "r")) == NULL) {
syslog(LOG_ERR, "fopen failed: %s", strerror(errno));
errx(EXIT_FAILURE, "%s", strerror(errno));
}

rval = send_dictionary(cf);
(void)fclose(cf);

/* Show sensors with interval */
} else if (interval) {
for (;;) {
timestamp = time(NULL);
rval = parse_dictionary(sysmonfd);
if (rval)
break;

(void)fflush(stdout);
(void)sleep(interval);
}
/* Show sensors without interval */
} else {
timestamp = time(NULL);
rval = parse_dictionary(sysmonfd);
}

(void)prog_close(sysmonfd);

return rval ? EXIT_FAILURE : EXIT_SUCCESS;
}

static int
send_dictionary(FILE *cf)
{
prop_dictionary_t kdict, udict;
int error = 0;

/* Retrieve dictionary from kernel */
error = prop_dictionary_recv_ioctl(sysmonfd,
ENVSYS_GETDICTIONARY, &kdict);
if (error)
return error;

config_parse(cf, kdict);

/*
* Dictionary built by the parser from the configuration file.
*/
udict = config_dict_parsed();

/*
* Close the read only descriptor and open a new one read write.
*/
(void)prog_close(sysmonfd);
if ((sysmonfd = prog_open(_PATH_SYSMON, O_RDWR)) == -1) {
error = errno;
warn("%s", _PATH_SYSMON);
return error;
}

/*
* Send our sensor properties dictionary to the kernel then.
*/
error = prop_dictionary_send_ioctl(udict,
sysmonfd, ENVSYS_SETDICTIONARY);
if (error)
warnx("%s", strerror(error));

prop_object_release(udict);
return error;
}

static sensor_stats_t
find_stats_sensor(const char *desc)
{
sensor_stats_t stats;

/*
* If we matched a sensor by its description return it, otherwise
* allocate a new one.
*/
SIMPLEQ_FOREACH(stats, &sensor_stats_list, entries)
if (strcmp(stats->desc, desc) == 0)
return stats;

stats = calloc(1, sizeof(*stats));
if (stats == NULL)
return NULL;

(void)strlcpy(stats->desc, desc, sizeof(stats->desc));
stats->min = INT32_MAX;
stats->max = INT32_MIN;
SIMPLEQ_INSERT_TAIL(&sensor_stats_list, stats, entries);

return stats;
}

static int
add_sensors(prop_dictionary_t ndict, prop_dictionary_t dict, const char *dev, const char *sensor)
{
prop_object_iterator_t iter, iter2;
prop_object_t obj, obj2, desc;
prop_array_t array, narray;
prop_dictionary_t sdict;
const char *dnp;
unsigned int capacity = 1;
uint64_t dummy;
bool found = false;

if (prop_dictionary_count(dict) == 0)
return 0;

narray = prop_dictionary_get(ndict, dev);
if (narray)
found = true;
else {
narray = prop_array_create_with_capacity(capacity);
if (!narray)
return -1;
if (!prop_dictionary_set(ndict, dev, narray)) {
prop_object_release(narray);
return -1;
}
}

iter = prop_dictionary_iterator(dict);
if (iter == NULL)
goto fail;
while ((obj = prop_object_iterator_next(iter)) != NULL) {
array = prop_dictionary_get_keysym(dict, obj);
if (prop_object_type(array) != PROP_TYPE_ARRAY)
break;

dnp = prop_dictionary_keysym_value(obj);
if (strcmp(dev, dnp))
continue;
found = true;

iter2 = prop_array_iterator(array);
while ((obj = prop_object_iterator_next(iter2)) != NULL) {
obj2 = prop_dictionary_get(obj, "device-properties");
if (obj2) {
if (!prop_dictionary_get_uint64(obj2,
"refresh-timeout", &dummy))
continue;
}

if (sensor) {
desc = prop_dictionary_get(obj, "description");
if (desc == NULL)
continue;

if (!prop_string_equals_string(desc, sensor))
continue;
}

if (!prop_array_ensure_capacity(narray, capacity))
goto fail;

sdict = prop_dictionary_copy(obj);
if (sdict == NULL)
goto fail;
prop_array_add(narray, sdict);
++capacity;
}
prop_object_iterator_release(iter2);
}
prop_object_iterator_release(iter);

/* drop key and array when device wasn't found */
if (!found) {
prop_dictionary_remove(ndict, dev);
prop_object_release(narray);
}

return 0;

fail:
prop_dictionary_remove(ndict, dev);
prop_object_release(narray);
return -1;
}

static int
parse_dictionary(int fd)
{
sensor_t sensor = NULL;
dvprops_t edp = NULL;
prop_array_t array;
prop_dictionary_t dict;
prop_object_iterator_t iter;
prop_object_t obj;
const char *dnp = NULL;
int rval = 0;

/* receive dictionary from kernel */
rval = prop_dictionary_recv_ioctl(fd, ENVSYS_GETDICTIONARY, &dict);
if (rval)
return rval;

/* No drivers registered? */
if (prop_dictionary_count(dict) == 0) {
warnx("no drivers registered");
goto out;
}

if (mydevname) {
/* -d flag specified, print sensors only for this device */
obj = prop_dictionary_get(dict, mydevname);
if (prop_object_type(obj) != PROP_TYPE_ARRAY) {
warnx("unknown device `%s'", mydevname);
rval = EINVAL;
goto out;
}

rval = find_sensors(obj, mydevname, NULL);
if (rval)
goto out;

} else {
/* print sensors for all devices registered */
iter = prop_dictionary_iterator(dict);
if (iter == NULL) {
rval = EINVAL;
goto out;
}

/* iterate over the dictionary returned by the kernel */
while ((obj = prop_object_iterator_next(iter)) != NULL) {
array = prop_dictionary_get_keysym(dict, obj);
if (prop_object_type(array) != PROP_TYPE_ARRAY) {
warnx("no sensors found");
rval = EINVAL;
goto out;
}

edp = calloc(1, sizeof(*edp));
if (!edp) {
rval = ENOMEM;
goto out;
}

dnp = prop_dictionary_keysym_value(obj);
rval = find_sensors(array, dnp, edp);
if (rval)
goto out;

if (((flags & ENVSYS_LFLAG) == 0) &&
(flags & ENVSYS_DFLAG)) {
(void)printf("%s (checking events every ",
dnp);
if (edp->refresh_timo == 1)
(void)printf("second)\n");
else
(void)printf("%d seconds)\n",
(int)edp->refresh_timo);
}

free(edp);
edp = NULL;
}
prop_object_iterator_release(iter);
}

/* print sensors now */
if (sensors)
rval = check_sensors(sensors);
if ((flags & ENVSYS_LFLAG) == 0 &&
(flags & ENVSYS_DFLAG) == 0 &&
(flags & ENVSYS_JFLAG) == 0)
print_sensors();
if ((flags & ENVSYS_LFLAG) == 0 &&
(flags & ENVSYS_DFLAG) == 0 &&
(flags & ENVSYS_JFLAG))
print_sensors_json();
if (interval && ((flags & ENVSYS_NFLAG) == 0 || sensors == NULL)) {
(void)printf("\n");
if (flags & ENVSYS_JFLAG)
(void)printf("#-------\n");
}

out:
while ((sensor = SIMPLEQ_FIRST(&sensors_list))) {
SIMPLEQ_REMOVE_HEAD(&sensors_list, entries);
free(sensor);
}
if (edp)
free(edp);
prop_object_release(dict);
return rval;
}

static int
find_sensors(prop_array_t array, const char *dvname, dvprops_t edp)
{
prop_object_iterator_t iter;
prop_object_t obj, obj1, obj2;
prop_string_t state, desc = NULL;
sensor_t sensor = NULL;
sensor_stats_t stats = NULL;

iter = prop_array_iterator(array);
if (!iter)
return ENOMEM;

/* iterate over the array of dictionaries */
while ((obj = prop_object_iterator_next(iter)) != NULL) {
/* get the refresh-timeout property */
obj2 = prop_dictionary_get(obj, "device-properties");
if (obj2) {
if (!edp)
continue;
if (!prop_dictionary_get_uint64(obj2,
"refresh-timeout",
&edp->refresh_timo))
continue;
}

/* new sensor coming */
sensor = calloc(1, sizeof(*sensor));
if (sensor == NULL) {
prop_object_iterator_release(iter);
return ENOMEM;
}

/* copy device name */
(void)strlcpy(sensor->dvname, dvname, sizeof(sensor->dvname));

/* description string */
desc = prop_dictionary_get(obj, "description");
if (desc) {
/* copy description */
(void)strlcpy(sensor->desc,
prop_string_value(desc),
sizeof(sensor->desc));
} else {
free(sensor);
continue;
}

/* type string */
obj1 = prop_dictionary_get(obj, "type");
if (obj1) {
/* copy type */
(void)strlcpy(sensor->type,
prop_string_value(obj1),
sizeof(sensor->type));
} else {
free(sensor);
continue;
}

/* index string */
obj1 = prop_dictionary_get(obj, "index");
if (obj1) {
/* copy type */
(void)strlcpy(sensor->index,
prop_string_value(obj1),
sizeof(sensor->index));
} else {
free(sensor);
continue;
}

/* check sensor's state */
state = prop_dictionary_get(obj, "state");

/* mark sensors with invalid/unknown state */
if ((prop_string_equals_string(state, "invalid") ||
prop_string_equals_string(state, "unknown")))
sensor->invalid = true;

/* get current drive state string */
obj1 = prop_dictionary_get(obj, "drive-state");
if (obj1) {
(void)strlcpy(sensor->drvstate,
prop_string_value(obj1),
sizeof(sensor->drvstate));
}

/* get current battery capacity string */
obj1 = prop_dictionary_get(obj, "battery-capacity");
if (obj1) {
(void)strlcpy(sensor->battcap,
prop_string_value(obj1),
sizeof(sensor->battcap));
}

/* get current value */
obj1 = prop_dictionary_get(obj, "cur-value");
if (obj1)
sensor->cur_value = prop_number_signed_value(obj1);

/* get max value */
obj1 = prop_dictionary_get(obj, "max-value");
if (obj1)
sensor->max_value = prop_number_signed_value(obj1);

/* get min value */
obj1 = prop_dictionary_get(obj, "min-value");
if (obj1)
sensor->min_value = prop_number_signed_value(obj1);

/* get percentage flag */
obj1 = prop_dictionary_get(obj, "want-percentage");
if (obj1)
sensor->percentage = prop_bool_true(obj1);

/* get critical max value if available */
obj1 = prop_dictionary_get(obj, "critical-max");
if (obj1)
sensor->critmax_value = prop_number_signed_value(obj1);

/* get maximum capacity value if available */
obj1 = prop_dictionary_get(obj, "maximum-capacity");
if (obj1)
sensor->critmax_value = prop_number_signed_value(obj1);

/* get critical min value if available */
obj1 = prop_dictionary_get(obj, "critical-min");
if (obj1)
sensor->critmin_value = prop_number_signed_value(obj1);

/* get critical capacity value if available */
obj1 = prop_dictionary_get(obj, "critical-capacity");
if (obj1)
sensor->critmin_value = prop_number_signed_value(obj1);

/* get warning max value if available */
obj1 = prop_dictionary_get(obj, "warning-max");
if (obj1)
sensor->warnmax_value = prop_number_signed_value(obj1);

/* get high capacity value if available */
obj1 = prop_dictionary_get(obj, "high-capacity");
if (obj1)
sensor->warnmax_value = prop_number_signed_value(obj1);

/* get warning min value if available */
obj1 = prop_dictionary_get(obj, "warning-min");
if (obj1)
sensor->warnmin_value = prop_number_signed_value(obj1);

/* get warning capacity value if available */
obj1 = prop_dictionary_get(obj, "warning-capacity");
if (obj1)
sensor->warnmin_value = prop_number_signed_value(obj1);

/* print sensor names if -l was given */
if (flags & ENVSYS_LFLAG) {
if (width)
(void)printf("%*s\n", width,
prop_string_value(desc));
else
(void)printf("%s\n",
prop_string_value(desc));
}

/* Add the sensor into the list */
SIMPLEQ_INSERT_TAIL(&sensors_list, sensor, entries);

/* Collect statistics if flag enabled */
if (statistics) {
/* ignore sensors not relevant for statistics */
if ((strcmp(sensor->type, "Indicator") == 0) ||
(strcmp(sensor->type, "Battery charge") == 0) ||
(strcmp(sensor->type, "Drive") == 0))
continue;

/* ignore invalid data */
if (sensor->invalid)
continue;

/* find or allocate a new statistics sensor */
stats = find_stats_sensor(sensor->desc);
if (stats == NULL) {
free(sensor);
prop_object_iterator_release(iter);
return ENOMEM;
}

/* update data */
if (sensor->cur_value > stats->max)
stats->max = sensor->cur_value;

if (sensor->cur_value < stats->min)
stats->min = sensor->cur_value;

/* compute avg value */
stats->avg =
(sensor->cur_value + stats->max + stats->min) / 3;
}
}

/* free memory */
prop_object_iterator_release(iter);
return 0;
}

static int
check_sensors(const char *str)
{
sensor_t sensor = NULL;
char *dvstring, *sstring, *p, *last, *s;
bool sensor_found = false;

if ((s = strdup(str)) == NULL)
return errno;

/*
* Parse device name and sensor description and find out
* if the sensor is valid.
*/
for ((p = strtok_r(s, ",", &last)); p;
(p = strtok_r(NULL, ",", &last))) {
/* get device name */
dvstring = strtok(p, ":");
if (dvstring == NULL) {
warnx("missing device name");
goto out;
}

/* get sensor description */
sstring = strtok(NULL, ":");
if (sstring == NULL) {
warnx("missing sensor description");
goto out;
}

SIMPLEQ_FOREACH(sensor, &sensors_list, entries) {
/* skip until we match device */
if (strcmp(dvstring, sensor->dvname))
continue;
if (strcmp(sstring, sensor->desc) == 0) {
sensor->visible = true;
sensor_found = true;
break;
}
}
if (sensor_found == false) {
warnx("unknown sensor `%s' for device `%s'",
sstring, dvstring);
goto out;
}
sensor_found = false;
}

/* check if all sensors were ok, and error out if not */
SIMPLEQ_FOREACH(sensor, &sensors_list, entries)
if (sensor->visible) {
free(s);
return 0;
}

warnx("no sensors selected to display");
out:
free(s);
return EINVAL;
}

/* When adding a new sensor type, be sure to address both
* print_sensors() and print_sensors_json()
*/

static void
print_sensors(void)
{
sensor_t sensor;
sensor_stats_t stats = NULL;
size_t maxlen = 0, ilen;
double temp = 0;
const char *invalid = "N/A", *degrees, *tmpstr, *stype;
const char *a, *b, *c, *d, *e, *units;
const char *sep;
int flen;
bool nflag = (flags & ENVSYS_NFLAG) != 0;
char tbuf[26];
bool tflag = (flags & ENVSYS_tFLAG) != 0;

tmpstr = stype = d = e = NULL;

/* find the longest description */
SIMPLEQ_FOREACH(sensor, &sensors_list, entries)
if (strlen(sensor->desc) > maxlen)
maxlen = strlen(sensor->desc);

if (width)
maxlen = width;

/*
* Print a header at the bottom only once showing different
* members if the statistics flag is set or not.
*
* As bonus if -s is set, only print this header every 10 iterations
* to avoid redundancy... like vmstat(1).
*/

a = "Current";
units = "Unit";
if (statistics) {
b = "Max";
c = "Min";
d = "Avg";
} else {
b = "CritMax";
c = "WarnMax";
d = "WarnMin";
e = "CritMin";
}

if (tflag) {
if (ctime_r(&timestamp, tbuf) != NULL)
(void)printf("%s\n",tbuf);
}

if (!nflag) {
if (!sensors || (!header_passes && sensors) ||
(header_passes == 10 && sensors)) {
if (statistics)
(void)printf("%s%*s %9s %8s %8s %8s %6s\n",
mydevname ? "" : " ", (int)maxlen,
"", a, b, c, d, units);
else
(void)printf("%s%*s %9s %8s %8s %8s %8s %5s\n",
mydevname ? "" : " ", (int)maxlen,
"", a, b, c, d, e, units);
if (sensors && header_passes == 10)
header_passes = 0;
}
if (sensors)
header_passes++;

sep = ":";
flen = 10;
} else {
sep = "";
flen = 1;
}

/* print the sensors */
SIMPLEQ_FOREACH(sensor, &sensors_list, entries) {
/* skip sensors that were not marked as visible */
if (sensors && !sensor->visible)
continue;

/* skip invalid sensors if -I is set */
if ((flags & ENVSYS_IFLAG) && sensor->invalid)
continue;

/* print device name */
if (!nflag && !mydevname) {
if (tmpstr == NULL || strcmp(tmpstr, sensor->dvname))
printf("[%s]\n", sensor->dvname);

tmpstr = sensor->dvname;
}

/* find out the statistics sensor */
if (statistics) {
stats = find_stats_sensor(sensor->desc);
if (stats == NULL) {
/* No statistics for this sensor */
continue;
}
}

if (!nflag) {
/* print sensor description */
(void)printf("%s%*.*s", mydevname ? "" : " ",
(int)maxlen,
(int)maxlen, sensor->desc);
}

/* print invalid string */
if (sensor->invalid) {
(void)printf("%s%*s\n", sep, flen, invalid);
continue;
}

/*
* Indicator and Battery charge sensors.
*/
if ((strcmp(sensor->type, "Indicator") == 0) ||
(strcmp(sensor->type, "Battery charge") == 0)) {

(void)printf("%s%*s", sep, flen,
sensor->cur_value ? "TRUE" : "FALSE");

/* convert and print a temp value in degC, degF, or Kelvin */
#define PRINTTEMP(a) \
do { \
if (a) { \
temp = ((a) / 1000000.0); \
if (flags & ENVSYS_FFLAG) { \
temp = temp * (9.0 / 5.0) - 459.67; \
degrees = "degF"; \
} else if (flags & ENVSYS_KFLAG) { \
degrees = "K"; \
} else { \
temp = temp - 273.15; \
degrees = "degC"; \
} \
(void)printf("%*.3f", (int)ilen, temp); \
ilen = 9; \
} else \
ilen += 9; \
} while (0)

/* temperatures */
} else if (strcmp(sensor->type, "Temperature") == 0) {

ilen = nflag ? 1 : 10;
degrees = "";
(void)printf("%s",sep);
PRINTTEMP(sensor->cur_value);
stype = degrees;

if (statistics) {
/* show statistics if flag set */
PRINTTEMP(stats->max);
PRINTTEMP(stats->min);
PRINTTEMP(stats->avg);
ilen += 2;
} else if (!nflag) {
PRINTTEMP(sensor->critmax_value);
PRINTTEMP(sensor->warnmax_value);
PRINTTEMP(sensor->warnmin_value);
PRINTTEMP(sensor->critmin_value);
}
if (!nflag)
(void)printf("%*s", (int)ilen - 3, stype);
#undef PRINTTEMP

/* fans */
} else if (strcmp(sensor->type, "Fan") == 0) {
stype = "RPM";

(void)printf("%s%*u", sep, flen, sensor->cur_value);

ilen = 8;
if (statistics) {
/* show statistics if flag set */
(void)printf(" %8u %8u %8u",
stats->max, stats->min, stats->avg);
ilen += 2;
} else if (!nflag) {
if (sensor->critmax_value) {
(void)printf(" %*u", (int)ilen,
sensor->critmax_value);
ilen = 8;
} else
ilen += 9;

if (sensor->warnmax_value) {
(void)printf(" %*u", (int)ilen,
sensor->warnmax_value);
ilen = 8;
} else
ilen += 9;

if (sensor->warnmin_value) {
(void)printf(" %*u", (int)ilen,
sensor->warnmin_value);
ilen = 8;
} else
ilen += 9;

if (sensor->critmin_value) {
(void)printf( " %*u", (int)ilen,
sensor->critmin_value);
ilen = 8;
} else
ilen += 9;

}

if (!nflag)
(void)printf(" %*s", (int)ilen - 3, stype);

/* integers */
} else if (strcmp(sensor->type, "Integer") == 0) {

stype = "none";

(void)printf("%s%*d", sep, flen, sensor->cur_value);

ilen = 8;

/* Print percentage of max_value */
#define PRINTPCT(a) \
do { \
if (sensor->max_value) { \
(void)printf(" %*.3f%%", (int)ilen, \
((a) * 100.0) / sensor->max_value); \
ilen = 8; \
} else \
ilen += 9; \
} while ( /* CONSTCOND*/ 0 )

/* Print an integer sensor value */
#define PRINTINT(a) \
do { \
(void)printf(" %*u", (int)ilen, (a)); \
ilen = 8; \
} while ( /* CONSTCOND*/ 0 )

if (statistics) {
if (sensor->percentage) {
PRINTPCT(stats->max);
PRINTPCT(stats->min);
PRINTPCT(stats->avg);
} else {
PRINTINT(stats->max);
PRINTINT(stats->min);
PRINTINT(stats->avg);
}
ilen += 2;
} else if (!nflag) {
if (sensor->percentage) {
PRINTPCT(sensor->critmax_value);
PRINTPCT(sensor->warnmax_value);
PRINTPCT(sensor->warnmin_value);
PRINTPCT(sensor->critmin_value);
} else {
PRINTINT(sensor->critmax_value);
PRINTINT(sensor->warnmax_value);
PRINTINT(sensor->warnmin_value);
PRINTINT(sensor->critmin_value);
}
}

if (!nflag)
(void)printf("%*s", (int)ilen - 3, stype);

#undef PRINTINT
#undef PRINTPCT

/* drives */
} else if (strcmp(sensor->type, "Drive") == 0) {

(void)printf("%s%*s", sep, flen, sensor->drvstate);

/* Battery capacity */
} else if (strcmp(sensor->type, "Battery capacity") == 0) {

(void)printf("%s%*s", sep, flen, sensor->battcap);

/* Illuminance */
} else if (strcmp(sensor->type, "Illuminance") == 0) {

stype = "lux";

(void)printf("%s%*u", sep, flen, sensor->cur_value);

ilen = 8;
if (statistics) {
/* show statistics if flag set */
(void)printf(" %8u %8u %8u",
stats->max, stats->min, stats->avg);
ilen += 2;
} else if (!nflag) {
if (sensor->critmax_value) {
(void)printf(" %*u", (int)ilen,
sensor->critmax_value);
ilen = 8;
} else
ilen += 9;

if (sensor->warnmax_value) {
(void)printf(" %*u", (int)ilen,
sensor->warnmax_value);
ilen = 8;
} else
ilen += 9;

if (sensor->warnmin_value) {
(void)printf(" %*u", (int)ilen,
sensor->warnmin_value);
ilen = 8;
} else
ilen += 9;

if (sensor->critmin_value) {
(void)printf( " %*u", (int)ilen,
sensor->critmin_value);
ilen = 8;
} else
ilen += 9;

}

if (!nflag)
(void)printf(" %*s", (int)ilen - 3, stype);

/* Pressure */
} else if (strcmp(sensor->type, "pressure") == 0) {
stype = "hPa";

(void)printf("%s%*.3f", sep, flen,
sensor->cur_value / 10000.0);

ilen = 8;
if (statistics) {
/* show statistics if flag set */
(void)printf(" %.3f %.3f %.3f",
stats->max / 10000.0, stats->min / 10000.0, stats->avg / 10000.0);
ilen += 2;
} else if (!nflag) {
if (sensor->critmax_value) {
(void)printf(" %*u", (int)ilen,
sensor->critmax_value);
ilen = 8;
} else
ilen += 9;

if (sensor->warnmax_value) {
(void)printf(" %*u", (int)ilen,
sensor->warnmax_value);
ilen = 8;
} else
ilen += 9;

if (sensor->warnmin_value) {
(void)printf(" %*u", (int)ilen,
sensor->warnmin_value);
ilen = 8;
} else
ilen += 9;

if (sensor->critmin_value) {
(void)printf( " %*u", (int)ilen,
sensor->critmin_value);
ilen = 8;
} else
ilen += 9;

}

if (!nflag)
(void)printf(" %*s", (int)ilen - 3, stype);

/* everything else */
} else {
if (strcmp(sensor->type, "Voltage DC") == 0)
stype = "V";
else if (strcmp(sensor->type, "Voltage AC") == 0)
stype = "VAC";
else if (strcmp(sensor->type, "Ampere") == 0)
stype = "A";
else if (strcmp(sensor->type, "Watts") == 0)
stype = "W";
else if (strcmp(sensor->type, "Ohms") == 0)
stype = "Ohms";
else if (strcmp(sensor->type, "Watt hour") == 0)
stype = "Wh";
else if (strcmp(sensor->type, "Ampere hour") == 0)
stype = "Ah";
else if (strcmp(sensor->type, "relative Humidity") == 0)
stype = "%rH";
else
stype = "?";

(void)printf("%s%*.3f", sep, flen,
sensor->cur_value / 1000000.0);

ilen = 9;

/* Print percentage of max_value */
#define PRINTPCT(a) \
do { \
if ((a) && sensor->max_value) { \
(void)printf("%*.3f%%", (int)ilen, \
((a) * 100.0) / sensor->max_value); \
ilen = 8; \
} else \
ilen += 9; \
} while ( /* CONSTCOND*/ 0 )

/* Print a generic sensor value */
#define PRINTVAL(a) \
do { \
if ((a)) { \
(void)printf("%*.3f", (int)ilen, (a) / 1000000.0); \
ilen = 9; \
} else \
ilen += 9; \
} while ( /* CONSTCOND*/ 0 )

if (statistics) {
if (sensor->percentage) {
PRINTPCT(stats->max);
PRINTPCT(stats->min);
PRINTPCT(stats->avg);
} else {
PRINTVAL(stats->max);
PRINTVAL(stats->min);
PRINTVAL(stats->avg);
}
ilen += 2;
} else if (!nflag) {
if (sensor->percentage) {
PRINTPCT(sensor->critmax_value);
PRINTPCT(sensor->warnmax_value);
PRINTPCT(sensor->warnmin_value);
PRINTPCT(sensor->critmin_value);
} else {

PRINTVAL(sensor->critmax_value);
PRINTVAL(sensor->warnmax_value);
PRINTVAL(sensor->warnmin_value);
PRINTVAL(sensor->critmin_value);
}
}
#undef PRINTPCT
#undef PRINTVAL

if (!nflag) {
(void)printf(" %*s", (int)ilen - 4, stype);
if (sensor->percentage && sensor->max_value) {
(void)printf(" (%5.2f%%)",
(sensor->cur_value * 100.0) /
sensor->max_value);
}
}
}
(void)printf("\n");
}
}

static void
print_sensors_json(void)
{
sensor_t sensor;
sensor_stats_t stats = NULL;
double temp = 0;

const char *degrees, *tmpstr, *stype;
const char *d, *e;
mj_t envstatj;
mj_t devices;
mj_t sensors_per_dev;
mj_t this_sensor;
mj_t a_float;
bool tflag = (flags & ENVSYS_tFLAG) != 0;
char tbuf[26];
char *output_s = NULL;
size_t output_size = 0;

tmpstr = stype = d = e = NULL;

memset(&envstatj, 0x0, sizeof(envstatj));
mj_create(&envstatj, "object");
memset(&devices, 0x0, sizeof(devices));
mj_create(&devices, "object");

/* print the sensors */
SIMPLEQ_FOREACH(sensor, &sensors_list, entries) {
/* completely skip sensors that were not marked as visible */
if (sensors && !sensor->visible)
continue;

/* completely skip invalid sensors if -I is set */
if ((flags & ENVSYS_IFLAG) && sensor->invalid)
continue;

/* find out the statistics sensor */
if (statistics) {
stats = find_stats_sensor(sensor->desc);
if (stats == NULL) {
/* No statistics for this sensor, completely skip */
continue;
}
}

if (tmpstr == NULL || strcmp(tmpstr, sensor->dvname)) {
if (tmpstr != NULL) {
mj_append_field(&devices, tmpstr, "array", &sensors_per_dev);
mj_delete(&sensors_per_dev);
}

memset(&sensors_per_dev, 0x0, sizeof(sensors_per_dev));
mj_create(&sensors_per_dev, "array");

tmpstr = sensor->dvname;
}

/* Any condition that that causes the sensor to be
* completely skipped should be checked before we are
* at this point */

memset(&this_sensor, 0x0, sizeof(this_sensor));
mj_create(&this_sensor, "object");

mj_append_field(&this_sensor, "index", "string",
sensor->index, strlen(sensor->index));
mj_append_field(&this_sensor, "description", "string",
sensor->desc, strlen(sensor->desc));
mj_append_field(&this_sensor, "type", "string",
sensor->type, strlen(sensor->type));
mj_append_field(&this_sensor, "invalid", "integer",
(int64_t)sensor->invalid);

/* The sensor is invalid, semi-skip it */
if (sensor->invalid) {
goto around;
}

/*
* Indicator and Battery charge sensors.
*/
if ((strcmp(sensor->type, "Indicator") == 0) ||
(strcmp(sensor->type, "Battery charge") == 0)) {

mj_append_field(&this_sensor, "cur-value", "integer",
(int64_t)sensor->cur_value);

/* convert and print a temp value in degC, degF, or Kelvin */
#define PRINTTEMP(a,b) \
do { \
if (a) { \
temp = ((a) / 1000000.0); \
if (flags & ENVSYS_FFLAG) { \
temp = temp * (9.0 / 5.0) - 459.67; \
degrees = "degF"; \
} else if (flags & ENVSYS_KFLAG) { \
degrees = "K"; \
} else { \
temp = temp - 273.15; \
degrees = "degC"; \
} \
memset(&a_float, 0x0, sizeof(a_float)); \
mj_create(&a_float, "number", temp); \
mj_append_field(&this_sensor, b, "object", &a_float); \
mj_delete(&a_float); \
} \
} while (0)

/* temperatures */
} else if (strcmp(sensor->type, "Temperature") == 0) {

degrees = "";
PRINTTEMP(sensor->cur_value, "cur-value");
stype = degrees;

if (statistics) {
/* show statistics if flag set */
PRINTTEMP(stats->max, "max");
PRINTTEMP(stats->min, "min");
PRINTTEMP(stats->avg, "avg");
}

PRINTTEMP(sensor->critmax_value, "critical-max");
PRINTTEMP(sensor->warnmax_value, "warning-max");
PRINTTEMP(sensor->warnmin_value, "warning-min");
PRINTTEMP(sensor->critmin_value, "critical-min");

mj_append_field(&this_sensor, "units", "string",
stype, strlen(stype));
#undef PRINTTEMP

/* fans */
} else if (strcmp(sensor->type, "Fan") == 0) {
stype = "RPM";

mj_append_field(&this_sensor, "cur-value", "integer",
(int64_t)sensor->cur_value);

if (statistics) {
/* show statistics if flag set */
mj_append_field(&this_sensor, "max", "integer",
(int64_t)stats->max);
mj_append_field(&this_sensor, "min", "integer",
(int64_t)stats->min);
mj_append_field(&this_sensor, "avg", "integer",
(int64_t)stats->avg);
}
mj_append_field(&this_sensor, "critical-max", "integer",
(int64_t)sensor->critmax_value);
mj_append_field(&this_sensor, "warning-max", "integer",
(int64_t)sensor->warnmax_value);
mj_append_field(&this_sensor, "warning-min", "integer",
(int64_t)sensor->warnmin_value);
mj_append_field(&this_sensor, "critical-min", "integer",
(int64_t)sensor->critmin_value);

mj_append_field(&this_sensor, "units", "string",
stype, strlen(stype));

/* integers */
} else if (strcmp(sensor->type, "Integer") == 0) {

stype = "none";

mj_append_field(&this_sensor, "cur-value", "integer",
(int64_t)sensor->cur_value);

/* Print percentage of max_value */
#define PRINTPCT(a,b) \
do { \
if ((a) && sensor->max_value) { \
mj_append_field(&this_sensor, b, "integer", \
(int64_t)((a) * 100.0) / sensor->max_value); \
} \
} while ( /* CONSTCOND*/ 0 )
if (statistics) {
if (sensor->percentage) {
PRINTPCT(stats->max, "max");
PRINTPCT(stats->min, "min");
PRINTPCT(stats->avg, "avg");
} else {
mj_append_field(&this_sensor, "max", "integer",
(int64_t)stats->max);
mj_append_field(&this_sensor, "min", "integer",
(int64_t)stats->min);
mj_append_field(&this_sensor, "avg", "integer",
(int64_t)stats->avg);
}
}
if (sensor->percentage) {
PRINTPCT(sensor->critmax_value, "critical-max");
PRINTPCT(sensor->warnmax_value, "warning-max");
PRINTPCT(sensor->warnmin_value, "warning-min");
PRINTPCT(sensor->critmin_value, "critical-min");
} else {
mj_append_field(&this_sensor, "critmax_value", "integer",
(int64_t)sensor->critmax_value);
mj_append_field(&this_sensor, "warning-max", "integer",
(int64_t)sensor->warnmax_value);
mj_append_field(&this_sensor, "warning-min", "integer",
(int64_t)sensor->warnmin_value);
mj_append_field(&this_sensor, "critical-min", "integer",
(int64_t)sensor->critmin_value);
}

mj_append_field(&this_sensor, "units", "string",
stype, strlen(stype));
/* drives */
} else if (strcmp(sensor->type, "Drive") == 0) {
mj_append_field(&this_sensor, "drvstate", "string",
sensor->drvstate, strlen(sensor->drvstate));
/* Battery capacity */
} else if (strcmp(sensor->type, "Battery capacity") == 0) {
mj_append_field(&this_sensor, "battcap", "string",
sensor->battcap, strlen(sensor->battcap));
/* Illuminance */
} else if (strcmp(sensor->type, "Illuminance") == 0) {

stype = "lux";

mj_append_field(&this_sensor, "cur-value", "integer",
(int64_t)sensor->cur_value);

if (statistics) {
/* show statistics if flag set */
mj_append_field(&this_sensor, "max", "integer",
(int64_t)stats->max);
mj_append_field(&this_sensor, "min", "integer",
(int64_t)stats->min);
mj_append_field(&this_sensor, "avg", "integer",
(int64_t)stats->avg);
}

mj_append_field(&this_sensor, "critmax_value", "integer",
(int64_t)sensor->critmax_value);
mj_append_field(&this_sensor, "warning-max", "integer",
(int64_t)sensor->warnmax_value);
mj_append_field(&this_sensor, "warning-min", "integer",
(int64_t)sensor->warnmin_value);
mj_append_field(&this_sensor, "critical-min", "integer",
(int64_t)sensor->critmin_value);

mj_append_field(&this_sensor, "units", "string",
stype, strlen(stype));
/* Pressure */
} else if (strcmp(sensor->type, "pressure") == 0) {
#define PRINTFLOAT(a,b) \
do { \
if (a) { \
memset(&a_float, 0x0, sizeof(a_float)); \
mj_create(&a_float, "number", a); \
mj_append_field(&this_sensor, b, "object", &a_float); \
mj_delete(&a_float); \
} \
} while (0)
stype = "hPa";

PRINTFLOAT(sensor->cur_value / 10000.0, "cur-value");

if (statistics) {
/* show statistics if flag set */
PRINTFLOAT(stats->max / 10000.0, "max");
PRINTFLOAT(stats->min / 10000.0, "min");
PRINTFLOAT(stats->avg / 10000.0, "avg");
}

PRINTFLOAT(sensor->critmax_value, "critmax_value");
PRINTFLOAT(sensor->warnmax_value, "warning-max");
PRINTFLOAT(sensor->warnmin_value, "warning-min");
PRINTFLOAT(sensor->critmin_value, "critical-min");

mj_append_field(&this_sensor, "units", "string",
stype, strlen(stype));
/* everything else */
} else {
if (strcmp(sensor->type, "Voltage DC") == 0)
stype = "V";
else if (strcmp(sensor->type, "Voltage AC") == 0)
stype = "VAC";
else if (strcmp(sensor->type, "Ampere") == 0)
stype = "A";
else if (strcmp(sensor->type, "Watts") == 0)
stype = "W";
else if (strcmp(sensor->type, "Ohms") == 0)
stype = "Ohms";
else if (strcmp(sensor->type, "Watt hour") == 0)
stype = "Wh";
else if (strcmp(sensor->type, "Ampere hour") == 0)
stype = "Ah";
else if (strcmp(sensor->type, "relative Humidity") == 0)
stype = "%rH";
else
stype = "?";

PRINTFLOAT(sensor->cur_value / 1000000.0, "cur-value");

mj_append_field(&this_sensor, "units", "string",
stype, strlen(stype));
#undef PRINTFLOAT

/* Print a generic sensor value */
#define PRINTVAL(a,b) \
do { \
if ((a)) { \
memset(&a_float, 0x0, sizeof(a_float)); \
mj_create(&a_float, "number", a / 1000000.0); \
mj_append_field(&this_sensor, b, "object", &a_float); \
mj_delete(&a_float); \
} \
} while ( /* CONSTCOND*/ 0 )

if (statistics) {
if (sensor->percentage) {
PRINTPCT(stats->max, "max");
PRINTPCT(stats->min, "min");
PRINTPCT(stats->avg, "avg");
} else {
PRINTVAL(stats->max, "max");
PRINTVAL(stats->min, "min");
PRINTVAL(stats->avg, "avg");
}
}
if (sensor->percentage) {
PRINTPCT(sensor->critmax_value, "critmax_value");
PRINTPCT(sensor->warnmax_value, "warning-max");
PRINTPCT(sensor->warnmin_value, "warning-min");
PRINTPCT(sensor->critmin_value, "critical-min");
} else {

PRINTVAL(sensor->critmax_value, "critmax_value");
PRINTVAL(sensor->warnmax_value, "warning-max");
PRINTVAL(sensor->warnmin_value, "warning-min");
PRINTVAL(sensor->critmin_value, "critical-min");
}
#undef PRINTPCT
#undef PRINTVAL

mj_append_field(&this_sensor, "units", "string",
stype, strlen(stype));
if (sensor->percentage && sensor->max_value) {
memset(&a_float, 0x0, sizeof(a_float));
mj_create(&a_float, "number",
(sensor->cur_value * 100.0) / sensor->max_value);
mj_append_field(&this_sensor, "pct", "object",
&a_float);
mj_delete(&a_float);
}
}
around:
mj_append(&sensors_per_dev, "object", &this_sensor);
mj_delete(&this_sensor);
}

if (tmpstr != NULL) {
mj_append_field(&devices, tmpstr, "array", &sensors_per_dev);
mj_delete(&sensors_per_dev);

mj_append_field(&envstatj, "devices", "object", &devices);
if (tflag) {
mj_append_field(&envstatj, "timestamp", "integer", (int64_t)timestamp);
if (ctime_r(&timestamp, tbuf) != NULL)
/* Pull off the newline */
mj_append_field(&envstatj, "human_timestamp", "string", tbuf, strlen(tbuf) - 1);
}

#ifdef __NOT
mj_asprint(&output_s, &envstatj, MJ_JSON_ENCODE);
printf("%s", output_s);
if (output_s != NULL)
free(output_s);
#endif
/* Work around lib/59230 for now. Way over allocate
* the output buffer. Summary of the problem:
* mj_string_size does not appear to allocate enough
* space if there are arrays present in the serialized
* superatom. It appears that for every array that is
* placed inside of another object (or probably array)
* the resulting buffer is a single character too
* small. So just do what mj_asprint() does, except
* make the size much larger than is needed.
*/

output_size = mj_string_size(&envstatj) * 3;
output_s = calloc(1, output_size);
if (output_s != NULL) {
mj_snprint(output_s, output_size, &envstatj, MJ_JSON_ENCODE);
printf("%s", output_s);
free(output_s);
}
}

mj_delete(&devices);
mj_delete(&envstatj);
}

static int
usage(void)
{
(void)fprintf(stderr, "Usage: %s [-DfIjklnrSTt] ", getprogname());
(void)fprintf(stderr, "[-c file] [-d device] [-i interval] ");
(void)fprintf(stderr, "[-s device:sensor,...] [-w width]\n");
(void)fprintf(stderr, " %s ", getprogname());
(void)fprintf(stderr, "[-d device] ");
(void)fprintf(stderr, "[-s device:sensor,...] ");
(void)fprintf(stderr, "-x [property]\n");
exit(EXIT_FAILURE);
/* NOTREACHED */
}