Subversion Repositories f9daq

#include <userint.h>

#include "mpod_uir.h"

/** WIENER SNMP basic SNMP library to Demonstrate C-Access to WIENER-Crates via SNMP

// modified for LabView imprt 04/23/06, Andreas Ruben

//

// The path to the Net-SNMP include files (default /usr/include) must be added to the

// include file search path!

// The following libraries must be included:

// netsnmp.lib ws2_32.lib

// The path to the Net-SNMP library must be added to the linker files.

// /usr/lib

// path for the WIENER MIB file (mibdirs) c:/usr/share/snmp/mibs

*/

#include <windows.h>

#define WIN32_LEAN_AND_MEAN     // Exclude rarely-used stuff from Windows headers   

#include <winsock2.h>

#include <ws2tcpip.h>    

#include "netsnmplib.h"  

#include "WIENER_SNMP.h"

#include "toolbox.h" 

#define _strdup StrDup

#define WIN32_LEAN_AND_MEAN

#include <stdio.h>

const char* readCommunity = "public";       ///< community name for read operations

const char* writeCommunity = "guru";        ///< community name for write operation

// System Information OIDS

char *S_sysMainSwitch = "sysMainSwitch.0";

oid oidSysMainSwitch [MAX_OID_LEN];

size_t lengthSysMainSwitch;

char *S_sysStatus = "sysStatus.0";

oid oidSysStatus [MAX_OID_LEN];

size_t lengthSysStatus;

char *S_sysVmeSysReset = "sysVmeSysReset.0";

oid oidSysVmeSysReset [MAX_OID_LEN];

size_t lengthSysVmeSysReset;

//Output Count Information

char *S_outputNumber = "outputNumber.0";

oid oidOutputNumber [MAX_OID_LEN];

size_t lengthOutputNumber;

char *S_groupsNumber = "groupsNumber.0";

oid oidGroupsNumber [MAX_OID_LEN];

size_t lengthGroupsNumber;

//Ouput Channel information

char *S_outputNameBase = "outputName.";

char *S_outputName[1100];

oid oidOutputName[1100] [MAX_OID_LEN];

size_t lengthOutputName[1100];

char *S_outputGroupBase = "outputGroup.";

char *S_outputGroup[1100];

oid oidOutputGroup[1100] [MAX_OID_LEN];

size_t lengthOutputGroup[1100];

char *S_outputStatusBase = "outputStatus.";

char *S_outputStatus[1100];

oid oidOutputStatus[1100] [MAX_OID_LEN];

size_t lengthOutputStatus[1100];

char *S_outputMeasurementSenseVoltageBase = "outputMeasurementSenseVoltage.";

char *S_outputMeasurementSenseVoltage[1100];

oid oidOutputMeasurementSenseVoltage[1100] [MAX_OID_LEN];

size_t lengthOutputMeasurementSenseVoltage[1100];

char *S_outputMeasurementTerminalVoltageBase = "outputMeasurementTerminalVoltage.";

char *S_outputMeasurementTerminalVoltage[1100];

oid oidOutputMeasurementTerminalVoltage[1100] [MAX_OID_LEN];

size_t lengthOutputMeasurementTerminalVoltage[1100];

char *S_outputMeasurementCurrentBase ="outputMeasurementCurrent.";

char *S_outputMeasurementCurrent[1100];

oid oidOutputMeasurementCurrent[1100] [MAX_OID_LEN];

size_t lengthOutputMeasurementCurrent[1100];

char *S_outputMeasurementTemperatureBase ="outputMeasurementTemperature.";

char *S_outputMeasurementTemperature[1100];

oid oidOutputMeasurementTemperature[1100] [MAX_OID_LEN];

size_t lengthOutputMeasurementTemperature[1100];

char *S_outputSwitchBase = "outputSwitch.";

char *S_outputSwitch[1100];

oid oidChannelSwitch[1100] [MAX_OID_LEN];

