nut/drivers/apcsmart.c

/*
 * apcsmart.c - driver for APC smart protocol units (originally "newapc")
 *
 * Copyright (C) 1999  Russell Kroll <rkroll@exploits.org>
 *           (C) 2000  Nigel Metheringham <Nigel.Metheringham@Intechnology.co.uk>
 *           (C) 2011  Michal Soltys <soltys@ziu.info>
 *
 * 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 <sys/types.h>
#include <sys/file.h>
#include <regex.h>
#include <ctype.h>

#include "main.h"
#include "serial.h"
#include "timehead.h"

#include "apcsmart.h"
#include "apcsmart_tabs.h"

/* driver description structure */
upsdrv_info_t upsdrv_info = {
	DRIVER_NAME,
	DRIVER_VERSION,
	"Russell Kroll <rkroll@exploits.org>\n"
	"Nigel Metheringham <Nigel.Metheringham@Intechnology.co.uk>\n"
	"Michal Soltys <soltys@ziu.info>",
	DRV_STABLE,
	{ &apc_tab_info, NULL }
};

static int ups_status = 0;

/* some forwards */

static int sdcmd_S(const void *);
static int sdcmd_AT(const void *);
static int sdcmd_K(const void *);
static int sdcmd_Z(const void *);
static int sdcmd_CS(const void *);

static int (*sdlist[])(const void *) = {
	sdcmd_S,
	sdcmd_AT,
	sdcmd_K,
	sdcmd_Z,
	sdcmd_CS,
};

#define SDIDX_S		0
#define SDIDX_AT	1
#define SDIDX_K		2
#define SDIDX_Z		3
#define SDIDX_CS	4
#define SDCNT 		((int)(sizeof(sdlist)/sizeof(sdlist[0])))

static apc_vartab_t *vartab_lookup_char(char cmdchar)
{
	int	i;

	for (i = 0; apc_vartab[i].name != NULL; i++)
		if (apc_vartab[i].cmd == cmdchar)
			return &apc_vartab[i];

	return NULL;
}

static apc_vartab_t *vartab_lookup_name(const char *var)
{
	int	i;

	for (i = 0; apc_vartab[i].name != NULL; i++)
		if (!(apc_vartab[i].flags & APC_DEPR) &&
		    !strcasecmp(apc_vartab[i].name, var))
			return &apc_vartab[i];

	return NULL;
}

/* FUTURE: change to use function pointers */

static int rexhlp(const char *rex, const char *val)
{
	int ret;
	regex_t mbuf;

	regcomp(&mbuf, rex, REG_EXTENDED|REG_NOSUB);
	ret = regexec(&mbuf, val, 0,0,0);
	regfree(&mbuf);
	return ret;
}

/* convert APC formatting to NUT formatting */
/* TODO: handle errors better */
static const char *convert_data(apc_vartab_t *cmd_entry, const char *upsval)
{
	static char temp[APC_LBUF];
	int tval;

	/* this should never happen */
	if (strlen(upsval) >= sizeof(temp)) {
		upslogx(LOG_CRIT, "length of [%s] too long", cmd_entry->name);
		strncpy(temp, upsval, sizeof(temp) - 1);
		temp[sizeof(temp) - 1] = '\0';
		return temp;
	}

	switch(cmd_entry->flags & APC_F_MASK) {
		case APC_F_PERCENT:
		case APC_F_VOLT:
		case APC_F_AMP:
		case APC_F_CELSIUS:
		case APC_F_HEX:
		case APC_F_DEC:
		case APC_F_SECONDS:
		case APC_F_LEAVE:
			/* no conversion for any of these */
			strcpy(temp, upsval);
			return temp;

		case APC_F_HOURS:
			/* convert to seconds */

			tval = 60 * 60 * strtol(upsval, NULL, 10);

			snprintf(temp, sizeof(temp), "%d", tval);
			return temp;

		case APC_F_MINUTES:
			/* Convert to seconds - NUT standard time measurement */
			tval = 60 * strtol(upsval, NULL, 10);
			/* Ignore errors - there's not much we can do */
			snprintf(temp, sizeof(temp), "%d", tval);
			return temp;

		case APC_F_REASON:
			switch (upsval[0]) {
				case 'R': return "unacceptable utility voltage rate of change";
				case 'H': return "high utility voltage";
				case 'L': return "low utility voltage";
				case 'T': return "line voltage notch or spike";
				case 'O': return "no transfers yet since turnon";
				case 'S': return "simulated power failure or UPS test";
				default:
					  strcpy(temp, upsval);
					  return temp;
			}
	}

	upslogx(LOG_NOTICE, "Unable to handle conversion of [%s]", cmd_entry->name);
	strcpy(temp, upsval);
	return temp;
}

static void apc_ser_set(void)
{
	struct termios tio, tio_chk;
	char *cable;

	/*
	 * this must be called before the rest, as ser_set_speed() performs
	 * early initialization of the port, apart from changing speed
	 */
	ser_set_speed(upsfd, device_path, B2400);

	memset(&tio, 0, sizeof(tio));
	errno = 0;

	if (tcgetattr(upsfd, &tio))
		fatal_with_errno(EXIT_FAILURE, "tcgetattr(%s)", device_path);

	/* set port mode: common stuff, canonical processing */

	tio.c_cflag |= (CS8 | CLOCAL | CREAD);

	tio.c_lflag |= ICANON;
	tio.c_lflag &= ~ISIG;

	tio.c_iflag |= (IGNCR | IGNPAR);
	tio.c_iflag &= ~(IXON | IXOFF);

	tio.c_oflag = 0;

	tio.c_cc[VEOL] = '*';	/* specially handled in apc_read() */

#ifdef _POSIX_VDISABLE
	tio.c_cc[VERASE] = _POSIX_VDISABLE;
	tio.c_cc[VKILL]  = _POSIX_VDISABLE;
	tio.c_cc[VEOF] = _POSIX_VDISABLE;
	tio.c_cc[VEOL2] = _POSIX_VDISABLE;
#endif

#if 0
	/* unused in canonical mode: */
	tio.c_cc[VMIN] = 1;
	tio.c_cc[VTIME] = 0;
#endif

	if (tcflush(upsfd, TCIOFLUSH))
		fatal_with_errno(EXIT_FAILURE, "tcflush(%s)", device_path);

	/*
	 * warn:
	 * Note, that tcsetattr() returns success if /any/ of the requested
	 * changes could be successfully carried out. Thus the more complicated
	 * test.
	 */
	if (tcsetattr(upsfd, TCSANOW, &tio))
		fatal_with_errno(EXIT_FAILURE, "tcsetattr(%s)", device_path);

	memset(&tio_chk, 0, sizeof(tio_chk));
	if (tcgetattr(upsfd, &tio_chk))
		fatal_with_errno(EXIT_FAILURE, "tcgetattr(%s)", device_path);
	if (memcmp(&tio_chk, &tio, sizeof(tio)))
		fatalx(EXIT_FAILURE, "unable to set the required attributes (%s)", device_path);

	cable = getval("cable");
	if (cable && !strcasecmp(cable, ALT_CABLE_1)) {
		if (ser_set_dtr(upsfd, 1) == -1)
			fatalx(EXIT_FAILURE, "ser_set_dtr() failed (%s)", device_path);
		if (ser_set_rts(upsfd, 0) == -1)
			fatalx(EXIT_FAILURE, "ser_set_rts() failed (%s)", device_path);
	}
}

