[public/netxms.git] / src / server / include / nxsrvapi.h

/* 
** NetXMS - Network Management System
** Server Library
** Copyright (C) 2003-2011 Victor Kirhenshtein
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU Lesser General Public License as published by
** the Free Software Foundation; either version 3 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 Lesser General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
**
** File: nxsrvapi.h
**
**/

#ifndef _nxsrvapi_h_
#define _nxsrvapi_h_

#ifdef _WIN32
#ifdef LIBNXSRV_EXPORTS
#define LIBNXSRV_EXPORTABLE __declspec(dllexport)
#else
#define LIBNXSRV_EXPORTABLE __declspec(dllimport)
#endif
#else    /* _WIN32 */
#define LIBNXSRV_EXPORTABLE
#endif

#ifndef LIBNXCL_NO_DECLARATIONS
#define LIBNXCL_NO_DECLARATIONS 1
#endif
#include <nxclapi.h>
#include <nxcpapi.h>
#include <nms_agent.h>
#include "../libnxsrv/messages.h"
#include <nxsnmp.h>
#include <netxms_isc.h>


//
// Default files
//

#ifdef _WIN32

#define DEFAULT_CONFIG_FILE   _T("C:\\netxmsd.conf")

#define DEFAULT_SHELL         _T("cmd.exe")
#define DEFAULT_LOG_FILE      _T("C:\\NetXMS.log")
#define DEFAULT_DATA_DIR      _T("C:\\NetXMS\\var")
#define DEFAULT_LIBDIR        _T("C:\\NetXMS\\lib")
#define DEFAULT_DUMP_DIR      _T("C:\\")

#define LDIR_NDD              _T("\\ndd")

#define DDIR_MIBS             _T("\\mibs")
#define DDIR_PACKAGES         _T("\\packages")
#define DDIR_BACKGROUNDS      _T("\\backgrounds")
#define DDIR_SHARED_FILES     _T("\\shared")
#define DFILE_KEYS            _T("\\server_key")
#define DFILE_COMPILED_MIB    _T("\\mibs\\netxms.mib")
#define DDIR_IMAGES           _T("\\images")
#define DDIR_FILES            _T("\\files")

#else    /* _WIN32 */

#define DEFAULT_CONFIG_FILE   _T("{search}")

#define DEFAULT_SHELL         _T("/bin/sh")

#ifndef DATADIR
#define DATADIR              _T("/var/netxms")
#endif

#ifndef LIBDIR
#define LIBDIR               _T("/usr/lib")
#endif

#ifndef PKGLIBDIR
#define PKGLIBDIR            _T("/usr/lib/netxms")
#endif

#define DEFAULT_LOG_FILE      DATADIR _T("/log/netxmsd.log")
#define DEFAULT_DATA_DIR      DATADIR
#define DEFAULT_LIBDIR        PKGLIBDIR
#define DEFAULT_DUMP_DIR      _T("/")

#define LDIR_NDD              _T("/ndd")

#define DDIR_MIBS             _T("/mibs")
#define DDIR_PACKAGES         _T("/packages")
#define DDIR_BACKGROUNDS      _T("/backgrounds")
#define DDIR_SHARED_FILES     _T("/shared")
#define DFILE_KEYS            _T("/.server_key")
#define DFILE_COMPILED_MIB    _T("/mibs/netxms.mib")
#define DDIR_IMAGES           _T("/images")
#define DDIR_FILES            _T("/files")

#endif   /* _WIN32 */


//
// Application flags
//

#define AF_DAEMON                         0x00000001
#define AF_USE_SYSLOG                     0x00000002
#define AF_ENABLE_NETWORK_DISCOVERY       0x00000004
#define AF_ACTIVE_NETWORK_DISCOVERY       0x00000008
#define AF_LOG_SQL_ERRORS                 0x00000010
#define AF_DELETE_EMPTY_SUBNETS           0x00000020
#define AF_ENABLE_SNMP_TRAPD              0x00000040
#define AF_ENABLE_ZONING                  0x00000080
#define AF_SYNC_NODE_NAMES_WITH_DNS       0x00000100
#define AF_CHECK_TRUSTED_NODES            0x00000200
#define AF_WRITE_FULL_DUMP                0x00080000
#define AF_RESOLVE_NODE_NAMES             0x00100000
#define AF_CATCH_EXCEPTIONS               0x00200000
#define AF_INTERNAL_CA                    0x00400000
#define AF_DB_LOCKED                      0x01000000
#define AF_ENABLE_MULTIPLE_DB_CONN        0x02000000
#define AF_DB_CONNECTION_LOST             0x04000000
#define AF_NO_NETWORK_CONNECTIVITY        0x08000000
#define AF_EVENT_STORM_DETECTED           0x08000000
#define AF_SERVER_INITIALIZED             0x40000000
#define AF_SHUTDOWN                       0x80000000

#define IsStandalone()                    (!(g_dwFlags & AF_DAEMON))
#define ShutdownInProgress()              (g_dwFlags & AF_SHUTDOWN)


//
// Encryption usage policies
//

#define ENCRYPTION_DISABLED   0
#define ENCRYPTION_ALLOWED    1
#define ENCRYPTION_PREFERRED  2
#define ENCRYPTION_REQUIRED   3


//
// Flags for SnmpGet
//

#define SG_VERBOSE        0x0001
#define SG_STRING_RESULT  0x0002
#define SG_RAW_RESULT     0x0004
#define SG_HSTRING_RESULT 0x0008


//
// Win32 service and syslog constants
//

#ifdef _WIN32

#define CORE_SERVICE_NAME     _T("NetXMSCore")
#define CORE_EVENT_SOURCE     _T("NetXMSCore")
#define NETXMSD_SYSLOG_NAME   CORE_EVENT_SOURCE

#else

#define NETXMSD_SYSLOG_NAME   _T("netxmsd")

#endif   /* _WIN32 */


//
// Single ARP cache entry
//

typedef struct
{
   DWORD dwIndex;       // Interface index
   DWORD dwIpAddr;
   BYTE bMacAddr[MAC_ADDR_LENGTH];
} ARP_ENTRY;


//
// ARP cache structure used by discovery functions and AgentConnection class
//

typedef struct
{
   DWORD dwNumEntries;
   ARP_ENTRY *pEntries;
} ARP_CACHE;


//
// Interface information structure used by discovery functions and AgentConnection class
//