size_t lengthChannelSwitch[1100];

char *S_groupSwitchBase = "GroupSwitch.";

char *S_groupSwitch[1100];

oid oidGroupSwitch[1100] [MAX_OID_LEN];

size_t lengthGroupSwitch[1100];

char *S_outputVoltageBase ="outputVoltage.";

char *S_outputVoltage[1100];

oid oidOutputVoltage[1100] [MAX_OID_LEN];

size_t lengthOutputVoltage[1100];

char *S_outputCurrentBase = "outputCurrent.";

char *S_outputCurrent[1100];

oid oidOutputCurrent[1100] [MAX_OID_LEN];

size_t lengthOutputCurrent[1100];

char *S_outputRiseRateBase ="outputVoltageRiseRate.";

char *S_outputRiseRate[1100];

oid oidOutputRiseRate[1100] [MAX_OID_LEN];

size_t lengthOutputRiseRate[1100];

char *S_outputFallRateBase ="outputVoltageFallRate.";

char *S_outputFallRate[1100];

oid oidOutputFallRate[1100] [MAX_OID_LEN];

size_t lengthOutputFallRate[1100];

char *S_outputSupervisionBehaviorBase ="outputSupervisionBehavior.";

char *S_outputSupervisionBehavior[1100];

oid oidOutputSupervisionBehavior[1100] [MAX_OID_LEN];

size_t lengthOutputSupervisionBehavior[1100];

char *S_outputSupervisionMinSenseVoltageBase ="outputSupervisionMinSenseVoltage.";

char *S_outputSupervisionMinSenseVoltage[1100];

oid oidOutputSupervisionMinSenseVoltage[1100] [MAX_OID_LEN];

size_t lengthOutputSupervisionMinSenseVoltage[1100];

char *S_outputSupervisionMaxSenseVoltageBase ="outputSupervisionMaxSenseVoltage.";

char *S_outputSupervisionMaxSenseVoltage[1100];

oid oidOutputSupervisionMaxSenseVoltage[1100] [MAX_OID_LEN];

size_t lengthOutputSupervisionMaxSenseVoltage[1100];

char *S_outputSupervisionMaxTerminalVoltageBase ="outputSupervisionMaxTerminalVoltage.";

char *S_outputSupervisionMaxTerminalVoltage[1100];

oid oidOutputSupervisionMaxTerminalVoltage[1100] [MAX_OID_LEN];

size_t lengthOutputSupervisionMaxTerminalVoltage[1100];

char *S_outputSupervisionMaxCurrentBase ="outputSupervisionMaxCurrent.";

char *S_outputSupervisionMaxCurrent[1100];

oid oidOutputSupervisionMaxCurrent[1100] [MAX_OID_LEN];

size_t lengthOutputSupervisionMaxCurrent[1100];

char *S_outputSupervisionMaxTemperatureBase ="outputSupervisionMaxTemperature.";

char *S_outputSupervisionMaxTemperature[1100];

oid oidOutputSupervisionMaxTemperature[1100] [MAX_OID_LEN];

size_t lengthOutputSupervisionMaxTemperature[1100];

char *S_outputConfigMaxSenseVoltageBase ="outputConfigMaxSenseVoltage.";

char *S_outputConfigMaxSenseVoltage[1100];

oid oidOutputConfigMaxSenseVoltage[1100] [MAX_OID_LEN];

size_t lengthOutputConfigMaxSenseVoltage[1100];

char *S_outputConfigMaxTerminalVoltageBase ="outputConfigMaxTerminalVoltage.";

char *S_outputConfigMaxTerminalVoltage[1100];

oid oidOutputConfigMaxTerminalVoltage[1100] [MAX_OID_LEN];

size_t lengthOutputConfigMaxTerminalVoltage[1100];

char *S_outputConfigMaxCurrentBase ="outputConfigMaxCurrent.";

char *S_outputConfigMaxCurrent[1100];