static void ups_status_set(void)
{
	status_init();
	if (ups_status & APC_STAT_CAL)
		status_set("CAL");		/* calibration */
	if (ups_status & APC_STAT_TRIM)
		status_set("TRIM");		/* SmartTrim */
	if (ups_status & APC_STAT_BOOST)
		status_set("BOOST");		/* SmartBoost */
	if (ups_status & APC_STAT_OL)
		status_set("OL");		/* on line */
	if (ups_status & APC_STAT_OB)
		status_set("OB");		/* on battery */
	if (ups_status & APC_STAT_OVER)
		status_set("OVER");		/* overload */
	if (ups_status & APC_STAT_LB)
		status_set("LB");		/* low battery */
	if (ups_status & APC_STAT_RB)
		status_set("RB");		/* replace batt */

	if (ups_status == 0)
		status_set("OFF");

	status_commit();
}

static void alert_handler(char ch)
{
	switch (ch) {
		case '!':		/* clear OL, set OB */
			upsdebugx(4, "alert_handler: OB");
			ups_status &= ~APC_STAT_OL;
			ups_status |= APC_STAT_OB;
			break;

		case '$':		/* clear OB, set OL */
			upsdebugx(4, "alert_handler: OL");
			ups_status &= ~APC_STAT_OB;
			ups_status |= APC_STAT_OL;
			break;

		case '%':		/* set LB */
			upsdebugx(4, "alert_handler: LB");
			ups_status |= APC_STAT_LB;
			break;

		case '+':		/* clear LB */
			upsdebugx(4, "alert_handler: not LB");
			ups_status &= ~APC_STAT_LB;
			break;

		case '#':		/* set RB */
			upsdebugx(4, "alert_handler: RB");
			ups_status |= APC_STAT_RB;
			break;

		case '?':		/* set OVER */
			upsdebugx(4, "alert_handler: OVER");
			ups_status |= APC_STAT_OVER;
			break;

		case '=':		/* clear OVER */
			upsdebugx(4, "alert_handler: not OVER");
			ups_status &= ~APC_STAT_OVER;
			break;

		default:
			upsdebugx(4, "alert_handler got 0x%02x (unhandled)", ch);
			break;
	}

	ups_status_set();
}

/*
 * we need a tiny bit different processing due to '*' and canonical mode; the
 * function is subtly different from generic ser_get_line_alert()
 */
static int apc_read(char *buf, size_t buflen, int flags)
{
	const char *iset = IGN_CHARS, *aset = "";
	size_t	count = 0;
	int	i, ret, sec = 3, usec = 0;
	char	temp[APC_LBUF];

	if (upsfd == -1)
		return 0;
	if (flags & SER_D0) {
		sec = 0; usec = 0;
	}
	if (flags & SER_DX) {
		sec = 0; usec = 200000;
	}
	if (flags & SER_D1) {
		sec = 1; usec = 500000;
	}
	if (flags & SER_D3) {
		sec = 3; usec = 0;
	}
	if (flags & SER_AA) {
		iset = IGN_AACHARS;
		aset = ALERT_CHARS;
	}
	if (flags & SER_CC) {
		iset = IGN_CCCHARS;
		aset = "";
		sec = 6; usec = 0;
	}
	if (flags & SER_CS) {
		iset = IGN_CSCHARS;
		aset = "";
		sec = 6; usec = 0;
	}

	memset(buf, '\0', buflen);

	while (count < buflen - 1) {
		errno = 0;
		ret = select_read(upsfd, temp, sizeof(temp), sec, usec);

		/* error or no timeout allowed */
		if (ret < 0 || (ret == 0 && !(flags & SER_TO))) {
			ser_comm_fail("%s", ret ? strerror(errno) : "timeout");
			return ret;
		}
		/* ok, timeout is acceptable */
		if (ret == 0 && (flags & SER_TO)) {
			/*
			 * but it doesn't imply ser_comm_good
			 *
			 * to be more precise - we might be in comm_fail
			 * condition, trying to "nudge" the UPS with some
			 * command obviously expecting timeout if the comm is
			 * still lost. This would result with filling logs with
			 * confusing comm lost/comm re-established pairs. Thus
			 * - just return here.
			 */
			return count;
		}

		/* parse input */
		for (i = 0; i < ret; i++) {
			/* standard "line received" condition */
			if ((count == buflen - 1) || (temp[i] == ENDCHAR)) {
				ser_comm_good();
				return count;
			}
			/*
			 * '*' is set as a secondary EOL; convert to 'OK' only as a
			 * reply to shutdown command in sdok(); otherwise next
			 * select_read() will continue normally
			 */
			if ((flags & SER_HA) && temp[i] == '*') {
				/*
				 * a bit paranoid, but remember '*' is not real EOL;
				 * there could be some firmware in existence, that
				 * would send both string: 'OK\n' and alert: '*'.
				 * Just in case, try to flush the input with small 1 sec.
				 * timeout
				 */
				memset(buf, '\0', buflen);
				errno = 0;
				ret = select_read(upsfd, temp, sizeof(temp), 1, 0);
				if (ret < 0) {
					ser_comm_fail("%s", strerror(errno));
					return ret;
				}
				buf[0] = 'O';
				buf[1] = 'K';
				ser_comm_good();
				return 2;
			}
			/* ignore set */
			if (strchr(iset, temp[i]) || temp[i] == '*') {
				continue;
			}
			/* alert set */
			if (strchr(aset, temp[i])) {
				alert_handler(temp[i]);
				continue;
			}

			buf[count++] = temp[i];
		}
	}

	ser_comm_good();
	return count;
}
static int apc_write(unsigned char code)
{
	errno = 0;
	if (upsfd == -1)
		return 0;
	return ser_send_char(upsfd, code);
}

/*
 * We have to watch out for NA, here;
 * This is generally safe, as otherwise we will just timeout. The reason we do
 * it, is that under certain conditions an ups might respond with NA for
 * something it would normally handle (e.g. calling @ while being in powered
 * off or hibernated state. If we keep sending the "arguments" after getting
 * NA, they will be interpreted as commands, which is quite a bug :)
 * Furthermore later flushes might not work properly, if the reply to those
 * commands are generated with some delay.
 *
 * We also set errno to something usable, so outside upslog calls don't output
 * confusing "success".
 */
static int apc_write_long(const char *code)
{
	char temp[APC_LBUF];
	int ret;
	errno = 0;

	if (upsfd == -1)
		return 0;

	ret = ser_send_char(upsfd, *code);
	if (ret != 1)
		return ret;
	/* peek for the answer - anything at this point is failure */
	ret = apc_read(temp, sizeof(temp), SER_DX|SER_TO);
	if (ret) {
		errno = ECANCELED;
		return -1;
	}

	return ser_send_pace(upsfd, 50000, "%s", code + 1);
}

static int apc_write_rep(unsigned char code)
{
	char temp[APC_LBUF];
	int ret;
	errno = 0;

	if (upsfd == -1)
		return 0;

	ret = ser_send_char(upsfd, code);
	if (ret != 1)
		return ret;
	/* peek for the answer - anything at this point is failure */
	ret = apc_read(temp, sizeof(temp), SER_DX|SER_TO);
	if (ret) {
		errno = ECANCELED;
		return -1;
	}

	usleep(1300000);
	ret = ser_send_char(upsfd, code);
	if (ret != 1)
		return ret;
	return 2;
}

/* all flags other than SER_AA are ignored */
static void apc_flush(int flags)
{
	char temp[APC_LBUF];

	if (flags & SER_AA) {
		tcflush(upsfd, TCOFLUSH);
		while(apc_read(temp, sizeof(temp), SER_D0|SER_TO|SER_AA));
	} else {
		tcflush(upsfd, TCIOFLUSH);
		/* tcflush(upsfd, TCIFLUSH); */
		/* while(apc_read(temp, sizeof(temp), SER_D0|SER_TO)); */
	}
}