typedef struct
{
   TCHAR szName[MAX_DB_STRING];			// Interface display name
	TCHAR szDescription[MAX_DB_STRING];	// Value of ifDescr MIB variable for SNMP agents
   DWORD dwIndex;
   DWORD dwType;
	DWORD dwBridgePortNumber;
	DWORD dwSlotNumber;
	DWORD dwPortNumber;
   DWORD dwIpAddr;
   DWORD dwIpNetMask;
   BYTE bMacAddr[MAC_ADDR_LENGTH];
   int iNumSecondary;      // Number of secondary IP's on this interface
	bool isPhysicalPort;
} NX_INTERFACE_INFO;


//
// Interface list used by discovery functions and AgentConnection class
//

class LIBNXSRV_EXPORTABLE InterfaceList
{
private:
   int m_size;       				 // Number of valid entries
	int m_allocated;               // Number of allocated entries
   void *m_data;                  // Can be used by custom enumeration handlers
   NX_INTERFACE_INFO *m_interfaces;  // Interface entries

public:
	InterfaceList(int initialAlloc = 8);
	~InterfaceList();

	void add(NX_INTERFACE_INFO *iface);
	void remove(int index);
	void removeLoopbacks();

	int getSize() { return m_size; }
	NX_INTERFACE_INFO *get(int index) { return ((index >= 0) && (index < m_size)) ? &m_interfaces[index] : NULL; }
	NX_INTERFACE_INFO *findByIfIndex(DWORD ifIndex);

	void setData(void *data) { m_data = data; }
	void *getData() { return m_data; }
};


//
// Vlan information
//

#define VLAN_PRM_IFINDEX   0
#define VLAN_PRM_SLOTPORT  1

class LIBNXSRV_EXPORTABLE VlanInfo
{
private:
	int m_vlanId;
	TCHAR *m_name;
	int m_portRefMode;	// Port reference mode - by ifIndex or by slot/port
	int m_allocated;
	int m_numPorts;	// Number of ports in VLAN
	DWORD *m_ports;	// member ports (slot/port pairs or ifIndex)
	DWORD *m_indexes;	// ifIndexes for ports
	DWORD *m_ids;		// Interface object IDs for ports

public:
	VlanInfo(int vlanId, int prm);
	~VlanInfo();

	int getVlanId() { return m_vlanId; }
	int getPortReferenceMode() { return m_portRefMode; }
	const TCHAR *getName() { return CHECK_NULL_EX(m_name); }
	int getNumPorts() { return m_numPorts; }
	DWORD *getPorts() { return m_ports; }
	DWORD *getIfIndexes() { return m_indexes; }
	DWORD *getIfIds() { return m_ids; }

	void add(DWORD slot, DWORD port);
	void add(DWORD ifIndex);
	void setName(const TCHAR *name);

	void prepareForResolve();
	void resolvePort(int index, DWORD sp, DWORD ifIndex, DWORD id);
};


//
// Vlan list
//

class LIBNXSRV_EXPORTABLE VlanList : public RefCountObject
{
private:
   int m_size;          // Number of valid entries
	int m_allocated;     // Number of allocated entries
   void *m_data;        // Can be used by custom enumeration handlers
   VlanInfo **m_vlans;  // VLAN entries

public:
	VlanList(int initialAlloc = 8);
	virtual ~VlanList();

	void add(VlanInfo *vlan);
	void addMemberPort(int vlanId, DWORD portId);

	int getSize() { return m_size; }
	VlanInfo *get(int index) { return ((index >= 0) && (index < m_size)) ? m_vlans[index] : NULL; }
	VlanInfo *findById(int id);

	void setData(void *data) { m_data = data; }
	void *getData() { return m_data; }

	void fillMessage(CSCPMessage *msg);
};


//
// Route information
//

typedef struct
{
   DWORD dwDestAddr;
   DWORD dwDestMask;
   DWORD dwNextHop;
   DWORD dwIfIndex;
   DWORD dwRouteType;
} ROUTE;


//
// Routing table
//

typedef struct
{
   int iNumEntries;     // Number of entries
   ROUTE *pRoutes;      // Route list
} ROUTING_TABLE;


//
// Information about policies installed on agent
//

class LIBNXSRV_EXPORTABLE AgentPolicyInfo
{
private:
	int m_size;
	BYTE *m_guidList;
	int *m_typeList;
	TCHAR **m_serverList;

public:
	AgentPolicyInfo(CSCPMessage *msg);
	~AgentPolicyInfo();

	int getSize() { return m_size; }
	bool getGuid(int index, uuid_t guid);
	int getType(int index) { return ((index >= 0) && (index < m_size)) ? m_typeList[index] : -1; }
	const TCHAR *getServer(int index) { return ((index >= 0) && (index < m_size)) ? m_serverList[index] : NULL; }
};


//
// Agent connection
//

class LIBNXSRV_EXPORTABLE AgentConnection
{
private:
   DWORD m_dwAddr;
   int m_nProtocolVersion;
   int m_iAuthMethod;
   char m_szSecret[MAX_SECRET_LENGTH];
   time_t m_tLastCommandTime;
   SOCKET m_hSocket;
   DWORD m_dwNumDataLines;
   DWORD m_dwRequestId;
   DWORD m_dwCommandTimeout;
	DWORD m_connectionTimeout;
   DWORD m_dwRecvTimeout;
   TCHAR **m_ppDataLines;
   MsgWaitQueue *m_pMsgWaitQueue;
   BOOL m_bIsConnected;
   MUTEX m_mutexDataLock;
	MUTEX m_mutexSocketWrite;
   THREAD m_hReceiverThread;
   CSCP_ENCRYPTION_CONTEXT *m_pCtx;
   int m_iEncryptionPolicy;
   BOOL m_bUseProxy;
   DWORD m_dwProxyAddr;
   WORD m_wPort;
   WORD m_wProxyPort;
   int m_iProxyAuth;
   char m_szProxySecret[MAX_SECRET_LENGTH];
	int m_hCurrFile;
	TCHAR m_currentFileName[MAX_PATH];
	DWORD m_dwDownloadRequestId;
	CONDITION m_condFileDownload;
	BOOL m_fileDownloadSucceeded;
	void (*m_downloadProgressCallback)(size_t, void *);
	void *m_downloadProgressCallbackArg;
	bool m_deleteFileOnDownloadFailure;
	bool m_fileUploadInProgress;