oid oidOutputConfigMaxCurrent[1100] [MAX_OID_LEN];

size_t lengthOutputConfigMaxCurrent[1100];

char *S_outputConfigMaxPowerBase ="outputSupervisionMaxPower.";

char *S_outputConfigMaxPower[1100];

oid oidOutputConfigMaxPower[1100] [MAX_OID_LEN];

size_t lengthOutputConfigMaxPower[1100];

//Sensor Information

char *S_sensorNumber ="sensorNumber.0";

oid oidSensorNumber [MAX_OID_LEN];

size_t lengthSensorNumber;

char *S_sensorTemperatureBase ="sensorTemperature.";

char *S_sensorTemperature[12];

oid oidSensorTemperature[12] [MAX_OID_LEN];

size_t lengthSensorTemperature[12];

char *S_sensorWarningThresholdBase ="sensorWarningThreshold.";

char *S_sensorWarningThreshold[12];

oid oidSensorWarningThreshold[12] [MAX_OID_LEN];

size_t lengthSensorWarningThreshold[12];

char *S_sensorFailureThresholdBase ="sensorFailureThreshold.";

char *S_sensorFailureThreshold[12];

oid oidSensorFailureThreshold[12] [MAX_OID_LEN];

size_t lengthSensorFailureThreshold[12];

//SNMP Community Information

char *S_snmpCommunityNameBase ="snmpCommunityName.";

char *S_snmpCommunityName[4];

oid oidSnmpCommunityName[4] [MAX_OID_LEN];

size_t lengthSnmpCommunityName[4];

// Power Supply Details

char *S_psFirmwareVersion ="psFirmwareVersion.0";

oid oidPsFirmwareVersion[MAX_OID_LEN];

size_t lengthPsFirmwareVersion;

char *S_psSerialNumber ="psSerialNumber.0";

oid oidPsSerialNumber[MAX_OID_LEN];

size_t lengthPsSerialNumber;

char *S_psOperatingTime ="psOperatingTime.0";

oid oidPsOperatingTime[MAX_OID_LEN];

size_t lengthPsOperatingTime;

char *S_psDirectAccess ="psDirectAccess.0";

oid oidPsDirectAccess[MAX_OID_LEN];

size_t lengthPsDirectAccess;

//Fan Tray Specific OIDs

char *S_fanFirmwareVersion ="fanFirmwareVersion.0";

oid oidFanFirmwareVersion[MAX_OID_LEN];

size_t lengthFanFirmwareVersion;

char *S_fanSerialNumber ="fanSerialNumber.0";

oid oidFanSerialNumber[MAX_OID_LEN];

size_t lengthFanSerialNumber;

char *S_fanOperatingTime ="fanOperatingTime.0";

oid oidFanOperatingTime[MAX_OID_LEN];

size_t lengthFanOperatingTime;

char *S_fanAirTemperature ="fanAirTemperature.0";

oid oidFanAirTemperature[MAX_OID_LEN];

size_t lengthFanAirTemperature;

char *S_fanSwitchOffDelay ="fanSwitchOffDelay.0";

oid oidFanSwitchOffDelay[MAX_OID_LEN];

size_t lengthFanSwitchOffDelay;

char *S_fanNominalSpeed ="fanNominalSpeed.0";

oid oidFanNominalSpeed[MAX_OID_LEN];

size_t lengthFanNominalSpeed;

char *S_fanNumberOfFans ="fanNumberOfFans.0";

oid oidFanNumberOfFans[MAX_OID_LEN];

size_t lengthFanNumberOfFans;

char *S_fanSpeedBase ="fanSpeed.";

char *S_fanSpeed[6];

oid oidFanSpeed[6] [MAX_OID_LEN];

size_t lengthFanSpeed[6];

char *winsock_startup(void)