static const char *preread_data(apc_vartab_t *vt)
{
	int ret;
	char temp[APC_LBUF];

	upsdebugx(4, "preread_data: %s", vt->name);

	apc_flush(0);
	ret = apc_write(vt->cmd);

	if (ret != 1) {
		upslogx(LOG_ERR, "preread_data: apc_write failed");
		return 0;
	}

	ret = apc_read(temp, sizeof(temp), SER_TO);

	if (ret < 0) {
		upslogx(LOG_ERR, "preread_data: apc_read failed");
		return 0;
	}

	if (!ret || !strcmp(temp, "NA")) {
		upslogx(LOG_ERR, "preread_data: %s timed out or not supported", vt->name);
		return 0;
	}

	return convert_data(vt, temp);
}

static void remove_var(const char *cal, apc_vartab_t *vt)
{
	const char *fmt;
	char info[256];

	if (isprint(vt->cmd))
		fmt = "[%c]";
	else
		fmt = "[0x%02x]";

	snprintf(info, sizeof(info), "%s%s%s",
		"%s: verified variable [%s] (APC: ",
		fmt,
		") returned NA"
	);
	upsdebugx(1, info, cal, vt->name, vt->cmd);

	snprintf(info, sizeof(info), "%s%s%s",
		"%s: removing [%s] (APC: ",
		fmt,
		")"
	);
	upsdebugx(1, info, cal, vt->name, vt->cmd);

	vt->flags &= ~APC_PRESENT;
	dstate_delinfo(vt->name);
}

static int poll_data(apc_vartab_t *vt)
{
	int	ret;
	char	temp[APC_LBUF];

	if (!(vt->flags & APC_PRESENT))
		return 1;

	upsdebugx(4, "poll_data: %s", vt->name);

	apc_flush(SER_AA);
	ret = apc_write(vt->cmd);

	if (ret != 1) {
		upslogx(LOG_ERR, "poll_data: apc_write failed");
		dstate_datastale();
		return 0;
	}

	if (apc_read(temp, sizeof(temp), SER_AA) < 1) {
		dstate_datastale();
		return 0;
	}

	/* automagically no longer supported by the hardware somehow */
	if (!strcmp(temp, "NA"))
		remove_var("poll_data", vt);

	dstate_setinfo(vt->name, "%s", convert_data(vt, temp));
	dstate_dataok();

	return 1;
}

static int dfa_fwnew(const char *val)
{
	int ret;
	regex_t mbuf;
	/* must be xx.yy.zz */
	const char rex[] = "^[[:alnum:]]+\\.[[:alnum:]]+\\.[[:alnum:]]+$";

	regcomp(&mbuf, rex, REG_EXTENDED|REG_NOSUB);
	ret = regexec(&mbuf, val, 0,0,0);
	regfree(&mbuf);
	return ret;
}

static int dfa_cmdset(const char *val)
{
	int ret;
	regex_t mbuf;
	/*
	 * must be #.alerts.commands ; we'll be a bit lax here
	 */
	const char rex[] = "^[0-9]\\.[^.]*\\.[^.]+$";

	regcomp(&mbuf, rex, REG_EXTENDED|REG_NOSUB);
	ret = regexec(&mbuf, val, 0,0,0);
	regfree(&mbuf);
	return ret;
}

static int valid_cmd(char cmd, const char *val)
{
	char info[256], *fmt;
	int ret;

	switch (cmd) {
		case APC_FW_NEW:
			ret = dfa_fwnew(val);
			break;
		case APC_CMDSET:
			ret = dfa_cmdset(val);
			break;
		default:
			return 1;
	}

	if (ret) {
		if (isprint(cmd))
			fmt = "[%c]";
		else
			fmt = "[0x%02x]";

		snprintf(info, sizeof(info), "%s%s%s",
			"valid_cmd: cmd ",
			fmt,
			" failed regex match"
		);
		upslogx(LOG_WARNING, info, cmd);
	}

	return !ret;
}

/*
 * query_ups() is called before any APC_PRESENT flags are determined;
 * only for the variable provided
 */
static int query_ups(const char *var)
{
	int i, j;
	const char *temp;
	apc_vartab_t *vt, *vtn;

	/*
	 * at first run we know nothing about variable; we have to handle
	 * APC_MULTI gracefully as well
	 */
	for (i = 0; apc_vartab[i].name != NULL; i++) {
		vt = &apc_vartab[i];
		if (strcmp(vt->name, var) || vt->flags & APC_DEPR)
			continue;

		/* found, [try to] get it */

		temp = preread_data(vt);
		if (!temp || !valid_cmd(vt->cmd, temp)) {
			if (vt->flags & APC_MULTI) {
				vt->flags |= APC_DEPR;
				continue;
			}
			upsdebugx(1, "query_ups: unknown variable %s", var);
			break;
		}

		vt->flags |= APC_PRESENT;
		dstate_setinfo(vt->name, "%s", temp);
		dstate_dataok();

		/* supported, deprecate all the remaining ones */
		if (vt->flags & APC_MULTI)
			for (j = i + 1; apc_vartab[j].name != NULL; j++) {
				vtn = &apc_vartab[j];
				if (strcmp(vtn->name, vt->name))
					continue;
				vtn->flags |= APC_DEPR;
				vtn->flags &= ~APC_PRESENT;
			}

		return 1; /* success */
	}

	return 0;
}

/*
 * This function iterates over vartab, deprecating nut:apc 1:n variables. We
 * prefer earliest present variable. All the other ones must be marked as
 * deprecated and as not present.
 * This is intended to call after verifying the presence of variables.
 * Otherwise it would take a while to execute due to preread_data()
 */
static void deprecate_vars(void)
{
	int i, j;
	const char *temp;
	apc_vartab_t *vt, *vtn;

	for (i = 0; apc_vartab[i].name != NULL; i++) {
		vt = &apc_vartab[i];
		if (vt->flags & APC_DEPR)
			/* already handled */
			continue;

		if (!(vt->flags & APC_MULTI))
			continue;
		if (!(vt->flags & APC_PRESENT)) {
			vt->flags |= APC_DEPR;
			continue;
		}
		/* pre-read data, we have to verify it */
		temp = preread_data(vt);
		if (!temp || !valid_cmd(vt->cmd, temp)) {
			upslogx(LOG_ERR, "deprecate_vars: [%s] is unreadable or invalid, deprecating", vt->name);
			vt->flags |= APC_DEPR;
			vt->flags &= ~APC_PRESENT;
			continue;
		}

		/* multi & present, deprecate all the remaining ones */
		for (j = i + 1; apc_vartab[j].name != NULL; j++) {
			vtn = &apc_vartab[j];
			if (strcmp(vtn->name, vt->name))
				continue;
			vtn->flags |= APC_DEPR;
			vtn->flags &= ~APC_PRESENT;
		}

		dstate_setinfo(vt->name, "%s", temp);
		dstate_dataok();
	}
}