   void ReceiverThread(void);
   static THREAD_RESULT THREAD_CALL ReceiverThreadStarter(void *);

protected:
   void destroyResultData();
   BOOL sendMessage(CSCPMessage *pMsg);
   CSCPMessage *waitForMessage(WORD wCode, DWORD dwId, DWORD dwTimeOut) { return m_pMsgWaitQueue->WaitForMessage(wCode, dwId, dwTimeOut); }
   DWORD waitForRCC(DWORD dwRqId, DWORD dwTimeOut);
   DWORD setupEncryption(RSA *pServerKey);
   DWORD authenticate(BOOL bProxyData);
   DWORD setupProxyConnection();
   DWORD getIpAddr() { return ntohl(m_dwAddr); }
	DWORD prepareFileDownload(const TCHAR *fileName, DWORD rqId, bool append, void (*downloadProgressCallback)(size_t, void *), void *cbArg);

   virtual void PrintMsg(const TCHAR *pszFormat, ...);
   virtual void onTrap(CSCPMessage *pMsg);
	virtual void onDataPush(CSCPMessage *msg);
	virtual bool processCustomMessage(CSCPMessage *pMsg);
	virtual void onFileDownload(BOOL success);

   void Lock(void) { MutexLock(m_mutexDataLock, INFINITE); }
   void Unlock(void) { MutexUnlock(m_mutexDataLock); }

public:
   AgentConnection(DWORD dwAddr, WORD wPort = AGENT_LISTEN_PORT,
                   int iAuthMethod = AUTH_NONE, const TCHAR *pszSecret = NULL);
   virtual ~AgentConnection();

   BOOL connect(RSA *pServerKey = NULL, BOOL bVerbose = FALSE, DWORD *pdwError = NULL, DWORD *pdwSocketError = NULL);
   void disconnect();
   BOOL isConnected() { return m_bIsConnected; }
	int getProtocolVersion() { return m_nProtocolVersion; }

	SOCKET getSocket() { return m_hSocket; }

   ARP_CACHE *getArpCache();
   InterfaceList *getInterfaceList();
   ROUTING_TABLE *getRoutingTable();
   DWORD getParameter(const TCHAR *pszParam, DWORD dwBufSize, TCHAR *pszBuffer);
   DWORD getList(const TCHAR *pszParam);
   DWORD getTable(const TCHAR *pszParam, Table **table);
   DWORD nop();
   DWORD execAction(const TCHAR *pszAction, int argc, TCHAR **argv);
   DWORD uploadFile(const TCHAR *localFile, const TCHAR *destinationFile = NULL, void (* progressCallback)(INT64, void *) = NULL, void *cbArg = NULL);
   DWORD startUpgrade(const TCHAR *pszPkgName);
   DWORD checkNetworkService(DWORD *pdwStatus, DWORD dwIpAddr, int iServiceType, WORD wPort = 0, 
                             WORD wProto = 0, const TCHAR *pszRequest = NULL, const TCHAR *pszResponse = NULL);
   DWORD getSupportedParameters(DWORD *pdwNumParams, NXC_AGENT_PARAM **ppParamList);
   DWORD getConfigFile(TCHAR **ppszConfig, DWORD *pdwSize);
   DWORD updateConfigFile(const TCHAR *pszConfig);
   DWORD enableTraps();
	DWORD getPolicyInventory(AgentPolicyInfo **info);
	DWORD uninstallPolicy(uuid_t guid);

	DWORD generateRequestId() { return m_dwRequestId++; }
	CSCPMessage *customRequest(CSCPMessage *pRequest, const TCHAR *recvFile = NULL, bool appendFile = false,
	                           void (*downloadProgressCallback)(size_t, void *) = NULL, void *cbArg = NULL);

   DWORD getNumDataLines() { return m_dwNumDataLines; }
   const TCHAR *getDataLine(DWORD dwIndex) { return dwIndex < m_dwNumDataLines ? m_ppDataLines[dwIndex] : _T("(error)"); }

   void setConnectionTimeout(DWORD dwTimeout) { m_connectionTimeout = max(dwTimeout, 1000); }
	DWORD getConnectionTimeout() { return m_connectionTimeout; }
   void setCommandTimeout(DWORD dwTimeout) { m_dwCommandTimeout = max(dwTimeout, 500); }
	DWORD getCommandTimeout() { return m_dwCommandTimeout; }
   void setRecvTimeout(DWORD dwTimeout) { m_dwRecvTimeout = max(dwTimeout, 10000); }
   void setEncryptionPolicy(int iPolicy) { m_iEncryptionPolicy = iPolicy; }
   void setProxy(DWORD dwAddr, WORD wPort = AGENT_LISTEN_PORT,
                 int iAuthMethod = AUTH_NONE, const TCHAR *pszSecret = NULL);
   void setPort(WORD wPort) { m_wPort = wPort; }
   void setAuthData(int nMethod, const char *pszSecret) { m_iAuthMethod = nMethod; strncpy(m_szSecret, pszSecret, MAX_SECRET_LENGTH); m_szSecret[MAX_SECRET_LENGTH - 1] = 0; }
	void setDeleteFileOnDownloadFailure(bool flag) { m_deleteFileOnDownloadFailure = flag; }
};


//
// Proxy SNMP transport
//

class LIBNXSRV_EXPORTABLE SNMP_ProxyTransport : public SNMP_Transport
{
protected:
	AgentConnection *m_pAgentConnection;
	CSCPMessage *m_pResponse;
	DWORD m_dwIpAddr;
	WORD m_wPort;

public:
	SNMP_ProxyTransport(AgentConnection *pConn, DWORD dwIpAddr, WORD wPort);
	virtual ~SNMP_ProxyTransport();

   virtual int readMessage(SNMP_PDU **ppData, DWORD dwTimeout = INFINITE,
                           struct sockaddr *pSender = NULL, socklen_t *piAddrSize = NULL,
	                        SNMP_SecurityContext* (*contextFinder)(struct sockaddr *, socklen_t) = NULL);
   virtual int sendMessage(SNMP_PDU *pdu);
};


//
// ISC flags
//

#define ISCF_IS_CONNECTED        ((DWORD)0x00000001)
#define ISCF_REQUIRE_ENCRYPTION  ((DWORD)0x00000002)


//
// Inter-server connection (ISC)
//

class LIBNXSRV_EXPORTABLE ISC
{
private:
	DWORD m_flags;
   DWORD m_addr;
	WORD m_port;
   SOCKET m_socket;
   int m_protocolVersion;
	DWORD m_requestId;
	DWORD m_recvTimeout;
   MsgWaitQueue *m_msgWaitQueue;
   MUTEX m_mutexDataLock;
	MUTEX m_socketLock;
   THREAD m_hReceiverThread;
   CSCP_ENCRYPTION_CONTEXT *m_ctx;
	DWORD m_commandTimeout;