{

    WORD wVersionRequested;

    WSADATA wsaData;

    int err;

/* Use the MAKEWORD(lowbyte, highbyte) macro declared in Windef.h */

    wVersionRequested = MAKEWORD(2, 2);

    err = WSAStartup(wVersionRequested, &wsaData);

    if (err != 0) {

        /* Tell the user that we could not find a usable */

        /* Winsock DLL.                                  */

        printf("WSAStartup failed with error: %d\n", err);

        return NULL;

    }

/* Confirm that the WinSock DLL supports 2.2.*/

/* Note that if the DLL supports versions greater    */

/* than 2.2 in addition to 2.2, it will still return */

/* 2.2 in wVersion since that is the version we      */

/* requested.                                        */

    if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {

        /* Tell the user that we could not find a usable */

        /* WinSock DLL.                                  */

        printf("Could not find a usable version of Winsock.dll\n");

        WSACleanup();

        return NULL;

    }

    else

        printf("The Winsock 2.2 dll was found okay\n");

/* The Winsock DLL is acceptable. Proceed to use it. */

/* Add network programming using Winsock here */

/* then call WSACleanup when done using the Winsock dll */

   return NULL;

};

void            winsock_cleanup(void){

 WSACleanup();

};

#define SOCK_STARTUP winsock_startup()

#define SOCK_CLEANUP winsock_cleanup()

BOOL APIENTRY DllMain( HANDLE hModule,

                       DWORD  ul_reason_for_call,

                       LPVOID lpReserved)

{

    return TRUE;

}

/******************************************************************************/

/** simple syslog replacement for this example.

*/

/*

 * priorities/facilities are encoded into a single 32-bit quantity, where the

 * bottom 3 bits are the priority (0-7) and the top 28 bits are the facility

 * (0-big number).  Both the priorities and the facilities map roughly

 * one-to-one to strings in the syslogd(8) source code.  This mapping is

 * included in this file.

 *

 * priorities (these are ordered)

 */

#define LOG_EMERG       0       /* system is unusable */

#define LOG_ALERT       1       /* action must be taken immediately */

#define LOG_CRIT        2       /* critical conditions */

#define LOG_ERR         3       /* error conditions */

#define LOG_WARNING     4       /* warning conditions */

#define LOG_NOTICE      5       /* normal but significant condition */

#define LOG_INFO        6       /* informational */

#define LOG_DEBUG       7       /* debug-level messages */

size_t lengthSysStatus;  

void syslog(int priority,const char* format,...) {

  va_list vaPrintf;

  va_start(vaPrintf,format);

  vprintf(format,vaPrintf); putchar('\n');

  va_end(vaPrintf);

}

/******************************************************************************/

/** SNMP Initialization.

*/