static void do_capabilities(int qco)
{
	const	char	*ptr, *entptr;
	char	upsloc, temp[APC_LBUF], cmd, loc, etmp[APC_SBUF], *endtemp;
	int	nument, entlen, i, matrix, ret, valid;
	apc_vartab_t *vt;

	upsdebugx(1, "APC - About to get capabilities string");
	/* If we can do caps, then we need the Firmware revision which has
	   the locale descriptor as the last character (ugh)
	*/
	ptr = dstate_getinfo("ups.firmware");
	if (ptr)
		upsloc = ptr[strlen(ptr) - 1];
	else
		upsloc = 0;

	/* get capability string */
	apc_flush(0);
	ret = apc_write(APC_CAPS);

	if (ret != 1) {
		upslog_with_errno(LOG_ERR, "do_capabilities: apc_write failed");
		return;
	}
	/*
	 * note - apc_read() needs larger timeout grace and different
	 * ignore set due to certain characters like '#' being received
	 */
	ret = apc_read(temp, sizeof(temp), SER_CC|SER_TO);

	if ((ret < 1) || (!strcmp(temp, "NA"))) {

		/* Early Smart-UPS, not as smart as later ones */
		/* This should never happen since we only call
		   this if the REQ_CAPABILITIES command is supported
		*/
		upslogx(LOG_ERR, "ERROR: APC cannot do capabilities but said it could !");
		return;
	}

	/* recv always puts a \0 at the end, so this is safe */
	/* however it assumes a zero byte cannot be embedded */
	endtemp = &temp[0] + strlen(temp);

	if (temp[0] != '#') {
		upsdebugx(1, "unrecognized capability start char %c", temp[0]);
		upsdebugx(1, "please report this error [%s]", temp);
		upslogx(LOG_ERR, "ERROR: unknown capability start char %c!",
			temp[0]);

		return;
	}

	if (temp[1] == '#') {		/* Matrix-UPS */
		matrix = 1;
		ptr = &temp[0];
	}
	else {
		ptr = &temp[1];
		matrix = 0;
	}

	/* command char, location, # of entries, entry length */

	while (ptr[0] != '\0') {
		if (matrix)
			ptr += 2;	/* jump over repeating ## */

		/* check for idiocy */
		if (ptr >= endtemp) {

			/* if we expected this, just ignore it */
			if (qco)
				return;

			fatalx(EXIT_FAILURE,
				"capability string has overflowed\n"
				"please report this error\n"
				"ERROR: capability overflow!"
				);
		}

		cmd = ptr[0];
		loc = ptr[1];
		nument = ptr[2] - 48;
		entlen = ptr[3] - 48;
		entptr = &ptr[4];

		vt = vartab_lookup_char(cmd);
		valid = vt && ((loc == upsloc) || (loc == '4'));

		/* mark this as writable */
		if (valid) {
			upsdebugx(1, "supported capability: %02x (%c) - %s",
				cmd, loc, vt->name);

			dstate_setflags(vt->name, ST_FLAG_RW);

			/* make sure setvar knows what this is */
			vt->flags |= APC_RW | APC_ENUM;
		}

		for (i = 0; i < nument; i++) {
			if (valid) {
				snprintf(etmp, entlen + 1, "%s", entptr);
				dstate_addenum(vt->name, "%s", convert_data(vt, etmp));
			}

			entptr += entlen;
		}

		ptr = entptr;
	}
}

static int update_status(void)
{
	int	ret;
	char	buf[APC_LBUF];

	upsdebugx(4, "update_status");

	apc_flush(SER_AA);
	ret = apc_write(APC_STATUS);

	if (ret != 1) {
		upslog_with_errno(LOG_ERR, "update_status: apc_write failed");
		dstate_datastale();
		return 0;
	}

	ret = apc_read(buf, sizeof(buf), SER_AA);

	if ((ret < 1) || (!strcmp(buf, "NA"))) {
		dstate_datastale();
		return 0;
	}

	ups_status = strtol(buf, 0, 16) & 0xff;
	ups_status_set();

	dstate_dataok();

	return 1;
}

static void oldapcsetup(void)
{
	/* really old models ignore REQ_MODEL, so find them first */
	if (!query_ups("ups.model")) {
		/* force the model name */
		dstate_setinfo("ups.model", "Smart-UPS");
	}

	/* see if this might be an old Matrix-UPS instead */
	if (query_ups("output.current"))
		dstate_setinfo("ups.model", "Matrix-UPS");

	query_ups("ups.firmware");
	query_ups("ups.serial");
	query_ups("input.voltage");
	query_ups("battery.charge");
	query_ups("battery.voltage");
	query_ups("input.voltage");
	query_ups("output.voltage");
	query_ups("ups.temperature");
	query_ups("ups.load");

	update_status();

	/*
	 * If we have come down this path then we dont do capabilities and
	 * other shiny features.
	 */
}

static void protocol_verify(unsigned char cmd)
{
	int i, found;
	const char *fmt, *temp;
	char info[256];

	/* don't bother with cmd/var we don't care about */
	if (strchr(APC_UNR_CMDS, cmd))
		return;

	if (isprint(cmd))
		fmt = "[%c]";
	else
		fmt = "[0x%02x]";

	/*
	 * see if it's a variable
	 * note: some nut variables map onto multiple APC ones (firmware)
	 */
	for (i = 0; apc_vartab[i].name != NULL; i++) {
		if (apc_vartab[i].cmd == cmd) {
			if (apc_vartab[i].flags & APC_MULTI) {
				/* APC_MULTI are handled by deprecate_vars() */
				apc_vartab[i].flags |= APC_PRESENT;
				return;
			}

			temp = preread_data(&apc_vartab[i]);
			if (!temp || !valid_cmd(cmd, temp)) {
				snprintf(info, sizeof(info), "%s%s%s",
					"UPS variable [%s] - APC: ",
					fmt,
					" invalid or unreadable"
				);
				upsdebugx(3, info, apc_vartab[i].name, cmd);
				return;
			}

			apc_vartab[i].flags |= APC_PRESENT;

			snprintf(info, sizeof(info), "%s%s",
				"UPS supports variable [%s] - APC: ",
				fmt
			);
			upsdebugx(3, info, apc_vartab[i].name, cmd);

			dstate_setinfo(apc_vartab[i].name, "%s", temp);
			dstate_dataok();

			/* handle special data for our two strings */
			if (apc_vartab[i].flags & APC_STRING) {
				dstate_setflags(apc_vartab[i].name,
					ST_FLAG_RW | ST_FLAG_STRING);
				dstate_setaux(apc_vartab[i].name, APC_STRLEN);

				apc_vartab[i].flags |= APC_RW;
			}
			return;
		}
	}

	/*
	 * check the command list
	 * some APC commands map onto multiple nut ones (start and stop)
	 */
	found = 0;
	for (i = 0; apc_cmdtab[i].name != NULL; i++) {
		if (apc_cmdtab[i].cmd == cmd) {

			snprintf(info, sizeof(info), "%s%s",
				"UPS supports command [%s] - APC: ",
				fmt
			);
			upsdebugx(3, info, apc_cmdtab[i].name, cmd);

			dstate_addcmd(apc_cmdtab[i].name);

			apc_cmdtab[i].flags |= APC_PRESENT;
			found = 1;
		}
	}

	if (found)
		return;

	snprintf(info, sizeof(info), "%s%s%s",
		"protocol_verify - APC: ",
		fmt,
		" unrecognized"
	);
	upsdebugx(1, info, cmd);
}

/* some hardware is a special case - hotwire the list of cmdchars */
static int firmware_table_lookup(void)
{
	int	ret;
	unsigned int	i, j;
	char	buf[APC_LBUF];

	upsdebugx(1, "attempting firmware lookup using command 'V'");

	apc_flush(0);
	ret = apc_write(APC_FW_OLD);

	if (ret != 1) {
		upslog_with_errno(LOG_ERR, "firmware_table_lookup: apc_write failed");
		return 0;
	}

	ret = apc_read(buf, sizeof(buf), SER_TO);

        /*
	 * Some UPSes support both 'V' and 'b'. As 'b' doesn't always return
	 * firmware version, we attempt that only if 'V' doesn't work.
	 */
	if ((ret < 1) || (!strcmp(buf, "NA"))) {
		upsdebugx(1, "attempting firmware lookup using command 'b'");
		ret = apc_write(APC_FW_NEW);

		if (ret != 1) {
			upslog_with_errno(LOG_ERR, "firmware_table_lookup: apc_write failed");
			return 0;
		}

		ret = apc_read(buf, sizeof(buf), SER_TO);

		if (ret < 1) {
			upslog_with_errno(LOG_ERR, "firmware_table_lookup: apc_read failed");
			return 0;
		}
	}

	upsdebugx(2, "firmware: [%s]", buf);

	/* this will be reworked if we get a lot of these things */
	if (!strcmp(buf, "451.2.I"))
		/* quirk_capability_overflow */
		return 2;

	for (i = 0; apc_compattab[i].firmware != NULL; i++) {
		if (!strcmp(apc_compattab[i].firmware, buf)) {

			upsdebugx(2, "matched - cmdchars: %s",
					apc_compattab[i].cmdchars);

			if (strspn(apc_compattab[i].firmware, "05")) {
				dstate_setinfo("ups.model", "Matrix-UPS");
			} else {
				dstate_setinfo("ups.model", "Smart-UPS");
			}

			/* matched - run the cmdchars from the table */
			for (j = 0; j < strlen(apc_compattab[i].cmdchars); j++)
				protocol_verify(apc_compattab[i].cmdchars[j]);
			deprecate_vars();

			return 1;	/* matched */
		}
	}

	return 0;
}