   void ReceiverThread(void);
   static THREAD_RESULT THREAD_CALL ReceiverThreadStarter(void *);

protected:
   void DestroyResultData(void);
   DWORD SetupEncryption(RSA *pServerKey);
	DWORD ConnectToService(DWORD service);

   void Lock(void) { MutexLock(m_mutexDataLock, INFINITE); }
   void Unlock(void) { MutexUnlock(m_mutexDataLock); }

   virtual void PrintMsg(const TCHAR *format, ...);

public:
   ISC();
   ISC(DWORD addr, WORD port = NETXMS_ISC_PORT);
   virtual ~ISC();

   DWORD Connect(DWORD service, RSA *serverKey = NULL, BOOL requireEncryption = FALSE);
	void Disconnect();

   BOOL SendMessage(CSCPMessage *msg);
   CSCPMessage *WaitForMessage(WORD code, DWORD id, DWORD timeOut) { return m_msgWaitQueue->WaitForMessage(code, id, timeOut); }
   DWORD WaitForRCC(DWORD rqId, DWORD timeOut);

   DWORD Nop(void);
};


//
// Functions
//

void LIBNXSRV_EXPORTABLE DestroyArpCache(ARP_CACHE *pArpCache);
void LIBNXSRV_EXPORTABLE DestroyRoutingTable(ROUTING_TABLE *pRT);
void LIBNXSRV_EXPORTABLE SortRoutingTable(ROUTING_TABLE *pRT);
const TCHAR LIBNXSRV_EXPORTABLE *AgentErrorCodeToText(int iError);

void LIBNXSRV_EXPORTABLE WriteLogOther(WORD wType, const TCHAR *format, ...);
void LIBNXSRV_EXPORTABLE DbgPrintf(int level, const TCHAR *format, ...);
void LIBNXSRV_EXPORTABLE DbgPrintf2(int level, const TCHAR *format, va_list args);

void LIBNXSRV_EXPORTABLE SetAgentDEP(int iPolicy);

const TCHAR LIBNXSRV_EXPORTABLE *ISCErrorCodeToText(DWORD code);

DWORD LIBNXSRV_EXPORTABLE SnmpNewRequestId();
DWORD LIBNXSRV_EXPORTABLE SnmpGet(DWORD dwVersion, SNMP_Transport *pTransport,
                                  const TCHAR *szOidStr, const DWORD *oidBinary, DWORD dwOidLen, void *pValue,
                                  DWORD dwBufferSize, DWORD dwFlags);
DWORD LIBNXSRV_EXPORTABLE SnmpEnumerate(DWORD dwVersion, SNMP_Transport *pTransport, const TCHAR *szRootOid,
						                      DWORD (* pHandler)(DWORD, SNMP_Variable *, SNMP_Transport *, void *),
                                        void *pUserArg, BOOL bVerbose);


//
// Variables
//

extern DWORD LIBNXSRV_EXPORTABLE g_dwFlags;
extern DWORD LIBNXSRV_EXPORTABLE g_dwSNMPTimeout;
extern int LIBNXSRV_EXPORTABLE g_nDebugLevel;

#endif   /* _nxsrvapi_h_ */
Commit	Line	Data
5039dede AK	1	/*
	2	** NetXMS - Network Management System
	3	** Server Library
619e5c9b	4	** Copyright (C) 2003-2011 Victor Kirhenshtein
5039dede AK	5	**
5039dede AK	6	** This program is free software; you can redistribute it and/or modify
0702ed69 VK	7	** it under the terms of the GNU Lesser General Public License as published by
0702ed69 VK	8	** the Free Software Foundation; either version 3 of the License, or
5039dede AK	9	** (at your option) any later version.
	10	**
	11	** This program is distributed in the hope that it will be useful,
	12	** but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	** GNU General Public License for more details.
	15	**
0702ed69	16	** You should have received a copy of the GNU Lesser General Public License
5039dede AK	17	** along with this program; if not, write to the Free Software
	18	** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	19	**
	20	** File: nxsrvapi.h
	21	**
	22	**/
	23
	24	#ifndef _nxsrvapi_h_
	25	#define _nxsrvapi_h_
	26
	27	#ifdef _WIN32
	28	#ifdef LIBNXSRV_EXPORTS
	29	#define LIBNXSRV_EXPORTABLE __declspec(dllexport)
	30	#else
	31	#define LIBNXSRV_EXPORTABLE __declspec(dllimport)
	32	#endif
	33	#else /* _WIN32 */
	34	#define LIBNXSRV_EXPORTABLE
	35	#endif
	36
	37	#ifndef LIBNXCL_NO_DECLARATIONS
	38	#define LIBNXCL_NO_DECLARATIONS 1
	39	#endif
	40	#include <nxclapi.h>
	41	#include <nxcpapi.h>
	42	#include <nms_agent.h>
944016d6	43	#include "../libnxsrv/messages.h"
5039dede AK	44	#include <nxsnmp.h>
	45	#include <netxms_isc.h>
	46
	47
	48	//
	49	// Default files
	50	//
	51
	52	#ifdef _WIN32
	53
9796ce45 VK	54	#define DEFAULT_CONFIG_FILE _T("C:\\netxmsd.conf")
	55
	56	#define DEFAULT_SHELL _T("cmd.exe")
	57	#define DEFAULT_LOG_FILE _T("C:\\NetXMS.log")
	58	#define DEFAULT_DATA_DIR _T("C:\\NetXMS\\var")
	59	#define DEFAULT_LIBDIR _T("C:\\NetXMS\\lib")
	60	#define DEFAULT_DUMP_DIR _T("C:\\")
	61
	62	#define LDIR_NDD _T("\\ndd")
	63
	64	#define DDIR_MIBS _T("\\mibs")
	65	#define DDIR_PACKAGES _T("\\packages")
	66	#define DDIR_BACKGROUNDS _T("\\backgrounds")
	67	#define DDIR_SHARED_FILES _T("\\shared")
	68	#define DFILE_KEYS _T("\\server_key")
	69	#define DFILE_COMPILED_MIB _T("\\mibs\\netxms.mib")
	70	#define DDIR_IMAGES _T("\\images")
	71	#define DDIR_FILES _T("\\files")
5039dede AK	72
	73	#else /* _WIN32 */
	74