int __stdcall SnmpInit(void) {

        syslog(LOG_DEBUG,"*** Initialise SNMP ***");

  init_snmp("CrateTest");                                                                         // I never saw this name used !?!

        init_mib();                                                                                                                             // init MIB processing

  if(!read_module("WIENER-CRATE-MIB")) {                // read specific mibs

    syslog(LOG_ERR,"Unable to load SNMP MIB file \"%s\"","WIENER-CRATE-MIB");

    return 0;

  }

  syslog(LOG_DEBUG,"*** Translate OIDs ***");

//Translate System OIDS

  lengthSysMainSwitch = MAX_OID_LEN;

  if(!get_node(S_sysMainSwitch,oidSysMainSwitch,&lengthSysMainSwitch)) {

                syslog(LOG_ERR,"OID \"sysMainSwitch.0\"not found"); return false; }

  lengthSysStatus = MAX_OID_LEN;

  if(!get_node(S_sysStatus,oidSysStatus,&lengthSysStatus)) {

                syslog(LOG_ERR,"OID \"sysStatus.0\"not found"); return false;}

  lengthSysVmeSysReset = MAX_OID_LEN;

  if(!get_node(S_sysVmeSysReset,oidSysVmeSysReset,&lengthSysVmeSysReset)) {

                syslog(LOG_ERR,"OID \"SysVmeSysReset.0\"not found"); return false;}

//Translate System Channel Count Information OIDS

  lengthOutputNumber = MAX_OID_LEN;

  if(!get_node(S_outputNumber,oidOutputNumber,&lengthOutputNumber)) {

                syslog(LOG_ERR,"OID \"OutputNumber.0\"not found"); return false; }

  lengthGroupsNumber = MAX_OID_LEN;

  if(!get_node(S_groupsNumber,oidGroupsNumber,&lengthGroupsNumber)) {

                syslog(LOG_ERR,"OID \"groupsNumber.0\"not found"); return false;}

//Translate Channel Information OIDS

  char s[10000];

  char index[4];

  int base =0;

  int indexBase=0;

  int j=0, idx;

// 2014/01/21:  i was set to run to 1 only and base was 32 resulting in module offset of 32

// corrected go to 100 and also field size for all OID's increased to 1000

//  for( int i = 0; i < 2; i++) {

  for( int i = 0; i < 10; i++) {

        base = 100*i;

        indexBase = 100*i+1;

    for( j = 0; j < 100; j++)

    {

          idx = indexBase+j;

          if (idx>=999) idx=999;

          strcpy(s, S_outputNameBase);

          sprintf(index, "%i", idx);

          strcat(s, index);

//        printf("%s\n", s);

          lengthOutputName[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputName[base+j],&lengthOutputName[base+j])) {

                syslog(LOG_ERR,"OID \"outputName\"not found"); return false;}

// groups not implemented

/*        strcpy(s, S_outputGroupBase);

          sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputGroup[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputGroup[base+j],&lengthOutputGroup[base+j])) {

                syslog(LOG_ERR,"OID \"OutputGroup\"not found"); return false;}

*/

      strcpy(s, S_outputStatusBase);

//        sprintf(index, "%i",indexBase+j);

          strcat(s, index);

          lengthOutputStatus[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputStatus[base+j],&lengthOutputStatus[base+j])) {

                syslog(LOG_ERR,"OID \"outputStatus.1\"not found"); return false; }

          strcpy(s, S_outputMeasurementSenseVoltageBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputMeasurementSenseVoltage[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputMeasurementSenseVoltage[base+j],&lengthOutputMeasurementSenseVoltage[base+j])) {

                syslog(LOG_ERR,"OID \"outputMeasurementSenseVoltage.1\"not found"); return false;}

          strcpy(s, S_outputMeasurementTerminalVoltageBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputMeasurementTerminalVoltage[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputMeasurementTerminalVoltage[base+j],&lengthOutputMeasurementTerminalVoltage[base+j])) {

                syslog(LOG_ERR,"OID \"outputMeasurementTerminalVoltage.1\"not found"); return false;}

          strcpy(s, S_outputMeasurementCurrentBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputMeasurementCurrent[base+j] = MAX_OID_LEN;

                if(!get_node(s,oidOutputMeasurementCurrent[base+j],&lengthOutputMeasurementCurrent[base+j])) {

                        syslog(LOG_ERR,"OID \"outputMeasurementCurrent.1\"not found"); return false; }

          strcpy(s, S_outputMeasurementTemperatureBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputMeasurementTemperature[base+j] = MAX_OID_LEN;

                if(!get_node(s,oidOutputMeasurementTemperature[base+j],&lengthOutputMeasurementTemperature[base+j])) {

                        syslog(LOG_ERR,"OID \"outputMeasurementTemperature\"not found"); return false; }

          strcpy(s, S_outputSwitchBase);

//        sprintf(index, "%i",indexBase+j);

          strcat(s, index);

          lengthChannelSwitch[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidChannelSwitch[base+j],&lengthChannelSwitch[base+j])) {

                syslog(LOG_ERR,"OID \"channelSwitch.1\"not found"); return false;  }

/*

          // groupSwitch added 05/16/2013___AR but not working!!!

          strcpy(s, S_groupSwitchBase);

          sprintf(index, "%i",indexBase+j);

          strcat(s, index);

          lengthGroupSwitch[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidGroupSwitch[base+j],&lengthGroupSwitch[base+j])) {

                syslog(LOG_ERR,"OID \"GroupSwitch.1\"not found"); return false;  }

*/        //----------------------------------- 

          strcpy(s, S_outputVoltageBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputVoltage[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputVoltage[base+j],&lengthOutputVoltage[base+j])) {

                syslog(LOG_ERR,"OID \"outputVoltage.1\"not found"); return false; }

          strcpy(s, S_outputCurrentBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputCurrent[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputCurrent[base+j],&lengthOutputCurrent[base+j])) {

                syslog(LOG_ERR,"OID \"outputCurrent\"not found"); return false; }

          strcpy(s, S_outputRiseRateBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputRiseRate[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputRiseRate[base+j],&lengthOutputRiseRate[base+j])) {

                syslog(LOG_ERR,"OID \"outputRiseRate.1\"not found"); return false;}

          strcpy(s, S_outputFallRateBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputFallRate[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputFallRate[base+j],&lengthOutputFallRate[base+j])) {

                syslog(LOG_ERR,"OID \"outputRiseRate.1\"not found"); return false; }

          strcpy(s, S_outputSupervisionBehaviorBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputSupervisionBehavior[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputSupervisionBehavior[base+j],&lengthOutputSupervisionBehavior[base+j])) {

                syslog(LOG_ERR,"OID \"outputSupervisionBehavior\"not found"); return false; }

          strcpy(s, S_outputSupervisionMinSenseVoltageBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputSupervisionMinSenseVoltage[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputSupervisionMinSenseVoltage[base+j],&lengthOutputSupervisionMinSenseVoltage[base+j])) {

                syslog(LOG_ERR,"OID \"outputSupervisionMinSenseVoltage\"not found"); return false; }

          strcpy(s, S_outputSupervisionMaxSenseVoltageBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputSupervisionMaxSenseVoltage[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputSupervisionMaxSenseVoltage[base+j],&lengthOutputSupervisionMaxSenseVoltage[base+j])) {

                syslog(LOG_ERR,"OID \"outputSupervisionMaxSenseVoltage\"not found"); return false; }

          strcpy(s, S_outputSupervisionMaxTerminalVoltageBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputSupervisionMaxTerminalVoltage[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputSupervisionMaxTerminalVoltage[base+j],&lengthOutputSupervisionMaxTerminalVoltage[base+j])) {

                syslog(LOG_ERR,"OID \"outputSupervisionMaxTerminalVoltage\"not found"); return false; }

          strcpy(s, S_outputSupervisionMaxCurrentBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputSupervisionMaxCurrent[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputSupervisionMaxCurrent[base+j],&lengthOutputSupervisionMaxCurrent[base+j])) {

                syslog(LOG_ERR,"OID \"outputSupervisionMaxCurrent\"not found"); return false; }

/*

          strcpy(s, S_outputSupervisionMaxTemperatureBase);

          sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputSupervisionMaxTemperature[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputSupervisionMaxTemperature[base+j],&lengthOutputSupervisionMaxTemperature[base+j])) {

                syslog(LOG_ERR,"OID \"outputSupervisionMaxTemperature\"not found"); return false; }

*/

          strcpy(s, S_outputConfigMaxSenseVoltageBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputConfigMaxSenseVoltage[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputConfigMaxSenseVoltage[base+j],&lengthOutputConfigMaxSenseVoltage[base+j])) {

                syslog(LOG_ERR,"OID \"outputConfigMaxSenseVoltage\"not found"); return false; }

          strcpy(s, S_outputConfigMaxTerminalVoltageBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputConfigMaxTerminalVoltage[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputConfigMaxTerminalVoltage[base+j],&lengthOutputConfigMaxTerminalVoltage[base+j])) {

                syslog(LOG_ERR,"OID \"outputConfigMaxTerminalVoltage\"not found"); return false; }

          strcpy(s, S_outputConfigMaxCurrentBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputConfigMaxCurrent[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputConfigMaxCurrent[base+j],&lengthOutputConfigMaxCurrent[base+j])) {

                syslog(LOG_ERR,"OID \"outputConfigMaxCurrent\"not found"); return false; }

          strcpy(s, S_outputConfigMaxPowerBase);

//        sprintf(index, "%i", indexBase+j);

          strcat(s, index);

          lengthOutputConfigMaxPower[base+j] = MAX_OID_LEN;

          if(!get_node(s,oidOutputConfigMaxPower[base+j],&lengthOutputConfigMaxPower[base+j])) {

                syslog(LOG_ERR,"OID \"outputConfigMaxPower\"not found"); return false; }

        }  

  }

