4107 lines
130 KiB
C
4107 lines
130 KiB
C
/* snmp-ups.c - NUT Generic SNMP driver core (supports different MIBs)
|
|
*
|
|
* Based on NetSNMP API (Simple Network Management Protocol v1-2c-3)
|
|
*
|
|
* Copyright (C)
|
|
* 2002 - 2014 Arnaud Quette <arnaud.quette@free.fr>
|
|
* 2015 - 2021 Eaton (author: Arnaud Quette <ArnaudQuette@Eaton.com>)
|
|
* 2016 - 2022 Eaton (author: Jim Klimov <EvgenyKlimov@Eaton.com>)
|
|
* 2002 - 2006 Dmitry Frolov <frolov@riss-telecom.ru>
|
|
* J.W. Hoogervorst <jeroen@hoogervorst.net>
|
|
* Niels Baggesen <niels@baggesen.net>
|
|
* 2009 - 2010 Arjen de Korte <adkorte-guest@alioth.debian.org>
|
|
*
|
|
* Sponsored by Eaton <http://www.eaton.com>
|
|
* and originally by MGE UPS SYSTEMS <http://www.mgeups.com/>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
|
|
/* NUT SNMP common functions */
|
|
#include "main.h" /* includes "config.h" which must be the first header */
|
|
#include "nut_float.h"
|
|
#include "nut_stdint.h"
|
|
#include "snmp-ups.h"
|
|
#include "parseconf.h"
|
|
|
|
#include <ctype.h> /* for isprint() */
|
|
|
|
/* include all known mib2nut lookup tables */
|
|
#include "apc-mib.h"
|
|
#include "mge-mib.h"
|
|
#include "netvision-mib.h"
|
|
#include "powerware-mib.h"
|
|
#include "eaton-pdu-genesis2-mib.h"
|
|
#include "eaton-pdu-marlin-mib.h"
|
|
#include "eaton-pdu-pulizzi-mib.h"
|
|
#include "eaton-pdu-revelation-mib.h"
|
|
#include "raritan-pdu-mib.h"
|
|
#include "raritan-px2-mib.h"
|
|
#include "baytech-mib.h"
|
|
#include "compaq-mib.h"
|
|
#include "bestpower-mib.h"
|
|
#include "cyberpower-mib.h"
|
|
#include "delta_ups-mib.h"
|
|
#include "huawei-mib.h"
|
|
#include "ietf-mib.h"
|
|
#include "xppc-mib.h"
|
|
#include "eaton-ats16-nmc-mib.h"
|
|
#include "eaton-ats16-nm2-mib.h"
|
|
#include "apc-ats-mib.h"
|
|
#include "apc-pdu-mib.h"
|
|
#include "eaton-ats30-mib.h"
|
|
#include "emerson-avocent-pdu-mib.h"
|
|
#include "hpe-pdu-mib.h"
|
|
|
|
/* Address API change */
|
|
#if ( ! NUT_HAVE_LIBNETSNMP_usmAESPrivProtocol ) && ( ! defined usmAESPrivProtocol )
|
|
#define usmAESPrivProtocol usmAES128PrivProtocol
|
|
#endif
|
|
|
|
#ifdef USM_PRIV_PROTO_AES_LEN
|
|
# define NUT_securityPrivProtoLen USM_PRIV_PROTO_AES_LEN
|
|
#else
|
|
# ifdef USM_PRIV_PROTO_AES128_LEN
|
|
# define NUT_securityPrivProtoLen USM_PRIV_PROTO_AES128_LEN
|
|
# else
|
|
/* FIXME: Find another way to get the size of array(?) to avoid:
|
|
* error: division 'sizeof (oid * {aka long unsigned int *}) / sizeof (oid {aka long unsigned int})' does not compute the number of array elements [-Werror=sizeof-pointer-div]
|
|
* See also https://bugs.php.net/bug.php?id=37564 for context
|
|
* which is due to most values in /usr/include/net-snmp/librarytransform_oids.h
|
|
* being defined as "oid[10]" or similar arrays, and "backwards compatibility"
|
|
* usmAESPrivProtocol name is an "oid *" pointer.
|
|
*/
|
|
# define NUT_securityPrivProtoLen (sizeof(usmAESPrivProtocol)/sizeof(oid))
|
|
# endif
|
|
#endif
|
|
|
|
static mib2nut_info_t *mib2nut[] = {
|
|
&apc_ats, /* This struct comes from : apc-ats-mib.c */
|
|
&apc_pdu_rpdu, /* This struct comes from : apc-pdu-mib.c */
|
|
&apc_pdu_rpdu2, /* This struct comes from : apc-pdu-mib.c */
|
|
&apc_pdu_msp, /* This struct comes from : apc-pdu-mib.c */
|
|
&apc, /* This struct comes from : apc-mib.c */
|
|
&baytech, /* This struct comes from : baytech-mib.c */
|
|
&bestpower, /* This struct comes from : bestpower-mib.c */
|
|
&compaq, /* This struct comes from : compaq-mib.c */
|
|
&cyberpower, /* This struct comes from : cyberpower-mib.c */
|
|
&delta_ups, /* This struct comes from : delta_ups-mib.c */
|
|
&eaton_ats16_nmc, /* This struct comes from : eaton-ats16-nmc-mib.c */
|
|
&eaton_ats16_nm2, /* This struct comes from : eaton-ats16-nm2-mib.c */
|
|
&eaton_ats30, /* This struct comes from : eaton-ats30-mib.c */
|
|
&eaton_marlin, /* This struct comes from : eaton-mib.c */
|
|
&emerson_avocent_pdu, /* This struct comes from : emerson-avocent-pdu-mib.c */
|
|
&aphel_revelation, /* This struct comes from : eaton-mib.c */
|
|
&aphel_genesisII, /* This struct comes from : eaton-mib.c */
|
|
&pulizzi_switched1, /* This struct comes from : eaton-mib.c */
|
|
&pulizzi_switched2, /* This struct comes from : eaton-mib.c */
|
|
&hpe_pdu, /* This struct comes from : hpe-pdu-mib.c */
|
|
&huawei, /* This struct comes from : huawei-mib.c */
|
|
&mge, /* This struct comes from : mge-mib.c */
|
|
&netvision, /* This struct comes from : netvision-mib.c */
|
|
&powerware, /* This struct comes from : powerware-mib.c */
|
|
&pxgx_ups, /* This struct comes from : powerware-mib.c */
|
|
&raritan, /* This struct comes from : raritan-pdu-mib.c */
|
|
&raritan_px2, /* This struct comes from : raritan-px2-mib.c */
|
|
&xppc, /* This struct comes from : xppc-mib.c */
|
|
/*
|
|
* Prepend vendor specific MIB mappings before IETF, so that
|
|
* if a device supports both IETF and vendor specific MIB,
|
|
* the vendor specific one takes precedence (when mibs=auto)
|
|
*/
|
|
&tripplite_ietf, /* This struct comes from : ietf-mib.c */
|
|
&ietf, /* This struct comes from : ietf-mib.c */
|
|
/* end of structure. */
|
|
NULL
|
|
};
|
|
|
|
struct snmp_session g_snmp_sess, *g_snmp_sess_p;
|
|
const char *OID_pwr_status;
|
|
int g_pwr_battery;
|
|
int pollfreq; /* polling frequency */
|
|
int semistaticfreq; /* semistatic entry update frequency */
|
|
static int semistatic_countdown = 0;
|
|
|
|
static int quirk_symmetra_threephase = 0;
|
|
|
|
/* Number of device(s): standard is "1", but talking
|
|
* to a daisychain (master device) means more than 1
|
|
* (a directly addressable member of a daisy chain
|
|
* would be seen as a single-device chain though)
|
|
*/
|
|
static long devices_count = 1;
|
|
/* global var to handle daisychain iterations -
|
|
* changed by loops in snmp_ups_walk() and su_addcmd();
|
|
* may be 0 for addressing certain values/commands
|
|
* across all chain devices via master (1);
|
|
* also may be 0 for non-daisychained devices
|
|
*/
|
|
static int current_device_number = 0;
|
|
/* global var to handle daisychain iterations -
|
|
* made TRUE if we resolved a "device.count" value
|
|
*/
|
|
static bool_t daisychain_enabled = FALSE;
|
|
static daisychain_info_t **daisychain_info = NULL;
|
|
|
|
/* pointer to the Snmp2Nut lookup table */
|
|
mib2nut_info_t *mib2nut_info;
|
|
/* FIXME: to be trashed */
|
|
snmp_info_t *snmp_info;
|
|
alarms_info_t *alarms_info;
|
|
static const char *mibname;
|
|
static const char *mibvers;
|
|
|
|
#define DRIVER_NAME "Generic SNMP UPS driver"
|
|
#define DRIVER_VERSION "1.21"
|
|
|
|
/* driver description structure */
|
|
upsdrv_info_t upsdrv_info = {
|
|
DRIVER_NAME,
|
|
DRIVER_VERSION,
|
|
"Arnaud Quette <arnaud.quette@free.fr>\n" \
|
|
"Arnaud Quette <ArnaudQuette@Eaton.com>\n" \
|
|
"Dmitry Frolov <frolov@riss-telecom.ru>\n" \
|
|
"J.W. Hoogervorst <jeroen@hoogervorst.net>\n" \
|
|
"Niels Baggesen <niels@baggesen.net>\n" \
|
|
"Jim Klimov <EvgenyKlimov@Eaton.com>\n" \
|
|
"Arjen de Korte <adkorte-guest@alioth.debian.org>",
|
|
DRV_STABLE,
|
|
{ NULL }
|
|
};
|
|
/* FIXME: integrate MIBs info? do the same as for usbhid-ups! */
|
|
|
|
static time_t lastpoll = 0;
|
|
|
|
/* Communication status handling */
|
|
#define COMM_UNKNOWN 0
|
|
#define COMM_OK 1
|
|
#define COMM_LOST 2
|
|
static int comm_status = COMM_UNKNOWN;
|
|
|
|
/* template OIDs index start with 0 or 1 (estimated stable for a MIB),
|
|
* automatically guessed at the first pass */
|
|
static int template_index_base = -1;
|
|
/* Not that stable in the end... */
|
|
static int device_template_index_base = -1; /* OID index of the 1rst daisychained device */
|
|
static int outlet_template_index_base = -1;
|
|
static int outletgroup_template_index_base = -1;
|
|
static int ambient_template_index_base = -1;
|
|
static int device_template_offset = -1;
|
|
|
|
/* sysOID location */
|
|
#define SYSOID_OID ".1.3.6.1.2.1.1.2.0"
|
|
|
|
/* Forward functions declarations */
|
|
static void disable_transfer_oids(void);
|
|
bool_t get_and_process_data(int mode, snmp_info_t *su_info_p);
|
|
int extract_template_number(snmp_info_flags_t template_type, const char* varname);
|
|
snmp_info_flags_t get_template_type(const char* varname);
|
|
|
|
/* ---------------------------------------------
|
|
* driver functions implementations
|
|
* --------------------------------------------- */
|
|
void upsdrv_initinfo(void)
|
|
{
|
|
snmp_info_t *su_info_p;
|
|
|
|
upsdebugx(1, "SNMP UPS driver: entering %s()", __func__);
|
|
|
|
dstate_setinfo("driver.version.data", "%s MIB %s", mibname, mibvers);
|
|
|
|
if (snmp_info == NULL) {
|
|
fatalx(EXIT_FAILURE, "%s: snmp_info is not initialized", __func__);
|
|
}
|
|
|
|
if (snmp_info[0].info_type == NULL) {
|
|
upsdebugx(1, "%s: WARNING: snmp_info is empty", __func__);
|
|
}
|
|
|
|
/* add instant commands to the info database.
|
|
* outlet (and groups) commands are processed later, during initial walk */
|
|
for (su_info_p = &snmp_info[0]; (su_info_p != NULL && su_info_p->info_type != NULL) ; su_info_p++)
|
|
{
|
|
if (su_info_p->flags == 0UL) {
|
|
upsdebugx(4,
|
|
"SNMP UPS driver: %s: MIB2NUT mapping '%s' (OID '%s') did not define flags bits. "
|
|
"Entry would be treated as SU_FLAG_OK if available in returned data.",
|
|
__func__,
|
|
(su_info_p->info_type ? su_info_p->info_type : "<null>"),
|
|
(su_info_p->OID ? su_info_p->OID : "<null>")
|
|
);
|
|
/* Treat as OK if avail, otherwise discarded */
|
|
}
|
|
|
|
su_info_p->flags |= SU_FLAG_OK;
|
|
if ((SU_TYPE(su_info_p) == SU_TYPE_CMD)
|
|
&& !(su_info_p->flags & SU_OUTLET)
|
|
&& !(su_info_p->flags & SU_OUTLET_GROUP))
|
|
{
|
|
/* first check that this OID actually exists */
|
|
/* FIXME: daisychain commands support! */
|
|
su_addcmd(su_info_p);
|
|
/*
|
|
if (nut_snmp_get(su_info_p->OID) != NULL) {
|
|
dstate_addcmd(su_info_p->info_type);
|
|
upsdebugx(1, "upsdrv_initinfo(): adding command '%s'", su_info_p->info_type);
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
|
|
if (testvar("notransferoids"))
|
|
disable_transfer_oids();
|
|
|
|
if (testvar("symmetrathreephase"))
|
|
quirk_symmetra_threephase = 1;
|
|
else
|
|
quirk_symmetra_threephase = 0;
|
|
|
|
/* initialize all other INFO_ fields from list */
|
|
if (snmp_ups_walk(SU_WALKMODE_INIT) == TRUE) {
|
|
dstate_dataok();
|
|
comm_status = COMM_OK;
|
|
}
|
|
else {
|
|
dstate_datastale();
|
|
comm_status = COMM_LOST;
|
|
}
|
|
|
|
/* setup handlers for instcmd and setvar functions */
|
|
upsh.setvar = su_setvar;
|
|
upsh.instcmd = su_instcmd;
|
|
}
|
|
|
|
void upsdrv_updateinfo(void)
|
|
{
|
|
upsdebugx(1,"SNMP UPS driver: entering %s()", __func__);
|
|
|
|
/* only update every pollfreq */
|
|
/* FIXME: only update status (SU_STATUS_*), à la usbhid-ups, in between */
|
|
if (time(NULL) > (lastpoll + pollfreq)) {
|
|
|
|
alarm_init();
|
|
status_init();
|
|
|
|
/* update all dynamic info fields */
|
|
if (snmp_ups_walk(SU_WALKMODE_UPDATE)) {
|
|
upsdebugx(1, "%s: pollfreq: Data OK", __func__);
|
|
dstate_dataok();
|
|
comm_status = COMM_OK;
|
|
}
|
|
else {
|
|
upsdebugx(1, "%s: pollfreq: Data STALE", __func__);
|
|
dstate_datastale();
|
|
comm_status = COMM_LOST;
|
|
}
|
|
|
|
/* Commit status first, otherwise in daisychain mode, "device.0" may
|
|
* clear the alarm count since it has an empty alarm buffer and if there
|
|
* is only one device that has alarms! */
|
|
if (daisychain_enabled == FALSE)
|
|
alarm_commit();
|
|
status_commit();
|
|
if (daisychain_enabled == TRUE)
|
|
alarm_commit();
|
|
|
|
/* store timestamp */
|
|
lastpoll = time(NULL);
|
|
}
|
|
else {
|
|
/* Just tell the same status to upsd */
|
|
if (comm_status == COMM_OK)
|
|
dstate_dataok();
|
|
else
|
|
dstate_datastale();
|
|
}
|
|
}
|
|
|
|
void upsdrv_shutdown(void)
|
|
{
|
|
/*
|
|
This driver will probably never support this. In order to
|
|
be any use, the driver should be called near the end of
|
|
the system halt script. By that time we in all likelyhood
|
|
we won't have network capabilities anymore, so we could
|
|
never send this command to the UPS. This is not an error,
|
|
but a limitation of the interface used.
|
|
*/
|
|
|
|
upsdebugx(1, "%s...", __func__);
|
|
|
|
/* set shutdown and autostart delay */
|
|
set_delays();
|
|
|
|
/* Try to shutdown with delay */
|
|
if (su_instcmd("shutdown.return", NULL) == STAT_INSTCMD_HANDLED) {
|
|
/* Shutdown successful */
|
|
return;
|
|
}
|
|
|
|
/* If the above doesn't work, try shutdown.reboot */
|
|
if (su_instcmd("shutdown.reboot", NULL) == STAT_INSTCMD_HANDLED) {
|
|
/* Shutdown successful */
|
|
return;
|
|
}
|
|
|
|
/* If the above doesn't work, try load.off.delay */
|
|
if (su_instcmd("load.off.delay", NULL) == STAT_INSTCMD_HANDLED) {
|
|
/* Shutdown successful */
|
|
return;
|
|
}
|
|
|
|
fatalx(EXIT_FAILURE, "Shutdown failed!");
|
|
}
|
|
|
|
void upsdrv_help(void)
|
|
{
|
|
upsdebugx(1, "entering %s", __func__);
|
|
}
|
|
|
|
/* list flags and values that you want to receive via -x */
|
|
void upsdrv_makevartable(void)
|
|
{
|
|
upsdebugx(1, "entering %s()", __func__);
|
|
|
|
addvar(VAR_VALUE, SU_VAR_MIBS,
|
|
"NOTE: You can run the driver binary with '-x mibs=--list' for an up to date listing)\n"
|
|
"Set MIB compliance (default=ietf, allowed: mge,apcc,netvision,pw,cpqpower,...)");
|
|
addvar(VAR_VALUE | VAR_SENSITIVE, SU_VAR_COMMUNITY,
|
|
"Set community name (default=public)");
|
|
addvar(VAR_VALUE, SU_VAR_VERSION,
|
|
"Set SNMP version (default=v1, allowed: v2c,v3)");
|
|
addvar(VAR_VALUE, SU_VAR_POLLFREQ,
|
|
"Set polling frequency in seconds, to reduce network flow (default=30)");
|
|
addvar(VAR_VALUE, SU_VAR_SEMISTATICFREQ,
|
|
"Set semistatic value update frequency in update cycles, to reduce network flow (default=10)");
|
|
addvar(VAR_VALUE, SU_VAR_RETRIES,
|
|
"Specifies the number of Net-SNMP retries to be used in the requests (default=5)");
|
|
addvar(VAR_VALUE, SU_VAR_TIMEOUT,
|
|
"Specifies the Net-SNMP timeout in seconds between retries (default=1)");
|
|
addvar(VAR_FLAG, "notransferoids",
|
|
"Disable transfer OIDs (use on APCC Symmetras)");
|
|
addvar(VAR_FLAG, "symmetrathreephase",
|
|
"Enable APCC three phase Symmetra quirks (use on APCC three phase Symmetras)");
|
|
addvar(VAR_VALUE, SU_VAR_SECLEVEL,
|
|
"Set the securityLevel used for SNMPv3 messages (default=noAuthNoPriv, allowed: authNoPriv,authPriv)");
|
|
addvar(VAR_VALUE | VAR_SENSITIVE, SU_VAR_SECNAME,
|
|
"Set the securityName used for authenticated SNMPv3 messages (no default)");
|
|
addvar(VAR_VALUE | VAR_SENSITIVE, SU_VAR_AUTHPASSWD,
|
|
"Set the authentication pass phrase used for authenticated SNMPv3 messages (no default)");
|
|
addvar(VAR_VALUE | VAR_SENSITIVE, SU_VAR_PRIVPASSWD,
|
|
"Set the privacy pass phrase used for encrypted SNMPv3 messages (no default)");
|
|
|
|
/* Construct addvar() for SU_VAR_AUTHPROT: */
|
|
{ int comma = 0;
|
|
char tmp_buf[SU_LARGEBUF];
|
|
char *p = tmp_buf;
|
|
char *pn; /* proto name to add */
|
|
size_t remain = sizeof(tmp_buf) - 1;
|
|
int ret;
|
|
NUT_UNUSED_VARIABLE(comma); /* potentially, if no protocols are available */
|
|
|
|
tmp_buf[0] = '\0';
|
|
|
|
ret = snprintf(p, remain, "%s",
|
|
"Set the authentication protocol (");
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar()");
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
|
|
#if NUT_HAVE_LIBNETSNMP_usmHMACMD5AuthProtocol
|
|
pn = "MD5";
|
|
ret = snprintf(p, remain, "%s%s", (comma++ ? ", " : ""), pn );
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar(%s)", pn);
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
#endif
|
|
#if NUT_HAVE_LIBNETSNMP_usmHMACSHA1AuthProtocol
|
|
pn = "SHA";
|
|
ret = snprintf(p, remain, "%s%s", (comma++ ? ", " : ""), pn );
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar(%s)", pn);
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
#endif
|
|
#if NUT_HAVE_LIBNETSNMP_usmHMAC192SHA256AuthProtocol
|
|
pn = "SHA256";
|
|
ret = snprintf(p, remain, "%s%s", (comma++ ? ", " : ""), pn );
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar(%s)", pn);
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
#endif
|
|
#if NUT_HAVE_LIBNETSNMP_usmHMAC256SHA384AuthProtocol
|
|
pn = "SHA384";
|
|
ret = snprintf(p, remain, "%s%s", (comma++ ? ", " : ""), pn );
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar(%s)", pn);
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
#endif
|
|
#if NUT_HAVE_LIBNETSNMP_usmHMAC384SHA512AuthProtocol
|
|
pn = "SHA512";
|
|
ret = snprintf(p, remain, "%s%s", (comma++ ? ", " : ""), pn );
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar(%s)", pn);
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
#endif
|
|
|
|
pn = "none supported";
|
|
ret = snprintf(p, remain, "%s", (comma++ ? "" : pn) );
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar(%s)", pn);
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
|
|
ret = snprintf(p, remain, "%s",
|
|
") used for authenticated SNMPv3 messages (default=MD5 if available)");
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar()");
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
|
|
addvar(VAR_VALUE, SU_VAR_AUTHPROT, tmp_buf);
|
|
} /* Construct addvar() for AUTHPROTO */
|
|
|
|
/* Construct addvar() for SU_VAR_PRIVPROT: */
|
|
{ int comma = 0;
|
|
char tmp_buf[SU_LARGEBUF];
|
|
char *p = tmp_buf;
|
|
char *pn; /* proto name to add */
|
|
size_t remain = sizeof(tmp_buf) - 1;
|
|
int ret;
|
|
NUT_UNUSED_VARIABLE(comma); /* potentially, if no protocols are available */
|
|
|
|
tmp_buf[0] = '\0';
|
|
|
|
ret = snprintf(p, remain, "%s",
|
|
"Set the privacy protocol (");
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar()");
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
|
|
#if NUT_HAVE_LIBNETSNMP_usmDESPrivProtocol
|
|
pn = "DES";
|
|
ret = snprintf(p, remain, "%s%s", (comma++ ? ", " : ""), pn );
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar(%s)", pn);
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
#endif
|
|
#if NUT_HAVE_LIBNETSNMP_usmAESPrivProtocol || NUT_HAVE_LIBNETSNMP_usmAES128PrivProtocol
|
|
pn = "AES";
|
|
ret = snprintf(p, remain, "%s%s", (comma++ ? ", " : ""), pn );
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar(%s)", pn);
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
#endif
|
|
#if NUT_HAVE_LIBNETSNMP_DRAFT_BLUMENTHAL_AES_04
|
|
# if NUT_HAVE_LIBNETSNMP_usmAES192PrivProtocol
|
|
pn = "AES192";
|
|
ret = snprintf(p, remain, "%s%s", (comma++ ? ", " : ""), pn );
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar(%s)", pn);
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
# endif
|
|
# if NUT_HAVE_LIBNETSNMP_usmAES256PrivProtocol
|
|
pn = "AES256";
|
|
ret = snprintf(p, remain, "%s%s", (comma++ ? ", " : ""), pn );
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar(%s)", pn);
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
# endif
|
|
#endif /* NUT_HAVE_LIBNETSNMP_DRAFT_BLUMENTHAL_AES_04 */
|
|
|
|
pn = "none supported";
|
|
ret = snprintf(p, remain, "%s", (comma++ ? "" : pn) );
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar(%s)", pn);
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
|
|
ret = snprintf(p, remain, "%s",
|
|
") used for encrypted SNMPv3 messages (default=DES if available)");
|
|
if (ret < 0 || (uintmax_t)ret > (uintmax_t)remain || (uintmax_t)ret > SIZE_MAX) {
|
|
fatalx(EXIT_FAILURE, "Could not addvar()");
|
|
}
|
|
p += ret;
|
|
remain -= (size_t)ret;
|
|
|
|
addvar(VAR_VALUE, SU_VAR_PRIVPROT, tmp_buf);
|
|
} /* Construct addvar() for PRIVPROTO */
|
|
|
|
addvar(VAR_VALUE, SU_VAR_ONDELAY,
|
|
"Set start delay time after shutdown");
|
|
addvar(VAR_VALUE, SU_VAR_OFFDELAY,
|
|
"Set delay time before shutdown ");
|
|
}
|
|
|
|
void upsdrv_initups(void)
|
|
{
|
|
snmp_info_t *su_info_p, *cur_info_p;
|
|
char model[SU_INFOSIZE];
|
|
bool_t status= FALSE;
|
|
const char *mibs;
|
|
int curdev = 0;
|
|
|
|
upsdebugx(1, "SNMP UPS driver: entering %s()", __func__);
|
|
|
|
/* Retrieve user's parameters */
|
|
mibs = testvar(SU_VAR_MIBS) ? getval(SU_VAR_MIBS) : "auto";
|
|
if (!strcmp(mibs, "--list")) {
|
|
printf("The 'mibs' argument is '%s', so just listing the mappings this driver knows,\n"
|
|
"and for 'mibs=auto' these mappings will be tried in the following order until\n"
|
|
"the first one matches your device\n\n", mibs);
|
|
int i;
|
|
printf("%7s\t%-23s\t%-7s\t%-31s\t%-s\n",
|
|
"NUMBER", "MAPPING NAME", "VERSION",
|
|
"ENTRY POINT OID", "AUTO CHECK OID");
|
|
for (i=0; mib2nut[i] != NULL; i++) {
|
|
printf(" %4d \t%-23s\t%7s\t%-31s\t%-s\n", (i+1),
|
|
mib2nut[i]->mib_name ? mib2nut[i]->mib_name : "<NULL>" ,
|
|
mib2nut[i]->mib_version ? mib2nut[i]->mib_version : "<NULL>" ,
|
|
mib2nut[i]->sysOID ? mib2nut[i]->sysOID : "<NULL>" ,
|
|
mib2nut[i]->oid_auto_check ? mib2nut[i]->oid_auto_check : "<NULL>" );
|
|
}
|
|
printf("\nOverall this driver has loaded %d MIB-to-NUT mapping tables\n", i);
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
/* init SNMP library, etc... */
|
|
nut_snmp_init(progname, device_path);
|
|
|
|
/* FIXME: first test if the device is reachable to avoid timeouts! */
|
|
|
|
/* Load the SNMP to NUT translation data */
|
|
load_mib2nut(mibs);
|
|
|
|
/* init polling frequency */
|
|
if (getval(SU_VAR_POLLFREQ))
|
|
pollfreq = atoi(getval(SU_VAR_POLLFREQ));
|
|
else
|
|
pollfreq = DEFAULT_POLLFREQ;
|
|
|
|
/* init semistatic update frequency */
|
|
if (getval(SU_VAR_SEMISTATICFREQ))
|
|
semistaticfreq = atoi(getval(SU_VAR_SEMISTATICFREQ));
|
|
else
|
|
semistaticfreq = DEFAULT_SEMISTATICFREQ;
|
|
if (semistaticfreq < 1) {
|
|
upsdebugx(1, "Bad %s value provided, setting to default", SU_VAR_SEMISTATICFREQ);
|
|
semistaticfreq = DEFAULT_SEMISTATICFREQ;
|
|
}
|
|
semistatic_countdown = semistaticfreq;
|
|
|
|
/* Get UPS Model node to see if there's a MIB */
|
|
/* FIXME: extend and use match_model_OID(char *model) */
|
|
su_info_p = su_find_info("ups.model");
|
|
/* Try to get device.model if ups.model is not available */
|
|
if (su_info_p == NULL)
|
|
su_info_p = su_find_info("device.model");
|
|
|
|
if (su_info_p != NULL) {
|
|
/* Daisychain specific: we may have a template (including formatting
|
|
* string) that needs to be adapted! */
|
|
if (strchr(su_info_p->OID, '%') != NULL)
|
|
{
|
|
upsdebugx(2, "Found template, need to be adapted");
|
|
cur_info_p = (snmp_info_t *)malloc(sizeof(snmp_info_t));
|
|
cur_info_p->info_type = (char *)xmalloc(SU_INFOSIZE);
|
|
cur_info_p->OID = (char *)xmalloc(SU_INFOSIZE);
|
|
snprintf((char*)cur_info_p->info_type, SU_INFOSIZE, "%s", su_info_p->info_type);
|
|
/* Use the daisychain master (0) / 1rst device index */
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_SECURITY
|
|
#pragma GCC diagnostic ignored "-Wformat-security"
|
|
#endif
|
|
snprintf((char*)cur_info_p->OID, SU_INFOSIZE, su_info_p->OID, 0);
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
}
|
|
else {
|
|
upsdebugx(2, "Found entry, not a template %s", su_info_p->OID);
|
|
/* Otherwise, just point at what we found */
|
|
cur_info_p = su_info_p;
|
|
}
|
|
|
|
/* Actually get the data */
|
|
status = nut_snmp_get_str(cur_info_p->OID, model, sizeof(model), NULL);
|
|
|
|
/* Free our malloc, if it was dynamic */
|
|
if (strchr(su_info_p->OID, '%') != NULL) {
|
|
if (cur_info_p->info_type != NULL)
|
|
free((char*)cur_info_p->info_type);
|
|
if (cur_info_p->OID != NULL)
|
|
free((char*)cur_info_p->OID);
|
|
if (cur_info_p != NULL)
|
|
free((char*)cur_info_p);
|
|
}
|
|
}
|
|
|
|
if (status == TRUE)
|
|
upslogx(0, "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);
|
|
/* FIXME: "No supported device detected" */
|
|
|
|
/* Init daisychain and check if support is required */
|
|
daisychain_init();
|
|
|
|
/* Allocate / init the daisychain info structure (for phases only for now)
|
|
* daisychain_info[0] is the whole chain! (added +1) */
|
|
daisychain_info = (daisychain_info_t**)malloc(
|
|
sizeof(daisychain_info_t) * (size_t)(devices_count + 1)
|
|
);
|
|
for (curdev = 0 ; curdev <= devices_count ; curdev++) {
|
|
daisychain_info[curdev] = (daisychain_info_t*)malloc(sizeof(daisychain_info_t));
|
|
daisychain_info[curdev]->input_phases = (long)-1;
|
|
daisychain_info[curdev]->output_phases = (long)-1;
|
|
daisychain_info[curdev]->bypass_phases = (long)-1;
|
|
}
|
|
|
|
/* FIXME: also need daisychain awareness (so init)!
|
|
* i.e load.off.delay+load.off + device.1.load.off.delay+device.1.load.off + ... */
|
|
/* FIXME: daisychain commands support! */
|
|
if (su_find_info("load.off.delay")) {
|
|
/* Adds default with a delay value of '0' (= immediate) */
|
|
dstate_addcmd("load.off");
|
|
}
|
|
|
|
if (su_find_info("load.on.delay")) {
|
|
/* Adds default with a delay value of '0' (= immediate) */
|
|
dstate_addcmd("load.on");
|
|
}
|
|
|
|
if (su_find_info("load.off.delay") && su_find_info("load.on.delay")) {
|
|
/* Add composite instcmds (require setting multiple OID values) */
|
|
dstate_addcmd("shutdown.return");
|
|
dstate_addcmd("shutdown.stayoff");
|
|
}
|
|
|
|
/* Publish sysDescr, sysContact and sysLocation (from IETF standard paths)
|
|
* for all subdrivers that do not have one defined in their mapping
|
|
* tables (note: for lack of better knowledge, defined as read-only
|
|
* entries here, and also read-once - not updated during driver uptime) */
|
|
|
|
if (NULL == dstate_getinfo("device.description")
|
|
&& NULL == dstate_getinfo("device.1.description")
|
|
) {
|
|
/* sysDescr.0 */
|
|
if (nut_snmp_get_str(".1.3.6.1.2.1.1.1.0", model, sizeof(model), NULL) == TRUE) {
|
|
upsdebugx(2, "Using IETF-MIB default to get and publish sysDescr for device.description (once)");
|
|
dstate_setinfo("device.description", "%s", model);
|
|
} else {
|
|
upsdebugx(2, "Can't get and publish sysDescr for device.description");
|
|
}
|
|
}
|
|
|
|
if (NULL == dstate_getinfo("device.contact")
|
|
&& NULL == dstate_getinfo("device.1.contact")
|
|
) {
|
|
/* sysContact.0 */
|
|
if (nut_snmp_get_str(".1.3.6.1.2.1.1.4.0", model, sizeof(model), NULL) == TRUE) {
|
|
upsdebugx(2, "Using IETF-MIB default to get and publish sysContact for device.contact (once)");
|
|
dstate_setinfo("device.contact", "%s", model);
|
|
} else {
|
|
upsdebugx(2, "Can't get and publish sysContact for device.contact");
|
|
}
|
|
}
|
|
|
|
if (NULL == dstate_getinfo("device.location")
|
|
&& NULL == dstate_getinfo("device.1.location")
|
|
) {
|
|
/* sysLocation.0 */
|
|
if (nut_snmp_get_str(".1.3.6.1.2.1.1.6.0", model, sizeof(model), NULL) == TRUE) {
|
|
upsdebugx(2, "Using IETF-MIB default to get and publish sysLocation for device.location (once)");
|
|
dstate_setinfo("device.location", "%s", model);
|
|
} else {
|
|
upsdebugx(2, "Can't get and publish sysLocation for device.location");
|
|
}
|
|
}
|
|
|
|
/* set shutdown and autostart delay */
|
|
set_delays();
|
|
}
|
|
|
|
void upsdrv_cleanup(void)
|
|
{
|
|
/* General cleanup */
|
|
if (daisychain_info)
|
|
free(daisychain_info);
|
|
|
|
/* Net-SNMP specific cleanup */
|
|
nut_snmp_cleanup();
|
|
}
|
|
|
|
/* -----------------------------------------------------------
|
|
* SNMP functions.
|
|
* ----------------------------------------------------------- */
|
|
|
|
void nut_snmp_init(const char *type, const char *hostname)
|
|
{
|
|
char *ns_options = NULL;
|
|
const char *community, *version;
|
|
const char *secLevel = NULL, *authPassword, *privPassword;
|
|
const char *authProtocol, *privProtocol;
|
|
int snmp_retries = DEFAULT_NETSNMP_RETRIES;
|
|
long snmp_timeout = DEFAULT_NETSNMP_TIMEOUT;
|
|
|
|
upsdebugx(2, "SNMP UPS driver: entering %s(%s)", __func__, type);
|
|
|
|
/* Force numeric OIDs resolution (ie, do not resolve to textual names)
|
|
* This is mostly for the convenience of debug output */
|
|
ns_options = snmp_out_toggle_options("n");
|
|
if (ns_options != NULL) {
|
|
upsdebugx(2, "Failed to enable numeric OIDs resolution");
|
|
}
|
|
|
|
/* Initialize the SNMP library */
|
|
init_snmp(type);
|
|
|
|
/* Initialize session */
|
|
snmp_sess_init(&g_snmp_sess);
|
|
|
|
g_snmp_sess.peername = xstrdup(hostname);
|
|
|
|
/* Net-SNMP timeout and retries */
|
|
if (testvar(SU_VAR_RETRIES)) {
|
|
snmp_retries = atoi(getval(SU_VAR_RETRIES));
|
|
}
|
|
g_snmp_sess.retries = snmp_retries;
|
|
upsdebugx(2, "Setting SNMP retries to %i", snmp_retries);
|
|
|
|
if (testvar(SU_VAR_TIMEOUT)) {
|
|
snmp_timeout = atol(getval(SU_VAR_TIMEOUT));
|
|
}
|
|
/* We have to convert from seconds to microseconds */
|
|
g_snmp_sess.timeout = snmp_timeout * ONE_SEC;
|
|
upsdebugx(2, "Setting SNMP timeout to %ld second(s)", snmp_timeout);
|
|
|
|
/* Retrieve user parameters */
|
|
version = testvar(SU_VAR_VERSION) ? getval(SU_VAR_VERSION) : "v1";
|
|
|
|
/* Older CLANG (e.g. clang-3.4) sees short strings in str{n}cmp()
|
|
* arguments as arrays and claims out-of-bounds accesses
|
|
*/
|
|
#if (defined HAVE_PRAGMA_GCC_DIAGNOSTIC_PUSH_POP) && (defined HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_ARRAY_BOUNDS)
|
|
# pragma GCC diagnostic push
|
|
# pragma GCC diagnostic ignored "-Warray-bounds"
|
|
#endif
|
|
#ifdef __clang__
|
|
# pragma clang diagnostic push
|
|
# pragma clang diagnostic ignored "-Warray-bounds"
|
|
#endif
|
|
if ((strcmp(version, "v1") == 0) || (strcmp(version, "v2c") == 0)) {
|
|
g_snmp_sess.version = (strcmp(version, "v1") == 0) ? SNMP_VERSION_1 : SNMP_VERSION_2c;
|
|
community = testvar(SU_VAR_COMMUNITY) ? getval(SU_VAR_COMMUNITY) : "public";
|
|
g_snmp_sess.community = (unsigned char *)xstrdup(community);
|
|
g_snmp_sess.community_len = strlen(community);
|
|
}
|
|
else if (strcmp(version, "v3") == 0) {
|
|
#ifdef __clang__
|
|
# pragma clang diagnostic pop
|
|
#endif
|
|
#if (defined HAVE_PRAGMA_GCC_DIAGNOSTIC_PUSH_POP) && (defined HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_ARRAY_BOUNDS)
|
|
# pragma GCC diagnostic pop
|
|
#endif
|
|
/* SNMP v3 related init */
|
|
g_snmp_sess.version = SNMP_VERSION_3;
|
|
|
|
/* Security level */
|
|
if (testvar(SU_VAR_SECLEVEL)) {
|
|
secLevel = getval(SU_VAR_SECLEVEL);
|
|
|
|
if (strcmp(secLevel, "noAuthNoPriv") == 0)
|
|
g_snmp_sess.securityLevel = SNMP_SEC_LEVEL_NOAUTH;
|
|
else if (strcmp(secLevel, "authNoPriv") == 0)
|
|
g_snmp_sess.securityLevel = SNMP_SEC_LEVEL_AUTHNOPRIV;
|
|
else if (strcmp(secLevel, "authPriv") == 0)
|
|
g_snmp_sess.securityLevel = SNMP_SEC_LEVEL_AUTHPRIV;
|
|
else
|
|
fatalx(EXIT_FAILURE, "Bad SNMPv3 securityLevel: %s", secLevel);
|
|
}
|
|
else
|
|
g_snmp_sess.securityLevel = SNMP_SEC_LEVEL_NOAUTH;
|
|
|
|
/* Security name */
|
|
if (testvar(SU_VAR_SECNAME)) {
|
|
g_snmp_sess.securityName = xstrdup(getval(SU_VAR_SECNAME));
|
|
g_snmp_sess.securityNameLen = strlen(g_snmp_sess.securityName);
|
|
}
|
|
else
|
|
fatalx(EXIT_FAILURE, "securityName is required for SNMPv3");
|
|
|
|
/* Process mandatory fields, based on the security level */
|
|
authPassword = testvar(SU_VAR_AUTHPASSWD) ? getval(SU_VAR_AUTHPASSWD) : NULL;
|
|
privPassword = testvar(SU_VAR_PRIVPASSWD) ? getval(SU_VAR_PRIVPASSWD) : NULL;
|
|
|
|
switch (g_snmp_sess.securityLevel) {
|
|
case SNMP_SEC_LEVEL_AUTHNOPRIV:
|
|
if (authPassword == NULL)
|
|
fatalx(EXIT_FAILURE, "authPassword is required for SNMPv3 in %s mode", secLevel);
|
|
break;
|
|
case SNMP_SEC_LEVEL_AUTHPRIV:
|
|
if ((authPassword == NULL) || (privPassword == NULL))
|
|
fatalx(EXIT_FAILURE, "authPassword and privPassword are required for SNMPv3 in %s mode", secLevel);
|
|
break;
|
|
default:
|
|
case SNMP_SEC_LEVEL_NOAUTH:
|
|
/* nothing else needed */
|
|
break;
|
|
}
|
|
|
|
/* Process authentication protocol and key */
|
|
g_snmp_sess.securityAuthKeyLen = USM_AUTH_KU_LEN;
|
|
authProtocol = testvar(SU_VAR_AUTHPROT) ? getval(SU_VAR_AUTHPROT) : "MD5";
|
|
|
|
#if NUT_HAVE_LIBNETSNMP_usmHMACMD5AuthProtocol
|
|
if (strcmp(authProtocol, "MD5") == 0) {
|
|
g_snmp_sess.securityAuthProto = usmHMACMD5AuthProtocol;
|
|
g_snmp_sess.securityAuthProtoLen = sizeof(usmHMACMD5AuthProtocol)/sizeof(oid);
|
|
}
|
|
else
|
|
#endif
|
|
#if NUT_HAVE_LIBNETSNMP_usmHMACSHA1AuthProtocol
|
|
if (strcmp(authProtocol, "SHA") == 0) {
|
|
g_snmp_sess.securityAuthProto = usmHMACSHA1AuthProtocol;
|
|
g_snmp_sess.securityAuthProtoLen = sizeof(usmHMACSHA1AuthProtocol)/sizeof(oid);
|
|
}
|
|
else
|
|
#endif
|
|
#if NUT_HAVE_LIBNETSNMP_usmHMAC192SHA256AuthProtocol
|
|
if (strcmp(authProtocol, "SHA256") == 0) {
|
|
g_snmp_sess.securityAuthProto = usmHMAC192SHA256AuthProtocol;
|
|
g_snmp_sess.securityAuthProtoLen = sizeof(usmHMAC192SHA256AuthProtocol)/sizeof(oid);
|
|
}
|
|
else
|
|
#endif
|
|
#if NUT_HAVE_LIBNETSNMP_usmHMAC256SHA384AuthProtocol
|
|
if (strcmp(authProtocol, "SHA384") == 0) {
|
|
g_snmp_sess.securityAuthProto = usmHMAC256SHA384AuthProtocol;
|
|
g_snmp_sess.securityAuthProtoLen = sizeof(usmHMAC256SHA384AuthProtocol)/sizeof(oid);
|
|
}
|
|
else
|
|
#endif
|
|
#if NUT_HAVE_LIBNETSNMP_usmHMAC384SHA512AuthProtocol
|
|
if (strcmp(authProtocol, "SHA512") == 0) {
|
|
g_snmp_sess.securityAuthProto = usmHMAC384SHA512AuthProtocol;
|
|
g_snmp_sess.securityAuthProtoLen = sizeof(usmHMAC384SHA512AuthProtocol)/sizeof(oid);
|
|
}
|
|
else
|
|
#endif
|
|
fatalx(EXIT_FAILURE, "Bad SNMPv3 authProtocol: %s", authProtocol);
|
|
|
|
/* set the authentication key to a MD5/SHA1 hashed version of our
|
|
* passphrase (must be at least 8 characters long) */
|
|
if (g_snmp_sess.securityLevel != SNMP_SEC_LEVEL_NOAUTH) {
|
|
#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) )
|
|
# pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_TYPE_LIMITS
|
|
# pragma GCC diagnostic ignored "-Wtype-limits"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE
|
|
# pragma GCC diagnostic ignored "-Wtautological-constant-out-of-range-compare"
|
|
#endif
|
|
|
|
/* NOTE: Net-SNMP headers just are weird like that, in the same release:
|
|
net-snmp/types.h: size_t securityAuthProtoLen;
|
|
net-snmp/library/keytools.h: int generate_Ku(const oid * hashtype, u_int hashtype_len, ...
|
|
* Should we match in configure like for "getnameinfo()" arg types?
|
|
* Currently we cast one to another, below (detecting target type could help).
|
|
*/
|
|
if ((uintmax_t)g_snmp_sess.securityAuthProtoLen > UINT_MAX) {
|
|
#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) )
|
|
# pragma GCC diagnostic pop
|
|
#endif
|
|
fatalx(EXIT_FAILURE,
|
|
"Bad SNMPv3 securityAuthProtoLen: %zu",
|
|
g_snmp_sess.securityAuthProtoLen);
|
|
}
|
|
|
|
if (generate_Ku(g_snmp_sess.securityAuthProto,
|
|
(u_int)g_snmp_sess.securityAuthProtoLen,
|
|
(const unsigned char *) authPassword, strlen(authPassword),
|
|
g_snmp_sess.securityAuthKey,
|
|
&g_snmp_sess.securityAuthKeyLen) !=
|
|
SNMPERR_SUCCESS) {
|
|
fatalx(EXIT_FAILURE, "Error generating Ku from authentication pass phrase");
|
|
}
|
|
}
|
|
|
|
privProtocol = testvar(SU_VAR_PRIVPROT) ? getval(SU_VAR_PRIVPROT) : "DES";
|
|
|
|
#if NUT_HAVE_LIBNETSNMP_usmDESPrivProtocol
|
|
if (strcmp(privProtocol, "DES") == 0) {
|
|
g_snmp_sess.securityPrivProto = usmDESPrivProtocol;
|
|
g_snmp_sess.securityPrivProtoLen = sizeof(usmDESPrivProtocol)/sizeof(oid);
|
|
}
|
|
else
|
|
#endif
|
|
#if NUT_HAVE_LIBNETSNMP_usmAESPrivProtocol || NUT_HAVE_LIBNETSNMP_usmAES128PrivProtocol
|
|
if (strcmp(privProtocol, "AES") == 0) {
|
|
g_snmp_sess.securityPrivProto = usmAESPrivProtocol;
|
|
g_snmp_sess.securityPrivProtoLen = NUT_securityPrivProtoLen;
|
|
}
|
|
else
|
|
#endif
|
|
#if NUT_HAVE_LIBNETSNMP_DRAFT_BLUMENTHAL_AES_04
|
|
# if NUT_HAVE_LIBNETSNMP_usmAES192PrivProtocol
|
|
if (strcmp(privProtocol, "AES192") == 0) {
|
|
g_snmp_sess.securityPrivProto = usmAES192PrivProtocol;
|
|
g_snmp_sess.securityPrivProtoLen = (sizeof(usmAES192PrivProtocol)/sizeof(oid));
|
|
}
|
|
else
|
|
# endif
|
|
# if NUT_HAVE_LIBNETSNMP_usmAES256PrivProtocol
|
|
if (strcmp(privProtocol, "AES256") == 0) {
|
|
g_snmp_sess.securityPrivProto = usmAES256PrivProtocol;
|
|
g_snmp_sess.securityPrivProtoLen = (sizeof(usmAES256PrivProtocol)/sizeof(oid));
|
|
}
|
|
else
|
|
# endif
|
|
#endif /* NUT_HAVE_LIBNETSNMP_DRAFT_BLUMENTHAL_AES_04 */
|
|
fatalx(EXIT_FAILURE, "Bad SNMPv3 privProtocol: %s", privProtocol);
|
|
|
|
/* set the privacy key to a MD5/SHA1 hashed version of our
|
|
* passphrase (must be at least 8 characters long) */
|
|
if (g_snmp_sess.securityLevel == SNMP_SEC_LEVEL_AUTHPRIV) {
|
|
g_snmp_sess.securityPrivKeyLen = USM_PRIV_KU_LEN;
|
|
|
|
#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) )
|
|
# pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_TYPE_LIMITS
|
|
# pragma GCC diagnostic ignored "-Wtype-limits"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE
|
|
# pragma GCC diagnostic ignored "-Wtautological-constant-out-of-range-compare"
|
|
#endif
|
|
/* See comment on generate_Ku() a few dozen lines above */
|
|
if ((uintmax_t)g_snmp_sess.securityAuthProtoLen > UINT_MAX) {
|
|
#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) )
|
|
# pragma GCC diagnostic pop
|
|
#endif
|
|
fatalx(EXIT_FAILURE,
|
|
"Bad SNMPv3 securityAuthProtoLen: %zu",
|
|
g_snmp_sess.securityAuthProtoLen);
|
|
}
|
|
|
|
if (generate_Ku(g_snmp_sess.securityAuthProto,
|
|
(u_int)g_snmp_sess.securityAuthProtoLen,
|
|
(const unsigned char *) privPassword, strlen(privPassword),
|
|
g_snmp_sess.securityPrivKey,
|
|
&g_snmp_sess.securityPrivKeyLen) !=
|
|
SNMPERR_SUCCESS) {
|
|
fatalx(EXIT_FAILURE, "Error generating Ku from privacy pass phrase");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
fatalx(EXIT_FAILURE, "Bad SNMP version: %s", version);
|
|
|
|
/* Open the session */
|
|
SOCK_STARTUP; /* MS Windows wrapper, not really needed on Unix! */
|
|
g_snmp_sess_p = snmp_open(&g_snmp_sess); /* establish the session */
|
|
if (g_snmp_sess_p == NULL) {
|
|
nut_snmp_perror(&g_snmp_sess, 0, NULL, "nut_snmp_init: snmp_open");
|
|
fatalx(EXIT_FAILURE, "Unable to establish communication");
|
|
}
|
|
}
|
|
|
|
void nut_snmp_cleanup(void)
|
|
{
|
|
/* close snmp session. */
|
|
if (g_snmp_sess_p) {
|
|
snmp_close(g_snmp_sess_p);
|
|
g_snmp_sess_p = NULL;
|
|
}
|
|
SOCK_CLEANUP; /* wrapper not needed on Unix! */
|
|
}
|
|
|
|
/* Free a struct snmp_pdu * returned by nut_snmp_walk */
|
|
static void nut_snmp_free(struct snmp_pdu ** array_to_free)
|
|
{
|
|
struct snmp_pdu ** current_element;
|
|
|
|
if (array_to_free != NULL) {
|
|
current_element = array_to_free;
|
|
|
|
while (*current_element != NULL) {
|
|
snmp_free_pdu(*current_element);
|
|
current_element++;
|
|
}
|
|
|
|
free( array_to_free );
|
|
}
|
|
}
|
|
|
|
/* Return a NULL terminated array of snmp_pdu * */
|
|
static struct snmp_pdu **nut_snmp_walk(const char *OID, int max_iteration)
|
|
{
|
|
int status;
|
|
struct snmp_pdu *pdu, *response = NULL;
|
|
oid name[MAX_OID_LEN];
|
|
size_t name_len = MAX_OID_LEN;
|
|
oid * current_name;
|
|
size_t current_name_len;
|
|
static unsigned int numerr = 0;
|
|
int nb_iteration = 0;
|
|
struct snmp_pdu ** ret_array = NULL;
|
|
int type = SNMP_MSG_GET;
|
|
|
|
upsdebugx(3, "%s(%s)", __func__, OID);
|
|
upsdebugx(4, "%s: max. iteration = %i", __func__, max_iteration);
|
|
|
|
/* create and send request. */
|
|
if (!snmp_parse_oid(OID, name, &name_len)) {
|
|
upsdebugx(2, "[%s] %s: %s: %s",
|
|
upsname?upsname:device_name, __func__, OID, snmp_api_errstring(snmp_errno));
|
|
return NULL;
|
|
}
|
|
|
|
current_name = name;
|
|
current_name_len = name_len;
|
|
|
|
while( nb_iteration < max_iteration ) {
|
|
/* Going to a shorter OID means we are outside our sub-tree */
|
|
if( current_name_len < name_len ) {
|
|
break;
|
|
}
|
|
|
|
pdu = snmp_pdu_create(type);
|
|
|
|
if (pdu == NULL) {
|
|
fatalx(EXIT_FAILURE, "Not enough memory");
|
|
}
|
|
|
|
snmp_add_null_var(pdu, current_name, current_name_len);
|
|
|
|
status = snmp_synch_response(g_snmp_sess_p, pdu, &response);
|
|
|
|
if (!response) {
|
|
break;
|
|
}
|
|
|
|
if (!((status == STAT_SUCCESS) && (response->errstat == SNMP_ERR_NOERROR))) {
|
|
if (mibname == NULL) {
|
|
/* We are probing for proper mib - ignore errors */
|
|
snmp_free_pdu(response);
|
|
nut_snmp_free(ret_array);
|
|
return NULL;
|
|
}
|
|
|
|
numerr++;
|
|
|
|
if ((numerr == SU_ERR_LIMIT) || ((numerr % SU_ERR_RATE) == 0)) {
|
|
upslogx(LOG_WARNING, "[%s] Warning: excessive poll "
|
|
"failures, limiting error reporting (OID = %s)",
|
|
upsname?upsname:device_name, OID);
|
|
}
|
|
|
|
if ((numerr < SU_ERR_LIMIT) || ((numerr % SU_ERR_RATE) == 0)) {
|
|
if (type == SNMP_MSG_GETNEXT) {
|
|
upsdebugx(2, "=> No more OID, walk complete");
|
|
}
|
|
else {
|
|
nut_snmp_perror(g_snmp_sess_p, status, response,
|
|
"%s: %s", __func__, OID);
|
|
}
|
|
}
|
|
|
|
snmp_free_pdu(response);
|
|
break;
|
|
} else {
|
|
numerr = 0;
|
|
}
|
|
|
|
nb_iteration++;
|
|
/* +1 is for the terminating NULL */
|
|
struct snmp_pdu ** new_ret_array = realloc(
|
|
ret_array,
|
|
sizeof(struct snmp_pdu*) * ((size_t)nb_iteration+1)
|
|
);
|
|
if (new_ret_array == NULL) {
|
|
upsdebugx(1, "%s: Failed to realloc thread", __func__);
|
|
break;
|
|
}
|
|
else {
|
|
ret_array = new_ret_array;
|
|
}
|
|
ret_array[nb_iteration-1] = response;
|
|
ret_array[nb_iteration]=NULL;
|
|
|
|
current_name = response->variables->name;
|
|
current_name_len = response->variables->name_length;
|
|
|
|
type = SNMP_MSG_GETNEXT;
|
|
}
|
|
|
|
return ret_array;
|
|
}
|
|
|
|
struct snmp_pdu *nut_snmp_get(const char *OID)
|
|
{
|
|
struct snmp_pdu ** pdu_array;
|
|
struct snmp_pdu * ret_pdu;
|
|
|
|
if (OID == NULL)
|
|
return NULL;
|
|
|
|
upsdebugx(3, "%s(%s)", __func__, OID);
|
|
|
|
pdu_array = nut_snmp_walk(OID,1);
|
|
|
|
if(pdu_array == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
ret_pdu = snmp_clone_pdu(*pdu_array);
|
|
|
|
nut_snmp_free(pdu_array);
|
|
|
|
return ret_pdu;
|
|
}
|
|
|
|
static bool_t decode_str(struct snmp_pdu *pdu, char *buf, size_t buf_len, info_lkp_t *oid2info)
|
|
{
|
|
size_t len = 0;
|
|
char tmp_buf[SU_LARGEBUF];
|
|
|
|
/* zero out buffer. */
|
|
memset(buf, 0, buf_len);
|
|
|
|
switch (pdu->variables->type) {
|
|
case ASN_OCTET_STR:
|
|
case ASN_OPAQUE:
|
|
len = pdu->variables->val_len > buf_len - 1 ?
|
|
buf_len - 1 : pdu->variables->val_len;
|
|
/* Test for hexadecimal values */
|
|
int hex = 0, x;
|
|
unsigned char *cp;
|
|
for(cp = pdu->variables->val.string, x = 0; x < (int)pdu->variables->val_len; x++, cp++) {
|
|
if (!(isprint((size_t)*cp) || isspace((size_t)*cp))) {
|
|
hex = 1;
|
|
}
|
|
}
|
|
if (hex)
|
|
snprint_hexstring(buf, buf_len, pdu->variables->val.string, pdu->variables->val_len);
|
|
else {
|
|
memcpy(buf, pdu->variables->val.string, len);
|
|
buf[len] = '\0';
|
|
}
|
|
break;
|
|
case ASN_INTEGER:
|
|
case ASN_COUNTER:
|
|
case ASN_GAUGE:
|
|
if(oid2info) {
|
|
const char *str;
|
|
/* See union netsnmp_vardata in net-snmp/types.h: "integer" is a "long*" */
|
|
assert(sizeof(pdu->variables->val.integer) == sizeof(long*));
|
|
/* If in future net-snmp headers val becomes not-a-pointer,
|
|
* compiler should complain about (void*) arg casting here */
|
|
if((str = su_find_infoval(oid2info, pdu->variables->val.integer))) {
|
|
strncpy(buf, str, buf_len-1);
|
|
}
|
|
/* when oid2info returns NULL, don't publish the variable! */
|
|
else {
|
|
/* strncpy(buf, "UNKNOWN", buf_len-1); */
|
|
return FALSE;
|
|
}
|
|
buf[buf_len-1]='\0';
|
|
}
|
|
else {
|
|
int ret = snprintf(buf, buf_len, "%ld", *pdu->variables->val.integer);
|
|
if (ret < 0)
|
|
upsdebugx(3, "Failed to retrieve ASN_GAUGE");
|
|
else
|
|
len = (size_t)ret;
|
|
}
|
|
break;
|
|
case ASN_TIMETICKS:
|
|
/* convert timeticks to seconds */
|
|
{
|
|
int ret = snprintf(buf, buf_len, "%ld", *pdu->variables->val.integer / 100);
|
|
if (ret < 0)
|
|
upsdebugx(3, "Failed to retrieve ASN_TIMETICKS");
|
|
else
|
|
len = (size_t)ret;
|
|
}
|
|
break;
|
|
case ASN_OBJECT_ID:
|
|
snprint_objid (tmp_buf, sizeof(tmp_buf), pdu->variables->val.objid, pdu->variables->val_len / sizeof(oid));
|
|
upsdebugx(2, "Received an OID value: %s", tmp_buf);
|
|
/* Try to get the value of the pointed OID */
|
|
if (nut_snmp_get_str(tmp_buf, buf, buf_len, oid2info) == FALSE) {
|
|
upsdebugx(3, "Failed to retrieve OID value, using fallback");
|
|
/* Otherwise return the last part of the returned OID (ex: 1.2.3 => 3) */
|
|
char *oid_leaf = strrchr(tmp_buf, '.');
|
|
snprintf(buf, buf_len, "%s", oid_leaf+1);
|
|
upsdebugx(3, "Fallback value: %s", buf);
|
|
}
|
|
break;
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool_t nut_snmp_get_str(const char *OID, char *buf, size_t buf_len, info_lkp_t *oid2info)
|
|
{
|
|
struct snmp_pdu *pdu;
|
|
bool_t ret;
|
|
|
|
upsdebugx(3, "Entering %s()", __func__);
|
|
|
|
pdu = nut_snmp_get(OID);
|
|
if (pdu == NULL)
|
|
return FALSE;
|
|
|
|
ret = decode_str(pdu,buf,buf_len,oid2info);
|
|
|
|
if(ret == FALSE) {
|
|
upsdebugx(2, "[%s] unhandled ASN 0x%x received from %s",
|
|
upsname?upsname:device_name, pdu->variables->type, OID);
|
|
}
|
|
|
|
snmp_free_pdu(pdu);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static bool_t decode_oid(struct snmp_pdu *pdu, char *buf, size_t buf_len)
|
|
{
|
|
/* zero out buffer. */
|
|
memset(buf, 0, buf_len);
|
|
|
|
switch (pdu->variables->type) {
|
|
case ASN_OBJECT_ID:
|
|
snprint_objid (buf, buf_len, pdu->variables->val.objid,
|
|
pdu->variables->val_len / sizeof(oid));
|
|
upsdebugx(2, "OID value: %s", buf);
|
|
break;
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* Return the value stored in OID, which is an OID (sysOID for example)
|
|
* and don't try to get the value pointed by this OID (no follow).
|
|
* To achieve the latter behavior, use standard nut_snmp_get_{str,int}() */
|
|
bool_t nut_snmp_get_oid(const char *OID, char *buf, size_t buf_len)
|
|
{
|
|
struct snmp_pdu *pdu;
|
|
bool_t ret = FALSE;
|
|
|
|
/* zero out buffer. */
|
|
memset(buf, 0, buf_len);
|
|
|
|
upsdebugx(3, "Entering %s()", __func__);
|
|
|
|
pdu = nut_snmp_get(OID);
|
|
if (pdu == NULL)
|
|
return FALSE;
|
|
|
|
ret = decode_oid(pdu, buf, buf_len);
|
|
|
|
if(ret == FALSE) {
|
|
upsdebugx(2, "[%s] unhandled ASN 0x%x received from %s",
|
|
upsname?upsname:device_name, pdu->variables->type, OID);
|
|
}
|
|
|
|
snmp_free_pdu(pdu);
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool_t nut_snmp_get_int(const char *OID, long *pval)
|
|
{
|
|
char tmp_buf[SU_LARGEBUF];
|
|
struct snmp_pdu *pdu;
|
|
long value;
|
|
char *buf;
|
|
|
|
upsdebugx(3, "Entering %s()", __func__);
|
|
|
|
pdu = nut_snmp_get(OID);
|
|
if (pdu == NULL)
|
|
return FALSE;
|
|
|
|
switch (pdu->variables->type) {
|
|
case ASN_OCTET_STR:
|
|
case ASN_OPAQUE:
|
|
buf = xmalloc(pdu->variables->val_len + 1);
|
|
memcpy(buf, pdu->variables->val.string, pdu->variables->val_len);
|
|
buf[pdu->variables->val_len] = '\0';
|
|
value = strtol(buf, NULL, 0);
|
|
free(buf);
|
|
break;
|
|
case ASN_INTEGER:
|
|
case ASN_COUNTER:
|
|
case ASN_GAUGE:
|
|
value = *pdu->variables->val.integer;
|
|
break;
|
|
case ASN_TIMETICKS:
|
|
/* convert timeticks to seconds */
|
|
value = *pdu->variables->val.integer / 100;
|
|
break;
|
|
case ASN_OBJECT_ID:
|
|
snprint_objid (tmp_buf, sizeof(tmp_buf), pdu->variables->val.objid, pdu->variables->val_len / sizeof(oid));
|
|
upsdebugx(2, "Received an OID value: %s", tmp_buf);
|
|
/* Try to get the value of the pointed OID */
|
|
if (nut_snmp_get_int(tmp_buf, &value) == FALSE) {
|
|
upsdebugx(3, "Failed to retrieve OID value, using fallback");
|
|
/* Otherwise return the last part of the returned OID (ex: 1.2.3 => 3) */
|
|
char *oid_leaf = strrchr(tmp_buf, '.');
|
|
value = strtol(oid_leaf+1, NULL, 0);
|
|
upsdebugx(3, "Fallback value: %ld", value);
|
|
}
|
|
break;
|
|
default:
|
|
upslogx(LOG_ERR, "[%s] unhandled ASN 0x%x received from %s",
|
|
upsname?upsname:device_name, pdu->variables->type, OID);
|
|
return FALSE;
|
|
}
|
|
|
|
snmp_free_pdu(pdu);
|
|
|
|
if (pval != NULL)
|
|
*pval = value;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool_t nut_snmp_set(const char *OID, char type, const char *value)
|
|
{
|
|
int status;
|
|
bool_t ret = FALSE;
|
|
struct snmp_pdu *pdu, *response = NULL;
|
|
oid name[MAX_OID_LEN];
|
|
size_t name_len = MAX_OID_LEN;
|
|
|
|
upsdebugx(1, "entering %s(%s, %c, %s)", __func__, OID, type, value);
|
|
|
|
if (!snmp_parse_oid(OID, name, &name_len)) {
|
|
upslogx(LOG_ERR, "[%s] %s: %s: %s",
|
|
upsname?upsname:device_name, __func__, OID, snmp_api_errstring(snmp_errno));
|
|
return FALSE;
|
|
}
|
|
|
|
pdu = snmp_pdu_create(SNMP_MSG_SET);
|
|
if (pdu == NULL)
|
|
fatalx(EXIT_FAILURE, "Not enough memory");
|
|
|
|
if (snmp_add_var(pdu, name, name_len, type, value)) {
|
|
upslogx(LOG_ERR, "[%s] %s: %s: %s",
|
|
upsname?upsname:device_name, __func__, OID, snmp_api_errstring(snmp_errno));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
status = snmp_synch_response(g_snmp_sess_p, pdu, &response);
|
|
|
|
if ((status == STAT_SUCCESS) && (response->errstat == SNMP_ERR_NOERROR))
|
|
ret = TRUE;
|
|
else
|
|
nut_snmp_perror(g_snmp_sess_p, status, response,
|
|
"%s: can't set %s", __func__, OID);
|
|
|
|
snmp_free_pdu(response);
|
|
return ret;
|
|
}
|
|
|
|
bool_t nut_snmp_set_str(const char *OID, const char *value)
|
|
{
|
|
return nut_snmp_set(OID, 's', value);
|
|
}
|
|
|
|
bool_t nut_snmp_set_int(const char *OID, long value)
|
|
{
|
|
char buf[SU_BUFSIZE];
|
|
|
|
snprintf(buf, sizeof(buf), "%ld", value);
|
|
return nut_snmp_set(OID, 'i', buf);
|
|
}
|
|
|
|
bool_t nut_snmp_set_time(const char *OID, long value)
|
|
{
|
|
char buf[SU_BUFSIZE];
|
|
|
|
snprintf(buf, SU_BUFSIZE, "%ld", value * 100);
|
|
return nut_snmp_set(OID, 't', buf);
|
|
}
|
|
|
|
/* log descriptive SNMP error message. */
|
|
void nut_snmp_perror(struct snmp_session *sess, int status,
|
|
struct snmp_pdu *response, const char *fmt, ...)
|
|
{
|
|
va_list va;
|
|
int cliberr, snmperr;
|
|
char *snmperrstr;
|
|
char buf[SU_LARGEBUF];
|
|
|
|
va_start(va, fmt);
|
|
vsnprintf(buf, sizeof(buf), fmt, va);
|
|
va_end(va);
|
|
|
|
if (response == NULL) {
|
|
snmp_error(sess, &cliberr, &snmperr, &snmperrstr);
|
|
upslogx(LOG_ERR, "[%s] %s: %s",
|
|
upsname?upsname:device_name, buf, snmperrstr);
|
|
free(snmperrstr);
|
|
} else if (status == STAT_SUCCESS) {
|
|
/* Net-SNMP headers provide and consume errstat with different types:
|
|
net-snmp/output_api.h: const char *snmp_errstring(int snmp_errorno);
|
|
net-snmp/types.h: long errstat;
|
|
* Should we match in configure like for "getnameinfo()" arg types?
|
|
* Currently we cast one to another, below (detecting target type could help).
|
|
*/
|
|
switch (response->errstat)
|
|
{
|
|
case SNMP_ERR_NOERROR:
|
|
break;
|
|
case SNMP_ERR_NOSUCHNAME: /* harmless */
|
|
upsdebugx(2, "[%s] %s: %s",
|
|
upsname?upsname:device_name,
|
|
buf,
|
|
(response->errstat > INT_MAX
|
|
? "(Net-SNMP errstat value is out of range)"
|
|
: snmp_errstring((int)response->errstat)
|
|
));
|
|
break;
|
|
default:
|
|
upslogx(LOG_ERR, "[%s] %s: Error in packet: %s",
|
|
upsname?upsname:device_name,
|
|
buf,
|
|
(response->errstat > INT_MAX
|
|
? "(Net-SNMP errstat value is out of range)"
|
|
: snmp_errstring((int)response->errstat)
|
|
));
|
|
break;
|
|
}
|
|
} else if (status == STAT_TIMEOUT) {
|
|
upslogx(LOG_ERR, "[%s] %s: Timeout: no response from %s",
|
|
upsname?upsname:device_name, buf, sess->peername);
|
|
} else {
|
|
snmp_sess_error(sess, &cliberr, &snmperr, &snmperrstr);
|
|
upslogx(LOG_ERR, "[%s] %s: %s",
|
|
upsname?upsname:device_name, buf, snmperrstr);
|
|
free(snmperrstr);
|
|
}
|
|
}
|
|
|
|
/* -----------------------------------------------------------
|
|
* utility functions.
|
|
* ----------------------------------------------------------- */
|
|
|
|
/* deal with APCC weirdness on Symmetras */
|
|
static void disable_transfer_oids(void)
|
|
{
|
|
snmp_info_t *su_info_p;
|
|
|
|
upslogx(LOG_INFO, "Disabling transfer OIDs");
|
|
|
|
if (snmp_info == NULL) {
|
|
fatalx(EXIT_FAILURE, "%s: snmp_info is not initialized", __func__);
|
|
}
|
|
|
|
if (snmp_info[0].info_type == NULL) {
|
|
upsdebugx(1, "%s: WARNING: snmp_info is empty", __func__);
|
|
}
|
|
|
|
for (su_info_p = &snmp_info[0]; (su_info_p != NULL && su_info_p->info_type != NULL) ; su_info_p++) {
|
|
if (!strcasecmp(su_info_p->info_type, "input.transfer.low")) {
|
|
su_info_p->flags &= ~SU_FLAG_OK;
|
|
continue;
|
|
}
|
|
|
|
if (!strcasecmp(su_info_p->info_type, "input.transfer.high")) {
|
|
su_info_p->flags &= ~SU_FLAG_OK;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Universal function to add or update info element.
|
|
* If value is NULL, use the default one (su_info_p->dfl) if provided */
|
|
void su_setinfo(snmp_info_t *su_info_p, const char *value)
|
|
{
|
|
info_lkp_t *info_lkp;
|
|
char info_type[128]; /* We tweak incoming "su_info_p->info_type" value in some cases */
|
|
|
|
/* FIXME: Replace hardcoded 128 with a macro above (use {SU_}LARGEBUF?),
|
|
* and same macro or sizeof(info_type) below (also more 128 cases below)?
|
|
*/
|
|
|
|
upsdebugx(1, "entering %s(%s, %s)", __func__, su_info_p->info_type, (value)?value:"");
|
|
|
|
/* FIXME: This 20 seems very wrong (should be "128", macro or sizeof? see above) */
|
|
memset(info_type, 0, 20);
|
|
/* pre-fill with the device name for checking */
|
|
snprintf(info_type, 128, "device.%i", current_device_number);
|
|
|
|
/* Daisy-chain template magic should only apply to defaulted
|
|
* entries (oid==null) or templated entries (contains .%i);
|
|
* however at this point we see exact OIDs handed down from
|
|
* su_ups_get() which instantiates a template (if needed -
|
|
* and knows it was a template) and calls su_setinfo().
|
|
* NOTE: For setting the values (or commands) from clients
|
|
* like `upsrw`, see su_setOID() method. Here we change our
|
|
* device state records based on readings from a device.
|
|
*/
|
|
if ((daisychain_enabled == TRUE) && (devices_count > 1)) {
|
|
if (su_info_p->OID != NULL
|
|
&& strstr(su_info_p->OID, ".%i") != NULL
|
|
) {
|
|
/* Only inform, do not react so far,
|
|
* need more understanding if and when
|
|
* such situation might happen at all:
|
|
*/
|
|
upsdebugx(5, "%s: in a daisy-chained device, "
|
|
"got a templated OID %s for type %s",
|
|
__func__, su_info_p->OID,
|
|
su_info_p->info_type);
|
|
}
|
|
|
|
/* Only append "device.X" for master and slaves, if not already done! */
|
|
if ((current_device_number > 0) && (strstr(su_info_p->info_type, info_type) == NULL)) {
|
|
/* Special case: we remove "device" from the device collection not to
|
|
* get "device.X.device.<something>", but "device.X.<something>" */
|
|
if (!strncmp(su_info_p->info_type, "device.", 7)) {
|
|
upsdebugx(6, "%s: in a daisy-chained device, "
|
|
"OID %s: TRIM 'device.' from type %s (value %s)",
|
|
__func__, su_info_p->OID,
|
|
su_info_p->info_type, (value)?value:"");
|
|
snprintf(info_type, 128, "device.%i.%s",
|
|
current_device_number, su_info_p->info_type + 7);
|
|
}
|
|
else {
|
|
upsdebugx(6, "%s: in a daisy-chained device, "
|
|
"OID %s is templated: for type %s (value %s)",
|
|
__func__, su_info_p->OID,
|
|
su_info_p->info_type, (value)?value:"");
|
|
snprintf(info_type, 128, "device.%i.%s",
|
|
current_device_number, su_info_p->info_type);
|
|
}
|
|
}
|
|
else {
|
|
upsdebugx(6, "%s: in a daisy-chained device, "
|
|
"OID %s: for type %s (value %s) "
|
|
"device %d is not positive or type already "
|
|
"contains the prepared expectation: %s",
|
|
__func__, su_info_p->OID,
|
|
su_info_p->info_type, (value)?value:"",
|
|
current_device_number,
|
|
info_type
|
|
);
|
|
snprintf(info_type, 128, "%s", su_info_p->info_type);
|
|
}
|
|
}
|
|
else {
|
|
upsdebugx(6, "%s: NOT in a daisy-chained device", __func__);
|
|
snprintf(info_type, 128, "%s", su_info_p->info_type);
|
|
}
|
|
|
|
upsdebugx(1, "%s: using info_type '%s'", __func__, info_type);
|
|
|
|
if (SU_TYPE(su_info_p) == SU_TYPE_CMD)
|
|
return;
|
|
|
|
/* ups.status and {ups, Lx, outlet, outlet.group}.alarm have special
|
|
* handling, not here! */
|
|
if ((strcasecmp(su_info_p->info_type, "ups.status"))
|
|
&& (strcasecmp(strrchr(su_info_p->info_type, '.'), ".alarm")))
|
|
{
|
|
if (value != NULL)
|
|
dstate_setinfo(info_type, "%s", value);
|
|
else if (su_info_p->dfl != NULL)
|
|
dstate_setinfo(info_type, "%s", su_info_p->dfl);
|
|
else {
|
|
upsdebugx(3, "%s: no value nor default provided, aborting...", __func__);
|
|
return;
|
|
}
|
|
|
|
dstate_setflags(info_type, su_info_p->info_flags);
|
|
dstate_setaux(info_type, su_info_p->info_len);
|
|
|
|
/* Set enumerated values, only if the data has ST_FLAG_RW and there
|
|
* are lookup values */
|
|
/* FIXME: daisychain settings support: check if applicable */
|
|
if ((su_info_p->info_flags & ST_FLAG_RW) && su_info_p->oid2info) {
|
|
|
|
upsdebugx(3, "%s: adding enumerated values", __func__);
|
|
|
|
/* Loop on all existing values */
|
|
for (info_lkp = su_info_p->oid2info; info_lkp != NULL
|
|
&& info_lkp->info_value != NULL; info_lkp++) {
|
|
dstate_addenum(info_type, "%s", info_lkp->info_value);
|
|
}
|
|
}
|
|
|
|
/* Commit the current value, to avoid staleness with huge
|
|
* data collections on slow devices */
|
|
dstate_dataok();
|
|
}
|
|
}
|
|
|
|
void su_status_set(snmp_info_t *su_info_p, long value)
|
|
{
|
|
const char *info_value = NULL;
|
|
|
|
upsdebugx(2, "SNMP UPS driver: entering %s()", __func__);
|
|
|
|
if ((info_value = su_find_infoval(su_info_p->oid2info, &value)) != NULL)
|
|
{
|
|
if (info_value[0] != '\0') {
|
|
status_set(info_value);
|
|
}
|
|
}
|
|
/* TODO: else */
|
|
}
|
|
|
|
void su_alarm_set(snmp_info_t *su_info_p, long value)
|
|
{
|
|
const char *info_value = NULL;
|
|
const char *info_type = NULL;
|
|
char alarm_info_value[SU_LARGEBUF];
|
|
/* number of the outlet or phase */
|
|
int item_number = -1;
|
|
|
|
upsdebugx(2, "SNMP UPS driver: entering %s(%s)", __func__, su_info_p->info_type);
|
|
|
|
/* daisychain handling
|
|
* extract the template part to get the relevant 'info_type' part
|
|
* ex: device.6.L1.alarm => L1.alarm
|
|
* ex: device.6.outlet.1.alarm => outlet.1.alarm */
|
|
if (!strncmp(su_info_p->info_type, "device.", 7)) {
|
|
info_type = strchr(su_info_p->info_type + 7, '.') + 1;
|
|
}
|
|
else
|
|
info_type = su_info_p->info_type;
|
|
|
|
upsdebugx(2, "%s: using definition %s", __func__, info_type);
|
|
|
|
if ((info_value = su_find_infoval(su_info_p->oid2info, &value)) != NULL
|
|
&& info_value[0] != 0)
|
|
{
|
|
/* Special handling for outlet & outlet groups alarms */
|
|
if ((su_info_p->flags & SU_OUTLET)
|
|
|| (su_info_p->flags & SU_OUTLET_GROUP)) {
|
|
/* Extract template number */
|
|
item_number = extract_template_number(su_info_p->flags, info_type);
|
|
|
|
upsdebugx(2, "%s: appending %s %i", __func__,
|
|
(su_info_p->flags & SU_OUTLET_GROUP) ? "outlet group" : "outlet", item_number);
|
|
|
|
/* Inject in the alarm string */
|
|
snprintf(alarm_info_value, sizeof(alarm_info_value),
|
|
"outlet%s %i %s", (su_info_p->flags & SU_OUTLET_GROUP) ? " group" : "",
|
|
item_number, info_value);
|
|
info_value = &alarm_info_value[0];
|
|
}
|
|
/* Special handling for phase alarms
|
|
* Note that SU_*PHASE flags are cleared, so match the 'Lx'
|
|
* start of path */
|
|
if (info_type[0] == 'L') {
|
|
/* Extract phase number */
|
|
item_number = atoi(info_type+1);
|
|
char alarm_info_value_more[SU_LARGEBUF + 32]; /* can sprintf() SU_LARGEBUF plus markup into here */
|
|
|
|
upsdebugx(2, "%s: appending phase L%i", __func__, item_number);
|
|
|
|
/* Inject in the alarm string */
|
|
snprintf(alarm_info_value_more, sizeof(alarm_info_value_more),
|
|
"phase L%i %s", item_number, info_value);
|
|
info_value = &alarm_info_value_more[0];
|
|
}
|
|
|
|
/* Set the alarm value */
|
|
alarm_set(info_value);
|
|
}
|
|
/* TODO: else */
|
|
}
|
|
|
|
/* find info element definition in my info array. */
|
|
snmp_info_t *su_find_info(const char *type)
|
|
{
|
|
snmp_info_t *su_info_p;
|
|
|
|
if (snmp_info == NULL) {
|
|
fatalx(EXIT_FAILURE, "%s: snmp_info is not initialized", __func__);
|
|
}
|
|
|
|
if (snmp_info[0].info_type == NULL) {
|
|
upsdebugx(1, "%s: WARNING: snmp_info is empty", __func__);
|
|
}
|
|
|
|
for (su_info_p = &snmp_info[0]; (su_info_p != NULL && su_info_p->info_type != NULL) ; su_info_p++)
|
|
if (!strcasecmp(su_info_p->info_type, type)) {
|
|
upsdebugx(3, "%s: \"%s\" found", __func__, type);
|
|
return su_info_p;
|
|
}
|
|
|
|
upsdebugx(3, "%s: unknown info type (%s)", __func__, type);
|
|
return NULL;
|
|
}
|
|
|
|
/* Counter match the sysOID using {device,ups}.model OID
|
|
* Return TRUE if this OID can be retrieved, FALSE otherwise */
|
|
static bool_t match_model_OID()
|
|
{
|
|
bool_t retCode = FALSE;
|
|
snmp_info_t *su_info_p, *cur_info_p;
|
|
char testOID_buf[LARGEBUF];
|
|
|
|
/* Try to get device.model first */
|
|
su_info_p = su_find_info("device.model");
|
|
/* Otherwise, try to get ups.model */
|
|
if (su_info_p == NULL)
|
|
su_info_p = su_find_info("ups.model");
|
|
|
|
if (su_info_p != NULL) {
|
|
/* Daisychain specific: we may have a template (including formatting
|
|
* string) that needs to be adapted! */
|
|
if (strchr(su_info_p->OID, '%') != NULL)
|
|
{
|
|
upsdebugx(2, "Found template, need to be adapted");
|
|
cur_info_p = (snmp_info_t *)malloc(sizeof(snmp_info_t));
|
|
cur_info_p->info_type = (char *)xmalloc(SU_INFOSIZE);
|
|
cur_info_p->OID = (char *)xmalloc(SU_INFOSIZE);
|
|
snprintf((char*)cur_info_p->info_type, SU_INFOSIZE, "%s", su_info_p->info_type);
|
|
/* Use the daisychain master (0) / 1rst device index */
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_SECURITY
|
|
#pragma GCC diagnostic ignored "-Wformat-security"
|
|
#endif
|
|
snprintf((char*)cur_info_p->OID, SU_INFOSIZE, su_info_p->OID, 0);
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
}
|
|
else {
|
|
upsdebugx(2, "Found entry, not a template %s", su_info_p->OID);
|
|
/* Otherwise, just point at what we found */
|
|
cur_info_p = su_info_p;
|
|
}
|
|
|
|
upsdebugx(2, "Testing %s using OID %s", cur_info_p->info_type, cur_info_p->OID);
|
|
retCode = nut_snmp_get_str(cur_info_p->OID, testOID_buf, LARGEBUF, NULL);
|
|
|
|
/* Free our malloc, if it was dynamic */
|
|
if (strchr(su_info_p->OID, '%') != NULL) {
|
|
if (cur_info_p->info_type != NULL)
|
|
free((char*)cur_info_p->info_type);
|
|
if (cur_info_p->OID != NULL)
|
|
free((char*)cur_info_p->OID);
|
|
if (cur_info_p != NULL)
|
|
free((char*)cur_info_p);
|
|
}
|
|
}
|
|
|
|
return retCode;
|
|
}
|
|
|
|
/* Try to find the MIB using sysOID matching.
|
|
* Return a pointer to a mib2nut definition if found, NULL otherwise */
|
|
static mib2nut_info_t *match_sysoid()
|
|
{
|
|
char sysOID_buf[LARGEBUF];
|
|
oid device_sysOID[MAX_OID_LEN];
|
|
size_t device_sysOID_len = MAX_OID_LEN;
|
|
oid mib2nut_sysOID[MAX_OID_LEN];
|
|
size_t mib2nut_sysOID_len = MAX_OID_LEN;
|
|
int i;
|
|
|
|
/* Retrieve sysOID value of this device */
|
|
if (nut_snmp_get_oid(SYSOID_OID, sysOID_buf, sizeof(sysOID_buf)) == TRUE)
|
|
{
|
|
upsdebugx(1, "%s: device sysOID value = %s", __func__, sysOID_buf);
|
|
|
|
/* Build OIDs for comparison */
|
|
if (!read_objid(sysOID_buf, device_sysOID, &device_sysOID_len))
|
|
{
|
|
upsdebugx(2, "%s: can't build device_sysOID %s: %s",
|
|
__func__, sysOID_buf, snmp_api_errstring(snmp_errno));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Now, iterate on mib2nut definitions */
|
|
for (i = 0; mib2nut[i] != NULL; i++)
|
|
{
|
|
upsdebugx(1, "%s: checking MIB %s", __func__, mib2nut[i]->mib_name);
|
|
|
|
if (mib2nut[i]->sysOID == NULL)
|
|
continue;
|
|
|
|
/* Clear variables */
|
|
memset(mib2nut_sysOID, 0, sizeof(mib2nut_sysOID));
|
|
mib2nut_sysOID_len = MAX_OID_LEN;
|
|
|
|
if (!read_objid(mib2nut[i]->sysOID, mib2nut_sysOID, &mib2nut_sysOID_len))
|
|
{
|
|
upsdebugx(2, "%s: can't build OID %s: %s",
|
|
__func__, sysOID_buf, snmp_api_errstring(snmp_errno));
|
|
|
|
/* Try to continue anyway! */
|
|
continue;
|
|
}
|
|
|
|
/* Now compare these */
|
|
upsdebugx(1, "%s: comparing %s with %s", __func__, sysOID_buf, mib2nut[i]->sysOID);
|
|
if (!netsnmp_oid_equals(device_sysOID, device_sysOID_len, mib2nut_sysOID, mib2nut_sysOID_len))
|
|
{
|
|
upsdebugx(2, "%s: sysOID matches MIB '%s'!", __func__, mib2nut[i]->mib_name);
|
|
/* Counter verify, using {ups,device}.model */
|
|
snmp_info = mib2nut[i]->snmp_info;
|
|
|
|
if (snmp_info == NULL) {
|
|
upsdebugx(0, "%s: WARNING: snmp_info is not initialized "
|
|
"for mapping table entry #%d \"%s\"",
|
|
__func__, i, mib2nut[i]->mib_name
|
|
);
|
|
continue;
|
|
}
|
|
else if (snmp_info[0].info_type == NULL) {
|
|
upsdebugx(1, "%s: WARNING: snmp_info is empty "
|
|
"for mapping table entry #%d \"%s\"",
|
|
__func__, i, mib2nut[i]->mib_name);
|
|
}
|
|
|
|
if (match_model_OID() != TRUE)
|
|
{
|
|
upsdebugx(2, "%s: testOID provided and doesn't match MIB '%s'!", __func__, mib2nut[i]->mib_name);
|
|
snmp_info = NULL;
|
|
continue;
|
|
}
|
|
else
|
|
upsdebugx(2, "%s: testOID provided and matches MIB '%s'!", __func__, mib2nut[i]->mib_name);
|
|
|
|
return mib2nut[i];
|
|
}
|
|
}
|
|
|
|
/* Yell all to call for user report */
|
|
upslogx(LOG_ERR, "No matching MIB found for sysOID '%s'!\n" \
|
|
"Please report it to NUT developers, with an 'upsc' output for your device.\n" \
|
|
"Going back to the classic MIB detection method.",
|
|
sysOID_buf);
|
|
}
|
|
else
|
|
upsdebugx(2, "Can't get sysOID value");
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Load the right snmp_info_t structure matching mib parameter */
|
|
bool_t load_mib2nut(const char *mib)
|
|
{
|
|
int i;
|
|
mib2nut_info_t *m2n = NULL;
|
|
/* Below we have many checks for "auto"; avoid redundant string walks: */
|
|
bool_t mibIsAuto = (0 == strcmp(mib, "auto"));
|
|
bool_t mibSeen = FALSE; /* Did we see the MIB name while walking mib2nut[]? */
|
|
|
|
upsdebugx(1, "SNMP UPS driver: entering %s(%s) to detect "
|
|
"proper MIB for device [%s] (host %s)",
|
|
__func__, mib,
|
|
upsname ? upsname : device_name,
|
|
device_path /* the "port" from config section is hostname/IP for networked drivers */
|
|
);
|
|
|
|
/* First, try to match against sysOID, if no MIB was provided.
|
|
* This should speed up init stage
|
|
* (Note: sysOID points the device main MIB entry point) */
|
|
if (mibIsAuto)
|
|
{
|
|
upsdebugx(2, "%s: trying the new match_sysoid() method with %s",
|
|
__func__, mib);
|
|
/* Retry at most 3 times, to maximise chances */
|
|
for (i = 0; i < 3 ; i++) {
|
|
upsdebugx(3, "%s: trying the new match_sysoid() method: attempt #%d",
|
|
__func__, (i+1));
|
|
if ((m2n = match_sysoid()) != NULL)
|
|
break;
|
|
|
|
if (m2n == NULL)
|
|
upsdebugx(3, "%s: failed with new match_sysoid() method",
|
|
__func__);
|
|
else
|
|
upsdebugx(3, "%s: found something with new match_sysoid() method",
|
|
__func__);
|
|
}
|
|
}
|
|
|
|
/* Otherwise, revert to the classic method */
|
|
if (m2n == NULL)
|
|
{
|
|
for (i = 0; mib2nut[i] != NULL; i++) {
|
|
/* Is there already a MIB name provided? */
|
|
upsdebugx(4, "%s: checking against mapping table entry #%d \"%s\"",
|
|
__func__, i, mib2nut[i]->mib_name);
|
|
if (!mibIsAuto && strcmp(mib, mib2nut[i]->mib_name)) {
|
|
/* "mib" is neither "auto" nor the name in mapping table */
|
|
upsdebugx(2, "%s: skip the \"%s\" entry which "
|
|
"is neither \"auto\" nor a valid name in the mapping table",
|
|
__func__, mib);
|
|
continue;
|
|
}
|
|
upsdebugx(2, "%s: trying classic sysOID matching method with '%s' mib",
|
|
__func__, mib2nut[i]->mib_name);
|
|
|
|
/* Classic method: test an OID specific to this MIB */
|
|
snmp_info = mib2nut[i]->snmp_info;
|
|
|
|
if (snmp_info == NULL) {
|
|
upsdebugx(0, "%s: WARNING: snmp_info is not initialized "
|
|
"for mapping table entry #%d \"%s\"",
|
|
__func__, i, mib2nut[i]->mib_name
|
|
);
|
|
continue;
|
|
}
|
|
else if (snmp_info[0].info_type == NULL) {
|
|
upsdebugx(1, "%s: WARNING: snmp_info is empty "
|
|
"for mapping table entry #%d \"%s\"",
|
|
__func__, i, mib2nut[i]->mib_name);
|
|
}
|
|
|
|
/* Device might not support this MIB, but we want to
|
|
* track that the name string is valid for diags below
|
|
*/
|
|
if (!mibIsAuto) {
|
|
mibSeen = TRUE;
|
|
}
|
|
|
|
if (match_model_OID() != TRUE)
|
|
{
|
|
upsdebugx(3, "%s: testOID provided and doesn't match MIB '%s'!",
|
|
__func__, mib2nut[i]->mib_name);
|
|
snmp_info = NULL;
|
|
continue;
|
|
}
|
|
else
|
|
upsdebugx(3, "%s: testOID provided and matches MIB '%s'!",
|
|
__func__, mib2nut[i]->mib_name);
|
|
|
|
/* MIB found */
|
|
m2n = mib2nut[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Store the result, if any */
|
|
if (m2n != NULL)
|
|
{
|
|
snmp_info = m2n->snmp_info;
|
|
OID_pwr_status = m2n->oid_pwr_status;
|
|
mibname = m2n->mib_name;
|
|
mibvers = m2n->mib_version;
|
|
alarms_info = m2n->alarms_info;
|
|
upsdebugx(1, "%s: using %s MIB for device [%s] (host %s)",
|
|
__func__, mibname,
|
|
upsname ? upsname : device_name, device_path);
|
|
return TRUE;
|
|
}
|
|
|
|
/* Did we find something or is it really an unknown mib */
|
|
if (!mibIsAuto) {
|
|
if (mibSeen) {
|
|
fatalx(EXIT_FAILURE, "Requested 'mibs' value '%s' "
|
|
"did not match this device [%s] (host %s)",
|
|
mib, upsname ? upsname : device_name, device_path);
|
|
} else {
|
|
/* String not seen during mib2nut[] walk -
|
|
* and if we had no hits, we walked it all
|
|
*/
|
|
fatalx(EXIT_FAILURE, "Unknown 'mibs' value: %s", mib);
|
|
}
|
|
} else {
|
|
fatalx(EXIT_FAILURE, "No supported device detected at [%s] (host %s)",
|
|
upsname ? upsname : device_name, device_path);
|
|
}
|
|
|
|
/* Should not get here thanks to fatalx() above, but need to silence a warning */
|
|
return FALSE;
|
|
}
|
|
|
|
/* find the OID value matching that INFO_* value */
|
|
long su_find_valinfo(info_lkp_t *oid2info, const char* value)
|
|
{
|
|
info_lkp_t *info_lkp;
|
|
|
|
for (info_lkp = oid2info; (info_lkp != NULL) &&
|
|
(strcmp(info_lkp->info_value, "NULL")); info_lkp++) {
|
|
|
|
if (!(strcmp(info_lkp->info_value, value))) {
|
|
upsdebugx(1, "%s: found %s (value: %s)",
|
|
__func__, info_lkp->info_value, value);
|
|
|
|
return info_lkp->oid_value;
|
|
}
|
|
}
|
|
upsdebugx(1, "%s: no matching INFO_* value for this OID value (%s)", __func__, value);
|
|
return -1;
|
|
}
|
|
|
|
/* String reformating function */
|
|
const char *su_find_strval(info_lkp_t *oid2info, void *value)
|
|
{
|
|
#if WITH_SNMP_LKP_FUN
|
|
/* First test if we have a generic lookup function */
|
|
if ( (oid2info != NULL) && (oid2info->fun_vp2s != NULL) ) {
|
|
upsdebugx(2, "%s: using generic lookup function (string reformatting)", __func__);
|
|
const char * retvalue = oid2info->fun_vp2s(value);
|
|
upsdebugx(2, "%s: got value '%s'", __func__, retvalue);
|
|
return retvalue;
|
|
}
|
|
upsdebugx(1, "%s: no result value for this OID string value (%s)", __func__, (char*)value);
|
|
#else
|
|
NUT_UNUSED_VARIABLE(oid2info);
|
|
upsdebugx(1, "%s: no mapping function for this OID string value (%s)", __func__, (char*)value);
|
|
#endif // WITH_SNMP_LKP_FUN
|
|
return NULL;
|
|
}
|
|
|
|
/* find the INFO_* value matching that OID numeric (long) value */
|
|
const char *su_find_infoval(info_lkp_t *oid2info, void *raw_value)
|
|
{
|
|
info_lkp_t *info_lkp;
|
|
long value = *((long *)raw_value);
|
|
|
|
#if WITH_SNMP_LKP_FUN
|
|
/* First test if we have a generic lookup function */
|
|
if ( (oid2info != NULL) && (oid2info->fun_vp2s != NULL) ) {
|
|
upsdebugx(2, "%s: using generic lookup function", __func__);
|
|
const char * retvalue = oid2info->fun_vp2s(raw_value);
|
|
upsdebugx(2, "%s: got value '%s'", __func__, retvalue);
|
|
return retvalue;
|
|
}
|
|
#endif // WITH_SNMP_LKP_FUN
|
|
|
|
/* Otherwise, use the simple values mapping */
|
|
for (info_lkp = oid2info; (info_lkp != NULL) &&
|
|
(info_lkp->info_value != NULL) && (strcmp(info_lkp->info_value, "NULL")); info_lkp++) {
|
|
|
|
if (info_lkp->oid_value == value) {
|
|
upsdebugx(1, "%s: found %s (value: %ld)",
|
|
__func__, info_lkp->info_value, value);
|
|
|
|
return info_lkp->info_value;
|
|
}
|
|
}
|
|
upsdebugx(1, "%s: no matching INFO_* value for this OID value (%ld)", __func__, value);
|
|
return NULL;
|
|
}
|
|
|
|
/* FIXME: doesn't work with templates! */
|
|
static void disable_competition(snmp_info_t *entry)
|
|
{
|
|
snmp_info_t *p;
|
|
|
|
if (snmp_info == NULL) {
|
|
fatalx(EXIT_FAILURE, "%s: snmp_info is not initialized", __func__);
|
|
}
|
|
|
|
if (snmp_info[0].info_type == NULL) {
|
|
upsdebugx(1, "%s: WARNING: snmp_info is empty", __func__);
|
|
}
|
|
|
|
for(p = snmp_info; (p != NULL && p->info_type != NULL) ; p++) {
|
|
if(p!=entry && !strcmp(p->info_type, entry->info_type)) {
|
|
upsdebugx(2, "%s: disabling %s %s",
|
|
__func__, p->info_type, p->OID);
|
|
p->flags &= ~SU_FLAG_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* set shutdown and/or start delays */
|
|
void set_delays(void)
|
|
{
|
|
int ondelay, offdelay;
|
|
char su_scratch_buf[255];
|
|
|
|
if (getval(SU_VAR_ONDELAY))
|
|
ondelay = atoi(getval(SU_VAR_ONDELAY));
|
|
else
|
|
ondelay = -1;
|
|
|
|
if (getval(SU_VAR_OFFDELAY))
|
|
offdelay = atoi(getval(SU_VAR_OFFDELAY));
|
|
else
|
|
offdelay = -1;
|
|
|
|
if (ondelay >= 0) {
|
|
sprintf(su_scratch_buf, "%d", ondelay);
|
|
su_setvar("ups.delay.start", su_scratch_buf);
|
|
}
|
|
|
|
if (offdelay >= 0) {
|
|
sprintf(su_scratch_buf, "%d", offdelay);
|
|
su_setvar("ups.delay.shutdown", su_scratch_buf);
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* Template handling functions
|
|
**********************************************************************/
|
|
|
|
/* Test if the template is a multiple one, i.e. with a formatting string that
|
|
* contains multiple "%i".
|
|
* Return TRUE if yes (multiple "%i" found), FALSE otherwise */
|
|
static bool_t is_multiple_template(const char *OID_template)
|
|
{
|
|
bool_t retCode = FALSE;
|
|
char *format_char = NULL;
|
|
|
|
if (OID_template) {
|
|
format_char = strchr(OID_template, '%');
|
|
upsdebugx(4, "%s(%s)", __func__, OID_template);
|
|
}
|
|
else
|
|
upsdebugx(4, "%s(NULL)", __func__);
|
|
|
|
if (format_char != NULL) {
|
|
if (strchr(format_char + 1, '%') != NULL) {
|
|
retCode = TRUE;
|
|
}
|
|
}
|
|
|
|
upsdebugx(4, "%s: has %smultiple template definition",
|
|
__func__, (retCode == FALSE)?"not ":"");
|
|
|
|
return retCode;
|
|
}
|
|
|
|
/* Instantiate an snmp_info_t from a template.
|
|
* Useful for device, outlet, outlet.group and ambient templates.
|
|
* Note: remember to adapt info_type, OID and optionaly dfl */
|
|
static snmp_info_t *instantiate_info(snmp_info_t *info_template, snmp_info_t *new_instance)
|
|
{
|
|
upsdebugx(1, "%s(%s)", __func__,
|
|
info_template ? info_template->info_type : "n/a");
|
|
|
|
/* sanity check */
|
|
if (info_template == NULL)
|
|
return NULL;
|
|
|
|
if (new_instance == NULL)
|
|
new_instance = (snmp_info_t *)xmalloc(sizeof(snmp_info_t));
|
|
/* TOTHINK: Should there be an "else" to free()
|
|
* the fields which we (re-)allocate below? */
|
|
|
|
new_instance->info_type = (char *)xmalloc(SU_INFOSIZE);
|
|
if (new_instance->info_type)
|
|
memset((char *)new_instance->info_type, 0, SU_INFOSIZE);
|
|
if (info_template->OID != NULL) {
|
|
new_instance->OID = (char *)xmalloc(SU_INFOSIZE);
|
|
if (new_instance->OID)
|
|
memset((char *)new_instance->OID, 0, SU_INFOSIZE);
|
|
}
|
|
else {
|
|
new_instance->OID = NULL;
|
|
}
|
|
|
|
new_instance->info_flags = info_template->info_flags;
|
|
new_instance->info_len = info_template->info_len;
|
|
/* FIXME: check if we need to adapt this one... */
|
|
new_instance->dfl = info_template->dfl;
|
|
new_instance->flags = info_template->flags;
|
|
new_instance->oid2info = info_template->oid2info;
|
|
|
|
upsdebugx(2, "instantiate_info: template instantiated");
|
|
return new_instance;
|
|
}
|
|
|
|
/* Free a dynamically allocated snmp_info_t.
|
|
* Useful for outlet and outlet.group templates */
|
|
static void free_info(snmp_info_t *su_info_p)
|
|
{
|
|
/* sanity check */
|
|
if (su_info_p == NULL)
|
|
return;
|
|
|
|
if (su_info_p->info_type != NULL)
|
|
free ((char *)su_info_p->info_type);
|
|
|
|
if (su_info_p->OID != NULL)
|
|
free ((char *)su_info_p->OID);
|
|
|
|
free (su_info_p);
|
|
}
|
|
|
|
/* return the base SNMP index (0 or 1) to start template iteration on
|
|
* the MIB, based on a test using a template OID */
|
|
static int base_snmp_template_index(const snmp_info_t *su_info_p)
|
|
{
|
|
if (!su_info_p)
|
|
return -1;
|
|
|
|
int base_index = -1;
|
|
char test_OID[SU_INFOSIZE];
|
|
snmp_info_flags_t template_type = get_template_type(su_info_p->info_type);
|
|
|
|
if (!su_info_p->OID)
|
|
return base_index;
|
|
|
|
upsdebugx(3, "%s: OID template = %s", __func__, su_info_p->OID);
|
|
|
|
/* Try to differentiate between template types which may have
|
|
* different indexes ; and store it to not redo it again */
|
|
switch (template_type) {
|
|
case SU_OUTLET:
|
|
template_index_base = outlet_template_index_base;
|
|
break;
|
|
case SU_OUTLET_GROUP:
|
|
template_index_base = outletgroup_template_index_base;
|
|
break;
|
|
case SU_DAISY:
|
|
template_index_base = device_template_index_base;
|
|
break;
|
|
case SU_AMBIENT_TEMPLATE:
|
|
template_index_base = ambient_template_index_base;
|
|
break;
|
|
default:
|
|
/* we should never fall here! */
|
|
upsdebugx(3, "%s: unknown template type '%" PRI_SU_FLAGS "' for %s",
|
|
__func__, template_type, su_info_p->info_type);
|
|
}
|
|
base_index = template_index_base;
|
|
|
|
if (template_index_base == -1)
|
|
{
|
|
/* not initialised yet */
|
|
for (base_index = 0 ; base_index < 2 ; base_index++) {
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_SECURITY
|
|
#pragma GCC diagnostic ignored "-Wformat-security"
|
|
#endif
|
|
/* Test if this template also includes daisychain, in which case
|
|
* we just use the current device index */
|
|
if (is_multiple_template(su_info_p->OID) == TRUE) {
|
|
if (su_info_p->flags & SU_TYPE_DAISY_1) {
|
|
snprintf(test_OID, sizeof(test_OID), su_info_p->OID,
|
|
current_device_number + device_template_offset, base_index);
|
|
}
|
|
else {
|
|
snprintf(test_OID, sizeof(test_OID), su_info_p->OID,
|
|
base_index, current_device_number + device_template_offset);
|
|
}
|
|
}
|
|
else {
|
|
snprintf(test_OID, sizeof(test_OID), su_info_p->OID, base_index);
|
|
}
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
|
|
if (nut_snmp_get(test_OID) != NULL) {
|
|
if (su_info_p->flags & SU_FLAG_ZEROINVALID) {
|
|
long value;
|
|
if ((nut_snmp_get_int(test_OID, &value)) && (value!=0)) {
|
|
break;
|
|
}
|
|
}
|
|
else if (su_info_p->flags & SU_FLAG_NAINVALID) {
|
|
char value[SU_BUFSIZE];
|
|
if ((nut_snmp_get_str(test_OID, value, SU_BUFSIZE, NULL))
|
|
&& (strncmp(value, "N/A", 3))) {
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
/* Only store if it's a template for outlets or outlets groups,
|
|
* not for daisychain (which has different index) */
|
|
if (su_info_p->flags & SU_OUTLET)
|
|
outlet_template_index_base = base_index;
|
|
else if (su_info_p->flags & SU_OUTLET_GROUP)
|
|
outletgroup_template_index_base = base_index;
|
|
else if (su_info_p->flags & SU_AMBIENT_TEMPLATE)
|
|
ambient_template_index_base = base_index;
|
|
else
|
|
device_template_index_base = base_index;
|
|
}
|
|
upsdebugx(3, "%s: template_index_base = %i", __func__, base_index);
|
|
return base_index;
|
|
}
|
|
|
|
/* Try to determine the number of items (outlets, outlet groups, ...),
|
|
* using a template definition. Walk through the template until we can't
|
|
* get anymore values. I.e., if we can iterate up to 8 item, return 8 */
|
|
static int guestimate_template_count(snmp_info_t *su_info_p)
|
|
{
|
|
int base_index = 0;
|
|
char test_OID[SU_INFOSIZE];
|
|
int base_count;
|
|
const char *OID_template = su_info_p->OID;
|
|
|
|
upsdebugx(1, "%s(%s)", __func__, OID_template);
|
|
|
|
/* Determine if OID index starts from 0 or 1? */
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_SECURITY
|
|
#pragma GCC diagnostic ignored "-Wformat-security"
|
|
#endif
|
|
snprintf(test_OID, sizeof(test_OID), OID_template, base_index);
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
if (nut_snmp_get(test_OID) == NULL) {
|
|
base_index++;
|
|
}
|
|
else {
|
|
if (su_info_p->flags & SU_FLAG_ZEROINVALID) {
|
|
long value;
|
|
if ((nut_snmp_get_int(test_OID, &value)) && (value==0)) {
|
|
base_index++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Now, actually iterate */
|
|
for (base_count = 0 ; ; base_count++) {
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_SECURITY
|
|
#pragma GCC diagnostic ignored "-Wformat-security"
|
|
#endif
|
|
snprintf(test_OID, sizeof(test_OID), OID_template, base_index + base_count);
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
if (nut_snmp_get(test_OID) == NULL)
|
|
break;
|
|
}
|
|
|
|
upsdebugx(3, "%s: %i", __func__, base_count);
|
|
return base_count;
|
|
}
|
|
|
|
/* Process template definition, instantiate and get data or register
|
|
* command
|
|
* type: outlet, outlet.group, device */
|
|
static bool_t process_template(int mode, const char* type, snmp_info_t *su_info_p)
|
|
{
|
|
/* Default to TRUE, and leave to get_and_process_data() to set
|
|
* to FALSE when actually getting data from devices, to avoid false
|
|
* negative with server side data */
|
|
bool_t status = TRUE;
|
|
int cur_template_number = 1;
|
|
int cur_nut_index = 0;
|
|
int template_count = 0;
|
|
int base_snmp_index = 0;
|
|
snmp_info_t cur_info_p;
|
|
char template_count_var[SU_BUFSIZE * 2];
|
|
/* Needed *2 to fit a max size_t in snprintf() below,
|
|
* even if that should never happen */
|
|
char tmp_buf[SU_INFOSIZE];
|
|
|
|
upsdebugx(1, "%s template definition found (%s)...", type, su_info_p->info_type);
|
|
|
|
if ((strncmp(type, "device", 6)) && (devices_count > 1) && (current_device_number > 0)) {
|
|
snprintf(template_count_var, sizeof(template_count_var), "device.%i.%s.count", current_device_number, type);
|
|
} else {
|
|
snprintf(template_count_var, sizeof(template_count_var), "%s.count", type);
|
|
}
|
|
|
|
if(dstate_getinfo(template_count_var) == NULL) {
|
|
/* FIXME: should we disable it?
|
|
* su_info_p->flags &= ~SU_FLAG_OK;
|
|
* or rely on guestimation? */
|
|
template_count = guestimate_template_count(su_info_p);
|
|
/* Publish the count estimation */
|
|
if (template_count > 0) {
|
|
dstate_setinfo(template_count_var, "%i", template_count);
|
|
}
|
|
}
|
|
else {
|
|
template_count = atoi(dstate_getinfo(template_count_var));
|
|
}
|
|
upsdebugx(1, "%i instances found...", template_count);
|
|
|
|
/* Only instantiate templates if needed! */
|
|
if (template_count > 0) {
|
|
/* general init of data using the template */
|
|
instantiate_info(su_info_p, &cur_info_p);
|
|
|
|
base_snmp_index = base_snmp_template_index(su_info_p);
|
|
|
|
for (cur_template_number = base_snmp_index ;
|
|
cur_template_number < (template_count + base_snmp_index) ;
|
|
cur_template_number++)
|
|
{
|
|
upsdebugx(1, "Processing instance %i/%i...", cur_template_number, template_count);
|
|
/* Special processing for daisychain:
|
|
* append 'device.x' to the NUT variable name, except for the
|
|
* whole daisychain ("device.0") */
|
|
if (!strncmp(type, "device", 6))
|
|
{
|
|
/* Device(s) 1-N (master + slave(s)) need to append 'device.x' */
|
|
if (current_device_number > 0) {
|
|
char *ptr = NULL;
|
|
/* Another special processing for daisychain
|
|
* device collection needs special appending */
|
|
if (!strncmp(su_info_p->info_type, "device.", 7))
|
|
ptr = (char*)&su_info_p->info_type[7];
|
|
else
|
|
ptr = (char*)su_info_p->info_type;
|
|
|
|
snprintf((char*)cur_info_p.info_type, SU_INFOSIZE,
|
|
"device.%i.%s", current_device_number, ptr);
|
|
}
|
|
else
|
|
{
|
|
/* Device 1 ("device.0", whole daisychain) needs no
|
|
* special processing */
|
|
cur_nut_index = cur_template_number;
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_SECURITY
|
|
#pragma GCC diagnostic ignored "-Wformat-security"
|
|
#endif
|
|
snprintf((char*)cur_info_p.info_type, SU_INFOSIZE,
|
|
su_info_p->info_type, cur_nut_index);
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
}
|
|
}
|
|
else if (!strncmp(type, "outlet", 6)) /* Outlet and outlet groups templates */
|
|
{
|
|
/* Get the index of the current template instance */
|
|
cur_nut_index = cur_template_number;
|
|
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_SECURITY
|
|
#pragma GCC diagnostic ignored "-Wformat-security"
|
|
#endif
|
|
/* Special processing for daisychain */
|
|
if (daisychain_enabled == TRUE) {
|
|
/* Device(s) 1-N (master + slave(s)) need to append 'device.x' */
|
|
if ((devices_count > 1) && (current_device_number > 0)) {
|
|
memset(&tmp_buf[0], 0, SU_INFOSIZE);
|
|
strcat(&tmp_buf[0], "device.%i.");
|
|
strcat(&tmp_buf[0], su_info_p->info_type);
|
|
|
|
upsdebugx(4, "FORMATTING STRING = %s", &tmp_buf[0]);
|
|
snprintf((char*)cur_info_p.info_type, SU_INFOSIZE,
|
|
&tmp_buf[0], current_device_number, cur_nut_index);
|
|
}
|
|
else {
|
|
/* FIXME: daisychain-whole, what to do? */
|
|
snprintf((char*)cur_info_p.info_type, SU_INFOSIZE,
|
|
su_info_p->info_type, cur_nut_index);
|
|
}
|
|
}
|
|
else {
|
|
snprintf((char*)cur_info_p.info_type, SU_INFOSIZE,
|
|
su_info_p->info_type, cur_nut_index);
|
|
}
|
|
}
|
|
else if (!strncmp(type, "ambient", 7))
|
|
{
|
|
/* FIXME: can be grouped with outlet* above */
|
|
/* Get the index of the current template instance */
|
|
cur_nut_index = cur_template_number;
|
|
|
|
/* Special processing for daisychain */
|
|
if (daisychain_enabled == TRUE) {
|
|
/* Only publish on the daisychain host */
|
|
if ( (su_info_p->flags & SU_TYPE_DAISY_MASTER_ONLY)
|
|
&& (current_device_number != 1) ) {
|
|
upsdebugx(2, "discarding variable due to daisychain master flag");
|
|
continue;
|
|
}
|
|
|
|
/* Device(s) 1-N (master + slave(s)) need to append 'device.x' */
|
|
if ((devices_count > 1) && (current_device_number > 0)) {
|
|
memset(&tmp_buf[0], 0, SU_INFOSIZE);
|
|
strcat(&tmp_buf[0], "device.%i.");
|
|
strcat(&tmp_buf[0], su_info_p->info_type);
|
|
|
|
upsdebugx(4, "FORMATTING STRING = %s", &tmp_buf[0]);
|
|
snprintf((char*)cur_info_p.info_type, SU_INFOSIZE,
|
|
&tmp_buf[0], current_device_number, cur_nut_index);
|
|
}
|
|
else {
|
|
/* FIXME: daisychain-whole, what to do? */
|
|
snprintf((char*)cur_info_p.info_type, SU_INFOSIZE,
|
|
su_info_p->info_type, cur_nut_index);
|
|
}
|
|
}
|
|
else {
|
|
snprintf((char*)cur_info_p.info_type, SU_INFOSIZE,
|
|
su_info_p->info_type, cur_nut_index);
|
|
}
|
|
}
|
|
else
|
|
upsdebugx(4, "Error: unknown template type '%s", type);
|
|
|
|
/* check if default value is also a template */
|
|
if ((cur_info_p.dfl != NULL) &&
|
|
(strstr(su_info_p->dfl, "%i") != NULL)) {
|
|
cur_info_p.dfl = (char *)xmalloc(SU_INFOSIZE);
|
|
snprintf((char *)cur_info_p.dfl, SU_INFOSIZE, su_info_p->dfl, cur_nut_index);
|
|
}
|
|
|
|
if (cur_info_p.OID != NULL) {
|
|
/* Special processing for daisychain */
|
|
if (!strncmp(type, "device", 6)) {
|
|
if (current_device_number > 0) {
|
|
snprintf((char *)cur_info_p.OID, SU_INFOSIZE, su_info_p->OID, current_device_number + device_template_offset);
|
|
}
|
|
/*else
|
|
* FIXME: daisychain-whole, what to do?
|
|
*/
|
|
}
|
|
else {
|
|
/* Special processing for daisychain:
|
|
* these outlet | outlet groups also include formatting info,
|
|
* so we have to check if the daisychain is enabled, and if
|
|
* the formatting info for it are in 1rst or 2nd position */
|
|
if (daisychain_enabled == TRUE) {
|
|
if (su_info_p->flags & SU_TYPE_DAISY_1) {
|
|
snprintf((char *)cur_info_p.OID, SU_INFOSIZE,
|
|
su_info_p->OID, current_device_number + device_template_offset, cur_template_number);
|
|
}
|
|
else if (su_info_p->flags & SU_TYPE_DAISY_2) {
|
|
snprintf((char *)cur_info_p.OID, SU_INFOSIZE,
|
|
su_info_p->OID, cur_template_number + device_template_offset,
|
|
current_device_number - device_template_offset);
|
|
}
|
|
else {
|
|
/* Note: no device daisychain templating (SU_TYPE_DAISY_MASTER_ONLY)! */
|
|
snprintf((char *)cur_info_p.OID, SU_INFOSIZE, su_info_p->OID, cur_template_number);
|
|
}
|
|
}
|
|
else {
|
|
snprintf((char *)cur_info_p.OID, SU_INFOSIZE, su_info_p->OID, cur_template_number);
|
|
}
|
|
}
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
|
|
/* add instant commands to the info database. */
|
|
if (SU_TYPE(su_info_p) == SU_TYPE_CMD) {
|
|
upsdebugx(1, "Adding template command %s", cur_info_p.info_type);
|
|
/* FIXME: only add if "su_ups_get(cur_info_p) == TRUE" */
|
|
if (mode == SU_WALKMODE_INIT)
|
|
dstate_addcmd(cur_info_p.info_type);
|
|
}
|
|
else /* get and process this data */
|
|
status = get_and_process_data(mode, &cur_info_p);
|
|
} else {
|
|
/* server side (ABSENT) data */
|
|
su_setinfo(&cur_info_p, NULL);
|
|
}
|
|
/* set back the flag */
|
|
su_info_p->flags = cur_info_p.flags;
|
|
}
|
|
free((char*)cur_info_p.info_type);
|
|
if (cur_info_p.OID != NULL)
|
|
free((char*)cur_info_p.OID);
|
|
if ((cur_info_p.dfl != NULL) &&
|
|
(strstr(su_info_p->dfl, "%i") != NULL))
|
|
free((char*)cur_info_p.dfl);
|
|
}
|
|
else {
|
|
upsdebugx(1, "No %s present, discarding template definition...", type);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
/* Return the type of template, according to a variable name.
|
|
* Return: SU_OUTLET_GROUP, SU_OUTLET or 0 if not a template */
|
|
snmp_info_flags_t get_template_type(const char* varname)
|
|
{
|
|
if (!strncmp(varname, "outlet.group", 12)) {
|
|
upsdebugx(4, "outlet.group template");
|
|
return SU_OUTLET_GROUP;
|
|
}
|
|
else if (!strncmp(varname, "outlet", 6)) {
|
|
upsdebugx(4, "outlet template");
|
|
return SU_OUTLET;
|
|
}
|
|
else if (!strncmp(varname, "device", 6)) {
|
|
upsdebugx(4, "device template");
|
|
return SU_DAISY;
|
|
}
|
|
else if (!strncmp(varname, "ambient", 7)) {
|
|
upsdebugx(4, "ambient template");
|
|
return SU_AMBIENT_TEMPLATE;
|
|
}
|
|
else {
|
|
upsdebugx(2, "Unknown template type: %s", varname);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* Extract the id number of an instantiated template.
|
|
* Example: return '1' for type = 'outlet.1.desc', -1 if unknown */
|
|
int extract_template_number(snmp_info_flags_t template_type, const char* varname)
|
|
{
|
|
const char* item_number_ptr = NULL;
|
|
int item_number = -1;
|
|
|
|
if (template_type & SU_OUTLET_GROUP)
|
|
item_number_ptr = &varname[12];
|
|
else if (template_type & SU_OUTLET)
|
|
item_number_ptr = &varname[6];
|
|
else if (template_type & SU_DAISY)
|
|
item_number_ptr = &varname[6];
|
|
else if (template_type & SU_AMBIENT_TEMPLATE)
|
|
item_number_ptr = &varname[7];
|
|
else
|
|
return -1;
|
|
|
|
item_number = atoi(++item_number_ptr);
|
|
upsdebugx(3, "%s: item %i", __func__, item_number);
|
|
return item_number;
|
|
}
|
|
|
|
/* Extract the id number of a template from a variable name.
|
|
* Example: return '1' for type = 'outlet.1.desc' */
|
|
static int extract_template_number_from_snmp_info_t(const char* varname)
|
|
{
|
|
return extract_template_number(get_template_type(varname), varname);
|
|
}
|
|
|
|
/* end of template functions */
|
|
|
|
|
|
/* process a single data from a walk */
|
|
bool_t get_and_process_data(int mode, snmp_info_t *su_info_p)
|
|
{
|
|
bool_t status = FALSE;
|
|
|
|
upsdebugx(1, "%s: %s (%s)", __func__,
|
|
su_info_p->info_type, su_info_p->OID);
|
|
|
|
/* ok, update this element. */
|
|
status = su_ups_get(su_info_p);
|
|
upsdebugx(4, "%s: su_ups_get returned %d", __func__, status);
|
|
|
|
/* set stale flag if data is stale, clear if not. */
|
|
if (status == TRUE) {
|
|
if (su_info_p->flags & SU_FLAG_STALE) {
|
|
upslogx(LOG_INFO, "[%s] %s: data resumed for %s",
|
|
upsname?upsname:device_name, __func__, su_info_p->info_type);
|
|
su_info_p->flags &= ~SU_FLAG_STALE;
|
|
}
|
|
if(su_info_p->flags & SU_FLAG_UNIQUE) {
|
|
/* We should be the only provider of this */
|
|
upsdebugx(4, "%s: unique flag", __func__);
|
|
disable_competition(su_info_p);
|
|
su_info_p->flags &= ~SU_FLAG_UNIQUE;
|
|
}
|
|
dstate_dataok();
|
|
} else {
|
|
if (mode == SU_WALKMODE_INIT) {
|
|
/* handle unsupported vars */
|
|
su_info_p->flags &= ~SU_FLAG_OK;
|
|
} else {
|
|
if (!(su_info_p->flags & SU_FLAG_STALE)) {
|
|
upslogx(LOG_INFO, "[%s] snmp_ups_walk: data stale for %s",
|
|
upsname?upsname:device_name, su_info_p->info_type);
|
|
su_info_p->flags |= SU_FLAG_STALE;
|
|
}
|
|
dstate_datastale();
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* Daisychain handling functions
|
|
**********************************************************************/
|
|
|
|
/*!
|
|
* Daisychained devices support init:
|
|
* Determine the number of device(s) and if daisychain support has to be enabled
|
|
* Set the values of devices_count (internal) and "device.count" (public)
|
|
* Return TRUE if daisychain support is enabled, FALSE otherwise */
|
|
bool_t daisychain_init()
|
|
{
|
|
snmp_info_t *su_info_p = NULL;
|
|
|
|
upsdebugx(1, "Checking if daisychain support has to be enabled");
|
|
|
|
su_info_p = su_find_info("device.count");
|
|
|
|
if (su_info_p != NULL)
|
|
{
|
|
upsdebugx(1, "Found device.count entry...");
|
|
|
|
/* Enable daisychain if there is a device.count entry.
|
|
* This means that will have templates for entries */
|
|
daisychain_enabled = TRUE;
|
|
|
|
/* Try to get the OID value, if it's not a template */
|
|
upsdebugx(3, "OID for device.count is %s",
|
|
su_info_p->OID ? su_info_p->OID : "<null>");
|
|
if ((su_info_p->OID != NULL) &&
|
|
(strstr(su_info_p->OID, "%i") == NULL))
|
|
{
|
|
#if WITH_SNMP_LKP_FUN
|
|
devices_count = -1;
|
|
/* First test if we have a generic lookup function
|
|
* FIXME: Check if the field type is a string?
|
|
*/
|
|
/* TODO: backport the 2x2 mapping function support
|
|
* and this would be "fun_s2l" in resulting codebase
|
|
*/
|
|
if ( (su_info_p->oid2info != NULL) && (su_info_p->oid2info->nuf_s2l != NULL) ) {
|
|
char buf[1024];
|
|
upsdebugx(2, "%s: using generic string-to-long lookup function", __func__);
|
|
if (TRUE == nut_snmp_get_str(su_info_p->OID, buf, sizeof(buf), su_info_p->oid2info)) {
|
|
devices_count = su_info_p->oid2info->nuf_s2l(buf);
|
|
upsdebugx(2, "%s: got value '%ld'", __func__, devices_count);
|
|
}
|
|
}
|
|
|
|
if (devices_count == -1) {
|
|
#endif /* WITH_SNMP_LKP_FUN */
|
|
|
|
if (nut_snmp_get_int(su_info_p->OID, &devices_count) == TRUE)
|
|
upsdebugx(1, "There are %ld device(s) present", devices_count);
|
|
else
|
|
{
|
|
upsdebugx(1, "Error: can't get the number of device(s) present!");
|
|
upsdebugx(1, "Falling back to 1 device!");
|
|
devices_count = 1;
|
|
}
|
|
|
|
#if WITH_SNMP_LKP_FUN
|
|
}
|
|
#endif /* WITH_SNMP_LKP_FUN */
|
|
}
|
|
/* Otherwise (template), use the guesstimation function to get
|
|
* the number of devices present */
|
|
else
|
|
{
|
|
devices_count = guestimate_template_count(su_info_p);
|
|
upsdebugx(1, "Guesstimation: there are %ld device(s) present", devices_count);
|
|
}
|
|
|
|
/* Sanity check before data publication */
|
|
if (devices_count < 1) {
|
|
devices_count = 1;
|
|
daisychain_enabled = FALSE;
|
|
upsdebugx(1, "Devices count is less than 1!");
|
|
upsdebugx(1, "Falling back to 1 device and disabling daisychain support!");
|
|
} else {
|
|
/* Publish the device(s) count - even if just one
|
|
* device was recognized at this moment */
|
|
dstate_setinfo("device.count", "%ld", devices_count);
|
|
|
|
/* Also publish the default value for mfr and a forged model
|
|
* for device.0 (whole daisychain) */
|
|
su_info_p = su_find_info("device.mfr");
|
|
if (su_info_p != NULL) {
|
|
su_info_p = su_find_info("ups.mfr");
|
|
if (su_info_p != NULL) {
|
|
su_setinfo(su_info_p, NULL);
|
|
}
|
|
}
|
|
/* Forge model using device.type and number */
|
|
su_info_p = su_find_info("device.type");
|
|
if ((su_info_p != NULL) && (su_info_p->dfl != NULL)) {
|
|
dstate_setinfo("device.model", "daisychain %s (1+%ld)",
|
|
su_info_p->dfl, devices_count - 1);
|
|
dstate_setinfo("device.type", "%s", su_info_p->dfl);
|
|
}
|
|
else {
|
|
dstate_setinfo("device.model", "daisychain (1+%ld)", devices_count - 1);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
daisychain_enabled = FALSE;
|
|
upsdebugx(1, "No device.count entry found, daisychain support not needed");
|
|
}
|
|
|
|
/* Finally, compute and store the base OID index and NUT offset */
|
|
su_info_p = su_find_info("device.model");
|
|
if (su_info_p != NULL) {
|
|
device_template_index_base = base_snmp_template_index(su_info_p);
|
|
upsdebugx(1, "%s: device_template_index_base = %i", __func__, device_template_index_base);
|
|
device_template_offset = device_template_index_base - 1;
|
|
upsdebugx(1, "%s: device_template_offset = %i", __func__, device_template_offset);
|
|
}
|
|
else {
|
|
upsdebugx(1, "%s: No device.model entry found.", __func__);
|
|
}
|
|
|
|
upsdebugx(1, "%s: daisychain support is %s", __func__,
|
|
(daisychain_enabled==TRUE)?"enabled":"disabled");
|
|
|
|
return daisychain_enabled;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* SNMP handling functions
|
|
**********************************************************************/
|
|
|
|
/* Process a data with regard to SU_OUTPHASES, SU_INPHASES and SU_BYPPHASES.
|
|
* 3phases related data are disabled if the unit is 1ph, and conversely.
|
|
* If the related phases data (input, output, bypass) is not yet valued,
|
|
* retrieve it first.
|
|
*
|
|
* type: input, output, bypass
|
|
* su_info_p: variable to process flags on
|
|
* Return 0 if OK, 1 if the caller needs to "continue" the walk loop (i.e.
|
|
* skip the present data)
|
|
*/
|
|
static int process_phase_data(const char* type, long *nb_phases, snmp_info_t *su_info_p)
|
|
{
|
|
snmp_info_t *tmp_info_p;
|
|
char tmpOID[SU_INFOSIZE];
|
|
char tmpInfo[SU_INFOSIZE];
|
|
long tmpValue;
|
|
snmp_info_flags_t phases_flag = 0, single_phase_flag = 0, three_phase_flag = 0;
|
|
|
|
/* Phase specific data */
|
|
if (!strncmp(type, "input", 5)) {
|
|
phases_flag = SU_INPHASES;
|
|
single_phase_flag = SU_INPUT_1;
|
|
three_phase_flag = SU_INPUT_3;
|
|
}
|
|
else if (!strncmp(type, "output", 6)) {
|
|
phases_flag = SU_OUTPHASES;
|
|
single_phase_flag = SU_OUTPUT_1;
|
|
three_phase_flag = SU_OUTPUT_3;
|
|
}
|
|
else if (!strncmp(type, "input.bypass", 12)) {
|
|
phases_flag = SU_BYPPHASES;
|
|
single_phase_flag = SU_BYPASS_1;
|
|
three_phase_flag = SU_BYPASS_3;
|
|
}
|
|
else {
|
|
upsdebugx(2, "%s: unknown type '%s'", __func__, type);
|
|
return 1;
|
|
}
|
|
|
|
/* Init the phase(s) info for this device, if not already done */
|
|
if (*nb_phases == -1) {
|
|
upsdebugx(2, "%s phases information not initialized for device %i",
|
|
type, current_device_number);
|
|
|
|
memset(tmpInfo, 0, SU_INFOSIZE);
|
|
|
|
/* daisychain specifics... */
|
|
if ( (daisychain_enabled == TRUE) && (current_device_number > 0) ) {
|
|
/* Device(s) 2-N (slave(s)) need to append 'device.x' */
|
|
snprintf(tmpInfo, SU_INFOSIZE,
|
|
"device.%i.%s.phases", current_device_number, type);
|
|
}
|
|
else {
|
|
snprintf(tmpInfo, SU_INFOSIZE, "%s.phases", type);
|
|
}
|
|
|
|
if (dstate_getinfo(tmpInfo) == NULL) {
|
|
/* {input,output,bypass}.phases is not yet published,
|
|
* try to get the template for it */
|
|
snprintf(tmpInfo, SU_INFOSIZE, "%s.phases", type);
|
|
tmp_info_p = su_find_info(tmpInfo);
|
|
if (tmp_info_p != NULL) {
|
|
memset(tmpOID, 0, SU_INFOSIZE);
|
|
|
|
/* Daisychain specific: we may have a template (including
|
|
* formatting string) that needs to be adapted! */
|
|
if (strchr(tmp_info_p->OID, '%') != NULL) {
|
|
upsdebugx(2, "Found template, need to be adapted");
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_SECURITY
|
|
#pragma GCC diagnostic ignored "-Wformat-security"
|
|
#endif
|
|
snprintf((char*)tmpOID, SU_INFOSIZE, tmp_info_p->OID, current_device_number + device_template_offset);
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
}
|
|
else {
|
|
/* Otherwise, just point at what we found */
|
|
upsdebugx(2, "Found entry, not a template %s", tmp_info_p->OID);
|
|
snprintf((char*)tmpOID, SU_INFOSIZE, "%s", tmp_info_p->OID);
|
|
}
|
|
/* Actually get the data */
|
|
if (nut_snmp_get_int(tmpOID, &tmpValue) == TRUE) {
|
|
*nb_phases = tmpValue;
|
|
}
|
|
else {
|
|
upsdebugx(2, "Can't get %s value. Defaulting to 1 %s.phase", tmpInfo, type);
|
|
*nb_phases = 1;
|
|
/* FIXME: return something or process using default?! */
|
|
}
|
|
}
|
|
else {
|
|
upsdebugx(2, "No %s entry. Defaulting to 1 %s.phase", tmpInfo, type);
|
|
*nb_phases = 1;
|
|
/* FIXME: return something or process using default?! */
|
|
}
|
|
}
|
|
else {
|
|
*nb_phases = atoi(dstate_getinfo(tmpInfo));
|
|
}
|
|
/* Publish the number of phase(s) */
|
|
dstate_setinfo(tmpInfo, "%ld", *nb_phases);
|
|
upsdebugx(2, "device %i has %ld %s.phases", current_device_number, *nb_phases, type);
|
|
}
|
|
/* FIXME: what to do here?
|
|
else if (*nb_phases == 0) {
|
|
return 1;
|
|
} */
|
|
|
|
|
|
/* Actual processing of phases related data */
|
|
/* FIXME: don't clear SU_INPHASES in daisychain mode!!! ??? */
|
|
if (su_info_p->flags & single_phase_flag) {
|
|
if (*nb_phases == 1) {
|
|
upsdebugx(1, "%s_phases is 1", type);
|
|
su_info_p->flags &= ~phases_flag;
|
|
} else {
|
|
upsdebugx(1, "%s_phases is not 1", type);
|
|
su_info_p->flags &= ~SU_FLAG_OK;
|
|
return 1;
|
|
}
|
|
} else if (su_info_p->flags & three_phase_flag) {
|
|
if (*nb_phases == 3) {
|
|
upsdebugx(1, "%s_phases is 3", type);
|
|
su_info_p->flags &= ~phases_flag;
|
|
} else {
|
|
upsdebugx(1, "%s_phases is not 3", type);
|
|
su_info_p->flags &= ~SU_FLAG_OK;
|
|
return 1;
|
|
}
|
|
} else {
|
|
upsdebugx(1, "%s_phases is %ld", type, *nb_phases);
|
|
}
|
|
return 0; /* FIXME: remap EXIT_SUCCESS to RETURN_SUCCESS */
|
|
}
|
|
|
|
|
|
/* walk ups variables and set elements of the info array. */
|
|
bool_t snmp_ups_walk(int mode)
|
|
{
|
|
long *walked_input_phases, *walked_output_phases, *walked_bypass_phases;
|
|
static unsigned long iterations = 0;
|
|
snmp_info_t *su_info_p;
|
|
bool_t status = FALSE;
|
|
|
|
if (mode == SU_WALKMODE_UPDATE) {
|
|
semistatic_countdown--;
|
|
if (semistatic_countdown < 0)
|
|
semistatic_countdown = semistaticfreq;
|
|
}
|
|
|
|
/* Loop through all device(s) */
|
|
/* Note: considering "unitary" and "daisy-chained" devices, we have
|
|
* several variables (and their values) that can come into play:
|
|
* devices_count == 1 (default) AND daisychain_enabled == FALSE => unitary
|
|
* devices_count > 1 (AND/OR?) daisychain_enabled == TRUE => a daisy-chain
|
|
* The current_device_number == 0 in context of daisy-chain means the
|
|
* "whole device" with composite or summary values that refer to the
|
|
* chain as a virtual power device (e.g. might be a sum of outlet counts).
|
|
* If daisychain_enabled == TRUE and current_device_number == 1 then we
|
|
* are looking at the "master" device (one that we have direct/networked
|
|
* connectivity to; the current_device_number > 1 is a slave (chained by
|
|
* some proprietary link not visible from the outside) and represented
|
|
* through the master - the slaves are not addressable directly. If the
|
|
* master dies/reboots, connection to the whole chain is interrupted.
|
|
* The dstate string names for daisychained sub-devices have the prefix
|
|
* "device." and number embedded (e.g. "device.3.input.phases") except
|
|
* for the whole (#0) virtual device, so it *seems* similar to unitary.
|
|
*/
|
|
|
|
for (current_device_number = (daisychain_enabled == FALSE && devices_count == 1 ? 1 : 0) ;
|
|
current_device_number <= devices_count; current_device_number++)
|
|
{
|
|
|
|
upsdebugx(1, "%s: walking device %d",
|
|
__func__, current_device_number);
|
|
|
|
/* reinit the alarm buffer, before */
|
|
if (devices_count > 1)
|
|
device_alarm_init();
|
|
|
|
/* better safe than sorry, check sanity on every loop cycle */
|
|
if (snmp_info == NULL) {
|
|
fatalx(EXIT_FAILURE, "%s: snmp_info is not initialized", __func__);
|
|
}
|
|
|
|
if (snmp_info[0].info_type == NULL) {
|
|
upsdebugx(1, "%s: WARNING: snmp_info is empty", __func__);
|
|
}
|
|
|
|
/* Loop through all mapping entries for the current_device_number */
|
|
for (su_info_p = &snmp_info[0]; (su_info_p != NULL && su_info_p->info_type != NULL) ; su_info_p++) {
|
|
|
|
/* NOTE: Effectively below we do this:
|
|
* switch(current_device_number) {
|
|
* case 0: devtype = "daisychain whole"
|
|
* case 1: devtype = "daisychain master"
|
|
* default: devtype = "daisychain slave"
|
|
* }
|
|
* with a consideration for directly-addressable
|
|
* slave devices (can be seen in chain via master,
|
|
* but also queryable alone with an IP connection)
|
|
* NOTE: until proven otherwise, "single" may mean
|
|
* both (either) a daisy-chain enabled master device
|
|
* without further connected "slave" devices, and
|
|
* a directly addressable (IP-connected) "slave".
|
|
* Possibly also an ePDU etc. that serves a MIB
|
|
* which resolves "device.count" with the selected
|
|
* subdriver.
|
|
*/
|
|
if (daisychain_enabled == TRUE) {
|
|
upsdebugx(1, "%s: processing daisy-chain device %i (%s)",
|
|
__func__, current_device_number,
|
|
(current_device_number == 1)
|
|
? (devices_count > 1 ? "master" : "single")
|
|
: (current_device_number > 1 ? "slave" : "whole")
|
|
);
|
|
} else {
|
|
upsdebugx(1, "%s: processing unitary device (%i)",
|
|
__func__, current_device_number);
|
|
}
|
|
|
|
/* Check if we are asked to stop (reactivity++) */
|
|
if (exit_flag != 0) {
|
|
upsdebugx(1, "%s: aborting because exit_flag was set", __func__);
|
|
return TRUE;
|
|
}
|
|
|
|
/* Skip daisychain data count */
|
|
if (mode == SU_WALKMODE_INIT &&
|
|
(!strncmp(su_info_p->info_type, "device.count", 12)))
|
|
{
|
|
su_info_p->flags &= ~SU_FLAG_OK;
|
|
continue;
|
|
}
|
|
|
|
/* FIXME: daisychain-whole, what to do? */
|
|
/* Note that when addressing the FIXME above,
|
|
* if (current_device_number == 0 && daisychain_enabled == FALSE)
|
|
* then we'd skip it still (unitary device is at current_device_number == 1)...
|
|
*/
|
|
/* skip the whole-daisychain for now */
|
|
if (current_device_number == 0 && daisychain_enabled == TRUE) {
|
|
upsdebugx(1, "Skipping daisychain device.0 for now...");
|
|
continue;
|
|
}
|
|
|
|
/* skip instcmd, not linked to outlets */
|
|
if ((SU_TYPE(su_info_p) == SU_TYPE_CMD)
|
|
&& !(su_info_p->flags & SU_OUTLET)
|
|
&& !(su_info_p->flags & SU_OUTLET_GROUP)) {
|
|
upsdebugx(1, "SU_CMD_MASK => %s", su_info_p->OID);
|
|
continue;
|
|
}
|
|
/* skip elements we shouldn't show in update mode */
|
|
if ((mode == SU_WALKMODE_UPDATE) && !(su_info_p->flags & SU_FLAG_OK))
|
|
continue;
|
|
|
|
/* skip semi-static elements in update mode: only parse when countdown reaches 0 */
|
|
if ((mode == SU_WALKMODE_UPDATE) && (su_info_p->flags & SU_FLAG_SEMI_STATIC)) {
|
|
if (semistatic_countdown != 0)
|
|
continue;
|
|
upsdebugx(1, "Refreshing semi-static entry %s", su_info_p->OID);
|
|
}
|
|
|
|
/* skip static elements in update mode */
|
|
if ((mode == SU_WALKMODE_UPDATE) && (su_info_p->flags & SU_FLAG_STATIC))
|
|
continue;
|
|
|
|
/* Set default value if we cannot fetch it */
|
|
/* and set static flag on this element.
|
|
* Not applicable to outlets (need SU_FLAG_STATIC tagging) */
|
|
if ((su_info_p->flags & SU_FLAG_ABSENT)
|
|
&& !(su_info_p->flags & SU_OUTLET)
|
|
&& !(su_info_p->flags & SU_OUTLET_GROUP)
|
|
&& !(su_info_p->flags & SU_AMBIENT_TEMPLATE))
|
|
{
|
|
if (mode == SU_WALKMODE_INIT)
|
|
{
|
|
if (su_info_p->dfl)
|
|
{
|
|
if ((daisychain_enabled == TRUE) && (devices_count > 1))
|
|
{
|
|
if (current_device_number == 0)
|
|
{
|
|
su_setinfo(su_info_p, NULL); /* FIXME: daisychain-whole, what to do? */
|
|
} else {
|
|
status = process_template(mode, "device", su_info_p);
|
|
}
|
|
}
|
|
else {
|
|
/* Set default value if we cannot fetch it from ups. */
|
|
su_setinfo(su_info_p, NULL);
|
|
}
|
|
}
|
|
su_info_p->flags |= SU_FLAG_STATIC;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
/* check stale elements only on each PN_STALE_RETRY iteration. */
|
|
/* if ((su_info_p->flags & SU_FLAG_STALE) &&
|
|
(iterations % SU_STALE_RETRY) != 0)
|
|
continue;
|
|
*/
|
|
/* Filter 1-phase Vs 3-phase according to {input,output,bypass}.phase.
|
|
* Non matching items are disabled, and flags are cleared at init
|
|
* time */
|
|
/* Process input phases information */
|
|
walked_input_phases = &daisychain_info[current_device_number]->input_phases;
|
|
if (su_info_p->flags & SU_INPHASES) {
|
|
upsdebugx(1, "Check input_phases (%ld)", *walked_input_phases);
|
|
if (process_phase_data("input", walked_input_phases, su_info_p) == 1)
|
|
continue;
|
|
}
|
|
|
|
/* Process output phases information */
|
|
walked_output_phases = &daisychain_info[current_device_number]->output_phases;
|
|
if (su_info_p->flags & SU_OUTPHASES) {
|
|
upsdebugx(1, "Check output_phases (%ld)", *walked_output_phases);
|
|
if (process_phase_data("output", walked_output_phases, su_info_p) == 1)
|
|
continue;
|
|
}
|
|
|
|
/* Process bypass phases information */
|
|
walked_bypass_phases = &daisychain_info[current_device_number]->bypass_phases;
|
|
if (su_info_p->flags & SU_BYPPHASES) {
|
|
upsdebugx(1, "Check bypass_phases (%ld)", *walked_bypass_phases);
|
|
if (process_phase_data("input.bypass", walked_bypass_phases, su_info_p) == 1)
|
|
continue;
|
|
}
|
|
|
|
/* process template (outlet, outlet group, inc. daisychain) definition */
|
|
if (su_info_p->flags & SU_OUTLET) {
|
|
/* Skip commands after init */
|
|
if ((SU_TYPE(su_info_p) == SU_TYPE_CMD) && (mode == SU_WALKMODE_UPDATE))
|
|
continue;
|
|
else
|
|
status = process_template(mode, "outlet", su_info_p);
|
|
}
|
|
else if (su_info_p->flags & SU_OUTLET_GROUP) {
|
|
/* Skip commands after init */
|
|
if ((SU_TYPE(su_info_p) == SU_TYPE_CMD) && (mode == SU_WALKMODE_UPDATE))
|
|
continue;
|
|
else
|
|
status = process_template(mode, "outlet.group", su_info_p);
|
|
}
|
|
else if (su_info_p->flags & SU_AMBIENT_TEMPLATE) {
|
|
/* Skip commands after init */
|
|
if ((SU_TYPE(su_info_p) == SU_TYPE_CMD) && (mode == SU_WALKMODE_UPDATE))
|
|
continue;
|
|
else
|
|
status = process_template(mode, "ambient", su_info_p);
|
|
}
|
|
else {
|
|
/* if (daisychain_enabled == TRUE) {
|
|
status = process_template(mode, "device", su_info_p);
|
|
}
|
|
else {
|
|
*/ /* get and process this data, including daisychain adaptation */
|
|
status = get_and_process_data(mode, su_info_p);
|
|
/*
|
|
}
|
|
*/
|
|
}
|
|
} /* for (su_info_p... */
|
|
|
|
if (devices_count > 1) {
|
|
/* commit the device alarm buffer */
|
|
device_alarm_commit(current_device_number);
|
|
|
|
/* reinit the alarm buffer, after, not to pollute "device.0" */
|
|
device_alarm_init();
|
|
}
|
|
}
|
|
iterations++;
|
|
return status;
|
|
}
|
|
|
|
bool_t su_ups_get(snmp_info_t *su_info_p)
|
|
{
|
|
static char buf[SU_INFOSIZE];
|
|
bool_t status;
|
|
long value;
|
|
double dvalue;
|
|
const char *strValue = NULL;
|
|
struct snmp_pdu ** pdu_array;
|
|
struct snmp_pdu * current_pdu;
|
|
alarms_info_t * alarms;
|
|
int index = 0;
|
|
char *format_char = NULL;
|
|
int saved_current_device_number = -1;
|
|
snmp_info_t *tmp_info_p = NULL;
|
|
|
|
upsdebugx(2, "%s: %s %s", __func__, su_info_p->info_type, su_info_p->OID);
|
|
|
|
/* Check if this is a daisychain template */
|
|
if (su_info_p->OID != NULL
|
|
&& (format_char = strchr(su_info_p->OID, '%')) != NULL
|
|
) {
|
|
upsdebugx(3, "%s: calling instantiate_info() for "
|
|
"daisy-chain template", __func__);
|
|
tmp_info_p = instantiate_info(su_info_p, tmp_info_p);
|
|
if (tmp_info_p != NULL) {
|
|
upsdebugx(3, "%s: instantiate_info() returned "
|
|
"non-null OID: %s",
|
|
__func__, tmp_info_p->OID);
|
|
/* adapt the OID */
|
|
if (su_info_p->OID != NULL) {
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_SECURITY
|
|
#pragma GCC diagnostic ignored "-Wformat-security"
|
|
#endif
|
|
snprintf((char *)tmp_info_p->OID, SU_INFOSIZE, su_info_p->OID,
|
|
current_device_number + device_template_offset);
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
upsdebugx(3, "%s: OID %s adapted into %s",
|
|
__func__, su_info_p->OID,
|
|
tmp_info_p->OID);
|
|
}
|
|
else {
|
|
free_info(tmp_info_p);
|
|
return FALSE;
|
|
}
|
|
|
|
/* adapt info_type */
|
|
if (su_info_p->info_type != NULL) {
|
|
snprintf((char *)tmp_info_p->info_type,
|
|
SU_INFOSIZE, "%s",
|
|
su_info_p->info_type);
|
|
}
|
|
else {
|
|
free_info(tmp_info_p);
|
|
return FALSE;
|
|
}
|
|
|
|
su_info_p = tmp_info_p;
|
|
}
|
|
else {
|
|
upsdebugx(2, "%s: can't instantiate template", __func__);
|
|
return FALSE;
|
|
}
|
|
}
|
|
else {
|
|
/* Non-templated OID, still may be aimed at a
|
|
* daisy-chained device (master of the chain
|
|
* makes sense for IETF device.contact etc.).
|
|
* BUT: It could be a direct request for earlier
|
|
* resolved OID. So check for "device.N." too.
|
|
*/
|
|
if (daisychain_enabled == TRUE
|
|
&& devices_count > 1
|
|
&& current_device_number > 0
|
|
) {
|
|
/* So we had a literal OID string, originally
|
|
* Check for "device.N." in the string: */
|
|
char * varname = su_info_p->info_type;
|
|
if (!strncmp(varname, "device.", 7)
|
|
&& (varname[7] >= '0' && varname[7] <= '9')
|
|
) {
|
|
upsdebugx(2, "%s: keeping original "
|
|
"current device == %d for "
|
|
"non-templated daisy value",
|
|
__func__, current_device_number);
|
|
} else {
|
|
upsdebugx(2, "%s: would fake "
|
|
"current device == 1 for "
|
|
"non-templated daisy value "
|
|
"instead of %d",
|
|
__func__, current_device_number);
|
|
saved_current_device_number = current_device_number;
|
|
}
|
|
/* At this point we applied no hacks yet,
|
|
* just stashed a non-negative value into
|
|
* saved_current_device_number
|
|
*/
|
|
}
|
|
}
|
|
|
|
if (!strcasecmp(su_info_p->info_type, "ups.status")) {
|
|
/* FIXME: daisychain status support! */
|
|
upsdebugx(2, "%s: requesting nut_snmp_get_int() for "
|
|
"ups.status, with%s daisy template originally",
|
|
__func__, (format_char!=NULL ? "" : "out"));
|
|
status = nut_snmp_get_int(su_info_p->OID, &value);
|
|
if (status == TRUE)
|
|
{
|
|
su_status_set(su_info_p, value);
|
|
upsdebugx(2, "=> value: %ld", value);
|
|
}
|
|
else
|
|
upsdebugx(2, "=> Failed");
|
|
|
|
free_info(tmp_info_p);
|
|
return status;
|
|
}
|
|
|
|
/* Handle 'ups.alarm', 'outlet.n.alarm' and 3phase 'Lx.alarm',
|
|
* nothing else! */
|
|
if (!strcmp(strrchr(su_info_p->info_type, '.'), ".alarm")) {
|
|
|
|
upsdebugx(2, "Processing alarm: %s", su_info_p->info_type);
|
|
|
|
/* FIXME: daisychain alarms support! */
|
|
upsdebugx(2, "%s: requesting nut_snmp_get_int() for "
|
|
"some alarm, with%s daisy template originally",
|
|
__func__, (format_char!=NULL ? "" : "out"));
|
|
status = nut_snmp_get_int(su_info_p->OID, &value);
|
|
if (status == TRUE)
|
|
{
|
|
su_alarm_set(su_info_p, value);
|
|
upsdebugx(2, "=> value: %ld", value);
|
|
}
|
|
else upsdebugx(2, "=> Failed");
|
|
|
|
free_info(tmp_info_p);
|
|
return status;
|
|
}
|
|
|
|
/* Walk a subtree (array) of alarms, composed of OID references.
|
|
* The object referenced should not be accessible, but rather when
|
|
* present, this means that the alarm condition is TRUE.
|
|
* Only present in powerware-mib.c for now */
|
|
if (!strcasecmp(su_info_p->info_type, "ups.alarms")) {
|
|
upsdebugx(2, "%s: requesting nut_snmp_get_int() for "
|
|
"ups.alarms, with%s daisy template originally",
|
|
__func__, (format_char!=NULL ? "" : "out"));
|
|
status = nut_snmp_get_int(su_info_p->OID, &value);
|
|
if (status == TRUE) {
|
|
upsdebugx(2, "=> %ld alarms present", value);
|
|
if( value > 0 ) {
|
|
pdu_array = nut_snmp_walk(su_info_p->OID, INT_MAX);
|
|
if(pdu_array == NULL) {
|
|
upsdebugx(2, "=> Walk failed");
|
|
return FALSE;
|
|
}
|
|
|
|
current_pdu = pdu_array[index];
|
|
while(current_pdu) {
|
|
/* Retrieve the OID name, for comparison */
|
|
if (decode_oid(current_pdu, buf, sizeof(buf)) == TRUE) {
|
|
alarms = alarms_info;
|
|
while( alarms->OID ) {
|
|
if(!strcmp(buf, alarms->OID)) {
|
|
upsdebugx(3, "Alarm OID found => %s", alarms->OID);
|
|
/* Check for ups.status value */
|
|
if (alarms->status_value) {
|
|
upsdebugx(3, "Alarm value (status) found => %s", alarms->status_value);
|
|
status_set(alarms->status_value);
|
|
}
|
|
/* Check for ups.alarm value */
|
|
if (alarms->alarm_value) {
|
|
upsdebugx(3, "Alarm value (alarm) found => %s", alarms->alarm_value);
|
|
alarm_set(alarms->alarm_value);
|
|
}
|
|
break;
|
|
}
|
|
alarms++;
|
|
}
|
|
}
|
|
index++;
|
|
current_pdu = pdu_array[index];
|
|
}
|
|
nut_snmp_free(pdu_array);
|
|
}
|
|
}
|
|
else {
|
|
upsdebugx(2, "=> Failed");
|
|
}
|
|
|
|
free_info(tmp_info_p);
|
|
return status;
|
|
}
|
|
|
|
/* another special case */
|
|
if (!strcasecmp(su_info_p->info_type, "ambient.temperature")) {
|
|
float temp=0;
|
|
|
|
upsdebugx(2, "%s: requesting nut_snmp_get_int() for "
|
|
"ambient.temperature, with%s daisy template originally",
|
|
__func__, (format_char!=NULL ? "" : "out"));
|
|
status = nut_snmp_get_int(su_info_p->OID, &value);
|
|
|
|
if(status != TRUE) {
|
|
free_info(tmp_info_p);
|
|
return status;
|
|
}
|
|
|
|
/* only do this if using the IEM sensor */
|
|
if (!strcmp(su_info_p->OID, APCC_OID_IEM_TEMP)) {
|
|
int su;
|
|
long units;
|
|
|
|
su = nut_snmp_get_int(APCC_OID_IEM_TEMP_UNIT, &units);
|
|
|
|
/* no response, or units == F */
|
|
if ((su == FALSE) || (units == APCC_IEM_FAHRENHEIT))
|
|
temp = (value - 32) / 1.8;
|
|
else
|
|
temp = value;
|
|
}
|
|
else {
|
|
temp = value * su_info_p->info_len;
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), "%.1f", temp);
|
|
su_setinfo(su_info_p, buf);
|
|
|
|
free_info(tmp_info_p);
|
|
return TRUE;
|
|
}
|
|
|
|
/* special treatment for element without oid but with default value */
|
|
if (su_info_p->OID == NULL && su_info_p->dfl != NULL) {
|
|
status = TRUE;
|
|
/* FIXME: strlcpy() would fit here safer; not used in NUT yet */
|
|
strncpy(buf, su_info_p->dfl, sizeof(buf) - 1);
|
|
buf[sizeof(buf) - 1] = '\0';
|
|
}
|
|
else if (su_info_p->info_flags & ST_FLAG_STRING) {
|
|
upsdebugx(2, "%s: requesting nut_snmp_get_str(), "
|
|
"with%s daisy template originally",
|
|
__func__, (format_char!=NULL ? "" : "out"));
|
|
status = nut_snmp_get_str(su_info_p->OID, buf,
|
|
sizeof(buf), su_info_p->oid2info);
|
|
if (status == TRUE) {
|
|
if (quirk_symmetra_threephase) {
|
|
if (!strcasecmp(su_info_p->info_type, "input.transfer.low")
|
|
|| !strcasecmp(su_info_p->info_type, "input.transfer.high")) {
|
|
/* Convert from three phase line-to-line voltage to line-to-neutral voltage */
|
|
double tmp_dvalue = atof(buf);
|
|
tmp_dvalue = tmp_dvalue * 0.707;
|
|
snprintf(buf, sizeof(buf), "%.2f", tmp_dvalue);
|
|
}
|
|
}
|
|
/* Check if there is a string reformating function */
|
|
const char *fmt_buf = NULL;
|
|
if ((fmt_buf = su_find_strval(su_info_p->oid2info, buf)) != NULL) {
|
|
snprintf(buf, sizeof(buf), "%s", fmt_buf);
|
|
}
|
|
}
|
|
} else {
|
|
upsdebugx(2, "%s: requesting nut_snmp_get_int(), "
|
|
"with%s daisy template originally",
|
|
__func__, (format_char!=NULL ? "" : "out"));
|
|
status = nut_snmp_get_int(su_info_p->OID, &value);
|
|
if (status == TRUE) {
|
|
if ((su_info_p->flags&SU_FLAG_NEGINVALID && value<0)
|
|
|| (su_info_p->flags&SU_FLAG_ZEROINVALID && value==0)) {
|
|
su_info_p->flags &= ~SU_FLAG_OK;
|
|
if(su_info_p->flags&SU_FLAG_UNIQUE) {
|
|
disable_competition(su_info_p);
|
|
su_info_p->flags &= ~SU_FLAG_UNIQUE;
|
|
}
|
|
free_info(tmp_info_p);
|
|
return FALSE;
|
|
}
|
|
/* Check if there is a value to be looked up */
|
|
if ((strValue = su_find_infoval(su_info_p->oid2info, &value)) != NULL)
|
|
snprintf(buf, sizeof(buf), "%s", strValue);
|
|
else {
|
|
/* Check if there is a need to publish decimal too,
|
|
* i.e. if switching to integer does not cause a
|
|
* loss of precision.
|
|
* FIXME: Use remainder? is (dvalue%1.0)>0 cleaner?
|
|
*/
|
|
dvalue = value * su_info_p->info_len;
|
|
if (f_equal((int)dvalue, dvalue))
|
|
snprintf(buf, sizeof(buf), "%i", (int)dvalue);
|
|
else
|
|
snprintf(buf, sizeof(buf), "%.2f", (float)dvalue);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (status == TRUE) {
|
|
if (saved_current_device_number >= 0) {
|
|
current_device_number = 1;
|
|
}
|
|
su_setinfo(su_info_p, buf);
|
|
if (saved_current_device_number >= 0) {
|
|
current_device_number = saved_current_device_number;
|
|
}
|
|
upsdebugx(2, "=> value: %s", buf);
|
|
}
|
|
else {
|
|
upsdebugx(2, "=> Failed");
|
|
}
|
|
|
|
free_info(tmp_info_p);
|
|
return status;
|
|
}
|
|
|
|
/* Common function for setting OIDs, from a NUT variable name,
|
|
* used by su_setvar() and su_instcmd()
|
|
* Params:
|
|
* @mode: SU_MODE_INSTCMD for instant commands, SU_MODE_SETVAR for settings
|
|
* @varname: name of variable or command to set the OID from
|
|
* @val: value for settings, NULL for commands
|
|
|
|
* Returns
|
|
* STAT_SET_HANDLED if OK,
|
|
* STAT_SET_INVALID or STAT_SET_UNKNOWN if the command / setting is not supported
|
|
* STAT_SET_FAILED otherwise
|
|
*/
|
|
static int su_setOID(int mode, const char *varname, const char *val)
|
|
{
|
|
snmp_info_t *su_info_p = NULL;
|
|
bool_t status;
|
|
int retval = STAT_SET_FAILED;
|
|
int cmd_offset = 0;
|
|
long value = -1;
|
|
/* normal (default), outlet, or outlet group variable */
|
|
snmp_info_flags_t vartype = 0;
|
|
int daisychain_device_number = -1;
|
|
/* variable without the potential "device.X" prefix, to find the template */
|
|
char *tmp_varname = NULL;
|
|
char setOID[SU_INFOSIZE];
|
|
/* Used for potentially appending "device.X." to {outlet,outlet.group}.count */
|
|
char template_count_var[SU_BUFSIZE];
|
|
|
|
upsdebugx(2, "entering %s(%s, %s, %s)", __func__,
|
|
(mode==SU_MODE_INSTCMD)?"instcmd":"setvar", varname, val);
|
|
|
|
memset(setOID, 0, SU_INFOSIZE);
|
|
memset(template_count_var, 0, SU_BUFSIZE);
|
|
|
|
/* Check if it's a daisychain setting (device.x.varname),
|
|
* or a non-daisy setting/value/cmd for the "master" unit
|
|
* (as un-numbered device.varname), or something else?
|
|
*/
|
|
if (!strncmp(varname, "device", 6)) {
|
|
if (varname[7] >= '0' && varname[7] <= '9') {
|
|
/* Extract the (single-digit) device number
|
|
* TODO: use strtol() or similar to support multi-digit
|
|
* chains and offset tmp_varname inside varname properly
|
|
*/
|
|
daisychain_device_number = atoi(&varname[7]);
|
|
/* Point at the command, without the "device.x" prefix */
|
|
tmp_varname = strdup(&varname[9]);
|
|
snprintf(template_count_var, 10, "%s", varname);
|
|
|
|
upsdebugx(2, "%s: got a daisychain %s (%s) for device %i",
|
|
__func__, (mode==SU_MODE_INSTCMD)?"command":"setting",
|
|
tmp_varname, daisychain_device_number);
|
|
|
|
if (daisychain_device_number > devices_count)
|
|
upsdebugx(2, "%s: item is out of bound (%i / %ld)",
|
|
__func__, daisychain_device_number, devices_count);
|
|
}
|
|
else {
|
|
/* Note: below we check if "OID" contains ".%i" template text
|
|
* like we do in su_setinfo(); eventually we might get vendor
|
|
* MIBs that do expose device.contact/location/description
|
|
* for each link in the chain...
|
|
*/
|
|
if (daisychain_enabled == TRUE) {
|
|
/* Is the original "device.varname" backed by a templated
|
|
* OID string, so we can commonly set e.g. device.contact
|
|
* for everything in the chain?
|
|
*/
|
|
su_info_p = su_find_info(varname);
|
|
if (su_info_p
|
|
&& (su_info_p->OID == NULL || strstr(su_info_p->OID, ".%i") != NULL)
|
|
) {
|
|
/* is templated or defaulted */
|
|
daisychain_device_number = 0;
|
|
} else {
|
|
daisychain_device_number = 1;
|
|
}
|
|
|
|
upsdebugx(2, "%s: got an un-numbered daisychain %s (%s), "
|
|
"directing it to %s",
|
|
__func__, (mode==SU_MODE_INSTCMD)?"command":"setting",
|
|
varname,
|
|
(daisychain_device_number==1)?"'master' device":"all devices"
|
|
);
|
|
} else {
|
|
/* No daisy, no poppy */
|
|
daisychain_device_number = 0;
|
|
}
|
|
tmp_varname = strdup(varname);
|
|
}
|
|
}
|
|
else {
|
|
daisychain_device_number = 0;
|
|
tmp_varname = strdup(varname);
|
|
}
|
|
|
|
/* skip the whole-daisychain for now:
|
|
* will send the settings to all devices in the daisychain */
|
|
if ((daisychain_enabled == TRUE) && (devices_count > 1) && (daisychain_device_number == 0)) {
|
|
upsdebugx(2, "daisychain %s for device.0 are not yet supported!",
|
|
(mode==SU_MODE_INSTCMD)?"command":"setting");
|
|
free(tmp_varname);
|
|
return STAT_SET_INVALID;
|
|
}
|
|
|
|
/* Check if it is outlet / outlet.group, or standard variable */
|
|
if (strncmp(tmp_varname, "outlet", 6)) {
|
|
su_info_p = su_find_info(tmp_varname);
|
|
/* what if e.g. "device.x.contact" is not found as a "contact"? */
|
|
if (!su_info_p && strcmp(tmp_varname, varname)) {
|
|
upsdebugx(2,
|
|
"%s: did not find info for daisychained entry %s, "
|
|
"retrying with original varname %s",
|
|
__func__, tmp_varname, varname);
|
|
su_info_p = su_find_info(varname);
|
|
|
|
/* Still nothing? Try to revert from "device.1."
|
|
* as a daisychain master? */
|
|
if (!su_info_p
|
|
&& daisychain_enabled == TRUE
|
|
&& devices_count > 1
|
|
&& daisychain_device_number == 1
|
|
&& !strncmp(varname, "device.1.", 9)
|
|
) {
|
|
char tmp_buf[SU_INFOSIZE];
|
|
snprintf(tmp_buf, sizeof(tmp_buf),
|
|
"device.%s", (varname + 9));
|
|
su_info_p = su_find_info(tmp_buf);
|
|
if (su_info_p) {
|
|
upsdebugx(2, "%s: finally found "
|
|
"as daisy master revert %s",
|
|
__func__, tmp_buf);
|
|
free(tmp_varname);
|
|
tmp_varname = strdup(tmp_buf);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
/* is indeed an outlet.* or device.x.outlet.* */
|
|
snmp_info_t *tmp_info_p;
|
|
/* Point the outlet or outlet group number in the string */
|
|
const char *item_number_ptr = NULL;
|
|
/* Store the target outlet or group number */
|
|
int item_number = extract_template_number_from_snmp_info_t(tmp_varname);
|
|
/* Store the total number of outlets or outlet groups */
|
|
int total_items = -1;
|
|
|
|
/* Check if it is outlet / outlet.group */
|
|
vartype = get_template_type(tmp_varname);
|
|
if (vartype == SU_OUTLET_GROUP) {
|
|
snprintfcat(template_count_var, SU_BUFSIZE, "outlet.group.count");
|
|
total_items = atoi(dstate_getinfo(template_count_var));
|
|
item_number_ptr = &tmp_varname[12];
|
|
}
|
|
else {
|
|
snprintfcat(template_count_var, SU_BUFSIZE, "outlet.count");
|
|
total_items = atoi(dstate_getinfo(template_count_var));
|
|
item_number_ptr = &tmp_varname[6];
|
|
}
|
|
upsdebugx(3, "Using count variable '%s'", template_count_var);
|
|
item_number = atoi(++item_number_ptr);
|
|
upsdebugx(3, "%s: item %i / %i", __func__, item_number, total_items);
|
|
|
|
/* ensure the item number is supported (filtered upstream though)! */
|
|
if (item_number > total_items) {
|
|
/* out of bound item number */
|
|
upsdebugx(2, "%s: item is out of bound (%i / %i)",
|
|
__func__, item_number, total_items);
|
|
return STAT_SET_INVALID;
|
|
}
|
|
/* find back the item template */
|
|
char *item_varname = (char *)xmalloc(SU_INFOSIZE);
|
|
snprintf(item_varname, SU_INFOSIZE, "%s.%s%s",
|
|
(vartype == SU_OUTLET)?"outlet":"outlet.group",
|
|
"%i", strchr(item_number_ptr++, '.'));
|
|
|
|
upsdebugx(3, "%s: searching for template\"%s\"", __func__, item_varname);
|
|
tmp_info_p = su_find_info(item_varname);
|
|
free(item_varname);
|
|
|
|
/* for an snmp_info_t instance */
|
|
su_info_p = instantiate_info(tmp_info_p, su_info_p);
|
|
|
|
/* check if default value is also a template */
|
|
if ((su_info_p->dfl != NULL) &&
|
|
(strstr(tmp_info_p->dfl, "%i") != NULL))
|
|
{
|
|
su_info_p->dfl = (char *)xmalloc(SU_INFOSIZE);
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_SECURITY
|
|
#pragma GCC diagnostic ignored "-Wformat-security"
|
|
#endif
|
|
snprintf((char *)su_info_p->dfl, SU_INFOSIZE, tmp_info_p->dfl,
|
|
item_number);
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
}
|
|
/* adapt the OID */
|
|
if (su_info_p->OID != NULL) {
|
|
if (mode==SU_MODE_INSTCMD) {
|
|
/* Workaround buggy Eaton Pulizzi implementation
|
|
* which have different offsets index for data & commands! */
|
|
if (su_info_p->flags & SU_CMD_OFFSET) {
|
|
upsdebugx(3, "Adding command offset");
|
|
cmd_offset++;
|
|
}
|
|
}
|
|
|
|
/* Special processing for daisychain:
|
|
* these outlet | outlet groups also include formatting info,
|
|
* so we have to check if the daisychain is enabled, and if
|
|
* the formatting info for it are in 1rst or 2nd position */
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_SECURITY
|
|
#pragma GCC diagnostic ignored "-Wformat-security"
|
|
#endif
|
|
if (daisychain_enabled == TRUE) {
|
|
/* Note: daisychain_enabled == TRUE means that we have
|
|
* daisychain template. However:
|
|
* * when there are multiple devices, offset "-1" applies
|
|
* since device.0 is a fake and actual devices start at
|
|
* index 1
|
|
* * when there is only 1 device, offset doesn't apply since
|
|
* the device index is "0"
|
|
*/
|
|
int daisychain_offset = 0;
|
|
if (devices_count > 1)
|
|
daisychain_offset = 1;
|
|
|
|
if (su_info_p->flags & SU_TYPE_DAISY_1) {
|
|
snprintf((char *)su_info_p->OID, SU_INFOSIZE, tmp_info_p->OID,
|
|
daisychain_device_number - daisychain_offset, item_number);
|
|
}
|
|
else {
|
|
snprintf((char *)su_info_p->OID, SU_INFOSIZE, tmp_info_p->OID,
|
|
item_number, daisychain_device_number - daisychain_offset);
|
|
}
|
|
}
|
|
else {
|
|
snprintf((char *)su_info_p->OID, SU_INFOSIZE, tmp_info_p->OID, item_number);
|
|
}
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
}
|
|
/* else, don't return STAT_SET_INVALID for mode==SU_MODE_SETVAR since we
|
|
* can be setting a server side variable! */
|
|
else {
|
|
if (mode==SU_MODE_INSTCMD) {
|
|
free_info(su_info_p);
|
|
return STAT_INSTCMD_UNKNOWN;
|
|
}
|
|
else {
|
|
/* adapt info_type */
|
|
if (su_info_p->info_type != NULL)
|
|
snprintf((char *)su_info_p->info_type, SU_INFOSIZE, "%s", tmp_varname);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Sanity check */
|
|
if (!su_info_p || !su_info_p->info_type || !(su_info_p->flags & SU_FLAG_OK)) {
|
|
|
|
upsdebugx(2, "%s: info element unavailable %s", __func__, varname);
|
|
|
|
/* Free template (outlet and outlet.group) */
|
|
free_info(su_info_p);
|
|
|
|
if (tmp_varname != NULL)
|
|
free(tmp_varname);
|
|
|
|
return STAT_SET_UNKNOWN;
|
|
}
|
|
|
|
/* set value into the device, using the provided one, or the default one otherwise */
|
|
if (mode==SU_MODE_INSTCMD) {
|
|
/* Sanity check: commands should either have a value or a default */
|
|
if ( (val == NULL) && (su_info_p->dfl == NULL) ) {
|
|
upsdebugx(1, "%s: cannot execute command '%s': a provided or default value is needed!", __func__, varname);
|
|
return STAT_SET_INVALID;
|
|
}
|
|
}
|
|
|
|
if (su_info_p->info_flags & ST_FLAG_STRING) {
|
|
status = nut_snmp_set_str(su_info_p->OID, val ? val : su_info_p->dfl);
|
|
}
|
|
else {
|
|
if (mode==SU_MODE_INSTCMD) {
|
|
if ( !str_to_long(val ? val : su_info_p->dfl, &value, 10) ) {
|
|
upsdebugx(1, "%s: cannot execute command '%s': value is not a number!", __func__, varname);
|
|
return STAT_SET_INVALID;
|
|
}
|
|
}
|
|
else {
|
|
/* non string data may imply a value lookup */
|
|
if (su_info_p->oid2info) {
|
|
value = su_find_valinfo(su_info_p->oid2info, val ? val : su_info_p->dfl);
|
|
}
|
|
else {
|
|
/* Convert value and apply multiplier */
|
|
if ( !str_to_long(val, &value, 10) ) {
|
|
upsdebugx(1, "%s: cannot set '%s': value is not a number!", __func__, varname);
|
|
return STAT_SET_INVALID;
|
|
}
|
|
value = (long)((double)value / su_info_p->info_len);
|
|
}
|
|
}
|
|
/* Actually apply the new value */
|
|
if (SU_TYPE(su_info_p) == SU_TYPE_TIME) {
|
|
status = nut_snmp_set_time(su_info_p->OID, value);
|
|
}
|
|
else {
|
|
status = nut_snmp_set_int(su_info_p->OID, value);
|
|
}
|
|
}
|
|
|
|
/* Process result */
|
|
if (status == FALSE) {
|
|
if (mode==SU_MODE_INSTCMD)
|
|
upsdebugx(1, "%s: cannot execute command '%s'", __func__, varname);
|
|
else
|
|
upsdebugx(1, "%s: cannot set value %s on OID %s", __func__, val, su_info_p->OID);
|
|
|
|
retval = STAT_SET_FAILED;
|
|
}
|
|
else {
|
|
retval = STAT_SET_HANDLED;
|
|
if (mode==SU_MODE_INSTCMD)
|
|
upsdebugx(1, "%s: successfully sent command %s", __func__, varname);
|
|
else {
|
|
upsdebugx(1, "%s: successfully set %s to \"%s\"", __func__, varname, val);
|
|
|
|
/* update info array: call dstate_setinfo, since flags and aux are
|
|
* already published, and this saves us some processing */
|
|
dstate_setinfo(varname, "%s", val);
|
|
}
|
|
}
|
|
|
|
/* Free template (outlet and outlet.group) */
|
|
if (!strncmp(tmp_varname, "outlet", 6))
|
|
free_info(su_info_p);
|
|
free(tmp_varname);
|
|
|
|
return retval;
|
|
}
|
|
|
|
/* set r/w INFO_ element to a value.
|
|
* 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);
|
|
}
|
|
|
|
/* Daisychain-aware function to add instant commands:
|
|
* Every command that is valid for a device has to be added for device.0
|
|
* This then allows to composite commands, called on device.0 and executed
|
|
* on all devices of the daisychain */
|
|
int su_addcmd(snmp_info_t *su_info_p)
|
|
{
|
|
upsdebugx(2, "entering %s(%s)", __func__, su_info_p->info_type);
|
|
|
|
if (daisychain_enabled == TRUE) {
|
|
/* FIXME?: daisychain */
|
|
for (current_device_number = 1 ; current_device_number <= devices_count ;
|
|
current_device_number++)
|
|
{
|
|
process_template(SU_WALKMODE_INIT, "device", su_info_p);
|
|
}
|
|
}
|
|
else {
|
|
if (nut_snmp_get(su_info_p->OID) != NULL) {
|
|
dstate_addcmd(su_info_p->info_type);
|
|
upsdebugx(1, "%s: adding command '%s'", __func__, su_info_p->info_type);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* process instant command and take action. */
|
|
int su_instcmd(const char *cmdname, const char *extradata)
|
|
{
|
|
return su_setOID(SU_MODE_INSTCMD, cmdname, extradata);
|
|
}
|
|
|
|
/* FIXME: the below functions can be removed since these were for loading
|
|
* the mib2nut information from a file instead of the .h definitions... */
|
|
/* return 1 if usable, 0 if not */
|
|
static int parse_mibconf_args(size_t numargs, char **arg)
|
|
{
|
|
bool_t ret;
|
|
|
|
/* everything below here uses up through arg[1] */
|
|
if (numargs < 6)
|
|
return 0;
|
|
|
|
/* <info type> <info flags> <info len> <OID name> <default value> <value lookup> */
|
|
|
|
/* special case for setting some OIDs value at driver startup */
|
|
if (!strcmp(arg[0], "init")) {
|
|
/* set value. */
|
|
if (!strcmp(arg[1], "str")) {
|
|
ret = nut_snmp_set_str(arg[3], arg[4]);
|
|
} else {
|
|
ret = nut_snmp_set_int(arg[3], strtol(arg[4], NULL, 0));
|
|
}
|
|
|
|
if (ret == FALSE)
|
|
upslogx(LOG_ERR, "%s: cannot set value %s for %s", __func__, arg[4], arg[3]);
|
|
else
|
|
upsdebugx(1, "%s: successfully set %s to \"%s\"", __func__, arg[0], arg[4]);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* TODO: create the lookup table */
|
|
upsdebugx(2, "%s, %s, %s, %s, %s, %s", arg[0], arg[1], arg[2], arg[3], arg[4], arg[5]);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* called for fatal errors in parseconf like malloc failures */
|
|
static void mibconf_err(const char *errmsg)
|
|
{
|
|
upslogx(LOG_ERR, "Fatal error in parseconf (*mib.conf): %s", errmsg);
|
|
}
|
|
|
|
/* load *mib.conf into an snmp_info_t structure */
|
|
void read_mibconf(char *mib)
|
|
{
|
|
char fn[SMALLBUF];
|
|
PCONF_CTX_t ctx;
|
|
|
|
upsdebugx(2, "SNMP UPS driver: entering %s(%s)", __func__, mib);
|
|
|
|
snprintf(fn, sizeof(fn), "%s/snmp/%s.conf", CONFPATH, mib);
|
|
|
|
pconf_init(&ctx, mibconf_err);
|
|
|
|
if (!pconf_file_begin(&ctx, fn))
|
|
fatalx(EXIT_FAILURE, "%s", ctx.errmsg);
|
|
|
|
while (pconf_file_next(&ctx)) {
|
|
if (pconf_parse_error(&ctx)) {
|
|
upslogx(LOG_ERR, "Parse error: %s:%d: %s",
|
|
fn, ctx.linenum, ctx.errmsg);
|
|
continue;
|
|
}
|
|
|
|
if (ctx.numargs < 1)
|
|
continue;
|
|
|
|
if (!parse_mibconf_args(ctx.numargs, ctx.arglist)) {
|
|
unsigned int i;
|
|
char errmsg[SMALLBUF];
|
|
|
|
snprintf(errmsg, sizeof(errmsg),
|
|
"mib.conf: invalid directive");
|
|
|
|
for (i = 0; i < ctx.numargs; i++)
|
|
snprintfcat(errmsg, sizeof(errmsg), " %s",
|
|
ctx.arglist[i]);
|
|
|
|
upslogx(LOG_WARNING, "%s", errmsg);
|
|
}
|
|
}
|
|
pconf_finish(&ctx);
|
|
}
|