9796ce45	75	#define DEFAULT_CONFIG_FILE _T("{search}")
5039dede	76
9796ce45	77	#define DEFAULT_SHELL _T("/bin/sh")
5039dede	78
9796ce45 VK	79	#ifndef DATADIR
	80	#define DATADIR _T("/var/netxms")
	81	#endif
5039dede	82
9796ce45 VK	83	#ifndef LIBDIR
	84	#define LIBDIR _T("/usr/lib")
	85	#endif
5039dede	86
644f97f5 VK	87	#ifndef PKGLIBDIR
	88	#define PKGLIBDIR _T("/usr/lib/netxms")
	89	#endif
	90
9796ce45 VK	91	#define DEFAULT_LOG_FILE DATADIR _T("/log/netxmsd.log")
9796ce45 VK	92	#define DEFAULT_DATA_DIR DATADIR
644f97f5	93	#define DEFAULT_LIBDIR PKGLIBDIR
9796ce45 VK	94	#define DEFAULT_DUMP_DIR _T("/")
	95
	96	#define LDIR_NDD _T("/ndd")
	97
	98	#define DDIR_MIBS _T("/mibs")
	99	#define DDIR_PACKAGES _T("/packages")
	100	#define DDIR_BACKGROUNDS _T("/backgrounds")
	101	#define DDIR_SHARED_FILES _T("/shared")
	102	#define DFILE_KEYS _T("/.server_key")
	103	#define DFILE_COMPILED_MIB _T("/mibs/netxms.mib")
	104	#define DDIR_IMAGES _T("/images")
	105	#define DDIR_FILES _T("/files")
5039dede AK	106
	107	#endif /* _WIN32 */
	108
	109
	110	//
	111	// Application flags
	112	//
	113
	114	#define AF_DAEMON 0x00000001
	115	#define AF_USE_SYSLOG 0x00000002
	116	#define AF_ENABLE_NETWORK_DISCOVERY 0x00000004
	117	#define AF_ACTIVE_NETWORK_DISCOVERY 0x00000008
	118	#define AF_LOG_SQL_ERRORS 0x00000010
	119	#define AF_DELETE_EMPTY_SUBNETS 0x00000020
	120	#define AF_ENABLE_SNMP_TRAPD 0x00000040
	121	#define AF_ENABLE_ZONING 0x00000080
	122	#define AF_SYNC_NODE_NAMES_WITH_DNS 0x00000100
	123	#define AF_CHECK_TRUSTED_NODES 0x00000200
cbc777ee	124	#define AF_WRITE_FULL_DUMP 0x00080000
5039dede AK	125	#define AF_RESOLVE_NODE_NAMES 0x00100000
	126	#define AF_CATCH_EXCEPTIONS 0x00200000
	127	#define AF_INTERNAL_CA 0x00400000
	128	#define AF_DB_LOCKED 0x01000000
	129	#define AF_ENABLE_MULTIPLE_DB_CONN 0x02000000
	130	#define AF_DB_CONNECTION_LOST 0x04000000
	131	#define AF_NO_NETWORK_CONNECTIVITY 0x08000000
	132	#define AF_EVENT_STORM_DETECTED 0x08000000
	133	#define AF_SERVER_INITIALIZED 0x40000000
	134	#define AF_SHUTDOWN 0x80000000
	135
	136	#define IsStandalone() (!(g_dwFlags & AF_DAEMON))
	137	#define ShutdownInProgress() (g_dwFlags & AF_SHUTDOWN)
	138
	139
	140	//
	141	// Encryption usage policies
	142	//
	143
	144	#define ENCRYPTION_DISABLED 0
	145	#define ENCRYPTION_ALLOWED 1
	146	#define ENCRYPTION_PREFERRED 2
	147	#define ENCRYPTION_REQUIRED 3
	148
	149
5ad2167d VK	150	//
	151	// Flags for SnmpGet
	152	//
	153
	154	#define SG_VERBOSE 0x0001
	155	#define SG_STRING_RESULT 0x0002
	156	#define SG_RAW_RESULT 0x0004
	157	#define SG_HSTRING_RESULT 0x0008
	158
	159
5039dede AK	160	//
	161	// Win32 service and syslog constants
	162	//
	163
	164	#ifdef _WIN32
	165
	166	#define CORE_SERVICE_NAME _T("NetXMSCore")
	167	#define CORE_EVENT_SOURCE _T("NetXMSCore")
	168	#define NETXMSD_SYSLOG_NAME CORE_EVENT_SOURCE
	169
	170	#else
	171
	172	#define NETXMSD_SYSLOG_NAME _T("netxmsd")
	173
	174	#endif /* _WIN32 */
	175
	176
	177	//
	178	// Single ARP cache entry
	179	//
	180
	181	typedef struct
	182	{
	183	DWORD dwIndex; // Interface index
	184	DWORD dwIpAddr;
	185	BYTE bMacAddr[MAC_ADDR_LENGTH];
	186	} ARP_ENTRY;
	187
	188
	189	//
	190	// ARP cache structure used by discovery functions and AgentConnection class
	191	//
	192
	193	typedef struct
	194	{
	195	DWORD dwNumEntries;
	196	ARP_ENTRY *pEntries;
	197	} ARP_CACHE;
	198
	199
	200	//
	201	// Interface information structure used by discovery functions and AgentConnection class
	202	//
	203
	204	typedef struct
	205	{
478d4ff4 VK	206	TCHAR szName[MAX_DB_STRING]; // Interface display name
478d4ff4 VK	207	TCHAR szDescription[MAX_DB_STRING]; // Value of ifDescr MIB variable for SNMP agents
5039dede AK	208	DWORD dwIndex;
5039dede AK	209	DWORD dwType;
eec253a8 VK	210	DWORD dwBridgePortNumber;
	211	DWORD dwSlotNumber;
	212	DWORD dwPortNumber;
5039dede AK	213	DWORD dwIpAddr;
	214	DWORD dwIpNetMask;
	215	BYTE bMacAddr[MAC_ADDR_LENGTH];
	216	int iNumSecondary; // Number of secondary IP's on this interface
4c16cdc7	217	bool isPhysicalPort;
36e44abe	218	} NX_INTERFACE_INFO;
5039dede AK	219
	220
	221	//
	222	// Interface list used by discovery functions and AgentConnection class
	223	//
	224