//Sensor Information

  lengthSensorNumber = MAX_OID_LEN;

  if(!get_node(S_sensorNumber,oidSensorNumber,&lengthSensorNumber)) {

                syslog(LOG_ERR,"OID \"SensorNumber.0\"not found"); return false;}

  for(j = 0; j < 8; j++)

  {

        strcpy(s, S_sensorTemperatureBase);

        sprintf(index, "%i", j+1);

        strcat(s, index);

        lengthSensorTemperature[j] = MAX_OID_LEN;

        if(!get_node(s,oidSensorTemperature[j],&lengthSensorTemperature[j])) {

                syslog(LOG_ERR,"OID \"sensorTemperature.0\"not found"); return false; }

        strcpy(s, S_sensorWarningThresholdBase);

        sprintf(index, "%i", j+1);

        strcat(s, index);

        lengthSensorWarningThreshold[j] = MAX_OID_LEN;

        if(!get_node(s,oidSensorWarningThreshold[j],&lengthSensorWarningThreshold[j])) {

                syslog(LOG_ERR,"OID \"WarningThreshold\"not found"); return false; }

        strcpy(s, S_sensorFailureThresholdBase);

        sprintf(index, "%i", j+1);

        strcat(s, index);

        lengthSensorFailureThreshold[j] = MAX_OID_LEN;

        if(!get_node(s,oidSensorFailureThreshold[j],&lengthSensorFailureThreshold[j])) {

                syslog(LOG_ERR,"OID \"FailureThreshold\"not found"); return false; }

  }

