16 #define strdup _strdup
17 #define vsnprintf vsprintf_s
18 #define strPrintf sprintf_s
20 #define strPrintf snprintf
23 #ifndef UNREFERENCED_PARAMETER
24 #define UNREFERENCED_PARAMETER(P) (void)(P)
27 static const char WienerMibFileName[] =
"WIENER-CRATE-MIB";
28 static const char DefaultReadCommunity[] =
"public";
29 static const char DefaultWriteCommunity[] =
"guru";
31 static char *m_readCommunity = (
char *)DefaultReadCommunity;
32 static char *m_writeCommunity = (
char *)DefaultWriteCommunity;
116 static double snmpSetDouble(
HSNMP session,
const SnmpObject &
object,
double value);
118 static int snmpSetInt(
HSNMP session,
const SnmpObject &
object,
int value);
130 BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
147 static void sysLog(
int priority,
const char *format, ...)
152 va_start(vaPrintf, format);
153 vprintf(format, vaPrintf);
157 if (priority == LOG_ERR)
173 static int getNode(
const char *
const node,
SnmpObject *
object)
175 object->len = MAX_OID_LEN;
176 if (!get_node(node, object->
id, &object->
len)) {
177 snmp_log(LOG_ERR,
"OID %s not found!\n", node);
182 strcpy_s(object->
desc,
sizeof(object->
desc), node);
184 strncpy(object->
desc, node,
sizeof(object->
desc));
199 static int getIndexNode(
const char *
const nodeBase,
int index,
SnmpObject *
object)
203 strPrintf(node,
sizeof(node),
"%s.%i", nodeBase, index);
205 return getNode(node,
object);
215 snmp_enable_stderrlog();
228 snmp_enable_filelog(fileName, 1);
242 return (version[0] << 24) + (version[1] << 16) + (version[2] << 8) + version[3];
261 static void setDefaultSettings(
void)
265 m_readCommunity = (
char *)DefaultReadCommunity;
266 m_writeCommunity = (
char *)DefaultWriteCommunity;
280 setDefaultSettings();
282 snmp_log(LOG_DEBUG,
"*** Initialise SNMP ***\n");
284 init_snmp(
"WIENER_SNMP_DLL");
286 if (!read_module(WienerMibFileName)) {
287 snmp_log(LOG_ERR,
"Unable to load SNMP MIB file \"%s\"\n", WienerMibFileName);
290 snmp_log(LOG_DEBUG,
"*** Translate OIDs ***\n");
293 getNode(
"sysDescr.0", &sysDescr);
296 (!getNode(
"sysMainSwitch.0", &sysMainSwitch)) ||
297 (!getNode(
"sysStatus.0", &sysStatus)) ||
298 (!getNode(
"sysVmeSysReset.0", &sysVmeSysReset)) ||
299 (!getNode(
"outputNumber.0", &outputNumber)) ||
300 (!getNode(
"groupsNumber.0", &groupsNumber)) ||
301 (!getNode(
"groupsSwitch.64", &highVoltageGroupsSwitch)) ||
302 (!getNode(
"groupsSwitch.128", &lowVoltageGroupsSwitch)) ||
303 (!getNode(
"ipStaticAddress.0", &ipStaticAddress)) ||
305 (!getNode(
"psSerialNumber.0", &psSerialNumber)) ||
306 (!getNode(
"psOperatingTime.0", &psOperatingTime)) ||
307 (!getNode(
"psDirectAccess.0", &psDirectAccess)) ||
308 (!getNode(
"sensorNumber.0", &sensorNumber)) ||
310 (!getNode(
"fanSerialNumber.0", &fanSerialNumber)) ||
311 (!getNode(
"fanOperatingTime.0", &fanOperatingTime)) ||
312 (!getNode(
"fanAirTemperature.0", &fanAirTemperature))||
313 (!getNode(
"fanSwitchOffDelay.0", &fanSwitchOffDelay)) ||
314 (!getNode(
"fanNominalSpeed.0", &fanNominalSpeed)) ||
315 (!getNode(
"fanNumberOfFans.0", &fanNumberOfFans))
324 (!getIndexNode(
"moduleIndex", slot + 1, &moduleIndex[slot])) ||
325 (!getIndexNode(
"moduleDescription", slot + 1, &moduleDescription[slot])) ||
326 (!getIndexNode(
"moduleAuxiliaryMeasurementVoltage0", slot + 1, &moduleSupply[0][slot])) ||
327 (!getIndexNode(
"moduleAuxiliaryMeasurementVoltage1", slot + 1, &moduleSupply[1][slot])) ||
328 (!getIndexNode(
"moduleAuxiliaryMeasurementTemperature0", slot + 1, &moduleAuxiliaryMeasurementTemperature[0][slot])) ||
329 (!getIndexNode(
"moduleAuxiliaryMeasurementTemperature1", slot + 1, &moduleAuxiliaryMeasurementTemperature[1][slot])) ||
330 (!getIndexNode(
"moduleAuxiliaryMeasurementTemperature2", slot + 1, &moduleAuxiliaryMeasurementTemperature[2][slot])) ||
331 (!getIndexNode(
"moduleAuxiliaryMeasurementTemperature3", slot + 1, &moduleAuxiliaryMeasurementTemperature[3][slot])) ||
332 (!getIndexNode(
"moduleHardwareLimitVoltage", slot + 1, &moduleHardwareLimitVoltage[slot])) ||
333 (!getIndexNode(
"moduleHardwareLimitCurrent", slot + 1, &moduleHardwareLimitCurrent[slot])) ||
334 (!getIndexNode(
"moduleRampSpeedVoltage", slot + 1, &moduleRampSpeedVoltage[slot])) ||
335 (!getIndexNode(
"moduleRampSpeedCurrent", slot + 1, &moduleRampSpeedCurrent[slot])) ||
336 (!getIndexNode(
"moduleStatus", slot + 1, &moduleStatus[slot])) ||
337 (!getIndexNode(
"moduleEventStatus", slot + 1, &moduleEventStatus[slot])) ||
338 (!getIndexNode(
"moduleDoClear", slot + 1, &moduleDoClear[slot]))
347 (!getIndexNode(
"outputName", channel + 1, &outputName[channel])) ||
348 (!getIndexNode(
"outputIndex", channel + 1, &outputIndex[channel])) ||
349 (!getIndexNode(
"outputGroup", channel + 1, &outputGroup[channel])) ||
350 (!getIndexNode(
"outputStatus", channel + 1, &outputStatus[channel])) ||
351 (!getIndexNode(
"outputMeasurementSenseVoltage", channel + 1, &outputMeasurementSenseVoltage[channel])) ||
352 (!getIndexNode(
"outputMeasurementTerminalVoltage", channel + 1, &outputMeasurementTerminalVoltage[channel])) ||
353 (!getIndexNode(
"outputMeasurementCurrent", channel + 1, &outputMeasurementCurrent[channel])) ||
354 (!getIndexNode(
"outputMeasurementTemperature", channel + 1, &outputMeasurementTemperature[channel])) ||
355 (!getIndexNode(
"outputSwitch", channel + 1, &outputSwitch[channel])) ||
356 (!getIndexNode(
"outputVoltage", channel + 1, &outputVoltage[channel])) ||
357 (!getIndexNode(
"outputCurrent", channel + 1, &outputCurrent[channel])) ||
358 (!getIndexNode(
"outputVoltageRiseRate", channel + 1, &outputVoltageRiseRate[channel])) ||
359 (!getIndexNode(
"outputVoltageFallRate", channel + 1, &outputVoltageFallRate[channel])) ||
360 (!getIndexNode(
"outputCurrentRiseRate", channel + 1, &outputCurrentRiseRate[channel])) ||
361 (!getIndexNode(
"outputCurrentFallRate", channel + 1, &outputCurrentFallRate[channel])) ||
362 (!getIndexNode(
"outputSupervisionBehavior", channel + 1, &outputSupervisionBehavior[channel])) ||
363 (!getIndexNode(
"outputSupervisionMinSenseVoltage", channel + 1, &outputSupervisionMinSenseVoltage[channel])) ||
364 (!getIndexNode(
"outputSupervisionMaxSenseVoltage", channel + 1, &outputSupervisionMaxSenseVoltage[channel])) ||
365 (!getIndexNode(
"outputSupervisionMaxTerminalVoltage", channel + 1, &outputSupervisionMaxTerminalVoltage[channel])) ||
366 (!getIndexNode(
"outputSupervisionMaxCurrent", channel + 1, &outputSupervisionMaxCurrent[channel])) ||
368 (!getIndexNode(
"outputConfigMaxSenseVoltage", channel + 1, &outputConfigMaxSenseVoltage[channel])) ||
369 (!getIndexNode(
"outputConfigMaxTerminalVoltage", channel + 1, &outputConfigMaxTerminalVoltage[channel])) ||
370 (!getIndexNode(
"outputSupervisionMaxPower", channel + 1, &outputSupervisionMaxPower[channel])) ||
371 (!getIndexNode(
"outputConfigMaxCurrent", channel + 1, &outputConfigMaxCurrent[channel])) ||
372 (!getIndexNode(
"outputTripTimeMaxCurrent", channel + 1, &outputTripTimeMaxCurrent[channel]))
379 for (
int sensor = 0; sensor <
MaxSensors; ++sensor)
381 (!getIndexNode(
"sensorTemperature", sensor + 1, &sensorTemperature[sensor])) ||
382 (!getIndexNode(
"sensorWarningThreshold", sensor + 1, &sensorWarningThreshold[sensor])) ||
383 (!getIndexNode(
"sensorFailureThreshold", sensor + 1, &sensorFailureThreshold[sensor]))
389 if (!getIndexNode(
"snmpCommunityName", name + 1, &snmpCommunityName[name]))
392 for (
int fan = 0; fan <
MaxFans; ++fan)
393 if (!getIndexNode(
"fanSpeed", fan + 1, &fanSpeed[fan]))
398 (!getIndexNode(
"psAuxiliaryMeasurementVoltage", aux + 1, &psAuxVoltage[aux])) ||
399 (!getIndexNode(
"psAuxiliaryMeasurementCurrent", aux + 1, &psAuxCurrent[aux]))
405 snmp_log(LOG_DEBUG,
"*** Initialise SNMP done ***\n");
430 m_readCommunity = strdup(readCommunityName);
444 m_writeCommunity = strdup(writeCommunityName);
459 struct snmp_session snmpSession;
460 snmp_sess_init(&snmpSession);
461 snmpSession.version = SNMP_VERSION_2c;
462 snmpSession.peername = strdup(ipAddress);
463 snmpSession.community = (u_char *)strdup(m_readCommunity);
464 snmpSession.community_len = strlen(m_readCommunity);
466 snmpSession.timeout = 300000;
467 snmpSession.retries = 2;
469 if (!(session = snmp_sess_open(&snmpSession))) {
472 snmp_error(&snmpSession, &liberr, &syserr, &errstr);
473 snmp_log(LOG_ERR,
"Open SNMP session for host \"%s\": %s\n", ipAddress, errstr);
478 snmp_log(LOG_INFO,
"SNMP session for host \"%s\" opened\n", ipAddress);
491 if (!snmp_sess_close(session))
492 snmp_log(LOG_ERR,
"Close SNMP session: ERROR\n");
494 snmp_log(LOG_INFO,
"SNMP session closed\n");
520 return snmpGetString(session, sysDescr);
535 return snmpGetInt(session, sysMainSwitch);
548 return snmpSetInt(session, sysMainSwitch, value);
558 return snmpGetInt(session, sysStatus);
568 return snmpGetInt(session, sysVmeSysReset);
578 return snmpSetInt(session, sysVmeSysReset, 1);
588 return snmpGetInt(session, ipStaticAddress);
599 return snmpSetInt(session, ipStaticAddress, value);
611 return snmpGetString(session, psSerialNumber);
623 return snmpGetInt(session, outputNumber);
633 return snmpGetInt(session, groupsNumber);
649 return snmpGetInt(session, outputGroup[channel]);
676 return snmpGetInt(session, outputStatus[channel]);
691 return snmpGetDouble(session, outputMeasurementSenseVoltage[channel]);
705 return snmpGetDouble(session, outputMeasurementTerminalVoltage[channel]);
719 return snmpGetDouble(session, outputMeasurementCurrent[channel]);
735 return snmpGetInt(session, outputMeasurementTemperature[channel]);
766 return snmpSetInt(session, outputSwitch[channel], value);
795 return snmpGetInt(session, outputSwitch[channel]);
806 return snmpSetInt(session, highVoltageGroupsSwitch, value);
816 return snmpGetInt(session, highVoltageGroupsSwitch);
827 return snmpSetInt(session, lowVoltageGroupsSwitch, value);
837 return snmpGetInt(session, lowVoltageGroupsSwitch);
851 return snmpGetDouble(session, outputVoltage[channel]);
866 return snmpSetDouble(session, outputVoltage[channel], value);
880 return snmpGetDouble(session, outputCurrent[channel]);
895 return snmpSetDouble(session, outputCurrent[channel], value);
912 return snmpGetDouble(session, outputVoltageRiseRate[channel]);
930 return snmpSetDouble(session, outputVoltageRiseRate[channel], value);
947 return snmpGetDouble(session, outputVoltageFallRate[channel]);
965 return snmpSetDouble(session, outputVoltageFallRate[channel], value);
982 return snmpGetDouble(session, outputCurrentRiseRate[channel]);
1000 return snmpSetDouble(session, outputCurrentRiseRate[channel], value);
1017 return snmpGetDouble(session, outputCurrentFallRate[channel]);
1035 return snmpSetDouble(session, outputCurrentFallRate[channel], value);
1050 return snmpGetInt(session, outputSupervisionBehavior[channel]);
1087 return snmpSetInt(session, outputSupervisionBehavior[channel], value );
1101 return snmpGetDouble(session, outputSupervisionMinSenseVoltage[channel]);
1116 return snmpSetDouble(session, outputSupervisionMinSenseVoltage[channel], value);
1130 return snmpGetDouble(session, outputSupervisionMaxSenseVoltage[channel]);
1145 return snmpSetDouble(session, outputSupervisionMaxSenseVoltage[channel], value);
1160 return snmpGetDouble(session, outputSupervisionMaxTerminalVoltage[channel]);
1176 return snmpSetDouble(session, outputSupervisionMaxTerminalVoltage[channel], value);
1191 return snmpGetDouble(session, outputSupervisionMaxCurrent[channel]);
1207 return snmpSetDouble(session, outputSupervisionMaxCurrent[channel], value );
1221 return snmpGetInt(session, outputSupervisionMaxTemperature[channel]);
1235 return snmpGetDouble(session, outputConfigMaxSenseVoltage[channel]);
1249 return snmpGetDouble(session, outputConfigMaxTerminalVoltage[channel]);
1263 return snmpGetDouble(session, outputConfigMaxCurrent[channel]);
1277 return snmpGetDouble(session, outputSupervisionMaxPower[channel]);
1291 return snmpGetInt(session, outputTripTimeMaxCurrent[channel]);
1306 return snmpSetInt(session, outputTripTimeMaxCurrent[channel], delay);
1313 return snmpGetInt(session, sensorNumber);
1321 return snmpGetInt(session, sensorTemperature[sensor]);
1329 return snmpGetInt(session, sensorWarningThreshold[sensor]);
1337 return snmpSetInt(session, sensorWarningThreshold[sensor], value);
1345 return snmpGetInt(session, sensorFailureThreshold[sensor]);
1353 return snmpSetInt(session, sensorFailureThreshold[sensor], value);
1365 return snmpGetInt(session, psOperatingTime);
1373 return snmpGetDouble(session, psAuxVoltage[auxIndex]);
1381 return snmpGetDouble(session, psAuxCurrent[auxIndex]);
1388 return snmpGetInt(session, fanOperatingTime);
1393 return snmpGetInt(session, fanAirTemperature);
1398 return snmpGetInt(session, fanSwitchOffDelay);
1403 return snmpSetInt(session, fanSwitchOffDelay, value);
1413 return snmpGetInt(session, fanNominalSpeed);
1424 return snmpSetInt(session, fanNominalSpeed, value );
1429 return snmpGetInt(session, fanNumberOfFans);
1437 return snmpGetInt(session, fanSpeed[fan]);
1460 return snmpGetString(session, moduleDescription[slot]);
1475 return snmpGetDouble(session, moduleSupply[0][slot]);
1490 return snmpGetDouble(session, moduleSupply[1][slot]);
1511 return snmpGetDouble(session, moduleAuxiliaryMeasurementTemperature[index][slot]);
1527 return snmpGetDouble(session, moduleHardwareLimitVoltage[slot]);
1543 return snmpGetDouble(session, moduleHardwareLimitCurrent[slot]);
1560 return snmpGetDouble(session, moduleRampSpeedVoltage[slot]);
1580 return snmpSetDouble(session, moduleRampSpeedVoltage[slot], value);
1599 return snmpGetDouble(session, moduleRampSpeedCurrent[slot]);
1619 return snmpSetDouble(session, moduleRampSpeedCurrent[slot], value);
1635 return snmpGetInt(session, moduleStatus[slot]);
1651 return snmpGetInt(session, moduleEventStatus[slot]);
1668 return snmpSetInt(session, moduleDoClear[slot], 1);
1673 static void logErrors(
HSNMP session,
struct snmp_pdu *response,
1674 const SnmpObject &
object,
int status,
const char *functionName)
1677 if (status == STAT_SUCCESS)
1678 snmp_log(LOG_ERR,
"%s(%s): Error in packet. Reason: %s\n",
1679 functionName,
object.desc, snmp_errstring(response->errstat));
1681 snmp_sess_perror(
"snmpget", snmp_sess_session(session));
1684 static int getIntegerVariable(
struct variable_list *vars)
1686 if (vars->type == ASN_BIT_STR || vars->type == ASN_OCTET_STR) {
1688 for (
size_t i = 0; i < vars->val_len && i <
sizeof(int); ++i)
1689 value |= (vars->val.bitstring[i] << (i * 8));
1691 }
if (vars->type == ASN_OPAQUE_FLOAT)
1692 return (
int)*vars->val.floatVal;
1693 else if (vars->type == ASN_OPAQUE_DOUBLE)
1694 return (
int)*vars->val.doubleVal;
1695 else if (vars->type == ASN_INTEGER)
1696 return *vars->val.integer;
1697 else if (vars->type == ASN_OCTET_STR)
1698 return *vars->val.integer;
1699 else if (vars->type == ASN_IPADDRESS)
1700 return *vars->val.integer;
1705 static double getDoubleVariable(
struct variable_list *vars)
1707 if (vars->type == ASN_OPAQUE_FLOAT)
1708 return *vars->val.floatVal;
1709 else if (vars->type == ASN_OPAQUE_DOUBLE)
1710 return *vars->val.doubleVal;
1711 else if (vars->type == ASN_INTEGER)
1712 return (
double)*vars->val.integer;
1717 static snmp_pdu *prepareSetRequestPdu(
void)
1719 struct snmp_pdu *pdu = snmp_pdu_create(SNMP_MSG_SET);
1720 pdu->community = (u_char *)strdup(m_writeCommunity);
1721 pdu->community_len = strlen(m_writeCommunity);
1726 static snmp_pdu *prepareGetRequestPdu()
1728 struct snmp_pdu *pdu = snmp_pdu_create(SNMP_MSG_GET);
1737 struct snmp_pdu *pdu = prepareGetRequestPdu();
1739 snmp_add_null_var(pdu,
object.
id,
object.len);
1741 struct snmp_pdu *response;
1742 int status = snmp_sess_synch_response(session, pdu, &response);
1744 if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
1745 value = getIntegerVariable(response->variables);
1747 logErrors(session, response,
object, status,
"snmpGetInt");
1751 snmp_free_pdu(response);
1755 static int snmpSetInt(
HSNMP session,
const SnmpObject &
object,
int value)
1757 struct snmp_pdu *pdu = prepareSetRequestPdu();
1759 if (snmp_oid_compare(
object.
id,
object.len, ipStaticAddress.
id, ipStaticAddress.
len) == 0)
1760 snmp_pdu_add_variable(pdu,
object.
id,
object.len, ASN_IPADDRESS, (u_char *)&value,
sizeof(value));
1762 snmp_pdu_add_variable(pdu,
object.
id,
object.len, ASN_INTEGER, (u_char *)&value,
sizeof(value));
1765 struct snmp_pdu *response;
1766 int status = snmp_sess_synch_response(session, pdu, &response);
1768 if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
1769 result = getIntegerVariable(response->variables);
1771 logErrors(session, response,
object, status,
"snmpSetInt");
1775 snmp_free_pdu(response);
1783 struct snmp_pdu *pdu = prepareGetRequestPdu();
1785 snmp_add_null_var(pdu,
object.
id,
object.len);
1787 struct snmp_pdu *response;
1788 int status = snmp_sess_synch_response(session, pdu, &response);
1790 if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
1791 value = getDoubleVariable(response->variables);
1793 logErrors(session, response,
object, status,
"snmpGetDouble");
1797 snmp_free_pdu(response);
1801 static double snmpSetDouble(
HSNMP session,
const SnmpObject &
object,
double value)
1803 struct snmp_pdu *pdu = prepareSetRequestPdu();
1805 float v = (float)value;
1806 snmp_pdu_add_variable(pdu,
object.
id,
object.len, ASN_OPAQUE_FLOAT, (u_char *)&v,
sizeof(v));
1810 struct snmp_pdu *response;
1811 int status = snmp_sess_synch_response(session, pdu, &response);
1813 if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
1814 result = getDoubleVariable(response->variables);
1816 logErrors(session, response,
object, status,
"snmpSetDouble");
1820 snmp_free_pdu(response);
1826 struct snmp_pdu *pdu = prepareGetRequestPdu();
1828 snmp_add_null_var(pdu,
object.
id,
object.len);
1830 struct snmp_pdu *response;
1831 int status = snmp_sess_synch_response(session, pdu, &response);
1835 if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
1836 struct variable_list *vars = response->variables;
1837 if (vars->type == ASN_OCTET_STR) {
1839 if (len > vars->val_len)
1840 len = vars->val_len;
1846 logErrors(session, response,
object, status,
"snmpGetString");
1850 snmp_free_pdu(response);
1856 struct snmp_pdu *pdu = prepareGetRequestPdu();
1861 memset(&snmpIntegerBuffer, 0,
sizeof(snmpIntegerBuffer));
1863 for (
int i = 0; i < size; ++i)
1864 snmp_add_null_var(pdu, objects[i].
id, objects[i].len);
1866 struct snmp_pdu *response;
1867 int status = snmp_sess_synch_response(session, pdu, &response);
1869 if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
1870 struct variable_list *vars;
1871 for (vars = response->variables; vars; vars = vars->next_variable)
1872 snmpIntegerBuffer.
value[snmpIntegerBuffer.
size++] = getIntegerVariable(vars);
1874 logErrors(session, response, objects[0], status,
"snmpGetMultipleInteger");
1878 snmp_free_pdu(response);
1884 struct snmp_pdu *pdu = prepareSetRequestPdu();
1886 int size = values->
size;
1890 for (
int i = 0; i < size; ++i) {
1891 int v = values->
value[i];
1892 snmp_pdu_add_variable(pdu, objects[i].
id, objects[i].len, ASN_INTEGER, (u_char *)&v,
sizeof(v));
1895 memset(&snmpIntegerBuffer, 0,
sizeof(snmpIntegerBuffer));
1897 struct snmp_pdu *response;
1898 int status = snmp_sess_synch_response(session, pdu, &response);
1900 if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
1901 struct variable_list *vars;
1902 for (vars = response->variables; vars; vars = vars->next_variable)
1903 snmpIntegerBuffer.
value[snmpIntegerBuffer.
size++] = getIntegerVariable(vars);
1905 logErrors(session, response, objects[0], status,
"snmpSetMultipleInteger");
1909 snmp_free_pdu(response);
1915 struct snmp_pdu *pdu = prepareGetRequestPdu();
1920 memset(&snmpDoubleBuffer, 0,
sizeof(snmpDoubleBuffer));
1922 for (
int i = 0; i < size; ++i)
1923 snmp_add_null_var(pdu, objects[i].
id, objects[i].len);
1925 struct snmp_pdu *response;
1926 int status = snmp_sess_synch_response(session, pdu, &response);
1928 if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
1929 struct variable_list *vars;
1930 for (vars = response->variables; vars; vars = vars->next_variable)
1931 snmpDoubleBuffer.
value[snmpDoubleBuffer.
size++] = getDoubleVariable(vars);
1933 logErrors(session, response, objects[0], status,
"snmpGetMultipleDouble");
1937 snmp_free_pdu(response);
1944 struct snmp_pdu *pdu = prepareSetRequestPdu();
1946 int size = values->
size;
1950 for (
int i = 0; i < size; ++i) {
1951 float v = (float)values->
value[i];
1952 snmp_pdu_add_variable(pdu, objects[i].
id, objects[i].len, ASN_OPAQUE_FLOAT, (u_char *)&v,
sizeof(v));
1955 memset(&snmpDoubleBuffer, 0,
sizeof(snmpDoubleBuffer));
1957 struct snmp_pdu *response;
1958 int status = snmp_sess_synch_response(session, pdu, &response);
1960 if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
1961 struct variable_list *vars;
1962 for (vars = response->variables; vars; vars = vars->next_variable)
1963 snmpDoubleBuffer.
value[snmpDoubleBuffer.
size++] = getDoubleVariable(vars);
1965 logErrors(session, response, objects[0], status,
"snmpSetMultipleDouble");
1969 snmp_free_pdu(response);
2004 memset(&snmpIntegerBuffer, 0,
sizeof(snmpIntegerBuffer));
2008 return snmpGetMultipleInteger(session, &outputStatus[start], size);
2024 memset(&snmpIntegerBuffer, 0,
sizeof(snmpIntegerBuffer));
2028 return snmpGetMultipleInteger(session, &outputSwitch[start], size);
2042 memset(&snmpIntegerBuffer, 0,
sizeof(snmpIntegerBuffer));
2046 return snmpSetMultipleInteger(session, &outputSwitch[start], values);
2062 memset(&snmpDoubleBuffer, 0,
sizeof(snmpDoubleBuffer));
2066 return snmpGetMultipleDouble(session, &outputVoltage[start], size);
2080 memset(&snmpDoubleBuffer, 0,
sizeof(snmpDoubleBuffer));
2084 return snmpSetMultipleDouble(session, &outputVoltage[start], values);
2116 memset(&snmpDoubleBuffer, 0,
sizeof(snmpDoubleBuffer));
2120 return snmpGetMultipleDouble(session, &outputMeasurementTerminalVoltage[start], size);
2134 memset(&snmpDoubleBuffer, 0,
sizeof(snmpDoubleBuffer));
2138 return snmpGetMultipleDouble(session, &outputConfigMaxTerminalVoltage[start], size);
2152 memset(&snmpDoubleBuffer, 0,
sizeof(snmpDoubleBuffer));
2156 return snmpGetMultipleDouble(session, &outputCurrent[start], size);
2170 memset(&snmpDoubleBuffer, 0,
sizeof(snmpDoubleBuffer));
2174 return snmpSetMultipleDouble(session, &outputCurrent[start], values);
2208 memset(&snmpDoubleBuffer, 0,
sizeof(snmpDoubleBuffer));
2212 return snmpGetMultipleDouble(session, &outputMeasurementCurrent[start], size);
2226 memset(&snmpDoubleBuffer, 0,
sizeof(snmpDoubleBuffer));
2230 return snmpGetMultipleDouble(session, &outputConfigMaxCurrent[start], size);
2244 memset(&snmpIntegerBuffer, 0,
sizeof(snmpIntegerBuffer));
2248 return snmpGetMultipleInteger(session, &outputTripTimeMaxCurrent[start], size);
2262 memset(&snmpIntegerBuffer, 0,
sizeof(snmpIntegerBuffer));
2266 return snmpSetMultipleInteger(session, &outputTripTimeMaxCurrent[start], values);
2280 memset(&snmpIntegerBuffer, 0,
sizeof(snmpIntegerBuffer));
2284 return snmpGetMultipleInteger(session, &outputSupervisionBehavior[start], size);
2298 memset(&snmpIntegerBuffer, 0,
sizeof(snmpIntegerBuffer));
2302 return snmpSetMultipleInteger(session, &outputSupervisionBehavior[start], values);