98762401	225	class LIBNXSRV_EXPORTABLE InterfaceList
5039dede	226	{
98762401 VK	227	private:
	228	int m_size; // Number of valid entries
	229	int m_allocated; // Number of allocated entries
	230	void *m_data; // Can be used by custom enumeration handlers
36e44abe	231	NX_INTERFACE_INFO *m_interfaces; // Interface entries
98762401 VK	232
	233	public:
	234	InterfaceList(int initialAlloc = 8);
	235	~InterfaceList();
	236
36e44abe	237	void add(NX_INTERFACE_INFO *iface);
98762401 VK	238	void remove(int index);
	239	void removeLoopbacks();
	240
	241	int getSize() { return m_size; }
36e44abe	242	NX_INTERFACE_INFO *get(int index) { return ((index >= 0) && (index < m_size)) ? &m_interfaces[index] : NULL; }
b1bd1fb2	243	NX_INTERFACE_INFO *findByIfIndex(DWORD ifIndex);
98762401 VK	244
	245	void setData(void *data) { m_data = data; }
	246	void *getData() { return m_data; }
	247	};
5039dede AK	248
5039dede AK	249
77c7801c VK	250	//
	251	// Vlan information
	252	//
	253
0208aa8c VK	254	#define VLAN_PRM_IFINDEX 0
	255	#define VLAN_PRM_SLOTPORT 1
	256
77c7801c VK	257	class LIBNXSRV_EXPORTABLE VlanInfo
	258	{
	259	private:
	260	int m_vlanId;
	261	TCHAR *m_name;
0208aa8c	262	int m_portRefMode; // Port reference mode - by ifIndex or by slot/port
77c7801c VK	263	int m_allocated;
77c7801c VK	264	int m_numPorts; // Number of ports in VLAN
0208aa8c	265	DWORD *m_ports; // member ports (slot/port pairs or ifIndex)
b1bd1fb2 VK	266	DWORD *m_indexes; // ifIndexes for ports
b1bd1fb2 VK	267	DWORD *m_ids; // Interface object IDs for ports
77c7801c VK	268
77c7801c VK	269	public:
0208aa8c	270	VlanInfo(int vlanId, int prm);
77c7801c VK	271	~VlanInfo();
	272
	273	int getVlanId() { return m_vlanId; }
0208aa8c	274	int getPortReferenceMode() { return m_portRefMode; }
77c7801c VK	275	const TCHAR *getName() { return CHECK_NULL_EX(m_name); }
	276	int getNumPorts() { return m_numPorts; }
	277	DWORD *getPorts() { return m_ports; }
b1bd1fb2 VK	278	DWORD *getIfIndexes() { return m_indexes; }
b1bd1fb2 VK	279	DWORD *getIfIds() { return m_ids; }
77c7801c VK	280
77c7801c VK	281	void add(DWORD slot, DWORD port);
0208aa8c	282	void add(DWORD ifIndex);
77c7801c	283	void setName(const TCHAR *name);
b1bd1fb2 VK	284
	285	void prepareForResolve();
	286	void resolvePort(int index, DWORD sp, DWORD ifIndex, DWORD id);
77c7801c VK	287	};
	288
	289
	290	//
	291	// Vlan list
	292	//
	293
7f632dfe	294	class LIBNXSRV_EXPORTABLE VlanList : public RefCountObject
77c7801c VK	295	{
	296	private:
	297	int m_size; // Number of valid entries
	298	int m_allocated; // Number of allocated entries
	299	void *m_data; // Can be used by custom enumeration handlers
	300	VlanInfo **m_vlans; // VLAN entries
	301
	302	public:
	303	VlanList(int initialAlloc = 8);
7f632dfe	304	virtual ~VlanList();
77c7801c VK	305
77c7801c VK	306	void add(VlanInfo *vlan);
0208aa8c	307	void addMemberPort(int vlanId, DWORD portId);
77c7801c VK	308
	309	int getSize() { return m_size; }
	310	VlanInfo *get(int index) { return ((index >= 0) && (index < m_size)) ? m_vlans[index] : NULL; }
0208aa8c	311	VlanInfo *findById(int id);
77c7801c VK	312
	313	void setData(void *data) { m_data = data; }
	314	void *getData() { return m_data; }
7f632dfe VK	315
7f632dfe VK	316	void fillMessage(CSCPMessage *msg);
77c7801c VK	317	};
	318
	319
5039dede AK	320	//
	321	// Route information
	322	//
	323
	324	typedef struct
	325	{
	326	DWORD dwDestAddr;
	327	DWORD dwDestMask;
	328	DWORD dwNextHop;
	329	DWORD dwIfIndex;
	330	DWORD dwRouteType;
	331	} ROUTE;
	332
	333
	334	//
	335	// Routing table
	336	//
	337
	338	typedef struct
	339	{
	340	int iNumEntries; // Number of entries
	341	ROUTE *pRoutes; // Route list
	342	} ROUTING_TABLE;
	343
	344
1f385e47 VK	345	//
	346	// Information about policies installed on agent
	347	//
	348
	349	class LIBNXSRV_EXPORTABLE AgentPolicyInfo
	350	{
	351	private:
	352	int m_size;
	353	BYTE *m_guidList;
	354	int *m_typeList;
	355	TCHAR **m_serverList;
	356
	357	public:
	358	AgentPolicyInfo(CSCPMessage *msg);
	359	~AgentPolicyInfo();
	360
	361	int getSize() { return m_size; }
	362	bool getGuid(int index, uuid_t guid);
	363	int getType(int index) { return ((index >= 0) && (index < m_size)) ? m_typeList[index] : -1; }
	364	const TCHAR *getServer(int index) { return ((index >= 0) && (index < m_size)) ? m_serverList[index] : NULL; }
	365	};
	366
	367