//Translate SNMP community Name OIDs

  for(j = 0; j < 4; j++)

  {

        strcpy(s, S_snmpCommunityNameBase);

        sprintf(index, "%i", j+1);

        strcat(s, index);

        lengthSnmpCommunityName[j] = MAX_OID_LEN;

        if(!get_node(s,oidSnmpCommunityName[j],&lengthSnmpCommunityName[j])) {

                syslog(LOG_ERR,"OID \"smpCommunityNameBase\"not found"); return false; }

  }

//Translate PS Specific OIDs

/*

  lengthPsFirmwareVersion = MAX_OID_LEN;

  if(!get_node(S_psFirmwareVersion,oidPsFirmwareVersion,&lengthPsFirmwareVersion)) {

                syslog(LOG_ERR,"OID \"psFirmwareRevision\"not found"); return false; }

*/

  lengthPsSerialNumber = MAX_OID_LEN;

  printf("\nPs Serial Number: %s\n", S_psSerialNumber);

  if(!get_node(S_psSerialNumber,oidPsSerialNumber,&lengthPsSerialNumber)) {

                syslog(LOG_ERR,"OID \"psSerialNumber\"not found"); return false; }

  lengthPsOperatingTime = MAX_OID_LEN;

  if(!get_node(S_psOperatingTime,oidPsOperatingTime,&lengthPsOperatingTime)) {

                syslog(LOG_ERR,"OID \"PsOperatingTime\"not found"); return false; }

  lengthPsDirectAccess = MAX_OID_LEN;

  if(!get_node(S_psDirectAccess,oidPsDirectAccess,&lengthPsDirectAccess)) {

                syslog(LOG_ERR,"OID \"PsDirectAccess\"not found"); return false; }