static void getbaseinfo(void)
{
	unsigned int	i;
	int	ret, qco;
	char 	*cmds, temp[APC_LBUF];

	/*
	 *  try firmware lookup first; we could start with 'a', but older models
	 *  sometimes return other things than a command set
	 */
	qco = firmware_table_lookup();
	if (qco == 1)
		/* found compat */
		return;

	upsdebugx(2, "firmware not found in compatibility table - trying normal method");
	upsdebugx(1, "APC - attempting to find command set");
	/*
	 * Initially we ask the UPS what commands it takes If this fails we are
	 * going to need an alternate strategy - we can deal with that if it
	 * happens
	 */

	apc_flush(0);
	ret = apc_write(APC_CMDSET);

	if (ret != 1) {
		upslog_with_errno(LOG_ERR, "getbaseinfo: apc_write failed");
		return;
	}

	ret = apc_read(temp, sizeof(temp), SER_CS|SER_TO);

	if ((ret < 1) || (!strcmp(temp, "NA")) || !valid_cmd(APC_CMDSET, temp)) {
		/* We have an old dumb UPS - go to specific code for old stuff */
		upsdebugx(1, "APC - trying to handle unknown model");
		oldapcsetup();
		return;
	}

	upsdebugx(1, "APC - Parsing out supported cmds and vars");
	/*
	 * returned set is verified for validity above, so just extract
	 * what's interesting for us
	 */
	cmds = strrchr(temp, '.');
	for (i = 1; i < strlen(cmds); i++)
		protocol_verify(cmds[i]);
	deprecate_vars();

	/* if capabilities are supported, add them here */
	if (strchr(cmds, APC_CAPS)) {
		do_capabilities(qco);
		upsdebugx(1, "APC - UPS capabilities determined");
	}
}

/* check for calibration status and either start or stop */
static int do_cal(int start)
{
	char	temp[APC_LBUF];
	int	tval, ret;

	apc_flush(SER_AA);
	ret = apc_write(APC_STATUS);

	if (ret != 1) {
		upslog_with_errno(LOG_ERR, "do_cal: apc_write failed");
		return STAT_INSTCMD_HANDLED;		/* FUTURE: failure */
	}

	ret = apc_read(temp, sizeof(temp), SER_AA);

	/* if we can't check the current calibration status, bail out */
	if ((ret < 1) || (!strcmp(temp, "NA")))
		return STAT_INSTCMD_HANDLED;		/* FUTURE: failure */

	tval = strtol(temp, 0, 16);

	if (tval & APC_STAT_CAL) {	/* calibration currently happening */
		if (start == 1) {
			/* requested start while calibration still running */
			upslogx(LOG_INFO, "runtime calibration already in progress");
			return STAT_INSTCMD_HANDLED;	/* FUTURE: failure */
		}

		/* stop requested */

		upslogx(LOG_INFO, "stopping runtime calibration");

		ret = apc_write(APC_CMD_CALTOGGLE);

		if (ret != 1) {
			upslog_with_errno(LOG_ERR, "do_cal: apc_write failed");
			return STAT_INSTCMD_HANDLED;	/* FUTURE: failure */
		}

		ret = apc_read(temp, sizeof(temp), SER_AA);

		if ((ret < 1) || (!strcmp(temp, "NA")) || (!strcmp(temp, "NO"))) {
			upslogx(LOG_WARNING, "stop calibration failed: %s",
				temp);
			return STAT_INSTCMD_HANDLED;	/* FUTURE: failure */
		}

		return STAT_INSTCMD_HANDLED;	/* FUTURE: success */
	}

	/* calibration not happening */

	if (start == 0) {		/* stop requested */
		upslogx(LOG_INFO, "runtime calibration not occurring");
		return STAT_INSTCMD_HANDLED;		/* FUTURE: failure */
	}

	upslogx(LOG_INFO, "starting runtime calibration");

	ret = apc_write(APC_CMD_CALTOGGLE);

	if (ret != 1) {
		upslog_with_errno(LOG_ERR, "do_cal: apc_write failed");
		return STAT_INSTCMD_HANDLED;	/* FUTURE: failure */
	}

	ret = apc_read(temp, sizeof(temp), SER_AA);

	if ((ret < 1) || (!strcmp(temp, "NA")) || (!strcmp(temp, "NO"))) {
		upslogx(LOG_WARNING, "start calibration failed: %s", temp);
		return STAT_INSTCMD_HANDLED;	/* FUTURE: failure */
	}

	return STAT_INSTCMD_HANDLED;			/* FUTURE: success */
}

#if 0
/* get the UPS talking to us in smart mode */
static int smartmode(void)
{
	int	ret;
	char	temp[APC_LBUF];

	apc_flush(0);
	ret = apc_write(APC_GOSMART);
	if (ret != 1) {
		upslog_with_errno(LOG_ERR, "smartmode: apc_write failed");
		return 0;
	}
	ret = apc_read(temp, sizeof(temp), 0);

	if ((ret < 1) || (!strcmp(temp, "NA")) || (!strcmp(temp, "NO"))) {
		upslogx(LOG_CRIT, "enabling smartmode failed !");
		return 0;
	}

	return 1;
}
#endif

/*
 * get the UPS talking to us in smart mode
 * note: this is weird overkill, but possibly excused due to some obscure
 * hardware/firmware combinations; simpler version commmented out above, for
 * now let's keep minimally adjusted old one
 */
static int smartmode(int cnt)
{
	int ret, tries;
	char temp[APC_LBUF];

	for (tries = 0; tries < cnt; tries++) {

		apc_flush(0);
		ret = apc_write(APC_GOSMART);

		if (ret != 1) {
			upslog_with_errno(LOG_ERR, "smartmode: issuing 'Y' failed");
			return 0;
		}
		ret = apc_read(temp, sizeof(temp), SER_D1);
		if (ret > 0 && !strcmp(temp, "SM"))
			return 1;	/* success */
		if (ret < 0) {
			/* error, so we didn't timeout - wait a bit before retry */
			sleep(1);
		}

		apc_flush(0);
		ret = apc_write(27); /* ESC */

		if (ret != 1) {
			upslog_with_errno(LOG_ERR, "smartmode: issuing ESC failed");
			return 0;
		}

		/* eat the response (might be NA, might be something else) */
		apc_read(temp, sizeof(temp), SER_TO|SER_D1);
	}

	return 0;	/* failure */
}

/*
 * all shutdown commands should respond with 'OK' or '*'
 * apc_read() handles conversion to 'OK' so we care only about that one
 * ign allows for timeout without assuming an error
 */