5039dede AK	368	//
	369	// Agent connection
	370	//
	371
	372	class LIBNXSRV_EXPORTABLE AgentConnection
	373	{
	374	private:
	375	DWORD m_dwAddr;
	376	int m_nProtocolVersion;
	377	int m_iAuthMethod;
08b214c6	378	char m_szSecret[MAX_SECRET_LENGTH];
5039dede AK	379	time_t m_tLastCommandTime;
	380	SOCKET m_hSocket;
	381	DWORD m_dwNumDataLines;
	382	DWORD m_dwRequestId;
	383	DWORD m_dwCommandTimeout;
7c521895	384	DWORD m_connectionTimeout;
5039dede AK	385	DWORD m_dwRecvTimeout;
	386	TCHAR **m_ppDataLines;
	387	MsgWaitQueue *m_pMsgWaitQueue;
	388	BOOL m_bIsConnected;
	389	MUTEX m_mutexDataLock;
d3a7cf4c	390	MUTEX m_mutexSocketWrite;
5039dede AK	391	THREAD m_hReceiverThread;
	392	CSCP_ENCRYPTION_CONTEXT *m_pCtx;
	393	int m_iEncryptionPolicy;
	394	BOOL m_bUseProxy;
	395	DWORD m_dwProxyAddr;
	396	WORD m_wPort;
	397	WORD m_wProxyPort;
	398	int m_iProxyAuth;
08b214c6	399	char m_szProxySecret[MAX_SECRET_LENGTH];
5039dede	400	int m_hCurrFile;
9f6d453a	401	TCHAR m_currentFileName[MAX_PATH];
bb85e341 VK	402	DWORD m_dwDownloadRequestId;
	403	CONDITION m_condFileDownload;
	404	BOOL m_fileDownloadSucceeded;
	405	void (m_downloadProgressCallback)(size_t, void );
	406	void *m_downloadProgressCallbackArg;
901a5a9b	407	bool m_deleteFileOnDownloadFailure;
4685a2ad	408	bool m_fileUploadInProgress;
5039dede AK	409
	410	void ReceiverThread(void);
	411	static THREAD_RESULT THREAD_CALL ReceiverThreadStarter(void *);
	412
	413	protected:
7c521895 VK	414	void destroyResultData();
	415	BOOL sendMessage(CSCPMessage *pMsg);
	416	CSCPMessage *waitForMessage(WORD wCode, DWORD dwId, DWORD dwTimeOut) { return m_pMsgWaitQueue->WaitForMessage(wCode, dwId, dwTimeOut); }
	417	DWORD waitForRCC(DWORD dwRqId, DWORD dwTimeOut);
	418	DWORD setupEncryption(RSA *pServerKey);
	419	DWORD authenticate(BOOL bProxyData);
	420	DWORD setupProxyConnection();
	421	DWORD getIpAddr() { return ntohl(m_dwAddr); }
	422	DWORD prepareFileDownload(const TCHAR fileName, DWORD rqId, bool append, void (downloadProgressCallback)(size_t, void ), void cbArg);
5039dede AK	423
5039dede AK	424	virtual void PrintMsg(const TCHAR *pszFormat, ...);
f480bdd4 VK	425	virtual void onTrap(CSCPMessage *pMsg);
f480bdd4 VK	426	virtual void onDataPush(CSCPMessage *msg);
90284364	427	virtual bool processCustomMessage(CSCPMessage *pMsg);
f480bdd4	428	virtual void onFileDownload(BOOL success);
5039dede AK	429
	430	void Lock(void) { MutexLock(m_mutexDataLock, INFINITE); }
	431	void Unlock(void) { MutexUnlock(m_mutexDataLock); }
	432
	433	public:
5039dede AK	434	AgentConnection(DWORD dwAddr, WORD wPort = AGENT_LISTEN_PORT,
	435	int iAuthMethod = AUTH_NONE, const TCHAR *pszSecret = NULL);
	436	virtual ~AgentConnection();
	437
c3acd0f6	438	BOOL connect(RSA pServerKey = NULL, BOOL bVerbose = FALSE, DWORD pdwError = NULL, DWORD *pdwSocketError = NULL);
7c521895 VK	439	void disconnect();
	440	BOOL isConnected() { return m_bIsConnected; }
	441	int getProtocolVersion() { return m_nProtocolVersion; }
5039dede	442
45d84f8a	443	SOCKET getSocket() { return m_hSocket; }
5a9e58a3	444
4687826e	445	ARP_CACHE *getArpCache();
98762401	446	InterfaceList *getInterfaceList();
4687826e VK	447	ROUTING_TABLE *getRoutingTable();
	448	DWORD getParameter(const TCHAR pszParam, DWORD dwBufSize, TCHAR pszBuffer);
	449	DWORD getList(const TCHAR *pszParam);
	450	DWORD getTable(const TCHAR pszParam, Table *table);
7c521895	451	DWORD nop();
4687826e	452	DWORD execAction(const TCHAR pszAction, int argc, TCHAR *argv);
619e5c9b	453	DWORD uploadFile(const TCHAR localFile, const TCHAR destinationFile = NULL, void (* progressCallback)(INT64, void ) = NULL, void cbArg = NULL);
4687826e VK	454	DWORD startUpgrade(const TCHAR *pszPkgName);
4687826e VK	455	DWORD checkNetworkService(DWORD *pdwStatus, DWORD dwIpAddr, int iServiceType, WORD wPort = 0,
5039dede	456	WORD wProto = 0, const TCHAR pszRequest = NULL, const TCHAR pszResponse = NULL);
4687826e VK	457	DWORD getSupportedParameters(DWORD pdwNumParams, NXC_AGENT_PARAM *ppParamList);
4687826e VK	458	DWORD getConfigFile(TCHAR *ppszConfig, DWORD pdwSize);
45d84f8a	459	DWORD updateConfigFile(const TCHAR *pszConfig);
7c521895	460	DWORD enableTraps();
1f385e47 VK	461	DWORD getPolicyInventory(AgentPolicyInfo **info);
1f385e47 VK	462	DWORD uninstallPolicy(uuid_t guid);
e58b5e54 VK	463
e58b5e54 VK	464	DWORD generateRequestId() { return m_dwRequestId++; }
45d84f8a	465	CSCPMessage customRequest(CSCPMessage pRequest, const TCHAR *recvFile = NULL, bool appendFile = false,
f2665675	466	void (downloadProgressCallback)(size_t, void ) = NULL, void *cbArg = NULL);
5039dede	467
7c521895 VK	468	DWORD getNumDataLines() { return m_dwNumDataLines; }
7c521895 VK	469	const TCHAR *getDataLine(DWORD dwIndex) { return dwIndex < m_dwNumDataLines ? m_ppDataLines[dwIndex] : _T("(error)"); }
5039dede	470
7c521895 VK	471	void setConnectionTimeout(DWORD dwTimeout) { m_connectionTimeout = max(dwTimeout, 1000); }
7c521895 VK	472	DWORD getConnectionTimeout() { return m_connectionTimeout; }
45d84f8a VK	473	void setCommandTimeout(DWORD dwTimeout) { m_dwCommandTimeout = max(dwTimeout, 500); }
45d84f8a VK	474	DWORD getCommandTimeout() { return m_dwCommandTimeout; }
7c521895 VK	475	void setRecvTimeout(DWORD dwTimeout) { m_dwRecvTimeout = max(dwTimeout, 10000); }
	476	void setEncryptionPolicy(int iPolicy) { m_iEncryptionPolicy = iPolicy; }
	477	void setProxy(DWORD dwAddr, WORD wPort = AGENT_LISTEN_PORT,
5039dede	478	int iAuthMethod = AUTH_NONE, const TCHAR *pszSecret = NULL);
7c521895	479	void setPort(WORD wPort) { m_wPort = wPort; }
08b214c6	480	void setAuthData(int nMethod, const char *pszSecret) { m_iAuthMethod = nMethod; strncpy(m_szSecret, pszSecret, MAX_SECRET_LENGTH); m_szSecret[MAX_SECRET_LENGTH - 1] = 0; }
901a5a9b	481	void setDeleteFileOnDownloadFailure(bool flag) { m_deleteFileOnDownloadFailure = flag; }
5039dede AK	482	};
	483
	484
	485	//
	486	// Proxy SNMP transport
	487	//
	488
	489	class LIBNXSRV_EXPORTABLE SNMP_ProxyTransport : public SNMP_Transport
	490	{
	491	protected:
	492	AgentConnection *m_pAgentConnection;
	493	CSCPMessage *m_pResponse;
	494	DWORD m_dwIpAddr;
	495	WORD m_wPort;
	496
	497	public:
	498	SNMP_ProxyTransport(AgentConnection *pConn, DWORD dwIpAddr, WORD wPort);
	499	virtual ~SNMP_ProxyTransport();
	500
c4366266	501	virtual int readMessage(SNMP_PDU **ppData, DWORD dwTimeout = INFINITE,
cd9f247e VK	502	struct sockaddr pSender = NULL, socklen_t piAddrSize = NULL,
cd9f247e VK	503	SNMP_SecurityContext* (contextFinder)(struct sockaddr , socklen_t) = NULL);
c4366266	504	virtual int sendMessage(SNMP_PDU *pdu);
5039dede AK	505	};
	506
	507
	508	//
	509	// ISC flags
	510	//
	511
	512	#define ISCF_IS_CONNECTED ((DWORD)0x00000001)
	513	#define ISCF_REQUIRE_ENCRYPTION ((DWORD)0x00000002)
	514
	515
	516	//
	517	// Inter-server connection (ISC)
	518	//
	519
	520	class LIBNXSRV_EXPORTABLE ISC
	521	{
	522	private:
	523	DWORD m_flags;
	524	DWORD m_addr;
	525	WORD m_port;
	526	SOCKET m_socket;
	527	int m_protocolVersion;
	528	DWORD m_requestId;
	529	DWORD m_recvTimeout;
	530	MsgWaitQueue *m_msgWaitQueue;
	531	MUTEX m_mutexDataLock;
7b8b337e	532	MUTEX m_socketLock;
5039dede AK	533	THREAD m_hReceiverThread;
	534	CSCP_ENCRYPTION_CONTEXT *m_ctx;
	535	DWORD m_commandTimeout;
	536
	537	void ReceiverThread(void);
	538	static THREAD_RESULT THREAD_CALL ReceiverThreadStarter(void *);
	539
	540	protected:
	541	void DestroyResultData(void);
	542	DWORD SetupEncryption(RSA *pServerKey);
	543	DWORD ConnectToService(DWORD service);
	544
	545	void Lock(void) { MutexLock(m_mutexDataLock, INFINITE); }
	546	void Unlock(void) { MutexUnlock(m_mutexDataLock); }
	547
	548	virtual void PrintMsg(const TCHAR *format, ...);
	549
	550	public:
	551	ISC();
	552	ISC(DWORD addr, WORD port = NETXMS_ISC_PORT);
	553	virtual ~ISC();
	554
	555	DWORD Connect(DWORD service, RSA *serverKey = NULL, BOOL requireEncryption = FALSE);
	556	void Disconnect();
	557
	558	BOOL SendMessage(CSCPMessage *msg);
	559	CSCPMessage *WaitForMessage(WORD code, DWORD id, DWORD timeOut) { return m_msgWaitQueue->WaitForMessage(code, id, timeOut); }
	560	DWORD WaitForRCC(DWORD rqId, DWORD timeOut);
	561
	562	DWORD Nop(void);
	563	};
	564
	565
	566	//
	567	// Functions
	568	//
	569
	570	void LIBNXSRV_EXPORTABLE DestroyArpCache(ARP_CACHE *pArpCache);
