diff --git a/Makefile.am b/Makefile.am index dd8f1f29ea..0fd826ba0a 100644 --- a/Makefile.am +++ b/Makefile.am @@ -157,7 +157,12 @@ EXTRA_DIST = LICENSE-GPL2 LICENSE-GPL3 LICENSE-DCO MAINTAINERS # Since the renaming of documentation to `*.adoc` extension to help IDE # and GitHub UIs to render the source files in a pretty fashion, we need # to list them: -EXTRA_DIST += INSTALL.nut.adoc UPGRADING.adoc TODO.adoc NEWS.adoc README.adoc ci_build.adoc +EXTRA_DIST += INSTALL.nut.adoc UPGRADING.adoc TODO.adoc NEWS.adoc README.adoc + +# The document is now part of qa-guide; the script might be a bit git-oriented, +# but can be useful in builds from tarball, probably. Anyhow, having the doc +# without the tool which it documents is odd. +EXTRA_DIST += ci_build.sh ci_build.adoc # Tarballs created by `make dist` include the `configure.ac` and `m4/*` sources # but lack NUT magic logic to recreate the `configure` script if someone would diff --git a/NEWS.adoc b/NEWS.adoc index b439d0746b..4c9d4883d7 100644 --- a/NEWS.adoc +++ b/NEWS.adoc @@ -88,6 +88,12 @@ https://github.com/networkupstools/nut/milestone/9 does not care where the token itself was raised for its notifications. Driver-code related test-cases were updated to reflect these changes. [issue #2928, PRs #2931 and #2934] + * Introduced some macros in `drivers/upshandler.h` for common syslog level + definitions and message wording for beginning and failing `instcmd()` or + `setvar()` operations consistently in different drivers. As a related + change, operations that intend to turn off or restart the load, or can + do that by side effect (e.g. calibration if batteries are old or dead), + would explicitly `upslogx(LOG_CRIT,...)` by default before commencing. - `dummy-ups` driver updates: * A new instruction `ALARM` was added for the `Dummy Mode` operation diff --git a/ci_build.sh b/ci_build.sh index 79d7a473f0..cabd5dbdf6 100755 --- a/ci_build.sh +++ b/ci_build.sh @@ -2323,7 +2323,10 @@ default|default-alldrv|default-alldrv:no-distcheck|default-all-errors|default-sp # Tack a remaining yes/no in the end to whatever scenario is there; # NOT a full matrix - if [ "${BUILDSTODO_UNMAPPED}" -gt 1 ] ; then + if [ "${BUILDSTODO_UNMAPPED}" -gt 1 ] && \ + ( [ "$CI_FAILFAST" != "true" ] \ + || [ "$CI_FAILFAST" = "true" -a "$RES_ALLERRORS" = 0 ] \ + ) ; then for NUT_UNMAPPED_VARIANT in $NUT_UNMAPPED_VARIANTS ; do case "${NUT_UNMAPPED_VARIANT}" in no) ;; # we already did the default ("no") implicitly diff --git a/clients/upsclient.c b/clients/upsclient.c index d0c9f28085..30062c81ed 100644 --- a/clients/upsclient.c +++ b/clients/upsclient.c @@ -887,11 +887,11 @@ static int upscli_sslinit(UPSCONN_t *ups, int verifycert) upsdebugx(3, "SSL connected (%s)", SSL_get_version(ups->ssl)); break; case 0: - upslog_with_errno(1, "SSL_connect do not accept handshake."); + upsdebug_with_errno(1, "SSL_connect do not accept handshake."); ssl_error(ups->ssl, res); return -1; default: - upslog_with_errno(1, "Unknown return value from SSL_connect %d", res); + upsdebug_with_errno(1, "Unknown return value from SSL_connect %d", res); ssl_error(ups->ssl, res); return -1; } diff --git a/drivers/adelsystem_cbi.c b/drivers/adelsystem_cbi.c index 9e30f001b7..11f7a78c7b 100644 --- a/drivers/adelsystem_cbi.c +++ b/drivers/adelsystem_cbi.c @@ -34,7 +34,7 @@ #endif #define DRIVER_NAME "NUT ADELSYSTEM DC-UPS CB/CBI driver (libmodbus link type: " NUT_MODBUS_LINKTYPE_STR ")" -#define DRIVER_VERSION "0.04" +#define DRIVER_VERSION "0.05" /* variables */ static modbus_t *mbctx = NULL; /* modbus memory context */ @@ -81,7 +81,7 @@ int register_read(modbus_t *mb, int addr, regtype_t type, void *data); int register_write(modbus_t *mb, int addr, regtype_t type, void *data); /* instant command triggered by upsd */ -int upscmd(const char *cmd, const char *arg); +int upscmd(const char *cmdname, const char *extra); /* count the time elapsed since start */ long time_elapsed(struct timeval *start); @@ -811,36 +811,43 @@ long time_elapsed(struct timeval *start) } /* instant command triggered by upsd */ -int upscmd(const char *cmd, const char *arg) +int upscmd(const char *cmdname, const char *extra) { int rval; int data; - if (!strcasecmp(cmd, "load.off")) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + + if (!strcasecmp(cmdname, "load.off")) { data = 1; + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); rval = register_write(mbctx, regs[FSD].xaddr, regs[FSD].type, &data); if (rval == -1) { - upslogx(2, + upsdebugx(2, "ERROR:(%s) modbus_write_register: addr:0x%08x, regtype: %u, path:%s", modbus_strerror(errno), (unsigned int)(regs[FSD].xaddr), regs[FSD].type, device_path ); - upslogx(LOG_NOTICE, "load.off: failed (communication error) [%s] [%s]", cmd, arg); + upslogx(LOG_INSTCMD_FAILED, "load.off: failed (communication error) [%s] [%s]", NUT_STRARG(cmdname), NUT_STRARG(extra)); rval = STAT_INSTCMD_FAILED; } else { upsdebugx(2, "load.off: addr: 0x%x, data: %d", (unsigned int)(regs[FSD].xaddr), data); rval = STAT_INSTCMD_HANDLED; } - } else if (!strcasecmp(cmd, "shutdown.stayoff")) { + } else if (!strcasecmp(cmdname, "shutdown.stayoff")) { /* FIXME: Which one is this actually - * "shutdown.stayoff" or "shutdown.return"? */ int cnt = FSD_REPEAT_CNT; /* shutdown repeat counter */ struct timeval start; long etime; + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + /* retry sending shutdown command on error */ while ((rval = upscmd("load.off", NULL)) != STAT_INSTCMD_HANDLED && cnt > 0) { rval = gettimeofday(&start, NULL); @@ -856,12 +863,12 @@ int upscmd(const char *cmd, const char *arg) switch (rval) { case STAT_INSTCMD_FAILED: case STAT_INSTCMD_INVALID: - upslog_with_errno(LOG_ERR, "instcmd: %s failed", cmd); + upslog_with_errno(LOG_INSTCMD_FAILED, "instcmd: %s failed", cmdname); if (handling_upsdrv_shutdown > 0) set_exit_flag(EF_EXIT_FAILURE); break; case STAT_INSTCMD_UNKNOWN: - upslog_with_errno(LOG_ERR, "instcmd: %s not supported", cmd); + upslog_with_errno(LOG_INSTCMD_UNKNOWN, "instcmd: %s not supported", cmdname); if (handling_upsdrv_shutdown > 0) set_exit_flag(EF_EXIT_FAILURE); break; @@ -872,7 +879,7 @@ int upscmd(const char *cmd, const char *arg) break; } } else { - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmd, arg); + upslog_INSTCMD_UNKNOWN(cmdname, extra); rval = STAT_INSTCMD_UNKNOWN; } return rval; diff --git a/drivers/al175.c b/drivers/al175.c index 6f2117f3a2..ba462d12ff 100644 --- a/drivers/al175.c +++ b/drivers/al175.c @@ -52,7 +52,7 @@ typedef uint8_t byte_t; #define DRIVER_NAME "Eltek AL175/COMLI driver" -#define DRIVER_VERSION "0.16" +#define DRIVER_VERSION "0.17" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -1295,7 +1295,9 @@ static int instcmd(const char *cmdname, const char *extra) { int err; - upsdebugx(1, "INSTCMD: %s", cmdname); + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); io_new_transaction(/*timeout=*/5); @@ -1305,16 +1307,18 @@ static int instcmd(const char *cmdname, const char *extra) */ if (!strcasecmp(cmdname, "test.battery.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); err = START_BATTERY_TEST(24, 1); return (!err ? STAT_INSTCMD_HANDLED : STAT_INSTCMD_FAILED); } if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); err = STOP_BATTERY_TEST(); return (!err ? STAT_INSTCMD_HANDLED : STAT_INSTCMD_FAILED); } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/apc_modbus.c b/drivers/apc_modbus.c index 30fae48114..1d28292779 100644 --- a/drivers/apc_modbus.c +++ b/drivers/apc_modbus.c @@ -44,7 +44,7 @@ #endif #define DRIVER_NAME "NUT APC Modbus driver " DRIVER_NAME_NUT_MODBUS_HAS_USB_WITH_STR " USB support (libmodbus link type: " NUT_MODBUS_LINKTYPE_STR ")" -#define DRIVER_VERSION "0.13" +#define DRIVER_VERSION "0.14" #if defined NUT_MODBUS_HAS_USB @@ -1224,6 +1224,8 @@ static int _apc_modbus_setvar(const char *nut_varname, const char *str_value) apc_modbus_register_t *apc_map = NULL, *apc_value = NULL; uint16_t reg_value[16]; + upsdebug_SET_STARTING(nut_varname, str_value); + for (mi = 0; mi < SIZEOF_ARRAY(apc_modbus_register_maps) && apc_value == NULL; mi++) { apc_map = apc_modbus_register_maps[mi]; @@ -1236,12 +1238,12 @@ static int _apc_modbus_setvar(const char *nut_varname, const char *str_value) } if (!apc_map || !apc_value) { - upslogx(LOG_WARNING, "%s: [%s] is unknown", __func__, nut_varname); + upslog_SET_UNKNOWN(nut_varname, str_value); return STAT_SET_UNKNOWN; } if (!(apc_value->value_flags & APC_VF_RW)) { - upslogx(LOG_WARNING, "%s: [%s] is not writable", __func__, nut_varname); + upslogx(LOG_SET_INVALID, "%s: [%s] is not writable", __func__, nut_varname); return STAT_SET_INVALID; } @@ -1249,7 +1251,7 @@ static int _apc_modbus_setvar(const char *nut_varname, const char *str_value) if (apc_value->value_converter && apc_value->value_converter->nut_to_apc) { if (!apc_value->value_converter->nut_to_apc(str_value, reg_value, apc_value->modbus_len)) { - upslogx(LOG_WARNING, "%s: [%s] failed to convert value", __func__, nut_varname); + upslogx(LOG_SET_CONVERSION_FAILED, "%s: [%s] failed to convert value", __func__, nut_varname); return STAT_SET_CONVERSION_FAILED; } } else { @@ -1292,7 +1294,7 @@ static int _apc_modbus_setvar(const char *nut_varname, const char *str_value) } if (!r) { - upslogx(LOG_WARNING, "%s: [%s] failed to convert value", __func__, nut_varname); + upslogx(LOG_SET_CONVERSION_FAILED, "%s: [%s] failed to convert value", __func__, nut_varname); return STAT_SET_CONVERSION_FAILED; } } @@ -1393,7 +1395,9 @@ static int _apc_modbus_instcmd(const char *nut_cmdname, const char *extra) apc_modbus_command_t *apc_command = NULL; uint16_t value[4]; /* Max 64-bit */ + /* May be used in logging below, but not as a command argument */ NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(nut_cmdname, extra); for (i = 0; apc_modbus_command_map[i].nut_command_name; i++) { if (!strcasecmp(nut_cmdname, apc_modbus_command_map[i].nut_command_name)) { @@ -1403,21 +1407,22 @@ static int _apc_modbus_instcmd(const char *nut_cmdname, const char *extra) } if (!apc_command) { - upslogx(LOG_WARNING, "%s: [%s] is unknown", __func__, nut_cmdname); + upslog_INSTCMD_UNKNOWN(nut_cmdname, extra); return STAT_INSTCMD_UNKNOWN; } assert(apc_command->modbus_len <= SIZEOF_ARRAY(value)); if (!_apc_modbus_from_uint64(apc_command->value, value, apc_command->modbus_len)) { - upslogx(LOG_WARNING, "%s: [%s] failed to convert value", __func__, nut_cmdname); + upslogx(LOG_INSTCMD_CONVERSION_FAILED, "%s: [%s] failed to convert value", __func__, nut_cmdname); return STAT_INSTCMD_CONVERSION_FAILED; } addr = apc_command->modbus_addr; nb = apc_command->modbus_len; + upslog_INSTCMD_POWERSTATE_CHECKED(nut_cmdname, extra); if (modbus_write_registers(modbus_ctx, addr, nb, value) < 0) { - upslogx(LOG_ERR, "%s: Write of %d:%d failed: %s (%s)", __func__, addr, addr + nb, modbus_strerror(errno), device_path); + upslogx(LOG_INSTCMD_FAILED, "%s: Write of %d:%d failed: %s (%s)", __func__, addr, addr + nb, modbus_strerror(errno), device_path); _apc_modbus_handle_error(modbus_ctx); return STAT_INSTCMD_FAILED; } diff --git a/drivers/apcsmart-old.c b/drivers/apcsmart-old.c index 1e28b09b2e..d5ea265fa9 100644 --- a/drivers/apcsmart-old.c +++ b/drivers/apcsmart-old.c @@ -25,7 +25,7 @@ #include "nut_stdint.h" #define DRIVER_NAME "APC Smart protocol driver (old)" -#define DRIVER_VERSION "2.34" +#define DRIVER_VERSION "2.35" static upsdrv_info_t table_info = { "APC command table", @@ -1321,13 +1321,15 @@ static int setvar(const char *varname, const char *val) { apc_vartab_t *vt; + upsdebug_SET_STARTING(varname, val); + 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); + upslogx(LOG_SET_INVALID, "setvar: [%s] is not writable", varname); return STAT_SET_INVALID; } @@ -1337,7 +1339,7 @@ static int setvar(const char *varname, const char *val) if (vt->flags & APC_STRING) return setvar_string(vt, val); - upslogx(LOG_WARNING, "setvar: Unknown type for [%s]", varname); + upslogx(LOG_SET_UNKNOWN, "setvar: Unknown type for [%s]", varname); return STAT_SET_UNKNOWN; } @@ -1351,7 +1353,7 @@ static int do_cmd(apc_cmdtab_t *ct) ret = ser_send_char(upsfd, ct->cmd); if (ret != 1) { - upslog_with_errno(LOG_ERR, "do_cmd: ser_send_char failed"); + upslog_with_errno(LOG_INSTCMD_FAILED, "do_cmd: ser_send_char failed"); return STAT_INSTCMD_HANDLED; /* FUTURE: failed */ } @@ -1362,7 +1364,7 @@ static int do_cmd(apc_cmdtab_t *ct) ret = ser_send_char(upsfd, ct->cmd); if (ret != 1) { - upslog_with_errno(LOG_ERR, "do_cmd: ser_send_char failed"); + upslog_with_errno(LOG_INSTCMD_FAILED, "do_cmd: ser_send_char failed"); return STAT_INSTCMD_HANDLED; /* FUTURE: failed */ } } @@ -1373,7 +1375,7 @@ static int do_cmd(apc_cmdtab_t *ct) return STAT_INSTCMD_HANDLED; /* FUTURE: failed */ if (strcmp(buf, "OK") != 0) { - upslogx(LOG_WARNING, "Got [%s] after command [%s]", + upslogx(LOG_INSTCMD_FAILED, "Got [%s] after command [%s]", buf, ct->name); return STAT_INSTCMD_HANDLED; /* FUTURE: failed */ @@ -1410,6 +1412,10 @@ static int instcmd(const char *cmdname, const char *extra) int i; apc_cmdtab_t *ct; + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + ct = NULL; for (i = 0; apc_cmdtab[i].name != NULL; i++) @@ -1417,22 +1423,28 @@ static int instcmd(const char *cmdname, const char *extra) ct = &apc_cmdtab[i]; if (!ct) { - upslogx(LOG_WARNING, "instcmd: unknown command [%s] [%s]", - cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } if ((ct->flags & APC_PRESENT) == 0) { - upslogx(LOG_WARNING, "instcmd: command [%s] [%s] is not supported", - cmdname, extra); + upslogx(LOG_INSTCMD_UNKNOWN, + "%s: command [%s] [%s] is not supported on this device", + __func__, NUT_STRARG(cmdname), NUT_STRARG(extra)); return STAT_INSTCMD_UNKNOWN; } - if (!strcasecmp(cmdname, "calibrate.start")) + if (!strcasecmp(cmdname, "calibrate.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); return do_cal(1); + } - if (!strcasecmp(cmdname, "calibrate.stop")) + if (!strcasecmp(cmdname, "calibrate.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); return do_cal(0); + } + + upslog_INSTCMD_POWERSTATE_CHECKED(cmdname, extra); if (ct->flags & APC_NASTY) return instcmd_chktime(ct); diff --git a/drivers/apcsmart.c b/drivers/apcsmart.c index 8b39d3a05d..9af6db00e2 100644 --- a/drivers/apcsmart.c +++ b/drivers/apcsmart.c @@ -37,7 +37,7 @@ #include "apcsmart_tabs.h" #define DRIVER_NAME "APC Smart protocol driver" -#define DRIVER_VERSION "3.35" +#define DRIVER_VERSION "3.36" #ifdef WIN32 # ifndef ECANCELED @@ -1609,7 +1609,8 @@ static int sdcmd_AT(const void *str) ret = apc_write_long(temp); /* Range-check: padto is 2 or 3 per above */ if (ret != (ssize_t)padto + 1) { - upslogx(LOG_ERR, + /* FIXME: ...INSTCMD_CONVERSION_FAILED ?*/ + upslogx(LOG_INSTCMD_FAILED, "issuing [%s] with %" PRIuSIZE " digits failed", prtchr(APC_CMD_GRACEDOWN), padto); return STAT_INSTCMD_FAILED; @@ -1619,7 +1620,8 @@ static int sdcmd_AT(const void *str) if (ret == STAT_INSTCMD_HANDLED || padto == 3) return (int)ret; - upslogx(LOG_ERR, + /* FIXME: ...INSTCMD_CONVERSION_FAILED ?*/ + upslogx(LOG_INSTCMD_FAILED, "command [%s] with 2 digits doesn't work - try 3 digits", prtchr(APC_CMD_GRACEDOWN)); /* @@ -1867,13 +1869,13 @@ static int setvar_enum(apc_vartab_t *vt, const char *val) /* check for wraparound */ if (!strcmp(ptr, orig)) { - upslogx(LOG_ERR, "%s: variable %s wrapped", __func__, vt->name); + upslogx(LOG_SET_FAILED, "%s: variable %s wrapped", __func__, vt->name); return STAT_SET_FAILED; } } - upslogx(LOG_ERR, "%s: gave up after 6 tries for %s", __func__, vt->name); + upslogx(LOG_SET_FAILED, "%s: gave up after 6 tries for %s", __func__, vt->name); /* refresh data from the hardware */ poll_data(vt); @@ -1889,7 +1891,7 @@ static int setvar_string(apc_vartab_t *vt, const char *val) /* sanitize length */ if (strlen(val) > APC_STRLEN) { - upslogx(LOG_ERR, "%s: value (%s) too long", __func__, val); + upslogx(LOG_SET_FAILED, "%s: value (%s) too long", __func__, val); return STAT_SET_FAILED; } @@ -1927,12 +1929,12 @@ static int setvar_string(apc_vartab_t *vt, const char *val) ret = apc_read(temp, sizeof(temp), SER_AA); if (ret < 1) { - upslogx(LOG_ERR, "%s: %s", __func__, "short final read"); + upslogx(LOG_SET_FAILED, "%s: %s", __func__, "short final read"); return STAT_SET_FAILED; } if (!strcmp(temp, "NO")) { - upslogx(LOG_ERR, "%s: %s", __func__, "got NO at final read"); + upslogx(LOG_SET_FAILED, "%s: %s", __func__, "got NO at final read"); return STAT_SET_FAILED; } @@ -1948,13 +1950,15 @@ static int setvar(const char *varname, const char *val) { apc_vartab_t *vt; + upsdebug_SET_STARTING(varname, val); + vt = vt_lookup_name(varname); if (!vt) return STAT_SET_UNKNOWN; if ((vt->flags & APC_RW) == 0) { - upslogx(LOG_WARNING, "%s: [%s] is not writable", __func__, varname); + upslogx(LOG_SET_UNKNOWN, "%s: [%s] is not writable", __func__, varname); return STAT_SET_UNKNOWN; } @@ -1964,7 +1968,7 @@ static int setvar(const char *varname, const char *val) if (vt->flags & APC_STRING) return setvar_string(vt, val); - upslogx(LOG_WARNING, "%s: unknown type for [%s]", __func__, varname); + upslogx(LOG_SET_UNKNOWN, "%s: unknown type for [%s]", __func__, varname); return STAT_SET_UNKNOWN; } @@ -2014,7 +2018,7 @@ static int do_cmd(const apc_cmdtab_t *ct) return STAT_INSTCMD_FAILED; if (strcmp(temp, "OK")) { - upslogx(LOG_WARNING, "%s: got [%s] after command [%s]", + upslogx(LOG_INSTCMD_FAILED, "%s: got [%s] after command [%s]", __func__, temp, ct->name); return STAT_INSTCMD_FAILED; @@ -2051,6 +2055,8 @@ static int instcmd(const char *cmd, const char *ext) int i; apc_cmdtab_t *ct = NULL; + upsdebug_INSTCMD_STARTING(cmd, ext); + for (i = 0; apc_cmdtab[i].name != NULL; i++) { /* cmd must match */ if (strcasecmp(apc_cmdtab[i].name, cmd)) @@ -2069,13 +2075,12 @@ static int instcmd(const char *cmd, const char *ext) } if (!ct) { - upslogx(LOG_WARNING, "%s: unknown command [%s %s]", __func__, cmd, - ext ? ext : "\b"); - return STAT_INSTCMD_INVALID; + upslog_INSTCMD_UNKNOWN(cmd, ext); + return STAT_INSTCMD_UNKNOWN; } if (!(ct->flags & APC_PRESENT)) { - upslogx(LOG_WARNING, "%s: command [%s %s] recognized, but" + upslogx(LOG_INSTCMD_INVALID, "%s: command [%s %s] recognized, but" " not supported by your UPS model", __func__, cmd, ext ? ext : "\b"); return STAT_INSTCMD_INVALID; @@ -2087,22 +2092,34 @@ static int instcmd(const char *cmd, const char *ext) /* we're good to go, handle special stuff first, then generic cmd */ - if (!strcasecmp(cmd, "calibrate.start")) + if (!strcasecmp(cmd, "calibrate.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmd, ext); return do_cal(1); + } - if (!strcasecmp(cmd, "calibrate.stop")) + if (!strcasecmp(cmd, "calibrate.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmd, ext); return do_cal(0); + } - if (!strcasecmp(cmd, "load.on")) + if (!strcasecmp(cmd, "load.on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmd, ext); return do_loadon(); + } - if (!strcasecmp(cmd, "load.off")) + if (!strcasecmp(cmd, "load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmd, ext); return sdcmd_Z(0); + } - if (!strcasecmp(cmd, "shutdown.stayoff")) + if (!strcasecmp(cmd, "shutdown.stayoff")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmd, ext); return sdcmd_K(0); + } if (!strcasecmp(cmd, "shutdown.return")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmd, ext); + if (!ext || !*ext) return sdcmd_S(0); @@ -2114,6 +2131,7 @@ static int instcmd(const char *cmd, const char *ext) } /* nothing special here */ + upslog_INSTCMD_POWERSTATE_CHECKED(cmd, ext); return do_cmd(ct); } diff --git a/drivers/bcmxcp.c b/drivers/bcmxcp.c index 34d3711fca..01837e2fc2 100644 --- a/drivers/bcmxcp.c +++ b/drivers/bcmxcp.c @@ -116,7 +116,7 @@ TODO List: #include "bcmxcp.h" #define DRIVER_NAME "BCMXCP UPS driver" -#define DRIVER_VERSION "0.36" +#define DRIVER_VERSION "0.37" #define MAX_NUT_NAME_LENGTH 128 #define NUT_OUTLET_POSITION 7 @@ -1967,7 +1967,9 @@ static int instcmd(const char *cmdname, const char *extra) int sec, outlet_num; int sddelay = 0x03; /* outlet off in 3 seconds, by default */ - upsdebugx(1, "entering instcmd(%s)(%s)", cmdname, extra); + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); if (!strcasecmp(cmdname, "shutdown.return")) { send_write_command(AUTHOR, 4); @@ -1978,6 +1980,7 @@ static int instcmd(const char *cmdname, const char *extra) cbuf[1] = (unsigned char)(bcmxcp_status.shutdowndelay & 0x00ff); /* "delay" sec delay for shutdown, */ cbuf[2] = (unsigned char)(bcmxcp_status.shutdowndelay >> 8); /* high byte sec. From ups.conf. */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); res = command_write_sequence(cbuf, 3, answer); sec = (256 * (unsigned char)answer[3]) + (unsigned char)answer[2]; @@ -1991,6 +1994,7 @@ static int instcmd(const char *cmdname, const char *extra) sleep(PW_SLEEP); /* Need to. Have to wait at least 0,25 sec max 16 sec */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); res = command_read_sequence(PW_UPS_OFF, answer); return decode_instcmd_exec(res, (unsigned char)answer[0], cmdname, "Going down NOW"); @@ -2001,6 +2005,7 @@ static int instcmd(const char *cmdname, const char *extra) sleep(PW_SLEEP); /* Need to. Have to wait at least 0,25 sec max 16 sec */ + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); res = command_read_sequence(PW_UPS_ON, answer); return decode_instcmd_exec(res, (unsigned char)answer[0], cmdname, "Enabling"); @@ -2011,6 +2016,7 @@ static int instcmd(const char *cmdname, const char *extra) sleep(PW_SLEEP); /* Need to. Have to wait at least 0,25 sec max 16 sec */ + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); res = command_read_sequence(PW_GO_TO_BYPASS, answer); return decode_instcmd_exec(res, (unsigned char)answer[0], cmdname, "Bypass enabled"); @@ -2028,6 +2034,7 @@ static int instcmd(const char *cmdname, const char *extra) cbuf[1] = 0x0A; /* 10 sec start delay for test.*/ cbuf[2] = 0x1E; /* 30 sec test duration.*/ + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); res = command_write_sequence(cbuf, 3, answer); return decode_instcmd_exec(res, (unsigned char)answer[0], cmdname, "Testing battery now"); @@ -2045,6 +2052,8 @@ static int instcmd(const char *cmdname, const char *extra) cbuf[0] = PW_INIT_SYS_TEST; cbuf[1] = PW_SYS_TEST_GENERAL; + + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); res = command_write_sequence(cbuf, 2, answer); return decode_instcmd_exec(res, (unsigned char)answer[0], cmdname, "Testing system now"); @@ -2122,6 +2131,7 @@ static int instcmd(const char *cmdname, const char *extra) cbuf[2] = (unsigned char)(sddelay >> 8); /* high byte of the 2 byte time argument */ cbuf[3] = (unsigned char)outlet_num; /* which outlet load segment? Assumes outlet number at position 8 of the command string. */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); res = command_write_sequence(cbuf, 4, answer); sec = (256 * (unsigned char)answer[3]) + (unsigned char)answer[2]; @@ -2139,8 +2149,14 @@ static int instcmd(const char *cmdname, const char *extra) if (outlet_num < 1 || outlet_num > 9) return STAT_INSTCMD_FAILED; - - cbuf[0] = (cmdname[NUT_OUTLET_POSITION+8] == 'n') ? PW_UPS_ON : PW_UPS_OFF; /* Cmd oN or not*/ + /* Cmd oN or not? */ + if (cmdname[NUT_OUTLET_POSITION+8] == 'n') { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + cbuf[0] = PW_UPS_ON; + } else { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + cbuf[0] = PW_UPS_OFF; + } cbuf[1] = (unsigned char)outlet_num; /* Outlet number */ res = command_write_sequence(cbuf, 2, answer); @@ -2152,14 +2168,14 @@ static int instcmd(const char *cmdname, const char *extra) return decode_instcmd_exec(res, (unsigned char)answer[0], cmdname, success_msg); } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s]", cmdname); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } static int decode_instcmd_exec(const ssize_t res, const unsigned char exec_status, const char *cmdname, const char *success_msg) { if (res <= 0) { - upslogx(LOG_ERR, "[%s] Short read from UPS", cmdname); + upslogx(LOG_INSTCMD_FAILED, "[%s] Short read from UPS", cmdname); dstate_datastale(); return STAT_INSTCMD_FAILED; } @@ -2178,23 +2194,23 @@ static int decode_instcmd_exec(const ssize_t res, const unsigned char exec_statu return STAT_INSTCMD_HANDLED; } case BCMXCP_RETURN_BUSY: { - upslogx(LOG_NOTICE, "[%s] Busy or disbled by front panel", cmdname); + upslogx(LOG_INSTCMD_FAILED, "[%s] Busy or disabled by front panel", cmdname); return STAT_INSTCMD_FAILED; } case BCMXCP_RETURN_UNRECOGNISED: { - upslogx(LOG_NOTICE, "[%s] Unrecognised command byte or corrupt checksum", cmdname); + upslogx(LOG_INSTCMD_FAILED, "[%s] Unrecognized command byte or corrupt checksum", cmdname); return STAT_INSTCMD_FAILED; } case BCMXCP_RETURN_INVALID_PARAMETER: { - upslogx(LOG_NOTICE, "[%s] Invalid parameter", cmdname); + upslogx(LOG_INSTCMD_INVALID, "[%s] Invalid parameter", cmdname); return STAT_INSTCMD_INVALID; } case BCMXCP_RETURN_PARAMETER_OUT_OF_RANGE: { - upslogx(LOG_NOTICE, "[%s] Parameter out of range", cmdname); + upslogx(LOG_INSTCMD_INVALID, "[%s] Parameter out of range", cmdname); return STAT_INSTCMD_INVALID; } default: { - upslogx(LOG_NOTICE, "[%s] Not supported", cmdname); + upslogx(LOG_INSTCMD_INVALID, "[%s] Not supported", cmdname); return STAT_INSTCMD_INVALID; } } @@ -2224,7 +2240,7 @@ int setvar (const char *varname, const char *val) int sec, outlet_num, tmp; int onOff_setting = PW_AUTO_OFF_DELAY; - upsdebugx(1, "entering setvar(%s, %s)", varname, val); + upsdebug_SET_STARTING(varname, val); if (!strcasecmp(varname, "input.transfer.boost.high")) { @@ -2511,7 +2527,7 @@ int setvar (const char *varname, const char *val) static int decode_setvar_exec(const ssize_t res, const unsigned char exec_status, const char *cmdname, const char *success_msg) { if (res <= 0) { - upslogx(LOG_ERR, "[%s] Short read from UPS", cmdname); + upslogx(LOG_SET_FAILED, "[%s] Short read from UPS", cmdname); dstate_datastale(); return STAT_SET_FAILED; } @@ -2530,23 +2546,23 @@ static int decode_setvar_exec(const ssize_t res, const unsigned char exec_status return STAT_SET_HANDLED; } case BCMXCP_RETURN_BUSY: { - upslogx(LOG_NOTICE, "[%s] Busy or disbled by front panel", cmdname); + upslogx(LOG_SET_FAILED, "[%s] Busy or disabled by front panel", cmdname); return STAT_SET_FAILED; } case BCMXCP_RETURN_UNRECOGNISED: { - upslogx(LOG_NOTICE, "[%s] Unrecognised command byte or corrupt checksum", cmdname); + upslogx(LOG_SET_FAILED, "[%s] Unrecognized command byte or corrupt checksum", cmdname); return STAT_SET_FAILED; } case BCMXCP_RETURN_INVALID_PARAMETER: { - upslogx(LOG_NOTICE, "[%s] Invalid parameter", cmdname); + upslogx(LOG_SET_INVALID, "[%s] Invalid parameter", cmdname); return STAT_SET_INVALID; } case BCMXCP_RETURN_PARAMETER_OUT_OF_RANGE: { - upslogx(LOG_NOTICE, "[%s] Parameter out of range", cmdname); + upslogx(LOG_SET_INVALID, "[%s] Parameter out of range", cmdname); return STAT_SET_INVALID; } default: { - upslogx(LOG_NOTICE, "[%s] Not supported", cmdname); + upslogx(LOG_SET_INVALID, "[%s] Not supported", cmdname); return STAT_SET_INVALID; } } diff --git a/drivers/belkin.c b/drivers/belkin.c index 7044fae268..e783fa25ad 100644 --- a/drivers/belkin.c +++ b/drivers/belkin.c @@ -29,7 +29,7 @@ #include "nut_stdint.h" #define DRIVER_NAME "Belkin Smart protocol driver" -#define DRIVER_VERSION "0.28" +#define DRIVER_VERSION "0.29" static ssize_t init_communication(void); static ssize_t get_belkin_reply(char *buf); @@ -409,6 +409,10 @@ static void do_off(void) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "beeper.disable")) { do_beeper_off(); return STAT_INSTCMD_HANDLED; @@ -422,6 +426,7 @@ static int instcmd(const char *cmdname, const char *extra) if (!strcasecmp(cmdname, "shutdown.return")) { ssize_t res; + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); res = init_communication(); if (res < 0) { printf("Detection failed. Trying a shutdown command anyway.\n"); @@ -444,31 +449,36 @@ static int instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); do_off(); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "load.on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); send_belkin_command(CONTROL,POWER_ON,"1;1"); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "test.battery.start.quick")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); send_belkin_command(CONTROL,TEST,TEST_10SEC); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "test.battery.start.deep")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); send_belkin_command(CONTROL,TEST,TEST_DEEP); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); send_belkin_command(CONTROL,TEST,TEST_CANCEL); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/belkinunv.c b/drivers/belkinunv.c index 9034605571..5f56264954 100644 --- a/drivers/belkinunv.c +++ b/drivers/belkinunv.c @@ -94,7 +94,7 @@ #include "serial.h" #define DRIVER_NAME "Belkin 'Universal UPS' driver" -#define DRIVER_VERSION "0.11" +#define DRIVER_VERSION "0.12" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -1204,6 +1204,10 @@ int instcmd(const char *cmdname, const char *extra) { int r; + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + /* We use test.failure.start to initiate a "deep battery test". This does not really simulate a 'power failure', because we won't start shutdown procedures during a test. @@ -1225,21 +1229,25 @@ int instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "test.failure.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); r = belkin_nut_write_int(REG_TESTSTATUS, 2); if (r == -1) upslogx(LOG_WARNING, "Command '%s' failed", cmdname); return STAT_INSTCMD_HANDLED; /* Future: failure if r==-1 */ } if (!strcasecmp(cmdname, "test.failure.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); r = belkin_nut_write_int(REG_TESTSTATUS, 3); if (r == -1) upslogx(LOG_WARNING, "Command '%s' failed", cmdname); return STAT_INSTCMD_HANDLED; /* Future: failure if r==-1 */ } if (!strcasecmp(cmdname, "test.battery.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); r = belkin_nut_write_int(REG_TESTSTATUS, 1); if (r == -1) upslogx(LOG_WARNING, "Command '%s' failed", cmdname); return STAT_INSTCMD_HANDLED; /* Future: failure if r==-1 */ } if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); r = belkin_nut_write_int(REG_TESTSTATUS, 3); if (r == -1) upslogx(LOG_WARNING, "Command '%s' failed", cmdname); return STAT_INSTCMD_HANDLED; /* Future: failure if r==-1 */ @@ -1260,12 +1268,14 @@ int instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; /* Future: failure if r==-1 */ } if (!strcasecmp(cmdname, "shutdown.stayoff")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); r = belkin_nut_write_int(REG_RESTARTTIMER, 0); r |= belkin_nut_write_int(REG_SHUTDOWNTIMER, 1); /* 1 second */ if (r == -1) upslogx(LOG_WARNING, "Command '%s' failed", cmdname); return STAT_INSTCMD_HANDLED; /* Future: failure if r==-1 */ } if (!strcasecmp(cmdname, "shutdown.reboot")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); /* restarttimer is in minutes, shutdowntimer is in seconds. Still, restarttimer=1 is not safe, because it might be decremented before @@ -1278,6 +1288,7 @@ int instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; /* Future: failure if r==-1 */ } if (!strcasecmp(cmdname, "shutdown.reboot.graceful")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); r = belkin_nut_write_int(REG_RESTARTTIMER, 2); /* 2 minutes */ r |= belkin_nut_write_int(REG_SHUTDOWNTIMER, 40); /* 40 seconds */ if (r == -1) upslogx(LOG_WARNING, "Command '%s' failed", cmdname); @@ -1290,7 +1301,7 @@ int instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -1299,6 +1310,8 @@ static int setvar(const char *varname, const char *val) { int i; + upsdebug_SET_STARTING(varname, val); + if (!strcasecmp(varname, "input.sensitivity")) { for (i=0; i= 0) { - upslogx(LOG_INFO, "Shutting down in %d seconds: response = 0x%02X", + upslogx(LOG_INSTCMD_POWERSTATE, "Shutting down in %d seconds: response = 0x%02X", seconds, (unsigned)response); } @@ -671,13 +671,17 @@ static ssize_t bicker_shutdown(void) static int bicker_instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); if (!strcasecmp(cmdname, "shutdown.return")) { - bicker_shutdown(); + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + if (bicker_shutdown() >= 0) + return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s]", cmdname); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -687,6 +691,8 @@ static int bicker_setvar(const char *varname, const char *val) unsigned i; BickerParameter parameter; + upsdebug_SET_STARTING(varname, val); + /* This should not be needed because when `bicker_write()` is * successful the `parameter` struct is populated but gcc seems * not to be smart enough to realize that and errors out with @@ -718,7 +724,7 @@ static int bicker_setvar(const char *varname, const char *val) } } - upslogx(LOG_NOTICE, "setvar: unknown variable [%s]", varname); + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } diff --git a/drivers/blazer.c b/drivers/blazer.c index 51ab180f42..8f2aff72cb 100644 --- a/drivers/blazer.c +++ b/drivers/blazer.c @@ -409,7 +409,7 @@ static int blazer_instcmd(const char *cmdname, const char *extra) char buf[SMALLBUF] = ""; int i; - upslogx(LOG_INFO, "instcmd(%s, %s)", cmdname, extra ? extra : "[NULL]"); + upsdebug_INSTCMD_STARTING(cmdname, extra); for (i = 0; instcmd[i].cmd; i++) { @@ -424,9 +424,10 @@ static int blazer_instcmd(const char *cmdname, const char *extra) * As an exception, Best UPS units will report "ACK" in case of success! * Other UPSes will reply "(ACK" in case of success. */ + upslog_INSTCMD_POWERSTATE_CHECKED(cmdname, extra); if (blazer_command(buf, buf, sizeof(buf)) > 0) { if (strncmp(buf, "ACK", 3) && strncmp(buf, "(ACK", 4)) { - upslogx(LOG_ERR, "instcmd: command [%s] failed", cmdname); + upslogx(LOG_INSTCMD_FAILED, "instcmd: command [%s] failed", cmdname); return STAT_INSTCMD_FAILED; } } @@ -436,6 +437,7 @@ static int blazer_instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "shutdown.return")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); /* * Sn: Shutdown after n minutes and then turn on when mains is back @@ -468,6 +470,7 @@ static int blazer_instcmd(const char *cmdname, const char *extra) } } else if (!strcasecmp(cmdname, "shutdown.stayoff")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); /* * SnR0000 @@ -485,15 +488,16 @@ static int blazer_instcmd(const char *cmdname, const char *extra) long delay = extra ? strtol(extra, NULL, 10) : 10; if ((delay < 1) || (delay > 99)) { - upslogx(LOG_ERR, + upslogx(LOG_INSTCMD_FAILED, "instcmd: command [%s] failed, delay [%s] out of range", cmdname, extra); return STAT_INSTCMD_FAILED; } + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); snprintf(buf, sizeof(buf), "T%02ld\r", delay); } else { - upslogx(LOG_ERR, "instcmd: command [%s] not found", cmdname); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -504,7 +508,7 @@ static int blazer_instcmd(const char *cmdname, const char *extra) */ if (blazer_command(buf, buf, sizeof(buf)) > 0) { if (strncmp(buf, "ACK", 3) && strncmp(buf, "(ACK", 4)) { - upslogx(LOG_ERR, "instcmd: command [%s] failed", cmdname); + upslogx(LOG_INSTCMD_FAILED, "instcmd: command [%s] failed", cmdname); return STAT_INSTCMD_FAILED; } } diff --git a/drivers/blazer_ser.c b/drivers/blazer_ser.c index 78a98cb1d9..e7095e7604 100644 --- a/drivers/blazer_ser.c +++ b/drivers/blazer_ser.c @@ -31,7 +31,7 @@ #include "blazer.h" #define DRIVER_NAME "Megatec/Q1 protocol serial driver" -#define DRIVER_VERSION "1.63" +#define DRIVER_VERSION "1.64" /* driver description structure */ upsdrv_info_t upsdrv_info = { diff --git a/drivers/blazer_usb.c b/drivers/blazer_usb.c index cf92a6146f..2e4656589a 100644 --- a/drivers/blazer_usb.c +++ b/drivers/blazer_usb.c @@ -37,7 +37,7 @@ #endif /* WIN32 */ #define DRIVER_NAME "Megatec/Q1 protocol USB driver" -#define DRIVER_VERSION "0.22" +#define DRIVER_VERSION "0.23" /* driver description structure */ upsdrv_info_t upsdrv_info = { diff --git a/drivers/clone.c b/drivers/clone.c index 9ded9cbc5c..7d4a35fe5f 100644 --- a/drivers/clone.c +++ b/drivers/clone.c @@ -498,7 +498,12 @@ static int sstate_dead(int maxage) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "shutdown.return")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); if (outlet && (ups.timer.shutdown < 0)) { ups.timer.shutdown = offdelay; status_set("FSD"); @@ -509,6 +514,7 @@ static int instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "shutdown.stayoff")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); if (outlet && (ups.timer.shutdown < 0)) { ups.timer.shutdown = offdelay; status_set("FSD"); @@ -518,13 +524,15 @@ static int instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } static int setvar(const char *varname, const char *val) { + upsdebug_SET_STARTING(varname, val); + if (!strcasecmp(varname, "battery.charge.low")) { battery.charge.low = strtod(val, NULL); dstate_setinfo("battery.charge.low", "%f", battery.charge.low); @@ -537,7 +545,7 @@ static int setvar(const char *varname, const char *val) return STAT_SET_HANDLED; } - upslogx(LOG_NOTICE, "setvar: unknown variable [%s]", varname); + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } diff --git a/drivers/dstate.c b/drivers/dstate.c index 9a165b397d..fc0483f681 100644 --- a/drivers/dstate.c +++ b/drivers/dstate.c @@ -840,7 +840,7 @@ static int sock_arg(conn_t *conn, size_t numarg, char **arg) cmdparam = arg[2]; cmdid = arg[4]; } else if (numarg != 2) { - upslogx(LOG_NOTICE, "Malformed INSTCMD request"); + upslogx(LOG_INSTCMD_INVALID, "Malformed INSTCMD request"); return 0; } @@ -876,11 +876,11 @@ static int sock_arg(conn_t *conn, size_t numarg, char **arg) } if (cmdparam) { - upslogx(LOG_NOTICE, + upslogx(LOG_INSTCMD_UNKNOWN, "Got INSTCMD '%s' '%s', but driver lacks a handler", NUT_STRARG(cmdname), NUT_STRARG(cmdparam)); } else { - upslogx(LOG_NOTICE, + upslogx(LOG_INSTCMD_UNKNOWN, "Got INSTCMD '%s', but driver lacks a handler", NUT_STRARG(cmdname)); } @@ -914,7 +914,7 @@ static int sock_arg(conn_t *conn, size_t numarg, char **arg) setid = arg[4]; } else { - upslogx(LOG_NOTICE, "Got SET with unsupported parameters (%s/%s)", + upslogx(LOG_SET_INVALID, "Got SET with unsupported parameters (%s/%s)", arg[3], arg[4]); return 0; } @@ -949,7 +949,7 @@ static int sock_arg(conn_t *conn, size_t numarg, char **arg) return 1; } - upslogx(LOG_NOTICE, "Got SET, but driver lacks a handler"); + upslogx(LOG_SET_UNKNOWN, "Got SET, but driver lacks a handler"); return 1; } diff --git a/drivers/dummy-ups.c b/drivers/dummy-ups.c index 5e3cf00891..d412ed5b46 100644 --- a/drivers/dummy-ups.c +++ b/drivers/dummy-ups.c @@ -48,7 +48,7 @@ #include "dummy-ups.h" #define DRIVER_NAME "Device simulation and repeater driver" -#define DRIVER_VERSION "0.21" +#define DRIVER_VERSION "0.22" /* driver description structure */ upsdrv_info_t upsdrv_info = @@ -393,8 +393,13 @@ void upsdrv_shutdown(void) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + /* if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); ser_send_buf(upsfd, ...); return STAT_INSTCMD_HANDLED; } @@ -404,7 +409,7 @@ static int instcmd(const char *cmdname, const char *extra) * if (mode == MODE_META) => ? */ - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -582,7 +587,7 @@ static int setvar(const char *varname, const char *val) { dummy_info_t *item; - upsdebugx(2, "entering setvar(%s, %s)", varname, val); + upsdebug_SET_STARTING(varname, val); /* FIXME: the below is only valid if (mode == MODE_DUMMY) * if (mode == MODE_REPEATER) => forward @@ -591,7 +596,11 @@ static int setvar(const char *varname, const char *val) if (!strncmp(varname, "ups.status", 10)) { status_init(); - /* FIXME: split and check values (support multiple values), à la usbhid-ups */ + /* FIXME: split and check values (support multiple values), + * à la usbhid-ups. + * UPDATE: Since NUT v2.8.3, status_set() does the splitting, + * but what about "checking values"? + */ status_set(val); status_commit(); diff --git a/drivers/etapro.c b/drivers/etapro.c index 8532e7986a..eed0be3a9d 100644 --- a/drivers/etapro.c +++ b/drivers/etapro.c @@ -55,7 +55,7 @@ #include "nut_stdint.h" #define DRIVER_NAME "ETA PRO driver" -#define DRIVER_VERSION "0.08" +#define DRIVER_VERSION "0.09" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -189,23 +189,30 @@ etapro_set_off_timer(unsigned int seconds) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); etapro_set_off_timer(1); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "load.on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); etapro_set_on_timer(1); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.return")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); etapro_set_on_timer(SHUTDOWN_GRACE_TIME + SHUTDOWN_TO_RETURN_TIME); etapro_set_off_timer(SHUTDOWN_GRACE_TIME); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/everups.c b/drivers/everups.c index b76c12b869..3308d894a0 100644 --- a/drivers/everups.c +++ b/drivers/everups.c @@ -21,7 +21,7 @@ #include "serial.h" #define DRIVER_NAME "Ever UPS driver (serial)" -#define DRIVER_VERSION "0.07" +#define DRIVER_VERSION "0.08" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -177,7 +177,9 @@ void upsdrv_updateinfo(void) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); /* FIXME: Which one is this - "load.off", * "shutdown.stayoff" or "shutdown.return"? */ @@ -185,14 +187,15 @@ int instcmd(const char *cmdname, const char *extra) /* Shutdown UPS */ if (!strcasecmp(cmdname, "load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); if (!Code(2)) { - upslog_with_errno(LOG_INFO, "Code failed"); + upslog_with_errno(LOG_INSTCMD_UNKNOWN, "Code failed"); return STAT_INSTCMD_UNKNOWN; } ser_send_char(upsfd, 28); ser_send_char(upsfd, 1); /* 1.28 sec */ if (!Code(1)) { - upslog_with_errno(LOG_INFO, "Code failed"); + upslog_with_errno(LOG_INSTCMD_UNKNOWN, "Code failed"); return STAT_INSTCMD_UNKNOWN; } ser_send_char(upsfd, 13); @@ -201,7 +204,7 @@ int instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/gamatronic.c b/drivers/gamatronic.c index 3f37046ab9..587c74e27a 100644 --- a/drivers/gamatronic.c +++ b/drivers/gamatronic.c @@ -33,7 +33,7 @@ #include "nut_stdint.h" #define DRIVER_NAME "Gamatronic UPS driver" -#define DRIVER_VERSION "0.07" +#define DRIVER_VERSION "0.08" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -346,8 +346,13 @@ void upsdrv_shutdown(void) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + /* if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); ser_send_buf(upsfd, ...); return STAT_INSTCMD_HANDLED; } @@ -358,6 +363,7 @@ int instcmd(const char *cmdname, const char *extra) char msgbuf[SMALLBUF]; msglen = snprintf(msgbuf, sizeof(msgbuf), "-1"); + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); sec_cmd(SEC_SETCMD, SEC_SHUTDOWN, msgbuf, &msglen); msglen = snprintf(msgbuf, sizeof(msgbuf), "1"); @@ -372,7 +378,7 @@ int instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/generic_modbus.c b/drivers/generic_modbus.c index 59a0369606..8b52391794 100644 --- a/drivers/generic_modbus.c +++ b/drivers/generic_modbus.c @@ -31,7 +31,7 @@ #endif #define DRIVER_NAME "NUT Generic Modbus driver (libmodbus link type: " NUT_MODBUS_LINKTYPE_STR ")" -#define DRIVER_VERSION "0.06" +#define DRIVER_VERSION "0.07" /* variables */ static modbus_t *mbctx = NULL; /* modbus memory context */ @@ -571,20 +571,26 @@ int upscmd(const char *cmd, const char *arg) struct timeval start; long etime; + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(arg); + upsdebug_INSTCMD_STARTING(cmd, arg); + if (!strcasecmp(cmd, "load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmd, arg); if (sigar[FSD_T].addr != NOTUSED && (sigar[FSD_T].type == COIL || sigar[FSD_T].type == HOLDING) ) { data = 1 ^ sigar[FSD_T].noro; rval = register_write(mbctx, sigar[FSD_T].addr, sigar[FSD_T].type, &data); if (rval == -1) { - upslogx(2, "ERROR:(%s) modbus_write_register: addr:0x%08x, regtype: %u, path:%s", + upsdebugx(2, "ERROR:(%s) modbus_write_register: addr:0x%08x, regtype: %u, path:%s", modbus_strerror(errno), (unsigned int)(sigar[FSD_T].addr), sigar[FSD_T].type, device_path ); - upslogx(LOG_NOTICE, "load.off: failed (communication error) [%s] [%s]", cmd, arg); + + upslogx(LOG_INSTCMD_FAILED, "load.off: failed (communication error) [%s] [%s]", cmd, NUT_STRARG(arg)); rval = STAT_INSTCMD_FAILED; } else { upsdebugx(2, "load.off: addr: 0x%x, data: %d", @@ -605,13 +611,14 @@ int upscmd(const char *cmd, const char *arg) data = 0 ^ sigar[FSD_T].noro; rval = register_write(mbctx, sigar[FSD_T].addr, sigar[FSD_T].type, &data); if (rval == -1) { - upslogx(LOG_ERR, "ERROR:(%s) modbus_write_register: addr:0x%08x, regtype: %u, path:%s\n", + upsdebugx(2, "ERROR:(%s) modbus_write_register: addr:0x%08x, regtype: %u, path:%s\n", modbus_strerror(errno), (unsigned int)(sigar[FSD_T].addr), sigar[FSD_T].type, device_path ); - upslogx(LOG_NOTICE, "load.off: failed (communication error) [%s] [%s]", cmd, arg); + + upslogx(LOG_INSTCMD_FAILED, "load.off: failed (communication error) [%s] [%s]", cmd, NUT_STRARG(arg)); rval = STAT_INSTCMD_FAILED; } else { upsdebugx(2, "load.off: addr: 0x%x, data: %d, elapsed time: %lims", @@ -623,9 +630,8 @@ int upscmd(const char *cmd, const char *arg) } } } else { - upslogx(LOG_NOTICE,"load.off: failed (FSD address undefined or invalid register type) [%s] [%s]", - cmd, - arg + upslogx(LOG_INSTCMD_FAILED, "load.off: failed (FSD address undefined or invalid register type) [%s] [%s]", + NUT_STRARG(cmd), NUT_STRARG(arg) ); rval = STAT_INSTCMD_FAILED; } @@ -634,6 +640,7 @@ int upscmd(const char *cmd, const char *arg) * "shutdown.stayoff" or "shutdown.return"? */ int cnt = FSD_REPEAT_CNT; /* shutdown repeat counter */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmd, arg); /* retry sending shutdown command on error */ while ((rval = upscmd("load.off", NULL)) != STAT_INSTCMD_HANDLED && cnt > 0) { rval = gettimeofday(&start, NULL); @@ -649,12 +656,12 @@ int upscmd(const char *cmd, const char *arg) switch (rval) { case STAT_INSTCMD_FAILED: case STAT_INSTCMD_INVALID: - upslogx(LOG_ERR, "shutdown failed"); + upslogx(LOG_INSTCMD_FAILED, "shutdown failed"); if (handling_upsdrv_shutdown > 0) set_exit_flag(EF_EXIT_FAILURE); return rval; case STAT_INSTCMD_UNKNOWN: - upslogx(LOG_ERR, "shutdown not supported"); + upslogx(LOG_INSTCMD_UNKNOWN, "shutdown not supported"); if (handling_upsdrv_shutdown > 0) set_exit_flag(EF_EXIT_FAILURE); return rval; @@ -665,7 +672,7 @@ int upscmd(const char *cmd, const char *arg) break; } } else { - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmd, arg); + upslog_INSTCMD_UNKNOWN(cmd, arg); rval = STAT_INSTCMD_UNKNOWN; } return rval; diff --git a/drivers/huawei-ups2000.c b/drivers/huawei-ups2000.c index b2e582a103..86a1802180 100644 --- a/drivers/huawei-ups2000.c +++ b/drivers/huawei-ups2000.c @@ -55,7 +55,7 @@ #endif #define DRIVER_NAME "NUT Huawei UPS2000 (1kVA-3kVA) RS-232 Modbus driver (libmodbus link type: " NUT_MODBUS_LINKTYPE_STR ")" -#define DRIVER_VERSION "0.09" +#define DRIVER_VERSION "0.10" #define CHECK_BIT(var,pos) ((var) & (1<<(pos))) #define MODBUS_SLAVE_ID 1 @@ -1198,6 +1198,8 @@ static int setvar(const char *name, const char *val) int i; int r; + upsdebug_SET_STARTING(name, val); + for (i = 0; ups2000_rw_var[i].name != NULL; i++) { if (!strcasecmp(ups2000_rw_var[i].name, name)) { r = ups2000_rw_var[i].setter(ups2000_rw_var[i].reg, val); @@ -1212,13 +1214,14 @@ static int setvar(const char *name, const char *val) } } + upslog_SET_UNKNOWN(name, val); return STAT_SET_UNKNOWN; found: if (r == STAT_SET_FAILED) - upslogx(LOG_ERR, "setvar: setting variable [%s] to [%s] failed", name, val); + upslog_SET_FAILED(name, val); else if (r == STAT_SET_INVALID) - upslogx(LOG_WARNING, "setvar: [%s] is not valid for variable [%s]", val, name); + upslog_SET_INVALID(name, val); return r; } @@ -1470,7 +1473,10 @@ static int instcmd(const char *cmd, const char *extra) int i; int status; struct ups2000_cmd_t *cmd_action = NULL; + + /* May be used in logging below, but not as a command argument */ NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmd, extra); for (i = 0; ups2000_cmd[i].cmd != NULL; i++) { if (!strcasecmp(cmd, ups2000_cmd[i].cmd)) { @@ -1479,14 +1485,17 @@ static int instcmd(const char *cmd, const char *extra) } if (!cmd_action) { - upslogx(LOG_WARNING, "instcmd: command [%s] unknown", cmd); + upslog_INSTCMD_UNKNOWN(cmd, extra); return STAT_INSTCMD_UNKNOWN; } + upslog_INSTCMD_POWERSTATE_CHECKED(cmd, extra); + if (cmd_action->handler_func) { /* handled by a function */ if (cmd_action->reg1 < 0) { - upslogx(LOG_WARNING, "instcmd: command [%s] reg1 is negative", cmd); + /* FIXME: ...INSTCMD_CONVERSION_FAILED ? */ + upslogx(LOG_INSTCMD_UNKNOWN, "instcmd: command [%s] reg1 is negative", cmd); return STAT_INSTCMD_UNKNOWN; } else { status = cmd_action->handler_func((uint16_t)cmd_action->reg1); @@ -1521,7 +1530,7 @@ static int instcmd(const char *cmd, const char *extra) } if (status == STAT_INSTCMD_FAILED) - upslogx(LOG_ERR, "instcmd: command [%s] failed", cmd); + upslog_INSTCMD_FAILED(cmd, extra); else if (status == STAT_INSTCMD_HANDLED) upslogx(LOG_INFO, "instcmd: command [%s] handled", cmd); return status; @@ -1565,13 +1574,15 @@ static int ups2000_instcmd_load_on(const uint16_t reg) * enter normal mode, but "load.on" is not supposed to affect the * normal/bypass status. Also log an error and suggest "bypass.stop". */ - upslogx(LOG_ERR, "load.on error: UPS is already on, and is in bypass mode. " + /* FIXME: ..._INVALID ? */ + upslogx(LOG_INSTCMD_FAILED, "load.on error: UPS is already on, and is in bypass mode. " "To enter normal mode, use bypass.stop"); return STAT_INSTCMD_FAILED; } else { /* unreachable, see comments for r != 0 at the beginning */ - upslogx(LOG_ERR, "load.on error: invalid ups.status (%s) detected. " + /* FIXME: ..._INVALID ? */ + upslogx(LOG_INSTCMD_FAILED, "load.on error: invalid ups.status (%s) detected. " "Please file a bug report!", status); return STAT_INSTCMD_FAILED; } @@ -1597,7 +1608,7 @@ static int ups2000_instcmd_bypass_start(const uint16_t reg) /* bypass input has a power failure, refuse to bypass */ if (!bypass_available) { - upslogx(LOG_ERR, "bypass input is abnormal, refuse to enter bypass mode."); + upslogx(LOG_INSTCMD_FAILED, "bypass input is abnormal, refuse to enter bypass mode."); return STAT_INSTCMD_FAILED; } diff --git a/drivers/isbmex.c b/drivers/isbmex.c index 94e167fced..734521158e 100644 --- a/drivers/isbmex.c +++ b/drivers/isbmex.c @@ -27,7 +27,7 @@ #include #define DRIVER_NAME "ISBMEX UPS driver" -#define DRIVER_VERSION "0.11" +#define DRIVER_VERSION "0.12" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -362,7 +362,9 @@ void upsdrv_updateinfo(void) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); /* FIXME: Which one is this - "load.off", * "shutdown.stayoff" or "shutdown.return"? */ @@ -388,6 +390,7 @@ int instcmd(const char *cmdname, const char *extra) set_exit_flag(EF_EXIT_FAILURE); */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); for (i = 0; i <= 5; i++) { ser_send_char(upsfd, '#'); @@ -397,7 +400,7 @@ int instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/ivtscd.c b/drivers/ivtscd.c index 01575fe6ca..a2c094eaba 100644 --- a/drivers/ivtscd.c +++ b/drivers/ivtscd.c @@ -25,7 +25,7 @@ #include "attribute.h" #define DRIVER_NAME "IVT Solar Controller driver" -#define DRIVER_VERSION "0.06" +#define DRIVER_VERSION "0.07" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -122,12 +122,16 @@ static ssize_t ivt_status(void) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "reset.input.minmax")) { ser_send(upsfd, "L"); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/liebert-esp2.c b/drivers/liebert-esp2.c index a719fb9589..97f93910fb 100644 --- a/drivers/liebert-esp2.c +++ b/drivers/liebert-esp2.c @@ -28,7 +28,7 @@ #define IsBitSet(val, bit) ((val) & (1 << (bit))) #define DRIVER_NAME "Liebert ESP-II serial UPS driver" -#define DRIVER_VERSION "0.08" +#define DRIVER_VERSION "0.09" #define UPS_SHUTDOWN_DELAY 12 /* it means UPS will be shutdown 120 sec */ #define SHUTDOWN_CMD_LEN 8 @@ -538,18 +538,26 @@ void upsdrv_shutdown(void) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + /* if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); ser_send_buf(upsfd, ...); return STAT_INSTCMD_HANDLED; } */ - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } static int setvar(const char *varname, const char *val) { + upsdebug_SET_STARTING(varname, val); + /* if (!strcasecmp(varname, "ups.test.interval")) { @@ -557,7 +565,8 @@ static int setvar(const char *varname, const char *val) return STAT_SET_HANDLED; } */ - upslogx(LOG_NOTICE, "setvar: unknown variable [%s] [%s]", varname, val); + + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } diff --git a/drivers/liebert-gxe.c b/drivers/liebert-gxe.c index dbed3f149a..6ff20c6527 100644 --- a/drivers/liebert-gxe.c +++ b/drivers/liebert-gxe.c @@ -24,7 +24,7 @@ #include "ydn23.h" #define DRIVER_NAME "Liebert GXE Series UPS driver" -#define DRIVER_VERSION "0.03" +#define DRIVER_VERSION "0.04" #define PROBE_RETRIES 3 #define DEFAULT_STALE_RETRIES 3 @@ -99,16 +99,24 @@ static int instcmd(const char *cmdname, const char *extra) int retry, ret, len = 4; char *data = NULL; - if (!strcasecmp(cmdname, "test.battery.start")) + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + + if (!strcasecmp(cmdname, "test.battery.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); data = "1002"; - else if (!strcasecmp(cmdname, "test.battery.stop")) + } else if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); data = "1003"; - else if (!strcasecmp(cmdname, "load.on")) + } else if (!strcasecmp(cmdname, "load.on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); data = "2001"; - else if (!strcasecmp(cmdname, "load.off")) + } else if (!strcasecmp(cmdname, "load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); data = "2003"; - else { - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + } else { + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -125,7 +133,7 @@ static int instcmd(const char *cmdname, const char *extra) } } - upslogx(LOG_WARNING, "instcmd: remote failed response, try again"); + upslogx(LOG_INSTCMD_FAILED, "instcmd: remote failed response, try again"); return STAT_INSTCMD_FAILED; } diff --git a/drivers/macosx-ups.c b/drivers/macosx-ups.c index de2e4f73a2..88c27ea596 100644 --- a/drivers/macosx-ups.c +++ b/drivers/macosx-ups.c @@ -29,7 +29,7 @@ #include "IOKit/ps/IOPSKeys.h" #define DRIVER_NAME "Mac OS X UPS meta-driver" -#define DRIVER_VERSION "1.42" +#define DRIVER_VERSION "1.43" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -292,12 +292,17 @@ void upsdrv_shutdown(void) /* static int instcmd(const char *cmdname, const char *extra) { + / * May be used in logging below, but not as a command argument * / + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); ser_send_buf(upsfd, ...); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s]", cmdname); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } */ @@ -320,12 +325,14 @@ static int instcmd(const char *cmdname, const char *extra) /* static int setvar(const char *varname, const char *val) { - if (!strcasecmp(varname, "ups.test.interval")) { + upsdebug_SET_STARTING(varname, val); + + if (!strcasecmp(varname, "ups.test.interval")) { ser_send_buf(upsfd, ...); return STAT_SET_HANDLED; } - upslogx(LOG_NOTICE, "setvar: unknown variable [%s]", varname); + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } */ diff --git a/drivers/main.c b/drivers/main.c index 778fd2f54f..b5b20077de 100644 --- a/drivers/main.c +++ b/drivers/main.c @@ -830,6 +830,8 @@ int do_loop_shutdown_commands(const char *sdcmds, char **cmdused) { upsdebugx(1, "Handle 'shutdown.default' directly, " "ignore other `sdcommands` (if any): %s", sdcmds); + /* TOTHINK : These logs are handled in driver codes */ + /* upslog_INSTCMD_POWERSTATE_CHANGE("shutdown.default", NULL); */ upsdrv_shutdown(); cmdret = STAT_INSTCMD_HANDLED; /* commented below */ @@ -846,9 +848,14 @@ int do_loop_shutdown_commands(const char *sdcmds, char **cmdused) { continue; if (!strcmp(s, "shutdown.default")) { + /* TOTHINK : These logs are handled in driver codes */ + /* We are trying (if at all implemented), so "maybe"... */ + /* upslog_INSTCMD_POWERSTATE_MAYBE(s, NULL); */ upsdrv_shutdown(); cmdret = STAT_INSTCMD_HANDLED; } else { + /* TOTHINK : These logs are handled in driver codes */ + /* upslog_INSTCMD_POWERSTATE_CHECKED(s, NULL); */ cmdret = upsh.instcmd(s, NULL); } @@ -940,7 +947,7 @@ int upsdrv_shutdown_sdcommands_or_default(const char *sdcmds_default, char **cmd } if (sdret == STAT_INSTCMD_HANDLED) { - upslogx(LOG_INFO, "UPS [%s]: shutdown request was successful with '%s'", + upslogx(LOG_CRIT, "UPS [%s]: shutdown request was successful with '%s'", NUT_STRARG(upsname), NUT_STRARG(sdcmd_used)); /* Pass it up to caller? */ @@ -965,6 +972,10 @@ int upsdrv_shutdown_sdcommands_or_default(const char *sdcmds_default, char **cmd /* handle instant commands common for all drivers */ int main_instcmd(const char *cmdname, const char *extra, conn_t *conn) { char buf[SMALLBUF]; + + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + if (conn) #ifndef WIN32 snprintf(buf, sizeof(buf), "socket %d", conn->fd); @@ -975,7 +986,8 @@ int main_instcmd(const char *cmdname, const char *extra, conn_t *conn) { snprintf(buf, sizeof(buf), "(null)"); upsdebugx(2, "entering main_instcmd(%s, %s) for [%s] on %s", - cmdname, extra, NUT_STRARG(upsname), buf); + NUT_STRARG(cmdname), NUT_STRARG(extra), + NUT_STRARG(upsname), buf); if (!strcmp(cmdname, "shutdown.default")) { /* Call the default implementation of UPS shutdown as @@ -1003,7 +1015,7 @@ int main_instcmd(const char *cmdname, const char *extra, conn_t *conn) { * flag involved. */ if (!strcmp("1", dstate_getinfo("driver.flag.allow_killpower"))) { - upslogx(LOG_WARNING, "Requesting UPS [%s] to power off, " + upslogx(LOG_CRIT, "Requesting UPS [%s] to power off, " "as/if handled by its driver by default (may exit), " "due to socket protocol request", NUT_STRARG(upsname)); if (handling_upsdrv_shutdown == 0) @@ -1013,7 +1025,7 @@ int main_instcmd(const char *cmdname, const char *extra, conn_t *conn) { dstate_setinfo("driver.state", "quiet"); return STAT_INSTCMD_HANDLED; } else { - upslogx(LOG_WARNING, "Got socket protocol request for UPS [%s] " + upslogx(LOG_CRIT, "Got socket protocol request for UPS [%s] " "to power off, but driver.flag.allow_killpower does not" "permit this - request was currently ignored!", NUT_STRARG(upsname)); @@ -1128,8 +1140,8 @@ int main_setvar(const char *varname, const char *val, conn_t *conn) { return STAT_SET_UNKNOWN; invalid: - upsdebugx(1, "Error: UPS [%s]: invalid %s value: %s", - NUT_STRARG(upsname), varname, val); + upsdebugx(1, "shared %s(): Error: UPS [%s]: invalid %s value: %s", + __func__, NUT_STRARG(upsname), varname, val); return STAT_SET_INVALID; } diff --git a/drivers/masterguard.c b/drivers/masterguard.c index 49c1c4dc31..06e748eb2c 100644 --- a/drivers/masterguard.c +++ b/drivers/masterguard.c @@ -31,7 +31,7 @@ #include "nut_stdint.h" #define DRIVER_NAME "MASTERGUARD UPS driver" -#define DRIVER_VERSION "0.28" +#define DRIVER_VERSION "0.29" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -543,18 +543,22 @@ void upsdrv_updateinfo(void) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); /* Shutdown UPS */ if (!strcasecmp(cmdname, "shutdown.return")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + /* ups will come up within a minute if utility is restored */ ser_send_pace(upsfd, UPS_PACE, "%s", "S.2R0001\x0D" ); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/metasys.c b/drivers/metasys.c index dc3ead8969..fd45b7872b 100644 --- a/drivers/metasys.c +++ b/drivers/metasys.c @@ -28,7 +28,7 @@ #include "nut_stdint.h" #define DRIVER_NAME "Metasystem UPS driver" -#define DRIVER_VERSION "0.11" +#define DRIVER_VERSION "0.12" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -933,7 +933,13 @@ static int instcmd(const char *cmdname, const char *extra) return instcmd("beeper.enable", NULL); } + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "shutdown.return")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + /* Same stuff as upsdrv_shutdown() */ if (! autorestart) { command[0]=UPS_SET_TIMES_ON_BATTERY; @@ -960,6 +966,8 @@ static int instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "shutdown.stayoff")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + /* schedule a shutdown in 30 seconds with no restart (-1) */ command[0]=UPS_SET_SCHEDULING; command[1]=0x1e; /* remaining */ @@ -976,6 +984,8 @@ static int instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "shutdown.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + /* set shutdown and restart time to -1 (no shutdown, no restart) */ command[0]=UPS_SET_SCHEDULING; command[1]=0xff; /* remaining */ @@ -992,6 +1002,8 @@ static int instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "test.failure.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + /* force ups on battery power */ command[0]=UPS_SET_BATTERY_TEST; command[1]=0x01; @@ -1003,6 +1015,8 @@ static int instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "test.failure.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + /* restore standard mode (mains power) */ command[0]=UPS_SET_BATTERY_TEST; command[1]=0x02; @@ -1014,6 +1028,8 @@ static int instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "test.battery.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + /* launch battery test */ command[0]=UPS_SET_BATTERY_TEST; command[1]=0x00; @@ -1077,7 +1093,7 @@ static int instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/mge-utalk.c b/drivers/mge-utalk.c index 1daf2ac34e..74c1c871b7 100644 --- a/drivers/mge-utalk.c +++ b/drivers/mge-utalk.c @@ -69,7 +69,7 @@ /* --------------------------------------------------------------- */ #define DRIVER_NAME "MGE UPS SYSTEMS/U-Talk driver" -#define DRIVER_VERSION "0.98" +#define DRIVER_VERSION "0.99" /* driver description structure */ @@ -543,9 +543,15 @@ int instcmd(const char *cmdname, const char *extra) { char temp[BUFFLEN]; + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + /* Start battery test */ if (!strcasecmp(cmdname, "test.battery.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + mge_command(temp, sizeof(temp), "Bx 1"); upsdebugx(2, "UPS response to %s was %s", cmdname, temp); @@ -571,18 +577,22 @@ int instcmd(const char *cmdname, const char *extra) if (!strcasecmp(cmdname, "shutdown.stayoff")) { sdtype = SD_STAYOFF; + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); upsdrv_shutdown(); } if (!strcasecmp(cmdname, "shutdown.return")) { sdtype = SD_RETURN; + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); upsdrv_shutdown(); } /* Power Off [all] plugs */ if (!strcasecmp(cmdname, "load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + /* TODO: Powershare (per plug) control */ mge_command(temp, sizeof(temp), "Wy 65535"); upsdebugx(2, "UPS response to Select All Plugs was %s", temp); @@ -603,6 +613,8 @@ int instcmd(const char *cmdname, const char *extra) /* Power On all plugs */ if (!strcasecmp(cmdname, "load.on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + /* TODO: add per plug control */ mge_command(temp, sizeof(temp), "Wy 65535"); upsdebugx(2, "UPS response to Select All Plugs was %s", temp); @@ -622,10 +634,11 @@ int instcmd(const char *cmdname, const char *extra) /* Switch on/off Maintenance Bypass */ if ((!strcasecmp(cmdname, "bypass.start")) - || (!strcasecmp(cmdname, "bypass.stop"))) + || (!strcasecmp(cmdname, "bypass.stop"))) { /* TODO: add control on bypass value */ /* read maintenance bypass status */ + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); if(mge_command(temp, sizeof(temp), "Ps") > 0) { if (temp[0] == '1') @@ -648,7 +661,7 @@ int instcmd(const char *cmdname, const char *extra) } } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -660,6 +673,8 @@ int setvar(const char *varname, const char *val) char temp[BUFFLEN]; char cmd[15]; + upsdebug_SET_STARTING(varname, val); + /* TODO : add some controls */ if(info_variable_ok(varname)) @@ -671,9 +686,11 @@ int setvar(const char *varname, const char *val) /* Execute command */ mge_command(temp, sizeof(temp), cmd); upslogx(LOG_INFO, "setvar: UPS response to Set %s to %s was %s", varname, val, temp); - } else - upsdebugx(1, "setvar: Variable %s not supported by UPS", varname); + return STAT_SET_HANDLED; + } + upsdebugx(1, "setvar: Variable %s not supported by UPS", varname); + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } diff --git a/drivers/microdowell.c b/drivers/microdowell.c index ac71676933..58081a3ac1 100644 --- a/drivers/microdowell.c +++ b/drivers/microdowell.c @@ -44,7 +44,7 @@ #define MAX_SHUTDOWN_DELAY_LEN 5 #define DRIVER_NAME "MICRODOWELL UPS driver" -#define DRIVER_VERSION "0.05" +#define DRIVER_VERSION "0.06" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -655,8 +655,9 @@ int instcmd(const char *cmdname, const char *extra) unsigned char *p ; /* int i ; */ - upsdebugx(1, "instcmd(%s, %s)", cmdname, extra); - + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); if (strcasecmp(cmdname, "load.on") == 0) { @@ -668,6 +669,9 @@ int instcmd(const char *cmdname, const char *extra) OutBuff[5] = 0 ; OutBuff[6] = 0 ; OutBuff[7] = 0 ; + + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + if ((p = CmdSerial(OutBuff, LEN_SD_ONESHOT, InpBuff)) != NULL) { p += 3 ; /* 'p' points to received data */ @@ -692,6 +696,9 @@ int instcmd(const char *cmdname, const char *extra) OutBuff[5] = 0 ; OutBuff[6] = 0 ; OutBuff[7] = 0 ; + + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + if ((p = CmdSerial(OutBuff, LEN_SD_ONESHOT, InpBuff)) != NULL) { p += 3 ; /* 'p' points to received data */ @@ -725,6 +732,8 @@ int instcmd(const char *cmdname, const char *extra) OutBuff[6] = (ups.WakeUpDelay >> 8) & 0xFF ; /* WUDELAY (...) */ OutBuff[7] = (ups.WakeUpDelay & 0xFF ) ; /* WUDELAY (LSB) */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + if ((p = CmdSerial(OutBuff, LEN_SD_ONESHOT, InpBuff)) != NULL) { p += 3 ; /* 'p' points to received data */ @@ -758,6 +767,8 @@ int instcmd(const char *cmdname, const char *extra) OutBuff[6] = 0 ; /* WUDELAY (...) */ OutBuff[7] = 0 ; /* WUDELAY (LSB) */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + if ((p = CmdSerial(OutBuff, LEN_SD_ONESHOT, InpBuff)) != NULL) { p += 3 ; /* 'p' points to received data */ @@ -772,6 +783,7 @@ int instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -791,13 +803,16 @@ int setvar(const char *varname, const char *val) { unsigned int delay; + upsdebug_SET_STARTING(varname, val); + if (sscanf(val, "%u", &delay) != 1) - { + { + /* FIXME: ..._CONVERSION_FAILED? log it? */ return STAT_SET_UNKNOWN; - } + } if (strcasecmp(varname, "ups.delay.start") == 0) - { + { #if (defined HAVE_PRAGMA_GCC_DIAGNOSTIC_PUSH_POP) && ( (defined HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_TYPE_LIMITS) || (defined HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE) || defined (HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_TAUTOLOGICAL_COMPARE) ) # pragma GCC diagnostic push #endif @@ -828,10 +843,10 @@ int setvar(const char *varname, const char *val) dstate_setinfo("ups.delay.start", "%u", ups.WakeUpDelay); dstate_dataok(); return STAT_SET_HANDLED; - } + } if (strcasecmp(varname, "ups.delay.shutdown") == 0) - { + { #if (defined HAVE_PRAGMA_GCC_DIAGNOSTIC_PUSH_POP) && ( (defined HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_TYPE_LIMITS) || (defined HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE) || defined (HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_TAUTOLOGICAL_COMPARE) ) # pragma GCC diagnostic push #endif @@ -862,8 +877,9 @@ int setvar(const char *varname, const char *val) dstate_setinfo("ups.delay.shutdown", "%u", ups.ShutdownDelay); dstate_dataok(); return STAT_SET_HANDLED; - } + } + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } #if (defined HAVE_PRAGMA_GCC_DIAGNOSTIC_PUSH_POP_BESIDEFUNC) && (!defined HAVE_PRAGMA_GCC_DIAGNOSTIC_PUSH_POP_INSIDEFUNC) && ( (defined HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_TYPE_LIMITS_BESIDEFUNC) || (defined HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE_BESIDEFUNC) || defined (HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_TAUTOLOGICAL_COMPARE_BESIDEFUNC) ) diff --git a/drivers/microsol-common.c b/drivers/microsol-common.c index 0d970b72e7..7e7b8ac6e4 100644 --- a/drivers/microsol-common.c +++ b/drivers/microsol-common.c @@ -660,19 +660,25 @@ static void get_updated_info(void) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + /* Power-cycle UPS */ if (!strcasecmp(cmdname, "shutdown.return")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); ser_send_char(upsfd, CMD_SHUTRET); /* 0xDE */ return STAT_INSTCMD_HANDLED; } /* Power-off UPS */ if (!strcasecmp(cmdname, "shutdown.stayoff")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); ser_send_char(upsfd, CMD_SHUT); /* 0xDD */ return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/netxml-ups.c b/drivers/netxml-ups.c index 072e1e3de6..fefde6add5 100644 --- a/drivers/netxml-ups.c +++ b/drivers/netxml-ups.c @@ -42,7 +42,7 @@ #include "nut_stdint.h" #define DRIVER_NAME "network XML UPS" -#define DRIVER_VERSION "0.47" +#define DRIVER_VERSION "0.48" /** *_OBJECT query multi-part body boundary */ #define FORM_POST_BOUNDARY "NUT-NETXML-UPS-OBJECTS" @@ -486,14 +486,21 @@ void upsdrv_shutdown(void) { static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + + /* FIXME: shutdown per above? */ + /* if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); ser_send_buf(upsfd, ...); return STAT_INSTCMD_HANDLED; } */ - upslogx(LOG_NOTICE, "%s: unknown command [%s] [%s]", __func__, cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -503,6 +510,8 @@ static int setvar(const char *varname, const char *val) { object_query_t *resp = NULL; object_query_t *req = NULL; + upsdebug_SET_STARTING(varname, val); + /* Pragmatic do { ... } while (0) loop allowing break to cleanup */ do { /* Create SET_OBJECT request */ @@ -522,6 +531,7 @@ static int setvar(const char *varname, const char *val) { /* Check if setting was done */ if (1 > object_query_size(resp)) { + upslog_SET_UNKNOWN(varname, val); status = STAT_SET_UNKNOWN; break; @@ -538,6 +548,8 @@ static int setvar(const char *varname, const char *val) { if (NULL != resp) object_query_destroy(resp); + if (status == STAT_SET_FAILED) + upslog_SET_FAILED(varname, val); return status; } diff --git a/drivers/nut-ipmipsu.c b/drivers/nut-ipmipsu.c index 9e978ee845..aa56464a1b 100644 --- a/drivers/nut-ipmipsu.c +++ b/drivers/nut-ipmipsu.c @@ -27,7 +27,7 @@ #include "nut-ipmi.h" #define DRIVER_NAME "IPMI PSU driver" -#define DRIVER_VERSION "0.34" +#define DRIVER_VERSION "0.35" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -170,12 +170,17 @@ void upsdrv_shutdown(void) /* static int instcmd(const char *cmdname, const char *extra) { + / * May be used in logging below, but not as a command argument * / + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); ser_send_buf(upsfd, ...); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s]", cmdname); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } */ @@ -183,12 +188,14 @@ static int instcmd(const char *cmdname, const char *extra) /* static int setvar(const char *varname, const char *val) { - if (!strcasecmp(varname, "ups.test.interval")) { + upsdebug_SET_STARTING(varname, val); + + if (!strcasecmp(varname, "ups.test.interval")) { ser_send_buf(upsfd, ...); return STAT_SET_HANDLED; } - upslogx(LOG_NOTICE, "setvar: unknown variable [%s]", varname); + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } */ diff --git a/drivers/nutdrv_atcl_usb.c b/drivers/nutdrv_atcl_usb.c index f0e57675c2..951514784e 100644 --- a/drivers/nutdrv_atcl_usb.c +++ b/drivers/nutdrv_atcl_usb.c @@ -28,7 +28,7 @@ /* driver version */ #define DRIVER_NAME "'ATCL FOR UPS' USB driver" -#define DRIVER_VERSION "1.19" +#define DRIVER_VERSION "1.20" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -661,7 +661,9 @@ void upsdrv_updateinfo(void) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); /* FIXME: Which one is this - "load.off", * "shutdown.stayoff" or "shutdown.return"? */ @@ -681,6 +683,7 @@ int instcmd(const char *cmdname, const char *extra) "%s: attempting to call usb_interrupt_write(01 00 00 00 00 00 00 00)", __func__); + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); ret = usb_interrupt_write(udev, SHUTDOWN_ENDPOINT, (usb_ctrl_charbuf)shutdown_packet, SHUTDOWN_PACKETSIZE, ATCL_USB_TIMEOUT); @@ -711,7 +714,7 @@ int instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/nutdrv_hashx.c b/drivers/nutdrv_hashx.c index d2d84e9856..33f187baa9 100644 --- a/drivers/nutdrv_hashx.c +++ b/drivers/nutdrv_hashx.c @@ -36,7 +36,7 @@ #define IGNCHARS "" #define DRIVER_NAME "Generic #* Serial driver" -#define DRIVER_VERSION "0.01" +#define DRIVER_VERSION "0.02" #define SESSION_ID "OoNUTisAMAZINGoO" #define SESSION_HASH "74279F35A48F5F13" @@ -606,6 +606,10 @@ static int hashx_instcmd(const char *cmd_name, const char *extra) { size_t i; + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmd_name, extra); + for (i = 0; i < sizeof (hashx_cmd) / sizeof (*hashx_cmd); ++i) { int status; @@ -613,15 +617,16 @@ static int hashx_instcmd(const char *cmd_name, const char *extra) continue; } + upslog_INSTCMD_POWERSTATE_CHECKED(cmd_name, extra); if ((status = hashx_send_command(hashx_cmd[i].ups_cmd)) == STATUS_SUCCESS) return STAT_INSTCMD_HANDLED; - upslogx(LOG_ERR, "Failed to execute command [%s] [%s]: %d", - cmd_name, extra, status); + upslogx(LOG_INSTCMD_FAILED, "Failed to execute command [%s] [%s]: %d", + NUT_STRARG(cmd_name), NUT_STRARG(extra), status); return STAT_INSTCMD_FAILED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmd_name, extra); + upslog_INSTCMD_UNKNOWN(cmd_name, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/nutdrv_qx.c b/drivers/nutdrv_qx.c index b0efad6701..e649424a47 100644 --- a/drivers/nutdrv_qx.c +++ b/drivers/nutdrv_qx.c @@ -58,7 +58,7 @@ # define DRIVER_NAME "Generic Q* Serial driver" #endif /* QX_USB */ -#define DRIVER_VERSION "0.43" +#define DRIVER_VERSION "0.44" #ifdef QX_SERIAL # include "serial.h" @@ -2462,8 +2462,12 @@ int instcmd(const char *cmdname, const char *extradata) return instcmd("beeper.enable", NULL); } + upsdebug_INSTCMD_STARTING(cmdname, extradata); + + /* Historically we did user-visible LOG_INFO in this driver + * with this markup, so we still do */ upslogx(LOG_INFO, "%s(%s, %s)", - __func__, cmdname, + __func__, NUT_STRARG(cmdname), extradata ? extradata : "[NULL]"); /* Retrieve item by command name */ @@ -2471,6 +2475,7 @@ int instcmd(const char *cmdname, const char *extradata) /* Check for fallback if not found */ if (item == NULL) { + /* Process aliases/fallbacks */ if (!strcasecmp(cmdname, "load.on")) { return instcmd("load.on.delay", "0"); @@ -2487,7 +2492,7 @@ int instcmd(const char *cmdname, const char *extradata) /* Ensure "ups.start.auto" is set to "yes", if supported */ if (dstate_getinfo("ups.start.auto")) { if (setvar("ups.start.auto", "yes") != STAT_SET_HANDLED) { - upslogx(LOG_ERR, "%s: FAILED", __func__); + upslogx(LOG_INSTCMD_FAILED, "%s: FAILED", __func__); return STAT_INSTCMD_FAILED; } } @@ -2509,7 +2514,7 @@ int instcmd(const char *cmdname, const char *extradata) /* Ensure "ups.start.auto" is set to "no", if supported */ if (dstate_getinfo("ups.start.auto")) { if (setvar("ups.start.auto", "no") != STAT_SET_HANDLED) { - upslogx(LOG_ERR, "%s: FAILED", __func__); + upslogx(LOG_INSTCMD_FAILED, "%s: FAILED", __func__); return STAT_INSTCMD_FAILED; } } @@ -2538,7 +2543,7 @@ int instcmd(const char *cmdname, const char *extradata) && item->preprocess(item, value, sizeof(value)) ) { /* Something went wrong */ - upslogx(LOG_ERR, "%s: FAILED", __func__); + upslogx(LOG_INSTCMD_FAILED, "%s: FAILED", __func__); return STAT_INSTCMD_FAILED; } @@ -2547,9 +2552,10 @@ int instcmd(const char *cmdname, const char *extradata) snprintf(value, sizeof(value), "%s", ""); /* Send the command, get the reply */ + upslog_INSTCMD_POWERSTATE_CHECKED(cmdname, extradata); if (qx_process(item, strlen(value) > 0 ? value : NULL)) { /* Something went wrong */ - upslogx(LOG_ERR, "%s: FAILED", __func__); + upslogx(LOG_INSTCMD_FAILED, "%s: FAILED", __func__); return STAT_INSTCMD_FAILED; } @@ -2568,7 +2574,7 @@ int instcmd(const char *cmdname, const char *extradata) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_ERR, "%s: FAILED", __func__); + upslogx(LOG_INSTCMD_FAILED, "%s: FAILED", __func__); return STAT_INSTCMD_FAILED; } @@ -2588,6 +2594,8 @@ int setvar(const char *varname, const char *val) st_tree_t *root = (st_tree_t *)dstate_getroot(); int ok = 0; + upsdebug_SET_STARTING(varname, val); + /* Retrieve variable */ item = find_nut_info(varname, QX_FLAG_SETVAR, QX_FLAG_SKIP); @@ -2625,7 +2633,8 @@ int setvar(const char *varname, const char *val) strlen(val) ? val : "[NULL]"); if (!strlen(val)) { - upslogx(LOG_ERR, "%s: value not given for %s", + /* FIXME: ..._INVALID? ..._CONVERSION_FAILED? */ + upslogx(LOG_SET_UNKNOWN, "%s: value not given for %s", __func__, item->info_type); return STAT_SET_UNKNOWN; /* TODO: HANDLED but FAILED, not UNKNOWN! */ } @@ -2647,7 +2656,8 @@ int setvar(const char *varname, const char *val) long valuetoset, min, max; if (strspn(value, "0123456789 .") != strlen(value)) { - upslogx(LOG_ERR, "%s: non numerical value [%s: %s]", + /* FIXME: ..._CONVERSION_FAILED? */ + upslogx(LOG_SET_UNKNOWN, "%s: non numerical value [%s: %s]", __func__, item->info_type, value); return STAT_SET_UNKNOWN; /* TODO: HANDLED but FAILED, not UNKNOWN! */ } @@ -2661,7 +2671,8 @@ int setvar(const char *varname, const char *val) info_rw_t *rvalue; if (!strlen(value)) { - upslogx(LOG_ERR, "%s: value not given for %s", + /* FIXME: ..._INVALID? ..._CONVERSION_FAILED? */ + upslogx(LOG_SET_UNKNOWN, "%s: value not given for %s", __func__, item->info_type); return STAT_SET_UNKNOWN; /* TODO: HANDLED but FAILED, not UNKNOWN! */ } @@ -2724,7 +2735,8 @@ int setvar(const char *varname, const char *val) } if (!ok) { - upslogx(LOG_ERR, "%s: value out of range [%s: %s]", + /* FIXME: ..._INVALID? ..._CONVERSION_FAILED? */ + upslogx(LOG_SET_UNKNOWN, "%s: value out of range [%s: %s]", __func__, item->info_type, value); return STAT_SET_UNKNOWN; /* TODO: HANDLED but FAILED, not UNKNOWN! */ } @@ -2739,7 +2751,8 @@ int setvar(const char *varname, const char *val) info_rw_t *envalue; if (!strlen(value)) { - upslogx(LOG_ERR, "%s: value not given for %s", + /* FIXME: ..._INVALID? ..._CONVERSION_FAILED? */ + upslogx(LOG_SET_UNKNOWN, "%s: value not given for %s", __func__, item->info_type); return STAT_SET_UNKNOWN; /* TODO: HANDLED but FAILED, not UNKNOWN! */ } @@ -2791,7 +2804,8 @@ int setvar(const char *varname, const char *val) } if (!ok) { - upslogx(LOG_ERR, "%s: value out of range [%s: %s]", + /* FIXME: ..._INVALID? ..._CONVERSION_FAILED? */ + upslogx(LOG_SET_UNKNOWN, "%s: value out of range [%s: %s]", __func__, item->info_type, value); return STAT_SET_UNKNOWN; /* TODO: HANDLED but FAILED, not UNKNOWN! */ } @@ -2813,7 +2827,8 @@ int setvar(const char *varname, const char *val) * even on architectures with a moderate INTMAX */ if (aux < (int)strlen(value)) { - upslogx(LOG_ERR, "%s: value is too long [%s: %s]", + /* FIXME: ..._INVALID? ..._CONVERSION_FAILED? */ + upslogx(LOG_SET_UNKNOWN, "%s: value is too long [%s: %s]", __func__, item->info_type, value); return STAT_SET_UNKNOWN; /* TODO: HANDLED but FAILED, not UNKNOWN! */ } @@ -2825,7 +2840,8 @@ int setvar(const char *varname, const char *val) && item->preprocess(item, value, sizeof(value)) ) { /* Something went wrong */ - upslogx(LOG_ERR, "%s: FAILED", __func__); + /* FIXME: Actually ..._FAILED? */ + upslogx(LOG_SET_UNKNOWN, "%s: FAILED", __func__); return STAT_SET_UNKNOWN; /* TODO: HANDLED but FAILED, not UNKNOWN! */ } @@ -2845,7 +2861,8 @@ int setvar(const char *varname, const char *val) /* Actual variable setting */ if (qx_process(item, strlen(value) > 0 ? value : NULL)) { /* Something went wrong */ - upslogx(LOG_ERR, "%s: FAILED", __func__); + /* FIXME: Actually ..._FAILED? */ + upslogx(LOG_SET_UNKNOWN, "%s: FAILED", __func__); return STAT_SET_UNKNOWN; /* TODO: HANDLED but FAILED, not UNKNOWN! */ } @@ -2863,7 +2880,8 @@ int setvar(const char *varname, const char *val) return STAT_SET_HANDLED; } - upslogx(LOG_ERR, "%s: FAILED", __func__); + /* FIXME: Actually ..._FAILED? */ + upslogx(LOG_SET_UNKNOWN, "%s: FAILED", __func__); return STAT_SET_UNKNOWN; /* TODO: HANDLED but FAILED, not UNKNOWN! */ } diff --git a/drivers/nutdrv_qx_blazer-common.c b/drivers/nutdrv_qx_blazer-common.c index 63d142d593..1fe00226dc 100644 --- a/drivers/nutdrv_qx_blazer-common.c +++ b/drivers/nutdrv_qx_blazer-common.c @@ -191,6 +191,8 @@ void blazer_initups_light(item_t *qx2nut) /* Preprocess setvars */ int blazer_process_setvar(item_t *item, char *value, const size_t valuelen) { + /* upsdebug_SET_STARTING(item->info_type, value); */ + if (!strlen(value)) { upsdebugx(2, "%s: value not given for %s", __func__, item->info_type); return -1; @@ -231,7 +233,8 @@ int blazer_process_setvar(item_t *item, char *value, const size_t valuelen) } else { - /* Don't know what happened */ + /* Don't know what happened: unknown entry for pre-processing? */ + /* upslog_SET_UNKNOWN(item->info_type, value); */ return -1; } @@ -242,6 +245,8 @@ int blazer_process_setvar(item_t *item, char *value, const size_t valuelen) /* Preprocess instant commands */ int blazer_process_command(item_t *item, char *value, const size_t valuelen) { + /* upsdebug_INSTCMD_STARTING(item->info_type, value); */ + if (!strcasecmp(item->info_type, "shutdown.return")) { /* Sn: Shutdown after n minutes and then turn on when mains is back @@ -351,7 +356,8 @@ int blazer_process_command(item_t *item, char *value, const size_t valuelen) } else { - /* Don't know what happened */ + /* Don't know what happened: unknown entry for pre-processing? */ + /* upslog_INSTCMD_UNKNOWN(item->info_type, value); */ return -1; } diff --git a/drivers/nutdrv_qx_voltronic.c b/drivers/nutdrv_qx_voltronic.c index 706e5757e1..08cdf21534 100644 --- a/drivers/nutdrv_qx_voltronic.c +++ b/drivers/nutdrv_qx_voltronic.c @@ -1863,6 +1863,8 @@ static int voltronic_process_setvar(item_t *item, char *value, const size_t valu { double val; + /* upsdebug_SET_STARTING(item->info_type, value); */ + if (!strlen(value)) { upsdebugx(2, "%s: value not given for %s", __func__, item->info_type); return -1; @@ -1939,6 +1941,8 @@ static int voltronic_process_command(item_t *item, char *value, const size_t val { char buf[SMALLBUF] = ""; + /* upsdebug_INSTCMD_STARTING(item->info_type, value); */ + if (!strcasecmp(item->info_type, "shutdown.return")) { /* Sn: Shutdown after n minutes and then turn on when mains is back @@ -2060,7 +2064,8 @@ static int voltronic_process_command(item_t *item, char *value, const size_t val } else { - /* Don't know what happened */ + /* Don't know what happened: unknown entry for pre-processing? */ + /* upslog_INSTCMD_UNKNOWN(item->info_type, value); */ return -1; } diff --git a/drivers/nutdrv_siemens_sitop.c b/drivers/nutdrv_siemens_sitop.c index 0029ed0eb0..811365b578 100644 --- a/drivers/nutdrv_siemens_sitop.c +++ b/drivers/nutdrv_siemens_sitop.c @@ -56,7 +56,7 @@ #include "nut_stdint.h" #define DRIVER_NAME "Siemens SITOP UPS500 series driver" -#define DRIVER_VERSION "0.06" +#define DRIVER_VERSION "0.07" #define RX_BUFFER_SIZE 100 @@ -160,6 +160,10 @@ static int check_for_new_data(void) { static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + /* Note: the UPS does not really like to receive data. * For example, sending an "R" without \n hangs the serial port. * In that situation, the UPS will no longer send any status updates. @@ -168,19 +172,21 @@ static int instcmd(const char *cmdname, const char *extra) { * lost as well. */ if (!strcasecmp(cmdname, "shutdown.return")) { - upslogx(LOG_NOTICE, "instcmd: sending command R"); + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + upsdebugx(1, "instcmd: sending command R"); ser_send_pace(upsfd, 200000, "\n\nR\n\n"); ser_send_pace(upsfd, 200000, "R\n\n"); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.stayoff")) { - upslogx(LOG_NOTICE, "instcmd: sending command S"); + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + upsdebugx(1, "instcmd: sending command S"); ser_send_pace(upsfd, 200000, "\n\nS\n\n"); ser_send_pace(upsfd, 200000, "S\n\n"); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/oneac.c b/drivers/oneac.c index a534ddbff9..c23b38a5b0 100644 --- a/drivers/oneac.c +++ b/drivers/oneac.c @@ -48,7 +48,7 @@ int setcmd(const char* varname, const char* setvalue); int instcmd(const char *cmdname, const char *extra); #define DRIVER_NAME "Oneac EG/ON/OZ/OB UPS driver" -#define DRIVER_VERSION "0.84" +#define DRIVER_VERSION "0.85" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -853,14 +853,18 @@ int instcmd(const char *cmdname, const char *extra) { int i; - upsdebugx(2, "In instcmd with %s and extra %s.", cmdname, extra); + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); if (!strcasecmp(cmdname, "test.failure.start")) { - ser_send(upsfd,"%s%s",SIM_PWR_FAIL,COMMAND_END); + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + ser_send(upsfd, "%s%s", SIM_PWR_FAIL, COMMAND_END); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.return")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); i = atoi(dstate_getinfo("ups.delay.shutdown")); @@ -868,84 +872,89 @@ int instcmd(const char *cmdname, const char *extra) (strncmp (UpsFamily, FAMILY_OB, FAMILY_SIZE) == 0)) { upsdebugx(3, "Shutdown using %c%d...", DELAYED_SHUTDOWN_PREFIX, i); - ser_send(upsfd,"%c%d%s",DELAYED_SHUTDOWN_PREFIX, i, COMMAND_END); + ser_send(upsfd, "%c%d%s", DELAYED_SHUTDOWN_PREFIX, i, COMMAND_END); } else { upsdebugx(3, "Shutdown using %c%03d...",DELAYED_SHUTDOWN_PREFIX, i); - ser_send(upsfd,"%c%03d%s",DELAYED_SHUTDOWN_PREFIX, i, COMMAND_END); + ser_send(upsfd, "%c%03d%s", DELAYED_SHUTDOWN_PREFIX, i, COMMAND_END); } return STAT_INSTCMD_HANDLED; } - if(!strcasecmp(cmdname, "shutdown.reboot")) { + if (!strcasecmp(cmdname, "shutdown.reboot")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); ser_send(upsfd, "%s", SHUTDOWN); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.stop")) { - ser_send(upsfd,"%c%s",DELAYED_SHUTDOWN_PREFIX,COMMAND_END); + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + ser_send(upsfd, "%c%s", DELAYED_SHUTDOWN_PREFIX, COMMAND_END); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "test.battery.start.quick")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); do_battery_test(); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "test.battery.start.deep")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); ser_send(upsfd, "%s%s", TEST_BATT_DEEP, COMMAND_END); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); if ((strncmp (UpsFamily, FAMILY_EG, FAMILY_SIZE) == 0) || (strncmp (UpsFamily, FAMILY_ON, FAMILY_SIZE) == 0)) { - ser_send(upsfd,"%s00%s",BAT_TEST_PREFIX,COMMAND_END); + ser_send(upsfd, "%s00%s", BAT_TEST_PREFIX, COMMAND_END); } else { - ser_send(upsfd,"%c%s",TEST_ABORT,COMMAND_END); + ser_send(upsfd, "%c%s", TEST_ABORT, COMMAND_END); } return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "reset.input.minmax")) { - ser_send(upsfd,"%c%s",RESET_MIN_MAX, COMMAND_END); + ser_send(upsfd, "%c%s", RESET_MIN_MAX, COMMAND_END); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "beeper.enable")) { - ser_send(upsfd,"%c%c%s",SETX_BUZZER_PREFIX, BUZZER_ENABLED,COMMAND_END); + ser_send(upsfd, "%c%c%s", SETX_BUZZER_PREFIX, BUZZER_ENABLED, COMMAND_END); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "beeper.disable")) { - ser_send(upsfd,"%c%c%s",SETX_BUZZER_PREFIX,BUZZER_DISABLED,COMMAND_END); + ser_send(upsfd, "%c%c%s", SETX_BUZZER_PREFIX, BUZZER_DISABLED, COMMAND_END); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "beeper.mute")) { - ser_send(upsfd,"%c%c%s",SETX_BUZZER_PREFIX, BUZZER_MUTED, COMMAND_END); + ser_send(upsfd, "%c%c%s", SETX_BUZZER_PREFIX, BUZZER_MUTED, COMMAND_END); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "test.panel.start")) { - ser_send(upsfd,"%s%s",TEST_INDICATORS, COMMAND_END); + ser_send(upsfd, "%s%s", TEST_INDICATORS, COMMAND_END); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s]", cmdname); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } int setcmd(const char* varname, const char* setvalue) { - upsdebugx(2, "In setcmd for %s with %s...", varname, setvalue); + upsdebug_SET_STARTING(varname, setvalue); if (!strcasecmp(varname, "ups.delay.shutdown")) { @@ -954,6 +963,7 @@ int setcmd(const char* varname, const char* setvalue) { if (atoi(setvalue) > 65535) { + /* FIXME: ..._INVALID? ..._CONVERSION_FAILED? */ upsdebugx(2, "Too big for OZ/OB (>65535)...(%s)", setvalue); return STAT_SET_UNKNOWN; } @@ -962,6 +972,7 @@ int setcmd(const char* varname, const char* setvalue) { if (atoi(setvalue) > 999) { + /* FIXME: ..._INVALID? ..._CONVERSION_FAILED? */ upsdebugx(2, "Too big for EG/ON (>999)...(%s)", setvalue); return STAT_SET_UNKNOWN; } @@ -1059,7 +1070,6 @@ int setcmd(const char* varname, const char* setvalue) return STAT_SET_UNKNOWN; } - upslogx(LOG_NOTICE, "setcmd: unknown command [%s]", varname); - + upslog_SET_UNKNOWN(varname, setvalue); return STAT_SET_UNKNOWN; } diff --git a/drivers/optiups.c b/drivers/optiups.c index f1fbb79efe..12765aac62 100644 --- a/drivers/optiups.c +++ b/drivers/optiups.c @@ -28,7 +28,7 @@ #include "nut_stdint.h" #define DRIVER_NAME "Opti-UPS driver" -#define DRIVER_VERSION "1.07" +#define DRIVER_VERSION "1.08" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -234,8 +234,13 @@ static void optifill( ezfill_t *a, size_t len ) /* Handle custom (but standardized) NUT commands */ static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "test.failure.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); optiquery( "Ts" ); return STAT_INSTCMD_HANDLED; } @@ -244,6 +249,7 @@ static int instcmd(const char *cmdname, const char *extra) /* You do realize this will kill power to ourself. * Would probably only be useful for killing power for * a computer with upsmon in "secondary" mode */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); if ( optimodel == OPTIMODEL_ZINTO ) { optiquery( "Ct1" ); @@ -257,6 +263,7 @@ static int instcmd(const char *cmdname, const char *extra) } else if (!strcasecmp(cmdname, "load.on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); if ( optimodel == OPTIMODEL_ZINTO ) { optiquery( "Ct1" ); @@ -272,6 +279,7 @@ static int instcmd(const char *cmdname, const char *extra) { /* This shuts down the UPS. When the power returns to the UPS, * it will power back up in its default state. */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); if ( optimodel == OPTIMODEL_ZINTO ) { optiquery( "Ct1" ); @@ -288,6 +296,7 @@ static int instcmd(const char *cmdname, const char *extra) /* This actually stays off as long as the batteries hold, * if the line power comes back before the batteries die, * the UPS will never powerup its output stage!!! */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); if ( optimodel == OPTIMODEL_ZINTO ) { optiquery( "Ct1" ); @@ -301,11 +310,12 @@ static int instcmd(const char *cmdname, const char *extra) else if (!strcasecmp(cmdname, "shutdown.stop")) { /* Aborts a shutdown that is counting down via the Cs command */ + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); optiquery( "Cs-0000001" ); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -314,6 +324,8 @@ static int setvar(const char *varname, const char *val) { int status; + upsdebug_SET_STARTING(varname, val); + if (sscanf(val, "%d", &status) != 1) { return STAT_SET_UNKNOWN; } @@ -326,6 +338,7 @@ static int setvar(const char *varname, const char *val) return STAT_SET_HANDLED; } + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } diff --git a/drivers/pijuice.c b/drivers/pijuice.c index 0ac56c8fb6..f6305296e7 100644 --- a/drivers/pijuice.c +++ b/drivers/pijuice.c @@ -23,7 +23,7 @@ #include "nut_stdint.h" #define DRIVER_NAME "PiJuice UPS driver" -#define DRIVER_VERSION "0.13" +#define DRIVER_VERSION "0.14" /* * Linux I2C userland is a bit of a mess until distros refresh to @@ -833,19 +833,23 @@ void upsdrv_updateinfo(void) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); /* FIXME: Which one is this - "load.off", * "shutdown.stayoff" or "shutdown.return"? */ /* Shutdown UPS */ if (!strcasecmp(cmdname, "shutdown.stayoff")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + set_power_off(); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/powercom.c b/drivers/powercom.c index acd61139bc..df6920eed3 100644 --- a/drivers/powercom.c +++ b/drivers/powercom.c @@ -86,7 +86,7 @@ #include "nut_float.h" #define DRIVER_NAME "PowerCom protocol UPS driver" -#define DRIVER_VERSION "0.24" +#define DRIVER_VERSION "0.25" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -317,23 +317,30 @@ static void shutdown_ret(void) /* registered instant commands */ static int instcmd (const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "test.battery.start")) { - ser_send_char (upsfd, BATTERY_TEST); - return STAT_INSTCMD_HANDLED; + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + ser_send_char (upsfd, BATTERY_TEST); + return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.return")) { /* NOTE: In this context, "return" is UPS behavior after the * wall-power gets restored. The routine exits the driver anyway. */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); shutdown_ret(); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.stayoff")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); shutdown_halt(); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/powerman-pdu.c b/drivers/powerman-pdu.c index db6bee3f5b..b760a6369e 100644 --- a/drivers/powerman-pdu.c +++ b/drivers/powerman-pdu.c @@ -23,7 +23,7 @@ #include /* pm_err_t and other beasts */ #define DRIVER_NAME "Powerman PDU client driver" -#define DRIVER_VERSION "0.15" +#define DRIVER_VERSION "0.16" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -54,7 +54,9 @@ static int instcmd(const char *cmdname, const char *extra) char *cmdindex = NULL; char outletname[SMALLBUF]; - upsdebugx(1, "entering instcmd (%s)", cmdname); + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); /* only consider the end of the command */ if ( (cmdsuffix = strrchr(cmdname, '.')) == NULL ) @@ -74,23 +76,26 @@ static int instcmd(const char *cmdname, const char *extra) /* Power on the outlet */ if (!strcasecmp(cmdsuffix, "on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); rv = pm_node_on(pm, outletname); return (rv==PM_ESUCCESS)?STAT_INSTCMD_HANDLED:STAT_INSTCMD_INVALID; } /* Power off the outlet */ if (!strcasecmp(cmdsuffix, "off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); rv = pm_node_off(pm, outletname); return (rv==PM_ESUCCESS)?STAT_INSTCMD_HANDLED:STAT_INSTCMD_INVALID; } /* Cycle the outlet */ if (!strcasecmp(cmdsuffix, "cycle")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); rv = pm_node_cycle(pm, outletname); return (rv==PM_ESUCCESS)?STAT_INSTCMD_HANDLED:STAT_INSTCMD_INVALID; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -99,7 +104,7 @@ void upsdrv_updateinfo(void) pm_err_t rv = PM_ESUCCESS; if ( (rv = query_all(pm, WALKMODE_UPDATE)) != PM_ESUCCESS) { - upslogx(2, "Error: %s (%i)\n", pm_strerror(rv, ebuf, sizeof(ebuf)), errno); + upsdebugx(2, "Error: %s (%i)\n", pm_strerror(rv, ebuf, sizeof(ebuf)), errno); /* FIXME: try to reconnect? * dstate_datastale(); */ @@ -122,7 +127,7 @@ void upsdrv_initinfo(void) /* Now walk the data tree */ if ( (rv = query_all(pm, WALKMODE_INIT)) != PM_ESUCCESS) { - upslogx(2, "Error: %s\n", pm_strerror(rv, ebuf, sizeof(ebuf))); + upsdebugx(2, "Error: %s\n", pm_strerror(rv, ebuf, sizeof(ebuf))); /* FIXME: try to reconnect? * dstate_datastale(); */ @@ -163,12 +168,14 @@ void upsdrv_shutdown(void) /* static int setvar(const char *varname, const char *val) { + upsdebug_SET_STARTING(varname, val); + if (!strcasecmp(varname, "outlet.n.delay.*")) { ... return STAT_SET_HANDLED; } - upslogx(LOG_NOTICE, "setvar: unknown variable [%s]", varname); + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } */ diff --git a/drivers/powerp-bin.c b/drivers/powerp-bin.c index 2ac906a8fa..f7e01238da 100644 --- a/drivers/powerp-bin.c +++ b/drivers/powerp-bin.c @@ -36,7 +36,7 @@ #include -#define POWERPANEL_BIN_VERSION "Powerpanel-Binary 0.62" +#define POWERPANEL_BIN_VERSION "Powerpanel-Binary 0.64" typedef struct { unsigned char start; @@ -260,6 +260,10 @@ static int powpan_instcmd(const char *cmdname, const char *extra) { int i; + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + for (i = 0; cmdtab[i].cmd != NULL; i++) { ssize_t ret; @@ -267,6 +271,7 @@ static int powpan_instcmd(const char *cmdname, const char *extra) continue; } + upslog_INSTCMD_POWERSTATE_CHECKED(cmdname, extra); ret = powpan_command(cmdtab[i].command, cmdtab[i].len); assert(cmdtab[i].len < SSIZE_MAX); if (ret >= 0 && @@ -276,11 +281,11 @@ static int powpan_instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_ERR, "%s: command [%s] [%s] failed", __func__, cmdname, extra); + upslog_INSTCMD_FAILED(cmdname, extra); return STAT_INSTCMD_FAILED; } - upslogx(LOG_ERR, "%s: command [%s] not found", __func__, cmdname); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -289,6 +294,8 @@ static int powpan_setvar(const char *varname, const char *val) char command[SMALLBUF]; int i, j; + upsdebug_SET_STARTING(varname, val); + for (i = 0; vartab[i].var != NULL; i++) { if (strcasecmp(varname, vartab[i].var)) { @@ -314,15 +321,15 @@ static int powpan_setvar(const char *varname, const char *val) return STAT_SET_HANDLED; } - upslogx(LOG_ERR, "powpan_setvar: setting variable [%s] to [%s] failed", varname, val); - return STAT_SET_UNKNOWN; + upslog_SET_FAILED(varname, val); + return STAT_SET_UNKNOWN; /* FIXME: ..._FAILED ? */ } - upslogx(LOG_ERR, "powpan_setvar: [%s] is not valid for variable [%s]", val, varname); - return STAT_SET_UNKNOWN; + upslog_SET_INVALID(varname, val); + return STAT_SET_UNKNOWN; /* FIXME: ..._INVALID? */ } - upslogx(LOG_ERR, "powpan_setvar: variable [%s] not found", varname); + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } diff --git a/drivers/powerp-txt.c b/drivers/powerp-txt.c index 406526a3e5..7f32d89cf7 100644 --- a/drivers/powerp-txt.c +++ b/drivers/powerp-txt.c @@ -36,7 +36,7 @@ #include -#define POWERPANEL_TEXT_VERSION "Powerpanel-Text 0.63" +#define POWERPANEL_TEXT_VERSION "Powerpanel-Text 0.64" typedef struct { float i_volt; @@ -146,40 +146,48 @@ static int powpan_instcmd(const char *cmdname, const char *extra) return powpan_instcmd("beeper.enable", NULL); } + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + for (i = 0; cmdtab[i].cmd != NULL; i++) { if (strcasecmp(cmdname, cmdtab[i].cmd)) { continue; } + upslog_INSTCMD_POWERSTATE_CHECKED(cmdname, extra); if ((powpan_command(cmdtab[i].command) == 2) && (!strcasecmp(powpan_answer, "#0"))) { return STAT_INSTCMD_HANDLED; } - upslogx(LOG_ERR, "%s: command [%s] [%s] failed", __func__, cmdname, extra); + upslog_INSTCMD_FAILED(cmdname, extra); return STAT_INSTCMD_FAILED; } if (!strcasecmp(cmdname, "shutdown.return")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); if (offdelay < 60) { snprintf(command, sizeof(command), "Z.%ld\r", offdelay / 6); } else { snprintf(command, sizeof(command), "Z%02ld\r", offdelay / 60); } } else if (!strcasecmp(cmdname, "shutdown.stayoff")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); if (offdelay < 60) { snprintf(command, sizeof(command), "S.%ld\r", offdelay / 6); } else { snprintf(command, sizeof(command), "S%02ld\r", offdelay / 60); } } else if (!strcasecmp(cmdname, "shutdown.reboot")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); if (offdelay < 60) { snprintf(command, sizeof(command), "S.%ldR%04ld\r", offdelay / 6, ondelay); } else { snprintf(command, sizeof(command), "S%02ldR%04ld\r", offdelay / 60, ondelay); } } else { - upslogx(LOG_NOTICE, "%s: command [%s] [%s] unknown", __func__, cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -187,7 +195,7 @@ static int powpan_instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_ERR, "%s: command [%s] [%s] failed", __func__, cmdname, extra); + upslog_INSTCMD_FAILED(cmdname, extra); return STAT_INSTCMD_FAILED; } @@ -196,6 +204,8 @@ static int powpan_setvar(const char *varname, const char *val) char command[SMALLBUF]; int i; + upsdebug_SET_STARTING(varname, val); + for (i = 0; vartab[i].var != NULL; i++) { if (strcasecmp(varname, vartab[i].var)) { @@ -214,11 +224,11 @@ static int powpan_setvar(const char *varname, const char *val) return STAT_SET_HANDLED; } - upslogx(LOG_ERR, "%s: setting variable [%s] to [%s] failed", __func__, varname, val); - return STAT_SET_UNKNOWN; + upslog_SET_FAILED(varname, val); + return STAT_SET_UNKNOWN; /* FIXME: ..._FAILED? */ } - upslogx(LOG_ERR, "%s: variable [%s] not found", __func__, varname); + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } diff --git a/drivers/rhino.c b/drivers/rhino.c index 60346ed806..b7af3f74f5 100644 --- a/drivers/rhino.c +++ b/drivers/rhino.c @@ -38,7 +38,7 @@ #include "timehead.h" #define DRIVER_NAME "Microsol Rhino UPS driver" -#define DRIVER_VERSION "0.55" +#define DRIVER_VERSION "0.56" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -656,9 +656,14 @@ static int instcmd(const char *cmdname, const char *extra) { ssize_t ret = 0; + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "shutdown.stayoff")) { /* shutdown now (one way) */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); /* send_command( CMD_SHUT ); */ sendshut(); return STAT_INSTCMD_HANDLED; @@ -667,6 +672,7 @@ static int instcmd(const char *cmdname, const char *extra) if (!strcasecmp(cmdname, "load.on")) { /* liga Saida */ + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); ret = send_command( 3 ); if ( ret < 1 ) upslogx(LOG_ERR, "send_command 3 failed"); @@ -676,6 +682,7 @@ static int instcmd(const char *cmdname, const char *extra) if (!strcasecmp(cmdname, "load.off")) { /* desliga Saida */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); ret = send_command( 4 ); if ( ret < 1 ) upslogx(LOG_ERR, "send_command 4 failed"); @@ -685,6 +692,7 @@ static int instcmd(const char *cmdname, const char *extra) if (!strcasecmp(cmdname, "bypass.start")) { /* liga Bypass */ + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); ret = send_command( 5 ); if ( ret < 1 ) upslogx(LOG_ERR, "send_command 5 failed"); @@ -694,13 +702,14 @@ static int instcmd(const char *cmdname, const char *extra) if (!strcasecmp(cmdname, "bypass.stop")) { /* desliga Bypass */ + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); ret = send_command( 6 ); if ( ret < 1 ) upslogx(LOG_ERR, "send_command 6 failed"); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/richcomm_usb.c b/drivers/richcomm_usb.c index 3f8aef9ed0..3b97e06f11 100644 --- a/drivers/richcomm_usb.c +++ b/drivers/richcomm_usb.c @@ -30,7 +30,7 @@ /* driver version */ #define DRIVER_NAME "Richcomm dry-contact to USB driver" -#define DRIVER_VERSION "0.14" +#define DRIVER_VERSION "0.15" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -716,7 +716,9 @@ void upsdrv_updateinfo(void) static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); /* Shutdown UPS */ if (!strcasecmp(cmdname, "shutdown.return")) @@ -759,6 +761,7 @@ int instcmd(const char *cmdname, const char *extra) char restart[QUERY_PACKETSIZE] = { 0x02, 0x01, 0x00, 0x00 }; char reply[REPLY_PACKETSIZE]; + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); execute_and_retrieve_query(prepare, reply); /* @@ -773,7 +776,7 @@ int instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/riello_ser.c b/drivers/riello_ser.c index 809dd9a146..a5fa3028d4 100644 --- a/drivers/riello_ser.c +++ b/drivers/riello_ser.c @@ -48,7 +48,7 @@ #include "riello.h" #define DRIVER_NAME "Riello serial driver" -#define DRIVER_VERSION "0.12" +#define DRIVER_VERSION "0.15" #define DEFAULT_OFFDELAY 5 /*!< seconds (max 0xFF) */ #define DEFAULT_BOOTDELAY 5 /*!< seconds (max 0xFF) */ @@ -407,8 +407,14 @@ static int riello_instcmd(const char *cmdname, const char *extra) uint16_t delay; const char *delay_char; + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!riello_test_bit(&DevData.StatusCode[0], 1)) { if (!strcasecmp(cmdname, "load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + delay = 0; riello_init_serial(); @@ -439,6 +445,9 @@ static int riello_instcmd(const char *cmdname, const char *extra) if (!strcasecmp(cmdname, "load.off.delay")) { int ipv; + + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + delay_char = dstate_getinfo("ups.delay.shutdown"); ipv = atoi(delay_char); if (ipv < 0 || (intmax_t)ipv > (intmax_t)UINT16_MAX) return STAT_INSTCMD_FAILED; @@ -471,6 +480,8 @@ static int riello_instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "load.on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + delay = 0; riello_init_serial(); @@ -520,6 +531,9 @@ static int riello_instcmd(const char *cmdname, const char *extra) if (!strcasecmp(cmdname, "load.on.delay")) { int ipv; + + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + delay_char = dstate_getinfo("ups.delay.reboot"); ipv = atoi(delay_char); if (ipv < 0 || (intmax_t)ipv > (intmax_t)UINT16_MAX) return STAT_INSTCMD_FAILED; @@ -574,6 +588,9 @@ static int riello_instcmd(const char *cmdname, const char *extra) else { if (!strcasecmp(cmdname, "shutdown.return")) { int ipv; + + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + delay_char = dstate_getinfo("ups.delay.shutdown"); ipv = atoi(delay_char); if (ipv < 0 || (intmax_t)ipv > (intmax_t)UINT16_MAX) return STAT_INSTCMD_FAILED; @@ -608,6 +625,8 @@ static int riello_instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "shutdown.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + riello_init_serial(); if (typeRielloProtocol == DEV_RIELLOGPSER) @@ -660,6 +679,8 @@ static int riello_instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "test.battery.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + riello_init_serial(); if (typeRielloProtocol == DEV_RIELLOGPSER) length = riello_prepare_tb(bufOut, gpser_error_control); @@ -686,7 +707,7 @@ static int riello_instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -1209,12 +1230,14 @@ void upsdrv_shutdown(void) /* static int setvar(const char *varname, const char *val) { - if (!strcasecmp(varname, "ups.test.interval")) { + upsdebug_SET_STARTING(varname, val); + + if (!strcasecmp(varname, "ups.test.interval")) { ser_send_buf(upsfd, ...); return STAT_SET_HANDLED; } - upslogx(LOG_NOTICE, "setvar: unknown variable [%s]", varname); + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } */ diff --git a/drivers/riello_usb.c b/drivers/riello_usb.c index e34b017d99..c7bfc9a5c2 100644 --- a/drivers/riello_usb.c +++ b/drivers/riello_usb.c @@ -36,7 +36,7 @@ #include "riello.h" #define DRIVER_NAME "Riello USB driver" -#define DRIVER_VERSION "0.14" +#define DRIVER_VERSION "0.15" #define DEFAULT_OFFDELAY 5 /*!< seconds (max 0xFF) */ #define DEFAULT_BOOTDELAY 5 /*!< seconds (max 0xFF) */ @@ -589,9 +589,15 @@ static int riello_instcmd(const char *cmdname, const char *extra) uint16_t delay; const char *delay_char; + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!riello_test_bit(&DevData.StatusCode[0], 1)) { if (!strcasecmp(cmdname, "load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + delay = 0; length = riello_prepare_cs(bufOut, gpser_error_control, delay); @@ -618,6 +624,9 @@ static int riello_instcmd(const char *cmdname, const char *extra) if (!strcasecmp(cmdname, "load.off.delay")) { int ipv; + + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + delay_char = dstate_getinfo("ups.delay.shutdown"); ipv = atoi(delay_char); /* With a "char" in the name, might assume we fit... but :) */ @@ -647,6 +656,8 @@ static int riello_instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "load.on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + delay = 0; length = riello_prepare_cr(bufOut, gpser_error_control, delay); @@ -673,6 +684,9 @@ static int riello_instcmd(const char *cmdname, const char *extra) if (!strcasecmp(cmdname, "load.on.delay")) { int ipv; + + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + delay_char = dstate_getinfo("ups.delay.reboot"); ipv = atoi(delay_char); /* With a "char" in the name, might assume we fit... but :) */ @@ -704,6 +718,9 @@ static int riello_instcmd(const char *cmdname, const char *extra) else { if (!strcasecmp(cmdname, "shutdown.return")) { int ipv; + + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); + delay_char = dstate_getinfo("ups.delay.shutdown"); ipv = atoi(delay_char); /* With a "char" in the name, might assume we fit... but :) */ @@ -734,6 +751,8 @@ static int riello_instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "shutdown.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + length = riello_prepare_cd(bufOut, gpser_error_control); recv = riello_command(&bufOut[0], &bufIn[0], length, LENGTH_DEF); @@ -780,6 +799,8 @@ static int riello_instcmd(const char *cmdname, const char *extra) } if (!strcasecmp(cmdname, "test.battery.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + length = riello_prepare_tb(bufOut, gpser_error_control); recv = riello_command(&bufOut[0], &bufIn[0], length, LENGTH_DEF); @@ -802,7 +823,7 @@ static int riello_instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/safenet.c b/drivers/safenet.c index ac5a6b0e14..59e68317e5 100644 --- a/drivers/safenet.c +++ b/drivers/safenet.c @@ -41,7 +41,7 @@ #include "safenet.h" #define DRIVER_NAME "Generic SafeNet UPS driver" -#define DRIVER_VERSION "1.82" +#define DRIVER_VERSION "1.83" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -176,10 +176,16 @@ static int instcmd(const char *cmdname, const char *extra) return instcmd("beeper.enable", NULL); } + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + /* * Start the UPS selftest */ if (!strcasecmp(cmdname, "test.battery.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + if (safenet_command(COM_BATT_TEST)) { return STAT_INSTCMD_FAILED; } else { @@ -191,6 +197,8 @@ static int instcmd(const char *cmdname, const char *extra) * Stop the UPS selftest */ if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + if (safenet_command(COM_STOP_TEST)) { return STAT_INSTCMD_FAILED; } else { @@ -202,6 +210,8 @@ static int instcmd(const char *cmdname, const char *extra) * Start simulated mains failure */ if (!strcasecmp (cmdname, "test.failure.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + if (safenet_command(COM_MAINS_TEST)) { return STAT_INSTCMD_FAILED; } else { @@ -213,6 +223,8 @@ static int instcmd(const char *cmdname, const char *extra) * Stop simulated mains failure */ if (!strcasecmp (cmdname, "test.failure.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); + if (safenet_command(COM_STOP_TEST)) { return STAT_INSTCMD_FAILED; } else { @@ -266,6 +278,7 @@ static int instcmd(const char *cmdname, const char *extra) command[5] += ((offdelay % 100) / 10); command[6] += (offdelay % 10); + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); safenet_command(command); return STAT_INSTCMD_HANDLED; } @@ -285,11 +298,12 @@ static int instcmd(const char *cmdname, const char *extra) command[9] += ((ondelay % 100) / 10); command[10] += (ondelay % 10); + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); safenet_command(command); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/skel.c b/drivers/skel.c index 3c0e6372bd..f33d703667 100644 --- a/drivers/skel.c +++ b/drivers/skel.c @@ -22,7 +22,7 @@ /* #define IGNCHARS "" */ #define DRIVER_NAME "Skeleton UPS driver" -#define DRIVER_VERSION "0.06" +#define DRIVER_VERSION "0.07" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -127,17 +127,23 @@ void upsdrv_shutdown(void) /* static int instcmd(const char *cmdname, const char *extra) { + / * May be used in logging below, but not as a command argument * / + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); ser_send_buf(upsfd, ...); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.stayoff")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); ser_send_buf(upsfd, ...); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } */ @@ -145,12 +151,14 @@ static int instcmd(const char *cmdname, const char *extra) /* static int setvar(const char *varname, const char *val) { - if (!strcasecmp(varname, "ups.test.interval")) { + upsdebug_SET_STARTING(varname, val); + + if (!strcasecmp(varname, "ups.test.interval")) { ser_send_buf(upsfd, ...); return STAT_SET_HANDLED; } - upslogx(LOG_NOTICE, "setvar: unknown variable [%s]", varname); + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } */ diff --git a/drivers/sms_ser.c b/drivers/sms_ser.c index 9a96b6f294..cd2d30b134 100644 --- a/drivers/sms_ser.c +++ b/drivers/sms_ser.c @@ -30,8 +30,8 @@ #define ENDCHAR '\r' -#define DRIVER_NAME "SMS Brazil UPS driver" -#define DRIVER_VERSION "1.02" +#define DRIVER_NAME "SMS Brazil UPS driver" +#define DRIVER_VERSION "1.03" #define QUERY_SIZE 7 #define BUFFER_SIZE 18 @@ -254,8 +254,12 @@ static int get_ups_features(void) { static int sms_instcmd(const char *cmdname, const char *extra) { size_t length; + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "test.battery.start")) { long delay = extra ? strtol(extra, NULL, 10) : 10; + + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); length = sms_prepare_test_battery_nsec(&bufOut[0], delay); if (ser_send_buf(upsfd, bufOut, length) == 0) { @@ -267,6 +271,7 @@ static int sms_instcmd(const char *cmdname, const char *extra) { } if (!strcasecmp(cmdname, "test.battery.start.quick")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); length = sms_prepare_test_battery_low(&bufOut[0]); if (ser_send_buf(upsfd, bufOut, length) == 0) { @@ -279,6 +284,7 @@ static int sms_instcmd(const char *cmdname, const char *extra) { } if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); length = sms_prepare_cancel_test(&bufOut[0]); if (ser_send_buf(upsfd, bufOut, length) == 0) { @@ -303,6 +309,7 @@ static int sms_instcmd(const char *cmdname, const char *extra) { } if (!strcasecmp(cmdname, "shutdown.return")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); length = sms_prepare_shutdown_restore(&bufOut[0]); if (ser_send_buf(upsfd, bufOut, length) == 0) { @@ -324,6 +331,8 @@ static int sms_instcmd(const char *cmdname, const char *extra) { upsdebugx(3, "tried to set up extra shutdown.reboot delay ut it was out of range, keeping default"); } } + + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); length = sms_prepare_shutdown_nsec(&bufOut[0], delay); if (ser_send_buf(upsfd, bufOut, length) == 0) { @@ -336,6 +345,7 @@ static int sms_instcmd(const char *cmdname, const char *extra) { } if (!strcasecmp(cmdname, "shutdown.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); length = sms_prepare_cancel_shutdown(&bufOut[0]); if (ser_send_buf(upsfd, bufOut, length) == 0) { @@ -347,11 +357,13 @@ static int sms_instcmd(const char *cmdname, const char *extra) { return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "sms_instcmd: unknown command [%s]", cmdname); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } static int sms_setvar(const char *varname, const char *val) { + upsdebug_SET_STARTING(varname, val); + if (!strcasecmp(varname, "ups.delay.reboot")) { int ipv = atoi(val); if (ipv >= 0) @@ -359,6 +371,8 @@ static int sms_setvar(const char *varname, const char *val) { dstate_setinfo("ups.delay.reboot", "%u", bootdelay); return STAT_SET_HANDLED; } + + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } diff --git a/drivers/snmp-ups.c b/drivers/snmp-ups.c index 4a2ef9755c..e39ab3ff61 100644 --- a/drivers/snmp-ups.c +++ b/drivers/snmp-ups.c @@ -177,7 +177,7 @@ static const char *mibname; static const char *mibvers; #define DRIVER_NAME "Generic SNMP UPS driver" -#define DRIVER_VERSION "1.34" +#define DRIVER_VERSION "1.35" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -695,7 +695,7 @@ void upsdrv_initups(void) } if (status == TRUE) - upslogx(0, "Detected %s on host %s (mib: %s %s)", + upslogx(LOG_INFO, "Detected %s on host %s (mib: %s %s)", model, device_path, mibname, mibvers); else fatalx(EXIT_FAILURE, "%s MIB wasn't found on %s", mibs, g_snmp_sess.peername); @@ -3675,7 +3675,8 @@ static int su_setOID(int mode, const char *varname, const char *val) char template_count_var[SU_BUFSIZE]; upsdebugx(2, "entering %s(%s, %s, %s)", __func__, - (mode==SU_MODE_INSTCMD)?"instcmd":"setvar", varname, val); + (mode==SU_MODE_INSTCMD)?"instcmd":"setvar", + NUT_STRARG(varname), NUT_STRARG(val)); memset(setOID, 0, SU_INFOSIZE); memset(template_count_var, 0, SU_BUFSIZE); @@ -3920,6 +3921,7 @@ static int su_setOID(int mode, const char *varname, const char *val) upsdebugx(1, "%s: cannot execute command '%s': a provided or default value is needed!", __func__, varname); return STAT_SET_INVALID; } + upslog_INSTCMD_POWERSTATE_CHECKED(varname, val); } if (su_info_p->info_flags & ST_FLAG_STRING) { @@ -3989,7 +3991,20 @@ static int su_setOID(int mode, const char *varname, const char *val) * FIXME: make a common function with su_instcmd! */ int su_setvar(const char *varname, const char *val) { - return su_setOID(SU_MODE_SETVAR, varname, val); + int ret; + + upsdebug_SET_STARTING(varname, val); + + ret = su_setOID(SU_MODE_SETVAR, varname, val); + + if (ret == STAT_SET_FAILED) + upslog_SET_FAILED(varname, val); + else if (ret == STAT_SET_UNKNOWN) + upslog_SET_UNKNOWN(varname, val); + else if (ret == STAT_SET_INVALID) + upslog_SET_INVALID(varname, val); + + return ret; } /* Daisychain-aware function to add instant commands: @@ -4020,7 +4035,20 @@ int su_addcmd(snmp_info_t *su_info_p) /* process instant command and take action. */ int su_instcmd(const char *cmdname, const char *extradata) { - return su_setOID(SU_MODE_INSTCMD, cmdname, extradata); + int ret; + + upsdebug_INSTCMD_STARTING(cmdname, extradata); + + ret = su_setOID(SU_MODE_INSTCMD, cmdname, extradata); + + if (ret == STAT_INSTCMD_FAILED) + upslog_INSTCMD_FAILED(cmdname, extradata); + else if (ret == STAT_INSTCMD_UNKNOWN) + upslog_INSTCMD_UNKNOWN(cmdname, extradata); + else if (ret == STAT_INSTCMD_INVALID) + upslog_INSTCMD_INVALID(cmdname, extradata); + + return ret; } /* FIXME: the below functions can be removed since these were for loading diff --git a/drivers/solis.c b/drivers/solis.c index 7ccdb183c7..2e23734fb9 100644 --- a/drivers/solis.c +++ b/drivers/solis.c @@ -48,7 +48,7 @@ #include "timehead.h" #define DRIVER_NAME "Microsol Solis UPS driver" -#define DRIVER_VERSION "0.71" +#define DRIVER_VERSION "0.72" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -896,10 +896,15 @@ static void get_update_info(void) { } static int instcmd(const char *cmdname, const char *extra) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "shutdown.return")) { /* shutdown and restart */ /* FIXME: check with HW if this is not * a "shutdown.reboot" instead (or also)? */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); ser_send_char(upsfd, CMD_SHUTRET); /* 0xDE */ /* ser_send_char(upsfd, ENDCHAR); */ return STAT_INSTCMD_HANDLED; @@ -907,12 +912,13 @@ static int instcmd(const char *cmdname, const char *extra) { if (!strcasecmp(cmdname, "shutdown.stayoff")) { /* shutdown now (one way) */ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); ser_send_char(upsfd, CMD_SHUT); /* 0xDD */ /* ser_send_char(upsfd, ENDCHAR); */ return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } @@ -967,10 +973,12 @@ void upsdrv_shutdown(void) { * general handling of other `sdcommands` here */ if (!SourceFail) { /* on line */ + upslog_INSTCMD_POWERSTATE_CHANGE("shutdown.return", (char *)NULL); upslogx(LOG_NOTICE, "On line, sending shutdown+return command...\n"); ser_send_char(upsfd, CMD_SHUTRET ); /* Seems AKA: instcmd("shutdown.return", NULL); */ } else { + upslog_INSTCMD_POWERSTATE_CHANGE("shutdown.stayoff", (char *)NULL); upslogx(LOG_NOTICE, "On battery, sending normal shutdown command...\n"); ser_send_char(upsfd, CMD_SHUT); /* Seems AKA: instcmd("shutdown.stayoff", NULL); */ diff --git a/drivers/tripplite.c b/drivers/tripplite.c index 2dee4c6808..0017f4c118 100644 --- a/drivers/tripplite.c +++ b/drivers/tripplite.c @@ -117,7 +117,7 @@ #include #define DRIVER_NAME "Tripp-Lite SmartUPS driver" -#define DRIVER_VERSION "0.97" +#define DRIVER_VERSION "0.98" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -235,57 +235,74 @@ static int instcmd(const char *cmdname, const char *extra) { char buf[256]; + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "test.battery.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); send_cmd(":A\r", buf, sizeof buf); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); send_cmd(":K0\r", buf, sizeof buf); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "load.on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); send_cmd(":K1\r", buf, sizeof buf); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "outlet.1.load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); send_cmd(":K2\r", buf, sizeof buf); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "outlet.1.load.on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); send_cmd(":K3\r", buf, sizeof buf); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "outlet.2.load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); send_cmd(":K4\r", buf, sizeof buf); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "outlet.2.load.on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); send_cmd(":K5\r", buf, sizeof buf); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.reboot")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); do_reboot_now(); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.reboot.graceful")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); do_reboot(); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.return")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); soft_shutdown(); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.stayoff")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); hard_shutdown(); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } static int setvar(const char *varname, const char *val) { + upsdebug_SET_STARTING(varname, val); + if (!strcasecmp(varname, "ups.delay.shutdown")) { int ipv = atoi(val); if (ipv >= 0) @@ -307,6 +324,8 @@ static int setvar(const char *varname, const char *val) dstate_setinfo("ups.delay.reboot", "%u", bootdelay); return STAT_SET_HANDLED; } + + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } diff --git a/drivers/tripplite_usb.c b/drivers/tripplite_usb.c index 2f57e4b488..f012e86f36 100644 --- a/drivers/tripplite_usb.c +++ b/drivers/tripplite_usb.c @@ -137,7 +137,7 @@ #include "usb-common.h" #define DRIVER_NAME "Tripp Lite OMNIVS / SMARTPRO driver" -#define DRIVER_VERSION "0.39" +#define DRIVER_VERSION "0.40" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -513,24 +513,24 @@ static const char *hexascdump(unsigned char *msg, size_t len) static enum tl_model_t decode_protocol(unsigned int proto) { - switch(proto) { + switch (proto) { case 0x0004: - upslogx(3, "Using older SMART protocol (%04x)", proto); + upslogx(LOG_INFO, "Using older SMART protocol (%04x)", proto); return TRIPP_LITE_SMART_0004; case 0x1001: - upslogx(3, "Using OMNIVS protocol (%x)", proto); + upslogx(LOG_INFO, "Using OMNIVS protocol (%x)", proto); return TRIPP_LITE_OMNIVS; case 0x2001: - upslogx(3, "Using OMNIVS 2001 protocol (%x)", proto); + upslogx(LOG_INFO, "Using OMNIVS 2001 protocol (%x)", proto); return TRIPP_LITE_OMNIVS_2001; case 0x3003: - upslogx(3, "Using SMARTPRO protocol (%x)", proto); + upslogx(LOG_INFO, "Using SMARTPRO protocol (%x)", proto); return TRIPP_LITE_SMARTPRO; case 0x3005: - upslogx(3, "Using binary SMART protocol (%x)", proto); + upslogx(LOG_INFO, "Using binary SMART protocol (%x)", proto); return TRIPP_LITE_SMART_3005; default: - printf("Unknown protocol (%04x)", proto); + upslogx(LOG_INFO, "Unknown protocol (%04x)", proto); break; } @@ -576,7 +576,7 @@ static void decode_v(const unsigned char *value) break; default: - upslogx(2, "Unknown input voltage range: 0x%02x", (unsigned int)ivn); + upslogx(LOG_WARNING, "Unknown input voltage range: 0x%02x", (unsigned int)ivn); break; } @@ -587,7 +587,7 @@ static void decode_v(const unsigned char *value) switchable_load_banks = lb; } else { if( lb != 'X' ) { - upslogx(2, "Unknown number of switchable load banks: 0x%02x", + upslogx(LOG_WARNING, "Unknown number of switchable load banks: 0x%02x", (unsigned int)lb); } } @@ -689,7 +689,7 @@ static int send_cmd(const unsigned char *msg, size_t msg_len, unsigned char *rep (usb_ctrl_charbufsize)sizeof(buffer_out)); if(ret != sizeof(buffer_out)) { - upslogx(1, "libusb_set_report() returned %d instead of %" PRIuSIZE, + upsdebugx(3, "libusb_set_report() returned %d instead of %" PRIuSIZE, ret, sizeof(buffer_out)); return ret; } @@ -705,7 +705,7 @@ static int send_cmd(const unsigned char *msg, size_t msg_len, unsigned char *rep (usb_ctrl_charbufsize)sizeof(buffer_out), RECV_WAIT_MSEC); if(ret != sizeof(buffer_out)) { - upslogx(1, "libusb_get_interrupt() returned %d instead of %u while sending %s", + upsdebugx(3, "libusb_get_interrupt() returned %d instead of %u while sending %s", ret, (unsigned)(sizeof(buffer_out)), hexascdump(buffer_out, sizeof(buffer_out))); } @@ -920,49 +920,62 @@ static int instcmd(const char *cmdname, const char *extra) { unsigned char buf[10]; - if(is_smart_protocol()) { + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + + if (is_smart_protocol()) { if (!strcasecmp(cmdname, "test.battery.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); send_cmd((const unsigned char *)"A", 2, buf, sizeof buf); return STAT_INSTCMD_HANDLED; } - if(!strcasecmp(cmdname, "reset.input.minmax")) { + if (!strcasecmp(cmdname, "reset.input.minmax")) { return (send_cmd((const unsigned char *)"Z", 2, buf, sizeof buf) == 2) ? STAT_INSTCMD_HANDLED : STAT_INSTCMD_UNKNOWN; } } if (!strcasecmp(cmdname, "load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); return control_outlet(0, 0) ? STAT_INSTCMD_HANDLED : STAT_INSTCMD_UNKNOWN; } if (!strcasecmp(cmdname, "load.on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); return control_outlet(0, 1) ? STAT_INSTCMD_HANDLED : STAT_INSTCMD_UNKNOWN; } /* code for individual outlets is in setvar() */ #if 0 if (!strcasecmp(cmdname, "shutdown.reboot")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); do_reboot_now(); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.reboot.graceful")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); do_reboot(); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.stayoff")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); hard_shutdown(); return STAT_INSTCMD_HANDLED; } #endif if (!strcasecmp(cmdname, "shutdown.return")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); soft_shutdown(); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } static int setvar(const char *varname, const char *val) { + upsdebug_SET_STARTING(varname, val); + if (!strcasecmp(varname, "ups.delay.shutdown")) { int ival = atoi(val); if (ival >= 0) { @@ -970,7 +983,7 @@ static int setvar(const char *varname, const char *val) dstate_setinfo("ups.delay.shutdown", "%u", offdelay); return STAT_SET_HANDLED; } else { - upslogx(LOG_NOTICE, "FAILED to set '%s' to %d", varname, ival); + upslogx(LOG_SET_UNKNOWN, "FAILED to set '%s' to %d", varname, ival); return STAT_SET_UNKNOWN; } } @@ -986,7 +999,7 @@ static int setvar(const char *varname, const char *val) ret = send_cmd(J_msg, sizeof(J_msg), buf, sizeof(buf)); if(ret <= 0) { - upslogx(LOG_NOTICE, "Could not set Unit ID (return code: %d).", ret); + upslogx(LOG_SET_UNKNOWN, "Could not set Unit ID (return code: %d).", ret); return STAT_SET_UNKNOWN; } @@ -1003,13 +1016,15 @@ static int setvar(const char *varname, const char *val) first_dot = strstr(varname, "."); next_dot = strstr(first_dot + 1, "."); if (!next_dot) { - upslogx(LOG_NOTICE, "FAILED to get outlet index from '%s' (no second dot)", varname); + upslogx(LOG_SET_UNKNOWN, "FAILED to get outlet index from '%s' (no second dot)", varname); return STAT_SET_UNKNOWN; } index_chars = next_dot - (first_dot + 1); - if(index_chars > 9 || index_chars < 0) return STAT_SET_UNKNOWN; - if(strcmp(next_dot, ".switch")) return STAT_SET_UNKNOWN; + if (index_chars > 9 || index_chars < 0) + return STAT_SET_UNKNOWN; + if (strcmp(next_dot, ".switch")) + return STAT_SET_UNKNOWN; strncpy(index_str, first_dot + 1, (size_t)index_chars); index_str[index_chars] = 0; @@ -1048,6 +1063,8 @@ static int setvar(const char *varname, const char *val) return STAT_SET_HANDLED; } #endif + + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } @@ -1088,7 +1105,7 @@ void upsdrv_initinfo(void) fatalx(EXIT_FAILURE, "Could not reset watchdog. Please check and" "see if usbhid-ups(8) works with this UPS."); } else { - upslogx(3, "Could not reset watchdog. Please send model " + upslogx(LOG_ERR, "Could not reset watchdog. Please send model " "information to nut-upsdev mailing list"); } } @@ -1677,7 +1694,7 @@ void upsdrv_initups(void) hd = &curDevice; - upslogx(1, "Detected a UPS: %s/%s", hd->Vendor ? hd->Vendor : "unknown", hd->Product ? hd->Product : "unknown"); + upslogx(LOG_INFO, "Detected a UPS: %s/%s", hd->Vendor ? hd->Vendor : "unknown", hd->Product ? hd->Product : "unknown"); dstate_setinfo("ups.vendorid", "%04x", hd->VendorID); dstate_setinfo("ups.productid", "%04x", hd->ProductID); diff --git a/drivers/tripplitesu.c b/drivers/tripplitesu.c index f738ebae12..05c079de67 100644 --- a/drivers/tripplitesu.c +++ b/drivers/tripplitesu.c @@ -126,7 +126,7 @@ #include "nut_stdint.h" #define DRIVER_NAME "Tripp Lite SmartOnline driver" -#define DRIVER_VERSION "0.09" +#define DRIVER_VERSION "0.10" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -472,7 +472,12 @@ static int instcmd(const char *cmdname, const char *extra) int i; char parm[20]; + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if (!strcasecmp(cmdname, "load.off")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); for (i = 0; i < ups.outlet_banks; i++) { snprintf(parm, sizeof(parm), "%d;1", i + 1); do_command(SET, RELAY_OFF, parm, NULL); @@ -480,6 +485,7 @@ static int instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "load.on")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); for (i = 0; i < ups.outlet_banks; i++) { snprintf(parm, sizeof(parm), "%d;1", i + 1); do_command(SET, RELAY_ON, parm, NULL); @@ -487,18 +493,21 @@ static int instcmd(const char *cmdname, const char *extra) return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.reboot")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); auto_reboot(1); do_command(SET, TSU_SHUTDOWN_RESTART, "1", NULL); do_command(SET, TSU_SHUTDOWN_ACTION, "10", NULL); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.reboot.graceful")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); auto_reboot(1); do_command(SET, TSU_SHUTDOWN_RESTART, "1", NULL); do_command(SET, TSU_SHUTDOWN_ACTION, "60", NULL); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "shutdown.return")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); auto_reboot(1); do_command(SET, TSU_SHUTDOWN_RESTART, "1", NULL); do_command(SET, TSU_SHUTDOWN_ACTION, "10", NULL); @@ -506,29 +515,35 @@ static int instcmd(const char *cmdname, const char *extra) } #if 0 /* doesn't seem to work */ if (!strcasecmp(cmdname, "shutdown.stayoff")) { + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra); auto_reboot(0); do_command(SET, TSU_SHUTDOWN_ACTION, "10", NULL); return STAT_INSTCMD_HANDLED; } #endif if (!strcasecmp(cmdname, "shutdown.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); do_command(SET, TSU_SHUTDOWN_ACTION, "0", NULL); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "test.battery.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); do_command(SET, TEST, "3", NULL); return STAT_INSTCMD_HANDLED; } if (!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); do_command(SET, TEST, "0", NULL); return STAT_INSTCMD_HANDLED; } - upslogx(LOG_NOTICE, "instcmd: unknown command [%s] [%s]", cmdname, extra); + + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } static int setvar(const char *varname, const char *val) { + upsdebug_SET_STARTING(varname, val); if (!strcasecmp(varname, "ups.id")) { set_identification(val); @@ -551,7 +566,7 @@ static int setvar(const char *varname, const char *val) return STAT_SET_HANDLED; } - upslogx(LOG_NOTICE, "setvar: unknown var [%s]", varname); + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } diff --git a/drivers/upscode2.c b/drivers/upscode2.c index f1d4ae16e3..da205d4b88 100644 --- a/drivers/upscode2.c +++ b/drivers/upscode2.c @@ -43,7 +43,7 @@ #include "nut_float.h" #define DRIVER_NAME "UPScode II UPS driver" -#define DRIVER_VERSION "0.93" +#define DRIVER_VERSION "0.94" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -907,12 +907,15 @@ static int instcmd (const char *auxcmd, const char *data) return instcmd("beeper.enable", NULL); } - upsdebugx(1, "Instcmd: %s %s", auxcmd, data ? data : "\"\""); + upsdebug_INSTCMD_STARTING(auxcmd, (data ? data : "\"\"")); for (cp = commands; cp->cmd; cp++) { if (strcasecmp(cp->cmd, auxcmd)) { continue; } + + upslog_INSTCMD_POWERSTATE_CHECKED(auxcmd, data); + upscsend(cp->upsc); if (cp->upsp) { upscsend(cp->upsp); @@ -922,7 +925,7 @@ static int instcmd (const char *auxcmd, const char *data) return STAT_INSTCMD_HANDLED; } - upslogx(LOG_INFO, "instcmd: unknown command %s", auxcmd); + upslog_INSTCMD_UNKNOWN(auxcmd, data); return STAT_INSTCMD_UNKNOWN; } @@ -931,7 +934,7 @@ static int setvar (const char *var, const char *data) { cmd_t *cp; - upsdebugx(1, "Setvar: %s %s", var, data); + upsdebug_SET_STARTING(var, data); for (cp = variables; cp->cmd; cp++) { if (strcasecmp(cp->cmd, var)) { @@ -941,7 +944,8 @@ static int setvar (const char *var, const char *data) return STAT_SET_HANDLED; } - upslogx(LOG_INFO, "Setvar: unsettable variable %s", var); + upslogx(LOG_SET_UNKNOWN, "%s: unsettable variable %s", + __func__, NUT_STRARG(var)); return STAT_SET_UNKNOWN; } diff --git a/drivers/upshandler.h b/drivers/upshandler.h index 78e6ffef0a..6071335257 100644 --- a/drivers/upshandler.h +++ b/drivers/upshandler.h @@ -1,6 +1,7 @@ /* upshandler.h - function callbacks used by the drivers Copyright (C) 2003 Russell Kroll + Copyright (C) 2025 Jim Klimov 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 @@ -45,4 +46,189 @@ struct ups_handler int (*instcmd)(const char *, const char *); }; +/* Log levels; packagers might want to fiddle with NOTICE vs. WARN or ERR, + * maybe even CRIT for shutdown commands?.. or we might eventually tie this + * into nut_debug_level run-time verbosity. + * Up to NUT v2.8.3 everything was LOG_NOTICE except in a few drivers. + * Conversion to these macros allows all drivers to behave consistently. + */ +#ifndef UPSHANDLER_LOGLEVEL_DIFFERENTIATE +# define UPSHANDLER_LOGLEVEL_DIFFERENTIATE 1 /* 0 to LOG_NOTICE everything by default */ +#endif + +#ifndef LOG_INSTCMD_POWERSTATE +# if UPSHANDLER_LOGLEVEL_DIFFERENTIATE +# define LOG_INSTCMD_POWERSTATE LOG_CRIT +# else +# define LOG_INSTCMD_POWERSTATE LOG_NOTICE +# endif +#endif + +#ifndef LOG_INSTCMD_UNKNOWN +# if UPSHANDLER_LOGLEVEL_DIFFERENTIATE +# define LOG_INSTCMD_UNKNOWN LOG_WARNING +# else +# define LOG_INSTCMD_UNKNOWN LOG_NOTICE +# endif +#endif + +#ifndef LOG_INSTCMD_INVALID +# if UPSHANDLER_LOGLEVEL_DIFFERENTIATE +# define LOG_INSTCMD_INVALID LOG_WARNING +# else +# define LOG_INSTCMD_INVALID LOG_NOTICE +# endif +#endif + +#ifndef LOG_INSTCMD_FAILED +# if UPSHANDLER_LOGLEVEL_DIFFERENTIATE +# define LOG_INSTCMD_FAILED LOG_ERR +# else +# define LOG_INSTCMD_FAILED LOG_NOTICE +# endif +#endif + +#ifndef LOG_INSTCMD_CONVERSION_FAILED +# if UPSHANDLER_LOGLEVEL_DIFFERENTIATE +# define LOG_INSTCMD_CONVERSION_FAILED LOG_ERR +# else +# define LOG_INSTCMD_CONVERSION_FAILED LOG_WARNING +# endif +#endif + +/* FIXME: Define here and apply in drivers log levels for + * mere HANDLED states (INFO?), + * like for instcmd about shutdowns (CRIT) in particular; + * see bestfortress.c for some practical inspiration. + */ + +#ifndef LOG_SET_UNKNOWN +# if UPSHANDLER_LOGLEVEL_DIFFERENTIATE +# define LOG_SET_UNKNOWN LOG_WARNING +# else +# define LOG_SET_UNKNOWN LOG_NOTICE +# endif +#endif + +#ifndef LOG_SET_INVALID +# if UPSHANDLER_LOGLEVEL_DIFFERENTIATE +# define LOG_SET_INVALID LOG_WARNING +# else +# define LOG_SET_INVALID LOG_NOTICE +# endif +#endif + +#ifndef LOG_SET_FAILED +# if UPSHANDLER_LOGLEVEL_DIFFERENTIATE +# define LOG_SET_FAILED LOG_ERR +# else +# define LOG_SET_FAILED LOG_NOTICE +# endif +#endif + +#ifndef LOG_SET_CONVERSION_FAILED +# if UPSHANDLER_LOGLEVEL_DIFFERENTIATE +# define LOG_SET_CONVERSION_FAILED LOG_ERR +# else +# define LOG_SET_CONVERSION_FAILED LOG_WARNING +# endif +#endif + +/* Call upslogx() with certain log level and wording/markup, so different + * driver programs present a consistent picture to their end-users. + */ + +/* Block of loggers instcmd(), upscmd() et al -- note an argument is optional. + * Many drivers have their own detailed messages, but are encouraged to follow + * the markup precedent here (NUT_STRARG and all). + * If they have non-standard commands (e.g. "experimental.eco*") they can use + * the upslog_INSTCMD_POWERSTATE*() macros directly in those clauses. + */ +#define upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra) do { \ + upslogx(LOG_INSTCMD_POWERSTATE, "%s: attempting a power state change operation [%s] [%s] on [%s]", \ + __func__, NUT_STRARG(cmdname), NUT_STRARG(extra), NUT_STRARG(upsname)); \ + } while(0) + +/* When calibration goes wrong on an UPS that overestimated itself, + * it may suddenly turn off (e.g. old battery never tested before) + * DUE TO running the test. + */ +#define upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra) do { \ + upslogx(LOG_INSTCMD_POWERSTATE, "%s: attempting an operation [%s] [%s] which may impact power state on [%s]", \ + __func__, NUT_STRARG(cmdname), NUT_STRARG(extra), NUT_STRARG(upsname)); \ + } while(0) + +/* This macro should simplify the call especially for drivers with mapping + * tables, where we do not have a preceding "if strcmp" to certainly know + * which command string we are acting on (at a cost of checking for several + * string matches, so direct-action macros above are preferable where we + * know the command for sure). + * Patterns matched below follow docs/nut-names.txt (INSTCMD section). + */ +#define upslog_INSTCMD_POWERSTATE_CHECKED(cmdname, extra) do { \ + if (cmdname) { \ + if ( \ + strstr(cmdname, "shutdown.stop") == cmdname || \ + strstr(cmdname, "load.on") == cmdname || \ + strstr(cmdname, "test.battery.st") == cmdname || \ + strstr(cmdname, "test.failure.st") == cmdname || \ + strstr(cmdname, "test.system.st") == cmdname || \ + strstr(cmdname, "calibrate.st") == cmdname || \ + strstr(cmdname, "bypass.st") == cmdname \ + ) { \ + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra) ; \ + } else if ( \ + strstr(cmdname, "shutdown.") == cmdname || \ + strstr(cmdname, "load.off") == cmdname || \ + strstr(cmdname, "load.cycle") == cmdname || \ + ( strstr(cmdname, "outlet.") == cmdname && ( \ + strstr(cmdname, "shutdown.") || \ + strstr(cmdname, "load") \ + ) ) \ + ) { \ + upslog_INSTCMD_POWERSTATE_CHANGE(cmdname, extra) ; \ + } \ + } } while(0) + +#define upsdebug_INSTCMD_STARTING(cmdname, extra) do { \ + upsdebugx(1, "Starting %s::%s('%s', '%s')", \ + __FILE__, __func__, NUT_STRARG(cmdname), NUT_STRARG(extra)); \ + } while(0) + +#define upslog_INSTCMD_UNKNOWN(cmdname, extra) do { \ + upslogx(LOG_INSTCMD_UNKNOWN, "%s: unknown command [%s] [%s]", \ + __func__, NUT_STRARG(cmdname), NUT_STRARG(extra)); \ + } while(0) + +#define upslog_INSTCMD_INVALID(cmdname, extra) do { \ + upslogx(LOG_INSTCMD_INVALID, "%s: parameter [%s] is invalid for command [%s]", \ + __func__, NUT_STRARG(extra), NUT_STRARG(cmdname)); \ + } while(0) + +#define upslog_INSTCMD_FAILED(cmdname, extra) do { \ + upslogx(LOG_INSTCMD_FAILED, "%s: FAILED command [%s] [%s]", \ + __func__, NUT_STRARG(cmdname), NUT_STRARG(extra)); \ + } while(0) + +/* setvar(), setcmd() et al -- note they MUST have an argument: */ +#define upsdebug_SET_STARTING(varname, value) do { \ + upsdebugx(1, "Starting %s::%s('%s', '%s')", \ + __FILE__, __func__, NUT_STRARG(varname), NUT_STRARG(value)); \ + } while(0) + +#define upslog_SET_UNKNOWN(varname, value) do { \ + upslogx(LOG_SET_UNKNOWN, "%s: unknown variable [%s] [%s]", \ + __func__, NUT_STRARG(varname), NUT_STRARG(value)); \ + } while(0) + +#define upslog_SET_INVALID(varname, value) do { \ + upslogx(LOG_SET_INVALID, "%s: value [%s] is invalid for variable [%s]", \ + __func__, NUT_STRARG(value), NUT_STRARG(varname)); \ + } while(0) + +#define upslog_SET_FAILED(varname, value) do { \ + upslogx(LOG_SET_FAILED, "%s: FAILED to set variable [%s] to value [%s]", \ + __func__, NUT_STRARG(varname), NUT_STRARG(value)); \ + } while(0) + #endif /* NUT_UPSHANDLER_H */ diff --git a/drivers/usbhid-ups.c b/drivers/usbhid-ups.c index abbf3a166d..633311c205 100644 --- a/drivers/usbhid-ups.c +++ b/drivers/usbhid-ups.c @@ -29,7 +29,7 @@ */ #define DRIVER_NAME "Generic HID driver" -#define DRIVER_VERSION "0.64" +#define DRIVER_VERSION "0.65" #define HU_VAR_WAITBEFORERECONNECT "waitbeforereconnect" @@ -836,15 +836,15 @@ int instcmd(const char *cmdname, const char *extradata) return instcmd("beeper.enable", NULL); } - upsdebugx(1, "instcmd(%s, %s)", - cmdname, - extradata ? extradata : "[NULL]"); + upsdebug_INSTCMD_STARTING(cmdname, extradata); /* Retrieve and check netvar & item_path */ hidups_item = find_nut_info(cmdname); /* Check for fallback if not found */ if (hidups_item == NULL) { + /* Process alias/fallback names */ + upsdebugx(3, "%s: cmdname '%s' not found; " "checking for alternatives", __func__, cmdname); @@ -900,7 +900,9 @@ int instcmd(const char *cmdname, const char *extradata) return instcmd("load.off.delay", dstate_getinfo("ups.delay.shutdown")); } + /* FIXME: ..._UNKNOWN? */ upsdebugx(2, "instcmd: info element unavailable %s", cmdname); + upslog_INSTCMD_INVALID(cmdname, extradata); return STAT_INSTCMD_INVALID; } @@ -945,7 +947,14 @@ int instcmd(const char *cmdname, const char *extradata) } } - /* Actual variable setting */ + /* Actual variable setting (as far as firmware is concerned) */ + { /* scoping + workaround for "error: the address of `argtmp` will always evaluate as `true`" */ + char argtmp[LARGEBUF], *s = NULL; + if (snprintf(argtmp, sizeof(argtmp), "%s (%f)", + NUT_STRARG(extradata), value) > 0) + s = argtmp; + upslog_INSTCMD_POWERSTATE_CHECKED(cmdname, s); + } if (HIDSetDataValue(udev, hidups_item->hiddata, value) == 1) { upsdebugx(3, "instcmd: SUCCEED"); /* Set the status so that SEMI_STATIC vars are polled */ @@ -953,7 +962,8 @@ int instcmd(const char *cmdname, const char *extradata) return STAT_INSTCMD_HANDLED; } - upsdebugx(3, "instcmd: FAILED"); /* TODO: HANDLED but FAILED, not UNKNOWN! */ + /* upsdebugx(3, "instcmd: FAILED"); / * FIXME: return HANDLED but FAILED, not UNKNOWN! */ + upslog_INSTCMD_FAILED(cmdname, extradata); return STAT_INSTCMD_FAILED; } @@ -963,13 +973,14 @@ int setvar(const char *varname, const char *val) hid_info_t *hidups_item; double value; - upsdebugx(1, "setvar(%s, %s)", varname, val); + upsdebug_SET_STARTING(varname, val); /* retrieve and check netvar & item_path */ hidups_item = find_nut_info(varname); if (hidups_item == NULL) { upsdebugx(2, "setvar: info element unavailable %s", varname); + upslog_SET_UNKNOWN(varname, val); return STAT_SET_UNKNOWN; } @@ -1028,7 +1039,8 @@ int setvar(const char *varname, const char *val) return STAT_SET_HANDLED; } - upsdebugx(3, "setvar: FAILED"); /* FIXME: HANDLED but FAILED, not UNKNOWN! */ + /* upsdebugx(3, "setvar: FAILED"); / * FIXME: return HANDLED but FAILED, not UNKNOWN! */ + upslog_SET_FAILED(varname, val); return STAT_SET_UNKNOWN; } @@ -1839,7 +1851,7 @@ static int callback( return 0; } - upslogx(2, "Using subdriver: %s", subdriver->name); + upslogx(LOG_INFO, "Using subdriver: %s", subdriver->name); if (subdriver->fix_report_desc(arghd, pDesc)) { upsdebugx(2, "Report Descriptor Fixed"); diff --git a/drivers/ve-direct.c b/drivers/ve-direct.c index 83aa0a1f09..564c057594 100644 --- a/drivers/ve-direct.c +++ b/drivers/ve-direct.c @@ -22,7 +22,7 @@ #include "serial.h" #define DRIVER_NAME "Victron Energy Direct UPS and solar controller driver" -#define DRIVER_VERSION "0.21" +#define DRIVER_VERSION "0.22" #define VE_GET 7 #define VE_SET 8 @@ -68,7 +68,7 @@ static int ve_process_text_buffer(void) ch = ~ch + 1; if (ch != checksum[9]) { - upslogx(1, "invalid checksum: %d %d", ch, checksum[9]); + upsdebugx(1, "invalid checksum: %d %d", ch, checksum[9]); ve_copy(checksum + 10); return 0; } @@ -187,7 +187,7 @@ static int ve_command(const char ve_cmd, const char *ve_extra, char *ve_return, } else { - upslogx(1, "invalid checksum on reply to command %c", line[1]); + upslogx(LOG_INSTCMD_FAILED, "invalid checksum on reply to command %c", line[1]); return STAT_INSTCMD_FAILED; } @@ -211,6 +211,8 @@ static int ve_command(const char ve_cmd, const char *ve_extra, char *ve_return, static int instcmd(const char *cmdname, const char *extra) { + upsdebug_INSTCMD_STARTING(cmdname, extra); + /* experimental: many of the names below are not among * standard docs/nut-names.txt */ @@ -224,7 +226,8 @@ static int instcmd(const char *cmdname, const char *extra) return ve_command(VE_SET, "FCEE0000", NULL, 0); if (!strcasecmp(cmdname, "beeper.enable")) return ve_command(VE_SET, "FCEE0001", NULL, 0); - upsdebugx(1, "instcmd: unknown command: %s", cmdname); + + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } diff --git a/drivers/victronups.c b/drivers/victronups.c index 10425d3fb8..6113e2f1fc 100644 --- a/drivers/victronups.c +++ b/drivers/victronups.c @@ -32,7 +32,7 @@ #include "serial.h" #define DRIVER_NAME "GE/IMV/Victron UPS driver" -#define DRIVER_VERSION "0.24" +#define DRIVER_VERSION "0.25" /* driver description structure */ upsdrv_info_t upsdrv_info = { @@ -100,8 +100,13 @@ static int instcmd(const char *cmdname, const char *extra) { char temp[ LENGTH_TEMP ]; + /* May be used in logging below, but not as a command argument */ + NUT_UNUSED_VARIABLE(extra); + upsdebug_INSTCMD_STARTING(cmdname, extra); + if(!strcasecmp(cmdname, "calibrate.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); if(get_data("vTi5!",temp)) { upsdebugx(1, "instcmd: ser_send calibrate.start failed"); @@ -116,6 +121,7 @@ static int instcmd(const char *cmdname, const char *extra) } else if(!strcasecmp(cmdname, "calibrate.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); if(get_data("vTi2!",temp)) { upsdebugx(1, "instcmd: ser_send calibrate.stop failed"); @@ -129,6 +135,7 @@ static int instcmd(const char *cmdname, const char *extra) } else if(!strcasecmp(cmdname, "test.battery.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); if(get_data("vTi2!",temp)) { upsdebugx(1, "instcmd: ser_send test.battery.stop failed"); @@ -142,6 +149,7 @@ static int instcmd(const char *cmdname, const char *extra) } else if(!strcasecmp(cmdname, "test.battery.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); if(get_data("vTi4!",temp)) { upsdebugx(1, "instcmd: ser_send test.battery.start failed"); @@ -183,6 +191,7 @@ static int instcmd(const char *cmdname, const char *extra) } else if(!strcasecmp(cmdname, "bypass.stop")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); if(get_data("vTi2!",temp)) { upsdebugx(1, "instcmd: ser_send bypass.stop failed"); @@ -196,6 +205,7 @@ static int instcmd(const char *cmdname, const char *extra) } else if(!strcasecmp(cmdname, "bypass.start")) { + upslog_INSTCMD_POWERSTATE_MAYBE(cmdname, extra); if(get_data("vTi101!",temp)) { upsdebugx(1, "instcmd: ser_send bypass.start failed"); @@ -210,7 +220,7 @@ static int instcmd(const char *cmdname, const char *extra) } else { - upsdebugx(1, "instcmd: unknown command: [%s] [%s]", cmdname, extra); + upslog_INSTCMD_UNKNOWN(cmdname, extra); return STAT_INSTCMD_UNKNOWN; } } diff --git a/m4/ax_c_pragmas.m4 b/m4/ax_c_pragmas.m4 index 5546cf730d..0d3740fc8b 100644 --- a/m4/ax_c_pragmas.m4 +++ b/m4/ax_c_pragmas.m4 @@ -1286,7 +1286,7 @@ if (strstr(buf, "null") == NULL) { } fprintf(stderr, "SUCCESS: RETURNED a string that contains something like 'null' from snprintf() with a variable NULL string argument: '%s'\n", buf); -res = printf("%s", NULL); +res = printf("%s", (char*)NULL); if (res < 0) { fprintf(stderr, "FAILED to printf() an explicit NULL string argument (to stdout)\n"); return 1; @@ -1300,6 +1300,55 @@ return 0; [${myWARN_CFLAGS}] )] ) + + AS_IF([test "${GCC}" = "yes" || test "${CLANGCC}" = "yes"], [ + myWARN_CFLAGS="-Wformat -Werror -Wall --pedantic" + AC_CACHE_CHECK([for compiler acceptance of printf("%s", NULL) if warnings are enabled], + [ax_cv__printf_string_null_nowarn], + [AX_RUN_OR_LINK_IFELSE( + [AC_LANG_PROGRAM([dnl +#include +#include +], [[ +char buf[128]; +char *s = NULL; +/* The following line may issue pedantic static analysis warnings (ignored); + * it may also crash (segfault) during a run on some systems - hence the test. + */ +int res = snprintf(buf, sizeof(buf), "%s", s); +buf[sizeof(buf)-1] = '\0'; +if (res < 0) { + fprintf(stderr, "FAILED to snprintf() a variable NULL string argument\n"); + return 1; +} +if (buf[0] == '\0') { + fprintf(stderr, "RETURNED empty string from snprintf() with a variable NULL string argument\n"); + return 0; +} +if (strstr(buf, "null") == NULL) { + fprintf(stderr, "RETURNED some string from snprintf() with a variable NULL string argument: '%s'\n", buf); + return 0; +} +fprintf(stderr, "SUCCESS: RETURNED a string that contains something like 'null' from snprintf() with a variable NULL string argument: '%s'\n", buf); + +/* Note that with warnings in place, default (void*)NULL is also a problem, + * so we must cast it out */ +res = printf("%s", (char*)NULL); +if (res < 0) { + fprintf(stderr, "FAILED to printf() an explicit NULL string argument (to stdout)\n"); + return 1; +} +return 0; + ]])], + [ax_cv__printf_string_null_nowarn=yes + ], + [ax_cv__printf_string_null_nowarn=no + ], + [${myWARN_CFLAGS}] + )] + )], + [ax_cv__printf_string_null_nowarn=""] + ) unset myWARN_CFLAGS NUT_ARG_ENABLE([NUT_STRARG-always], @@ -1315,7 +1364,11 @@ return 0; ]) AS_IF([test x"$nut_enable_NUT_STRARG_always" = xauto], [ nut_enable_NUT_STRARG_always=no - AS_IF([test "${CLANGCC}" = "yes"], [ + AS_IF([test x"${ax_cv__printf_string_null_nowarn}" = xno], + [nut_enable_NUT_STRARG_always=yes + AC_MSG_NOTICE([Automatically enabled NUT_STRARG-always due to compiler stance on warnings]) + ], + [AS_IF([test "${CLANGCC}" = "yes"], [ true dnl no-op at the moment dnl AS_CASE(["$CC_VERSION"], dnl [*" "18.*], [nut_enable_NUT_STRARG_always=yes] @@ -1326,9 +1379,10 @@ dnl ) [*" "13.*], [nut_enable_NUT_STRARG_always=yes] ) ]) - ]) - AS_IF([test x"$nut_enable_NUT_STRARG_always" = xyes], + ]) + AS_IF([test x"$nut_enable_NUT_STRARG_always" = xyes], [AC_MSG_NOTICE([Automatically enabled NUT_STRARG-always due to compiler version used])]) + ]) ]) AS_IF([test "$ax_cv__printf_string_null" = "yes" && test x"$nut_enable_NUT_STRARG_always" != xyes],[