static int sdok(int ign)
{
	int ret;
	char temp[APC_SBUF];

	/*
	 * older upses on failed commands might just timeout, we cut down
	 * timeout grace though
	 * furthermore, command 'Z' will not reply with anything
	 */
	ret = apc_read(temp, sizeof(temp), SER_HA|SER_D1|SER_TO);
	if (ret < 0) {
		upslog_with_errno(LOG_ERR, "sdok: apc_read failed");
		return STAT_INSTCMD_FAILED;
	}

	upsdebugx(4, "sdok: got \"%s\"", temp);

	if ((!ret && ign) || !strcmp(temp, "OK")) {
		upsdebugx(4, "sdok: last issued shutdown cmd succeeded");
		return STAT_INSTCMD_HANDLED;
	}

	upsdebugx(1, "sdok: last issued shutdown cmd failed");
	return STAT_INSTCMD_FAILED;
}

/* soft hibernate: S - working only when OB, otherwise ignored */
static int sdcmd_S(const void *foo)
{
	int ret;

	apc_flush(0);
	upsdebugx(1, "issuing soft hibernate");
	ret = apc_write(APC_CMD_SOFTDOWN);
	if (ret < 0) {
		upslog_with_errno(LOG_ERR, "sdcmd_S: issuing 'S' failed");
		return STAT_INSTCMD_FAILED;
	}

	return sdok(0);
}

/* soft hibernate, hack version for CS 350 & co. */
static int sdcmd_CS(const void *foo)
{
	int ret;
	char temp[APC_SBUF];

	upsdebugx(1, "using CS 350 'force OB' shutdown method");
	if (ups_status & APC_STAT_OL) {
		apc_flush(0);
		upsdebugx(1, "status OL - forcing OB temporarily");
		ret = apc_write(APC_CMD_SIMPWF);
		if (ret < 0) {
			upslog_with_errno(LOG_ERR, "sdcmd_CS: issuing 'U' failed");
			return STAT_INSTCMD_FAILED;
		}
		/* eat response */
		ret = apc_read(temp, sizeof(temp), SER_D1);
		if (ret < 0) {
			upslog_with_errno(LOG_ERR, "sdcmd_CS: 'U' returned nothing ?");
			return STAT_INSTCMD_FAILED;
		}
	}
	return sdcmd_S(0);
}

/*
 * hard hibernate: @nnn / @nn
 * note: works differently for older and new models, see manual page for
 * thorough explanation
 */
static int sdcmd_AT(const void *str)
{
	int ret, cnt, padto, i;
	const char *awd = str;
	char temp[APC_SBUF], *ptr;

	if (!awd)
		awd = "000";

	cnt = strlen(awd);
	padto = cnt == 2 ? 2 : 3;

	temp[0] = APC_CMD_GRACEDOWN;
	ptr = temp + 1;
	for (i = cnt; i < padto ; i++) {
		*ptr++ = '0';
	}
	strcpy(ptr, awd);

	upsdebugx(1, "issuing '@' with %d minutes of additional wakeup delay", (int)strtol(awd, NULL, 10)*6);

	apc_flush(0);
	ret = apc_write_long(temp);
	if (ret < 0) {
		upslog_with_errno(LOG_ERR, "sdcmd_AT: issuing '@' with %d digits failed", padto);
		return STAT_INSTCMD_FAILED;
	}

	ret = sdok(0);
	if (ret == STAT_INSTCMD_HANDLED || padto == 3)
		return ret;

	upslog_with_errno(LOG_ERR, "sdcmd_AT: command '@' with 2 digits doesn't work - try 3 digits");
	/*
	 * "tricky" part - we tried @nn variation and it (unsurprisingly)
	 * failed; we have to abort the sequence with something bogus to have
	 * the clean state; newer upses will respond with 'NO', older will be
	 * silent (YMMV);
	 */
	apc_write(APC_CMD_GRACEDOWN);
	/* eat response, allow it to timeout */
	apc_read(temp, sizeof(temp), SER_D1|SER_TO);

	return STAT_INSTCMD_FAILED;
}

/* shutdown: K - delayed poweroff */
static int sdcmd_K(const void *foo)
{
	int ret;

	upsdebugx(1, "issuing 'K'");

	apc_flush(0);
	ret = apc_write_rep(APC_CMD_SHUTDOWN);
	if (ret < 0) {
		upslog_with_errno(LOG_ERR, "sdcmd_K: issuing 'K' failed");
		return STAT_INSTCMD_FAILED;
	}

	return sdok(0);
}

/* shutdown: Z - immediate poweroff */
static int sdcmd_Z(const void *foo)
{
	int ret;

	upsdebugx(1, "issuing 'Z'");

	apc_flush(0);
	ret = apc_write_rep(APC_CMD_OFF);
	if (ret < 0) {
		upslog_with_errno(LOG_ERR, "sdcmd_Z: issuing 'Z' failed");
		return STAT_INSTCMD_FAILED;
	}

	/* note: ups will not reply anything after this command */
	return sdok(1);
}

static void upsdrv_shutdown_simple(void)
{
	unsigned int sdtype = 0;
	const char *val;

	if ((val = getval("sdtype")))
		sdtype = strtol(val, NULL, 10);

	switch (sdtype) {

	case 5:		/* hard hibernate */
		sdcmd_AT(getval("awd"));
		break;
	case 4:		/* special hack for CS 350 and similar models */
		sdcmd_CS(0);
		break;

	case 3:		/* delayed poweroff */
		sdcmd_K(0);
		break;

	case 2:		/* instant poweroff */
		sdcmd_Z(0);
		break;
	case 1:
		/*
		 * Send a combined set of shutdown commands which can work
		 * better if the UPS gets power during shutdown process
		 * Specifically it sends both the soft shutdown 'S' and the
		 * hard hibernate '@nnn' commands
		 */
		upsdebugx(1, "UPS - currently %s - sending soft/hard hibernate commands",
			(ups_status & APC_STAT_OL) ? "on-line" : "on battery");

		/* S works only when OB */
		if ((ups_status & APC_STAT_OB) && sdcmd_S(0) == STAT_INSTCMD_HANDLED)
			break;
		sdcmd_AT(getval("awd"));
		break;

	default:
		/*
		 * Send @nnn or S, depending on OB / OL status
		 */
		if (ups_status & APC_STAT_OL)		/* on line */
			sdcmd_AT(getval("awd"));
		else
			sdcmd_S(0);
	}
}

static void upsdrv_shutdown_advanced(void)
{
	const void *arg;
	const char *val;
	size_t i, len;

	val = getval("advorder");
	len = strlen(val);

	/*
	 * try each method in the list with a little bit of handling in certain
	 * cases
	 */
	for (i = 0; i < len; i++) {
		switch (val[i] - '0') {
			case SDIDX_AT:
				arg = getval("awd");
				break;
			default:
				arg = NULL;
		}

		if (sdlist[val[i] - '0'](arg) == STAT_INSTCMD_HANDLED)
			break;	/* finish if command succeeded */
	}
}

/* power down the attached load immediately */
void upsdrv_shutdown(void)
{
	char	temp[APC_LBUF];
	int	ret;

	if (!smartmode(1))
		upsdebugx(1, "SM detection failed. Trying a shutdown command anyway");

	/* check the line status */

	ret = apc_write(APC_STATUS);

	if (ret == 1) {
		ret = apc_read(temp, sizeof(temp), SER_D1);

		if (ret < 1) {
			upsdebugx(1, "status read failed ! assuming on battery state");
			ups_status = APC_STAT_LB | APC_STAT_OB;
		} else {
			ups_status = strtol(temp, 0, 16);
		}

	} else {
		upsdebugx(1, "status request failed; assuming on battery state");
		ups_status = APC_STAT_LB | APC_STAT_OB;
	}

	if (testvar("advorder") && strcasecmp(getval("advorder"), "no"))
		upsdrv_shutdown_advanced();
	else
		upsdrv_shutdown_simple();
}

