/* upsimage - cgi program to create graphical ups information reports
Status:
20020814 - Simon Rozman
- redesigned the meters
20020823 - Simon Rozman
- added support for width, height and scale_height parameters
- added support for outvolt
- noimage now writes out a clue, why upsimage failed
20020902 - Simon Rozman
- background now transparent by default
- added support for colorization parameters
- removed linear antialiasing of the scale, until I come up with a better algorithm
20020913 - Simon Rozman
- added width, height and scale_height to imgarg table
20020928 - Simon Rozman
- added imgvar table to hold description, how to draw each UPS variable supported
- added support for ACFREQ, OUT_FREQ and UPSTEMP
Copyrights:
(C) 1998 Russell Kroll <rkroll@exploits.org>
(C) 2002 Simon Rozman <simon@rozman.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "common.h"
#include "upsclient.h"
#include "cgilib.h"
#include <stdlib.h>
#ifdef HAVE_GD_H
#include <gd.h>
#include <gdfontmb.h>
#else
#error "You need gd to build this! http://www.boutell.com/gd/"
#endif
#include "upsimagearg.h"
#define MAX_CGI_STRLEN 64
static char *monhost = NULL, *cmd = NULL;
static int port;
static char *upsname, *hostname;
static UPSCONN_t ups;
#define RED(x) ((x >> 16) & 0xff)
#define GREEN(x) ((x >> 8) & 0xff)
#define BLUE(x) (x & 0xff)
void parsearg(char *var, char *value)
{
int i, v;
/* avoid bogus junk from evil people */
if ((strlen(var) > MAX_CGI_STRLEN) || (strlen(value) > MAX_CGI_STRLEN))
return;
if (!strcmp(var, "host")) {
free(monhost);
monhost = xstrdup(value);
return;
}
if (!strcmp(var, "display")) {
free(cmd);
cmd = xstrdup(value);
return;
}
/* see if this is one of the shared (upsimagearg.h) variables */
for (i = 0; imgarg[i].name != NULL; i++) {
if (!strcmp(imgarg[i].name, var)) {
if (!strncmp(value, "0x", 2))
v = strtoul(value + 2, (char **)NULL, 16);
else
v = atoi(value);
/* avoid false numbers from bad people */
if (v < imgarg[i].min)
imgarg[i].val = imgarg[i].min;
else if (v > imgarg[i].max)
imgarg[i].val = imgarg[i].max;
else
imgarg[i].val = v;
return;
}
}
}
/* return the value from the URL or the default if it wasn't set */
static int get_imgarg(const char *name)
{
int i;
for (i = 0; imgarg[i].name != NULL; i++)
if (!strcmp(imgarg[i].name, name))
return imgarg[i].val;
return -1;
}
/* write the HTML header then have gd dump the image */
static void drawimage(gdImagePtr im)
{
printf("Pragma: no-cache\n");
printf("Content-type: image/png\n\n");
gdImagePng(im, stdout);
gdImageDestroy(im);
upscli_disconnect(&ups);
exit(EXIT_SUCCESS);
}
/* helper function to allocate color in the image */
static int color_alloc(gdImagePtr im, int rgb)
{
return gdImageColorAllocate(im, RED(rgb), GREEN(rgb), BLUE(rgb));
}
/* draws the scale behind the bar indicator */
static void drawscale(
gdImagePtr im, /* image where we would like to draw scale */
int lvllo, int lvlhi, /* min and max numbers on the scale */
int step, int step5, int step10, /* steps for minor, submajor and major dashes */
int redlo1, int redhi1, /* first red zone start and end */
int redlo2, int redhi2, /* second red zone start and end */
int grnlo, int grnhi) /* green zone start and end */
{
int col1, col2, back_color, scale_num_color, ok_zone_maj_color,
ok_zone_min_color, neutral_zone_maj_color,
neutral_zone_min_color, warn_zone_maj_color,
warn_zone_min_color;
char lbltxt[SMALLBUF];
int y, level, range;
int width, height, scale_height;
back_color = color_alloc(im, get_imgarg("back_col"));
scale_num_color = color_alloc(im, get_imgarg("scale_num_col"));
ok_zone_maj_color = color_alloc(im, get_imgarg("ok_zone_maj_col"));
ok_zone_min_color = color_alloc(im, get_imgarg("ok_zone_min_col"));
neutral_zone_maj_color = color_alloc(im, get_imgarg("neutral_zone_maj_col"));
neutral_zone_min_color = color_alloc(im, get_imgarg("neutral_zone_min_col"));
warn_zone_maj_color = color_alloc(im, get_imgarg("warn_zone_maj_col"));
warn_zone_min_color = color_alloc(im, get_imgarg("warn_zone_min_col"));
width = get_imgarg("width");
height = get_imgarg("height");
scale_height = get_imgarg("scale_height");
/* start out with a background color and make it transparent */
gdImageFilledRectangle(im, 0, 0, width, height, back_color);
gdImageColorTransparent(im, back_color);
range = lvlhi - lvllo;
/* draw scale to correspond with the values */
for (level = lvlhi; level >= lvllo; level -= step) {
/* select dash RGB color according to the level */
if (((redlo1 <= level) && (level <=redhi1)) ||
((redlo2 <= level) && (level <=redhi2))) {
col1 = warn_zone_maj_color;
col2 = warn_zone_min_color;
} else if ((grnlo <= level) && (level <= grnhi)) {
col1 = ok_zone_maj_color;
col2 = ok_zone_min_color;
} else {
col1 = neutral_zone_maj_color;
col2 = neutral_zone_min_color;
}
/* calculate integer value for y */
y = scale_height * (lvlhi - level) / range;
/* draw major, semimajor or minor dash accordingly */
if (level % step10 == 0) {
gdImageLine(im, 0, y, width, y, col1);
} else {
if (level % step5 == 0)
gdImageLine(im, 5, y, width - 5, y, col2);
else
gdImageLine(im, 10, y, width - 10, y, col2);
}
}
/* put the values on the scale */
for (level = lvlhi; level >= lvllo; level -= step) {
if (level % step10 == 0) {
y = scale_height * (lvlhi - level) / range;
snprintf(lbltxt, sizeof(lbltxt), "%u", level);
gdImageString(im, gdFontMediumBold, width - 20, y,
(unsigned char *) lbltxt, scale_num_color);
}
}
}
/* draws the bar style indicator */
static void drawbar(
int lvllo, int lvlhi, /* min and max numbers on the scale */
int step, int step5, int step10, /* steps for minor, submajor and major dashes */
int redlo1, int redhi1, /* first red zone start and end */
int redlo2, int redhi2, /* second red zone start and end */
int grnlo, int grnhi, /* green zone start and end */
double value, /* UPS variable value to draw */
const char *format /* sprintf style format to be used when rendering summary text */
)
{
gdImagePtr im;
int bar_color, summary_color;
char text[SMALLBUF];
int bar_y;
int width, height, scale_height;
/* get the dimension parameters */
width = get_imgarg("width");
height = get_imgarg("height");
scale_height = get_imgarg("scale_height");
/* create the image */
im = gdImageCreate(width, height);
/* draw the scale */
drawscale(im, lvllo, lvlhi, step, step5, step10, redlo1, redhi1,
redlo2, redhi2, grnlo, grnhi);
/* allocate colors for the bar and summary text */
bar_color = color_alloc(im, get_imgarg("bar_col"));
summary_color = color_alloc(im, get_imgarg("summary_col"));
/* rescale UPS value to fit in the scale */
bar_y = (1 - (value - lvllo) / (lvlhi - lvllo)) * scale_height;
/* sanity checks: */
/* 1: if value is above maximum, then bar_y goes negative */
if (bar_y < 0)
bar_y = 0;
/* 2: if value is below minimum, bar_y goes off the scale */
if (bar_y > scale_height)
bar_y = scale_height;
/* draw it */
gdImageFilledRectangle(im, 25, bar_y, width - 25, scale_height,
bar_color);
/* stick the text version of the value at the bottom center */
snprintf(text, sizeof(text), format, value);
gdImageString(im, gdFontMediumBold,
(width - strlen(text)*gdFontMediumBold->w)/2,
height - gdFontMediumBold->h,
(unsigned char *) text, summary_color);
drawimage(im);
/* NOTREACHED */
}
/* draws the error image */
static void noimage(const char *fmt, ...)
{
gdImagePtr im;
int back_color, summary_color;
int width, height;
char msg[SMALLBUF];
va_list ap;
va_start(ap, fmt);
vsnprintf(msg, sizeof(msg), fmt, ap);
va_end(ap);
width = get_imgarg("width");
height = get_imgarg("height");
im = gdImageCreate(width, height);
back_color = color_alloc(im, get_imgarg("back_col"));
summary_color = color_alloc(im, get_imgarg("summary_col"));
gdImageFilledRectangle(im, 0, 0, width, height, back_color);
gdImageColorTransparent(im, back_color);
if (width > height)
gdImageString(im, gdFontMediumBold,
(width - strlen(msg)*gdFontMediumBold->w)/2,
(height - gdFontMediumBold->h)/2,
(unsigned char *) msg, summary_color);
else
gdImageStringUp(im, gdFontMediumBold,
(width - gdFontMediumBold->h)/2,
(height + strlen(msg)*gdFontMediumBold->w)/2,
(unsigned char *) msg, summary_color);
drawimage(im);
/* NOTREACHED */
}
/* draws bar indicator when minimum, nominal or maximum values for the given
UPS variable can be determined.
deviation < 0 means that values below nom should be grey instead of
green */
static void drawgeneralbar(double var, int min, int nom, int max,
int deviation, const char *format)
{
int hi, lo, step1, step5, step10, graybelownom=0;
if(deviation < 0) {
deviation=-deviation;
graybelownom=1;
}
if ((nom == -1) && ((min == -1) || (max == -1)))
noimage("Can't determine range");
/* if min, max and nom are mixed up, arrange them appropriately */
if (nom != -1) {
if (min == -1)
min = nom - 3*deviation;
if (max == -1)
max = nom + 3*deviation;
} else {
/* if nominal value isn't available, assume, it's the
average between min and max */
nom = (min + max) / 2;
}
/* draw scale in the background */
if ((max - min) <= 50) {
/* the scale is sparse enough to draw finer scale */
step1 = 1;
step5 = 5;
step10 = 10;
} else if((max - min) <= 100) {
step1 = 2;
step5 = 10;
step10 = 20;
} else {
step1 = 5;
step5 = 20;
step10 = 40;
}
/* round min and max points to get high and low numbers for graph */
lo = ((min - deviation) / step10) * step10;
hi = ((max + deviation + step10/2) / step10) * step10;
if(!graybelownom) {
drawbar(lo, hi, step1, step5, step10, max, hi, lo, min,
nom - deviation, nom + deviation, var, format);
}
else {
drawbar(lo, hi, step1, step5, step10, 0, min, max, hi,
nom, max, var, format);
}
/* NOTREACHED */
}
/* draws input and output voltage bar style indicators */
static void draw_utility(double var, int min, int nom, int max,
int deviation, const char *format)
{
/* hack: deal with hardware that doesn't have known transfer points */
if (min == -1) {
if(var < 200) {
min = 90;
}
else if(var < 300) {
min = 200;
}
else {
min = 340;
}
}
/* somewhere between 220 and 230 V, to keep everybody satisfied */
if (nom == -1) {
if(var < 200) {
nom = 110;
}
else if(var < 300) {
nom = 225;
}
else {
nom = 400;
}
}
/* symmetrical around nom */
if (max == -1)
max = nom+(nom-min);
/* Acceptable range of voltage is 85%-110% of nominal voltage
* in EU at least. Be conservative and say +-10% */
deviation = nom*0.1;
drawgeneralbar(var, min, nom, max, deviation, format);
/* NOTREACHED */
}
/* draws battery.percent bar style indicator */
static void draw_battpct(double var, int min, int nom, int max,
int deviation, const char *format)
{
drawbar(0, 100, 1, 10, 20, 0, 50, -1, -1, 80, 100, var, format);
}
/* draws battery.voltage bar style indicator */
static void draw_battvolt(double var, int min, int nom, int max,
int deviation, const char *format)
{
if(nom == -1) {
/* Use a fixed set of reasonable nominal voltages, seems to
* be the only way to get reasonable behaviour during
* discharge */
if(var < 9)
nom = 6;
else if(var < 18)
nom = 12;
else if(var < 30)
nom = 24;
else if(var < 60)
nom = 48;
else if(var < 120)
nom = 96;
else if(var < 230)
nom = 192;
else
nom = 384;
}
if(min == -1) {
min = nom/2*1.6+1; /* Assume a 2V cell is dead at 1.6V */
}
if(max == -1) {
max = nom/2*2.3+1; /* Assume 2.3V float charge voltage */
}
if (nom < min || nom > max)
nom = -1;
deviation = -(nom*0.05); /* 5% deviation from nominal voltage */
if(deviation==0) {
deviation = -1;
}
drawgeneralbar(var, min, nom, max, deviation, format);
}
/* draws ups.load bar style indicator */
static void draw_upsload(double var, int min, int nom, int max,
int deviation, const char *format)
{
drawbar(0, 125, 5, 5, 25, 100, 125, -1, -1, 0, 50, var, format);
}
static int get_var(const char *var, char *buf, size_t buflen)
{
int ret;
unsigned int numq, numa;
const char *query[4];
char **answer;
query[0] = "VAR";
query[1] = upsname;
query[2] = var;
numq = 3;
ret = upscli_get(&ups, numq, query, &numa, &answer);
if (ret < 0)
return 0;
if (numa < numq)
return 0;
snprintf(buf, buflen, "%s", answer[3]);
return 1;
}
int main(int argc, char **argv)
{
char str[SMALLBUF];
int i, min, nom, max;
double var = 0;
extractcgiargs();
/* no 'host=' or 'display=' given */
if ((!monhost) || (!cmd))
noimage("No host or display");
if (!checkhost(monhost, NULL))
noimage("Access denied");
upsname = hostname = NULL;
if (upscli_splitname(monhost, &upsname, &hostname, &port) != 0) {
noimage("Invalid UPS definition (upsname[@hostname[:port]])\n");
exit(EXIT_FAILURE);
}
if (upscli_connect(&ups, hostname, port, 0) < 0) {
noimage("Can't connect to server:\n%s\n",
upscli_strerror(&ups));
exit(EXIT_FAILURE);
}
for (i = 0; imgvar[i].name; i++)
if (!strcmp(cmd, imgvar[i].name)) {
/* sanity check whether we have draw function
registered with this variable */
if (!imgvar[i].drawfunc) {
noimage("Draw function N/A");
exit(EXIT_FAILURE);
}
/* get the variable value */
if (get_var(imgvar[i].name, str, sizeof(str)) == 1) {
var = strtod(str, NULL);
} else {
/* no value, no fun */
snprintf(str, sizeof(str), "%s N/A",
imgvar[i].name);
noimage(str);
exit(EXIT_FAILURE);
}
/* when getting minimum, nominal and maximum values,
we first look if the marginal value is supported
by the UPS driver, if not, we look it up in the
imgarg table under the SAME name */
/* get the minimum value */
if (imgvar[i].minimum) {
if (get_var(imgvar[i].minimum, str,
sizeof(str)) == 1) {
min = atoi(str);
} else {
min = get_imgarg(imgvar[i].minimum);
}
} else {
min = -1;
}
/* get the nominal value */
if (imgvar[i].nominal) {
if (get_var(imgvar[i].nominal, str,
sizeof(str)) == 1) {
nom = atoi(str);
} else {
nom = get_imgarg(imgvar[i].nominal);
}
} else {
nom = -1;
}
/* get the maximum value */
if (imgvar[i].maximum) {
if (get_var(imgvar[i].maximum, str,
sizeof(str)) == 1) {
max = atoi(str);
} else {
max = get_imgarg(imgvar[i].maximum);
}
} else {
max = -1;
}
imgvar[i].drawfunc(var, min, nom, max,
imgvar[i].deviation, imgvar[i].format);
exit(EXIT_SUCCESS);
}
noimage("Unknown display");
exit(EXIT_FAILURE);
}
struct imgvar_t imgvar[] = {
{ "input.voltage", "input.transfer.low", "input.voltage.nominal",
"input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "input.L1-N.voltage", "input.transfer.low", "input.voltage.nominal",
"input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "input.L2-N.voltage", "input.transfer.low", "input.voltage.nominal",
"input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "input.L3-N.voltage", "input.transfer.low", "input.voltage.nominal",
"input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "input.L1-L2.voltage", "input.transfer.low", "input.voltage.nominal",
"input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "input.L2-L3.voltage", "input.transfer.low", "input.voltage.nominal",
"input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "input.L3-L1.voltage", "input.transfer.low", "input.voltage.nominal",
"input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "battery.charge", NULL, NULL, NULL, 0,
"%.1f %%", draw_battpct },
{ "battery.voltage", "battery.voltage.minimum", "battery.voltage.nominal",
"battery.voltage.maximum", 0,
"%.1f VDC", draw_battvolt },
{ "ups.temperature", "ups.temperature.minimum", NULL,
"ups.temperature.maximum", 10,
"%.1f C", drawgeneralbar },
{ "input.frequency", NULL, "input.frequency.nominal", NULL, 2,
"%.1f Hz", drawgeneralbar },
{ "ups.load", NULL, NULL, NULL, 0,
"%.1f %%", draw_upsload },
{ "output.L1.power.percent", NULL, NULL, NULL, 0,
"%.1f %%", draw_upsload },
{ "output.L2.power.percent", NULL, NULL, NULL, 0,
"%.1f %%", draw_upsload },
{ "output.L3.power.percent", NULL, NULL, NULL, 0,
"%.1f %%", draw_upsload },
{ "output.L1.realpower.percent", NULL, NULL, NULL, 0,
"%.1f %%", draw_upsload },
{ "output.L2.realpower.percent", NULL, NULL, NULL, 0,
"%.1f %%", draw_upsload },
{ "output.L3.realpower.percent", NULL, NULL, NULL, 0,
"%.1f %%", draw_upsload },
{ "output.voltage", "input.transfer.low", "output.voltage.nominal",
"input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "output.L1-N.voltage", "input.transfer.low",
"output.voltage.nominal", "input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "output.L2-N.voltage", "input.transfer.low",
"output.voltage.nominal", "input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "output.L3-N.voltage", "input.transfer.low",
"output.voltage.nominal", "input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "output.L1-L2.voltage", "input.transfer.low",
"output.voltage.nominal", "input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "output.L2-L3.voltage", "input.transfer.low",
"output.voltage.nominal", "input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "output.L3-L1.voltage", "input.transfer.low",
"output.voltage.nominal", "input.transfer.high", 0,
"%.1f VAC", draw_utility },
{ "output.frequency", NULL, "output.frequency.nominal", NULL, 2,
"%.1f Hz", drawgeneralbar },
{ NULL, NULL, NULL, NULL, 0,
NULL, NULL }
};
syntax highlighted by Code2HTML, v. 0.9.1