/*

//Translate Fan Tray OIDs

  lengthFanFirmwareVersion = MAX_OID_LEN;

  if(!get_node(S_fanFirmwareVersion,oidFanFirmwareVersion,&lengthFanFirmwareVersion)) {

                syslog(LOG_ERR,"OID \"FanFirmwareVersion\"not found"); return false; }

*/

  lengthFanSerialNumber = MAX_OID_LEN;

  if(!get_node(S_fanSerialNumber,oidFanSerialNumber,&lengthFanSerialNumber)) {

                syslog(LOG_ERR,"OID \"FanSerialNumber\"not found"); return false; }

  lengthFanOperatingTime = MAX_OID_LEN;

  if(!get_node(S_fanOperatingTime,oidFanOperatingTime,&lengthFanOperatingTime)) {

                syslog(LOG_ERR,"OID \"FanOperatingTime\"not found"); return false; }

  lengthFanAirTemperature = MAX_OID_LEN;

  if(!get_node(S_fanAirTemperature,oidFanAirTemperature,&lengthFanAirTemperature)) {

                syslog(LOG_ERR,"OID \"fanAirTemperature.0\"not found"); return false; }

  lengthFanSwitchOffDelay = MAX_OID_LEN;

  if(!get_node(S_fanSwitchOffDelay,oidFanSwitchOffDelay,&lengthFanSwitchOffDelay)) {

                syslog(LOG_ERR,"OID \"FanSwitchOffDelay\"not found"); return false; }

  lengthFanNominalSpeed = MAX_OID_LEN;

  if(!get_node(S_fanNominalSpeed,oidFanNominalSpeed,&lengthFanNominalSpeed)) {

                syslog(LOG_ERR,"OID \"FanNominalSpeed\"not found"); return false; }

  lengthFanNumberOfFans = MAX_OID_LEN;

  if(!get_node(S_fanNumberOfFans,oidFanNumberOfFans,&lengthFanNumberOfFans)) {

                syslog(LOG_ERR,"OID \"NumberOfFans\"not found"); return false; }

  for(j = 0; j < 6; j++)

  {

        strcpy(s, S_fanSpeedBase);

        sprintf(index, "%i", j+1);

        strcat(s, index);

        lengthFanSpeed[j] = MAX_OID_LEN;

        if(!get_node(s,oidFanSpeed[j],&lengthFanSpeed[j])) {

                syslog(LOG_ERR,"OID \"FanSpeed\"not found"); return false; }

  }

  syslog(LOG_DEBUG,"*** Initialise SNMP done ***");

  SOCK_STARTUP;                                                                                                                 // only in main thread

  return 1;

}

/******************************************************************************/

/** SNMP Cleanup.

*/

void __stdcall SnmpCleanup(void) {

        SOCK_CLEANUP;

}

/******************************************************************************/

/** SNMP Open Session.

*/

//typedef void* HSNMP;                              // SNMP handle (like FILE)

HSNMP __stdcall SnmpOpen(const char* ipAddress) {

        HSNMP m_sessp;

  struct snmp_session session;

  snmp_sess_init(&session);                                       // structure defaults

  session.version = SNMP_VERSION_2c;

  session.peername = _strdup(ipAddress);

  session.community = (u_char*)_strdup(readCommunity);

  session.community_len = strlen((char*)session.community);

  session.timeout = 100000;   // timeout (us)

  session.retries = 3;        // retries

  if(!(m_sessp = snmp_sess_open(&session))) {

    int liberr, syserr;

    char *errstr;

    snmp_error(&session, &liberr, &syserr, &errstr);

    syslog(LOG_ERR,"Open SNMP session for host \"%s\": %s",ipAddress,errstr);

    //free(errstr);

    return 0;

  }