static void update_info_normal(void)
{
	int	i;

	upsdebugx(3, "update_info_normal: starting");

	for (i = 0; apc_vartab[i].name != NULL; i++) {
		if ((apc_vartab[i].flags & APC_POLL) == 0)
			continue;

		if (!poll_data(&apc_vartab[i])) {
			upsdebugx(3, "update_info_normal: poll_data (%s) failed - "
				"aborting scan", apc_vartab[i].name);
			return;
		}
	}

	upsdebugx(3, "update_info_normal: done");
}

static void update_info_all(void)
{
	int	i;

	upsdebugx(3, "update_info_all: starting");

	for (i = 0; apc_vartab[i].name != NULL; i++) {
		if (!poll_data(&apc_vartab[i])) {
			upsdebugx(3, "update_info_all: poll_data (%s) failed - "
				"aborting scan", apc_vartab[i].name);
			return;
		}
	}

	upsdebugx(3, "update_info_all: done");
}

static int setvar_enum(apc_vartab_t *vt, const char *val)
{
	int	i, ret;
	char	orig[APC_LBUF], temp[APC_LBUF];
	const char	*ptr;

	apc_flush(SER_AA);
	ret = apc_write(vt->cmd);

	if (ret != 1) {
		upslog_with_errno(LOG_ERR, "setvar_enum: apc_write failed");
		return STAT_SET_FAILED;
	}

	ret = apc_read(orig, sizeof(orig), SER_AA);

	if ((ret < 1) || (!strcmp(orig, "NA")))
		return STAT_SET_FAILED;

	ptr = convert_data(vt, orig);

	/* suppress redundant changes - easier on the eeprom */
	if (!strcmp(ptr, val)) {
		upslogx(LOG_INFO, "ignoring enum SET %s='%s' (unchanged value)",
			vt->name, val);

		return STAT_SET_HANDLED;	/* FUTURE: no change */
	}

	for (i = 0; i < 6; i++) {
		ret = apc_write(APC_NEXTVAL);

		if (ret != 1) {
			upslog_with_errno(LOG_ERR, "setvar_enum: apc_write failed");
			return STAT_SET_FAILED;
		}

		/* this should return either OK (if rotated) or NO (if not) */
		ret = apc_read(temp, sizeof(temp), SER_AA);

		if ((ret < 1) || (!strcmp(temp, "NA")))
			return STAT_SET_FAILED;

		/* sanity checks */
		if (!strcmp(temp, "NO"))
			return STAT_SET_FAILED;
		if (strcmp(temp, "OK"))
			return STAT_SET_FAILED;

		/* see what it rotated onto */
		ret = apc_write(vt->cmd);

		if (ret != 1) {
			upslog_with_errno(LOG_ERR, "setvar_enum: apc_write failed");
			return STAT_SET_FAILED;
		}

		ret = apc_read(temp, sizeof(temp), SER_AA);

		if ((ret < 1) || (!strcmp(temp, "NA")))
			return STAT_SET_FAILED;

		ptr = convert_data(vt, temp);

		upsdebugx(1, "rotate value: got [%s], want [%s]",
			ptr, val);

		if (!strcmp(ptr, val)) {	/* got it */
			upslogx(LOG_INFO, "SET %s='%s'", vt->name, val);

			/* refresh data from the hardware */
			poll_data(vt);
			/* query_ups(vt->name, 0); */

			return STAT_SET_HANDLED;	/* FUTURE: success */
		}

		/* check for wraparound */
		if (!strcmp(ptr, orig)) {
			upslogx(LOG_ERR, "setvar: variable %s wrapped",
				vt->name);

			return STAT_SET_FAILED;
		}
	}

	upslogx(LOG_ERR, "setvar: gave up after 6 tries for %s",
		vt->name);

	/* refresh data from the hardware */
	poll_data(vt);
	/* query_ups(vt->name, 0); */

	return STAT_SET_HANDLED;
}

static int setvar_string(apc_vartab_t *vt, const char *val)
{
	unsigned int	i;
	int	ret;
	char	temp[APC_LBUF], *ptr;

	/* sanitize length */
	if (strlen(val) > APC_STRLEN) {
		upslogx(LOG_ERR, "setvar_string: value (%s) too long", val);
		return STAT_SET_FAILED;
	}

	apc_flush(SER_AA);
	ret = apc_write(vt->cmd);

	if (ret != 1) {
		upslog_with_errno(LOG_ERR, "setvar_string: apc_write failed");
		return STAT_SET_FAILED;
	}

	ret = apc_read(temp, sizeof(temp), SER_AA);

	if ((ret < 1) || (!strcmp(temp, "NA")))
		return STAT_SET_FAILED;

	/* suppress redundant changes - easier on the eeprom */
	if (!strcmp(temp, val)) {
		upslogx(LOG_INFO, "ignoring string SET %s='%s' (unchanged value)",
			vt->name, val);

		return STAT_SET_HANDLED;	/* FUTURE: no change */
	}

	/* length sanitized above */
	temp[0] = APC_NEXTVAL;
	strcpy(temp + 1, val);
	ptr = temp + strlen(temp);
	for (i = strlen(val); i < APC_STRLEN; i++)
		*ptr++ = '\015'; /* pad with CRs */
	*ptr = 0;

	ret = apc_write_long(ptr);

	if ((size_t)ret != strlen(ptr)) {
		upslog_with_errno(LOG_ERR, "setvar_string: apc_write_long failed");
		return STAT_SET_FAILED;
	}

	ret = apc_read(temp, sizeof(temp), SER_AA);

	if (ret < 1) {
		upslogx(LOG_ERR, "setvar_string: short final read");
		return STAT_SET_FAILED;
	}

	if (!strcmp(temp, "NO")) {
		upslogx(LOG_ERR, "setvar_string: got NO at final read");
		return STAT_SET_FAILED;
	}

	/* refresh data from the hardware */
	poll_data(vt);
	/* query_ups(vt->name, 0); */

	upslogx(LOG_INFO, "SET %s='%s'", vt->name, val);

	return STAT_SET_HANDLED;	/* FUTURE: success */
}

static int setvar(const char *varname, const char *val)
{
	apc_vartab_t	*vt;

	vt = vartab_lookup_name(varname);

	if (!vt)
		return STAT_SET_UNKNOWN;

	if ((vt->flags & APC_RW) == 0) {
		upslogx(LOG_WARNING, "setvar: [%s] is not writable", varname);
		return STAT_SET_UNKNOWN;
	}

	if (vt->flags & APC_ENUM)
		return setvar_enum(vt, val);

	if (vt->flags & APC_STRING)
		return setvar_string(vt, val);

	upslogx(LOG_WARNING, "setvar: Unknown type for [%s]", varname);
	return STAT_SET_UNKNOWN;
}

/* load on */
static int do_loadon(void)
{
	int ret;
	apc_flush(0);
	upsdebugx(1, "issuing load-on command");

	ret = apc_write_rep(APC_CMD_ON);
	if (ret < 0) {
		upslog_with_errno(LOG_ERR, "do_loadon: apc_write_rep failed");
		return STAT_INSTCMD_FAILED;
	}

	/*
	 * ups will not reply anything after this command, but might
	 * generate brief OVER condition (which will be corrected on
	 * the next status update)
	 */

	upsdebugx(1, "load-on command (apc:^N) executed");
	return STAT_INSTCMD_HANDLED;
}