5039dede AK	571	void LIBNXSRV_EXPORTABLE DestroyRoutingTable(ROUTING_TABLE *pRT);
	572	void LIBNXSRV_EXPORTABLE SortRoutingTable(ROUTING_TABLE *pRT);
	573	const TCHAR LIBNXSRV_EXPORTABLE *AgentErrorCodeToText(int iError);
	574
	575	void LIBNXSRV_EXPORTABLE WriteLogOther(WORD wType, const TCHAR *format, ...);
	576	void LIBNXSRV_EXPORTABLE DbgPrintf(int level, const TCHAR *format, ...);
9d88cdc9	577	void LIBNXSRV_EXPORTABLE DbgPrintf2(int level, const TCHAR *format, va_list args);
c20b2798	578
5039dede AK	579	void LIBNXSRV_EXPORTABLE SetAgentDEP(int iPolicy);
	580
	581	const TCHAR LIBNXSRV_EXPORTABLE *ISCErrorCodeToText(DWORD code);
	582
5ad2167d VK	583	DWORD LIBNXSRV_EXPORTABLE SnmpNewRequestId();
	584	DWORD LIBNXSRV_EXPORTABLE SnmpGet(DWORD dwVersion, SNMP_Transport *pTransport,
	585	const TCHAR szOidStr, const DWORD oidBinary, DWORD dwOidLen, void *pValue,
	586	DWORD dwBufferSize, DWORD dwFlags);
	587	DWORD LIBNXSRV_EXPORTABLE SnmpEnumerate(DWORD dwVersion, SNMP_Transport pTransport, const TCHAR szRootOid,
	588	DWORD (* pHandler)(DWORD, SNMP_Variable , SNMP_Transport , void *),
	589	void *pUserArg, BOOL bVerbose);
	590
5039dede AK	591
	592	//
	593	// Variables
	594	//
	595
	596	extern DWORD LIBNXSRV_EXPORTABLE g_dwFlags;
5ad2167d	597	extern DWORD LIBNXSRV_EXPORTABLE g_dwSNMPTimeout;
5039dede	598	extern int LIBNXSRV_EXPORTABLE g_nDebugLevel;
5039dede AK	599
5039dede AK	600	#endif /* _nxsrvapi_h_ */