/* actually send the instcmd's char to the ups */
static int do_cmd(const apc_cmdtab_t *ct)
{
	int ret;
	char temp[APC_LBUF];
	const char *strerr;

	apc_flush(SER_AA);

	if (ct->flags & APC_REPEAT) {
		ret = apc_write_rep(ct->cmd);
		strerr = "apc_write_rep";
	} else {
		ret = apc_write(ct->cmd);
		strerr = "apc_write";
	}

	if (ret < 1) {
		upslog_with_errno(LOG_ERR, "do_cmd: %s failed", strerr);
		return STAT_INSTCMD_FAILED;
	}

	ret = apc_read(temp, sizeof(temp), SER_AA);

	if (ret < 1)
		return STAT_INSTCMD_FAILED;

	if (strcmp(temp, "OK")) {
		upslogx(LOG_WARNING, "got [%s] after command [%s]",
			temp, ct->name);

		return STAT_INSTCMD_FAILED;
	}

	upslogx(LOG_INFO, "command: %s", ct->name);
	return STAT_INSTCMD_HANDLED;
}

/* some commands must be repeated in a window to execute */
static int instcmd_chktime(apc_cmdtab_t *ct, const char *ext)
{
	double	elapsed;
	time_t	now;
	static	time_t	last = 0;

	time(&now);

	elapsed = difftime(now, last);
	last = now;

	/* you have to hit this in a small window or it fails */
	if ((elapsed < MINCMDTIME) || (elapsed > MAXCMDTIME)) {
		upsdebugx(1, "instcmd_chktime: outside window for [%s %s] (%2.0f)",
				ct->name, ext ? ext : "\b", elapsed);
		return 0;
	}

	return 1;
}

static int instcmd(const char *cmd, const char *ext)
{
	int i;
	apc_cmdtab_t *ct = NULL;

	for (i = 0; apc_cmdtab[i].name != NULL; i++) {
		/* main command must match */
		if (strcasecmp(apc_cmdtab[i].name, cmd))
			continue;
		/* extra was provided - check it */
		if (ext && *ext) {
			if (!apc_cmdtab[i].ext)
				continue;
			if (strlen(apc_cmdtab[i].ext) > 2) {
				if (rexhlp(apc_cmdtab[i].ext, ext))
					continue;
			} else {
				if (strcasecmp(apc_cmdtab[i].ext, ext))
					continue;
			}
		} else if (apc_cmdtab[i].ext)
			continue;
		ct = &apc_cmdtab[i];
		break;
	}

	if (!ct) {
		upslogx(LOG_WARNING, "instcmd: unknown command [%s %s]", cmd,
				ext ? ext : "\b");
		return STAT_INSTCMD_INVALID;
	}

	if (!(ct->flags & APC_PRESENT)) {
		upslogx(LOG_WARNING, "instcmd: command [%s %s] recognized, but"
		       " not supported by your UPS model", cmd,
				ext ? ext : "\b");
		return STAT_INSTCMD_INVALID;
	}

	/* first verify if the command is "nasty" */
	if ((ct->flags & APC_NASTY) && !instcmd_chktime(ct, ext))
		return STAT_INSTCMD_HANDLED;	/* future: again */

	/* we're good to go, handle special stuff first, then generic cmd */

	if (!strcasecmp(cmd, "calibrate.start"))
		return do_cal(1);

	if (!strcasecmp(cmd, "calibrate.stop"))
		return do_cal(0);

	if (!strcasecmp(cmd, "load.on"))
		return do_loadon();

	if (!strcasecmp(cmd, "load.off"))
		return sdcmd_Z(0);

	if (!strcasecmp(cmd, "shutdown.stayoff"))
		return sdcmd_K(0);

	if (!strcasecmp(cmd, "shutdown.return")) {
		if (!ext || !*ext)
			return sdcmd_S(0);

		/* ext length is guaranteed by regex match above */
		if (!strncasecmp(ext, "at", 2))
			return sdcmd_AT(ext + 3);

		if (!strncasecmp(ext, "cs", 2))
			return sdcmd_CS(0);
	}

	/* nothing special here */
	return do_cmd(ct);
}

/* install pointers to functions for msg handlers called from msgparse */
static void setuphandlers(void)
{
	upsh.setvar = setvar;
	upsh.instcmd = instcmd;
}

/* functions that interface with main.c */

void upsdrv_makevartable(void)
{
	addvar(VAR_VALUE, "cable", "specify alternate cable (940-0095B)");
	addvar(VAR_VALUE, "awd", "hard hibernate's additional wakeup delay");
	addvar(VAR_VALUE, "sdtype", "specify simple shutdown method (0 - " APC_SDMAX ")");
	addvar(VAR_VALUE, "advorder", "enable advanced shutdown control");
}

void upsdrv_initups(void)
{
	size_t i, len;
	char *val;

	upsfd = extrafd = ser_open(device_path);
	apc_ser_set();

	/* sanitize awd (additional waekup delay of '@' command) */
	if ((val = getval("awd")) && rexhlp(APC_AWDFMT, val)) {
			fatalx(EXIT_FAILURE, "invalid value (%s) for option 'awd'", val);
	}

	/* sanitize sdtype */
	if ((val = getval("sdtype")) && rexhlp(APC_SDFMT, val)) {
			fatalx(EXIT_FAILURE, "invalid value (%s) for option 'sdtype'", val);
	}

	/* sanitize advorder */
	if ((val = getval("advorder")) && strcasecmp(val, "no")) {
		len = strlen(val);

		if (!len || len > SDCNT)
			fatalx(EXIT_FAILURE, "invalid length of 'advorder' option (%s)", val);
		for (i = 0; i < len; i++) {
			if (val[i] < '0' || val[i] >= '0' + SDCNT) {
				fatalx(EXIT_FAILURE, "invalid characters in 'advorder' option (%s)", val);
			}
		}
	}
}

void upsdrv_cleanup(void)
{
	char temp[APC_LBUF];

	apc_flush(0);
	/* try to bring the UPS out of smart mode */
	apc_write(APC_GODUMB);
	apc_read(temp, sizeof(temp), SER_TO);
	ser_close(upsfd, device_path);
}

void upsdrv_help(void)
{
}

void upsdrv_initinfo(void)
{
	const char *pmod, *pser;

	if (!smartmode(5)) {
		fatalx(EXIT_FAILURE,
			"unable to detect an APC Smart protocol UPS on port %s\n"
			"check the cabling, port name or model name and try again", device_path
			);
	}

	/* manufacturer ID - hardcoded in this particular module */
	dstate_setinfo("ups.mfr", "APC");

	getbaseinfo();

	if (!(pmod = dstate_getinfo("ups.model")))
		pmod = "\"unknown model\"";
	if (!(pser = dstate_getinfo("ups.serial")))
		pser = "unknown serial";

	upsdebugx(1, "detected %s [%s] on %s", pmod, pser, device_path);

	setuphandlers();
}

void upsdrv_updateinfo(void)
{
	static int last_worked = 0;
	static time_t last_full = 0;
	time_t now;

	/* try to wake up a dead ups once in awhile */
	if (dstate_is_stale()) {
		if (!last_worked)
			upsdebugx(LOG_DEBUG, "upsdrv_updateinfo: comm lost");

		/* reset this so a full update runs when the UPS returns */
		last_full = 0;

		if (++last_worked < 10)
			return;

		/* become aggressive after a few tries */
		upsdebugx(LOG_DEBUG, "upsdrv_updateinfo: nudging ups with 'Y', iteration #%d ...", last_worked);
		if (!smartmode(1))
			return;

		last_worked = 0;
	}

	if (!update_status())
		return;

	time(&now);

	/* refresh all variables hourly */
	/* does not catch measure-ups II insertion/removal */
	if (difftime(now, last_full) > 3600) {
		last_full = now;
		update_info_all();
		return;
	}

	update_info_normal();
}