7a151dbdc4de99be25f8f06cfc72933bd6c6751a
[public/netxms.git] / src / server / include / nms_core.h
1 /*
2 ** NetXMS - Network Management System
3 ** Copyright (C) 2003-2016 Victor Kirhenshtein
4 **
5 ** This program is free software; you can redistribute it and/or modify
6 ** it under the terms of the GNU General Public License as published by
7 ** the Free Software Foundation; either version 2 of the License, or
8 ** (at your option) any later version.
9 **
10 ** This program is distributed in the hope that it will be useful,
11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 ** GNU General Public License for more details.
14 **
15 ** You should have received a copy of the GNU General Public License
16 ** along with this program; if not, write to the Free Software
17 ** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 **
19 ** File: nms_core.h
20 **
21 **/
22
23 #ifndef _nms_core_h_
24 #define _nms_core_h_
25
26 #ifdef _WIN32
27 #ifdef NXCORE_EXPORTS
28 #define NXCORE_EXPORTABLE __declspec(dllexport)
29 #else
30 #define NXCORE_EXPORTABLE __declspec(dllimport)
31 #endif
32 #else /* _WIN32 */
33 #define NXCORE_EXPORTABLE
34 #endif
35
36 #define LIBNXCL_NO_DECLARATIONS 1
37
38 #include <nms_common.h>
39
40 #ifndef _WIN32
41
42 #if HAVE_SYS_TYPES_H
43 # include <sys/types.h>
44 #endif
45
46 #if HAVE_DLFCN_H
47 #include <dlfcn.h>
48 #endif
49
50
51 #define WSAGetLastError() (errno)
52
53 #endif /* _WIN32 */
54
55 #include <time.h>
56 #include <stdio.h>
57 #include <string.h>
58 #include <stdarg.h>
59
60 #ifdef _WITH_ENCRYPTION
61 #include <openssl/ssl.h>
62 #endif
63
64 //
65 // Common includes
66 //
67
68 #include <nms_util.h>
69 #include <dbdrv.h>
70 #include <nms_cscp.h>
71 #include <uuid.h>
72 #include <nxsrvapi.h>
73 #include <nxqueue.h>
74 #include <nxsnmp.h>
75 #include <nxmodule.h>
76 #include <nxsl.h>
77 #include <nxdbapi.h>
78 #include <nddrv.h>
79 #include <npe.h>
80 #include <nxcore_smclp.h>
81
82 /**
83 * Console context
84 */
85 struct __console_ctx
86 {
87 SOCKET hSocket;
88 MUTEX socketMutex;
89 NXCPMessage *pMsg;
90 ClientSession *session;
91 String *output;
92 };
93
94 typedef __console_ctx * CONSOLE_CTX;
95
96 /**
97 * Server includes
98 */
99 #include "nms_dcoll.h"
100 #include "nms_users.h"
101 #include "nxcore_winperf.h"
102 #include "nms_objects.h"
103 #include "nms_locks.h"
104 #include "nms_pkg.h"
105 #include "nms_topo.h"
106 #include "nms_script.h"
107 #include "nxcore_ps.h"
108 #include "nxcore_jobs.h"
109 #include "nxcore_logs.h"
110 #include "nxcore_schedule.h"
111 #ifdef WITH_ZMQ
112 #include "zeromq.h"
113 #endif
114
115 /**
116 * Common constants and macros
117 */
118 #define MAX_LINE_SIZE 4096
119 #define GROUP_FLAG_BIT ((UINT32)0x80000000)
120 #define CHECKPOINT_SNMP_PORT 260
121 #define DEFAULT_AFFINITY_MASK 0xFFFFFFFF
122
123 #define MAX_CLIENT_SESSIONS 128
124 #define MAX_DEVICE_SESSIONS 256
125
126 #define PING_TIME_TIMEOUT 10000
127
128 typedef void * HSNMPSESSION;
129
130 /**
131 * Prefixes for poller messages
132 */
133 #define POLLER_ERROR _T("\x7F") _T("e")
134 #define POLLER_WARNING _T("\x7Fw")
135 #define POLLER_INFO _T("\x7Fi")
136
137 /**
138 * Unique identifier group codes
139 */
140 #define IDG_NETWORK_OBJECT 0
141 #define IDG_EVENT 1
142 #define IDG_ITEM 2
143 #define IDG_SNMP_TRAP 3
144 #define IDG_JOB 4
145 #define IDG_ACTION 5
146 #define IDG_EVENT_GROUP 6
147 #define IDG_THRESHOLD 7
148 #define IDG_USER 8
149 #define IDG_USER_GROUP 9
150 #define IDG_ALARM 10
151 #define IDG_ALARM_NOTE 11
152 #define IDG_PACKAGE 12
153 #define IDG_SLM_TICKET 13
154 #define IDG_OBJECT_TOOL 14
155 #define IDG_SCRIPT 15
156 #define IDG_AGENT_CONFIG 16
157 #define IDG_GRAPH 17
158 #define IDG_CERTIFICATE 18
159 #define IDG_DCT_COLUMN 19
160 #define IDG_MAPPING_TABLE 20
161 #define IDG_DCI_SUMMARY_TABLE 21
162 #define IDG_SCHEDULED_TASK 22
163 #define IDG_ALARM_CATEGORY 23
164
165 /**
166 * Exit codes for console commands
167 */
168 #define CMD_EXIT_CONTINUE 0
169 #define CMD_EXIT_CLOSE_SESSION 1
170 #define CMD_EXIT_SHUTDOWN 2
171
172 /**
173 * Network discovery mode
174 */
175 #define DISCOVERY_DISABLED 0
176 #define DISCOVERY_PASSIVE_ONLY 1
177 #define DISCOVERY_ACTIVE 2
178
179 /**
180 * Client session flags
181 */
182 #define CSF_TERMINATED ((UINT32)0x00000001)
183 #define CSF_EPP_LOCKED ((UINT32)0x00000002)
184 #define CSF_PACKAGE_DB_LOCKED ((UINT32)0x00000004)
185 #define CSF_USER_DB_LOCKED ((UINT32)0x00000008)
186 #define CSF_EPP_UPLOAD ((UINT32)0x00000010)
187 #define CSF_CONSOLE_OPEN ((UINT32)0x00000020)
188 #define CSF_AUTHENTICATED ((UINT32)0x00000080)
189 #define CSF_COMPRESSION_ENABLED ((UINT32)0x00000100)
190 #define CSF_RECEIVING_MAP_DATA ((UINT32)0x00000200)
191 #define CSF_SYNC_OBJECT_COMMENTS ((UINT32)0x00000400)
192 #define CSF_CUSTOM_LOCK_1 ((UINT32)0x01000000)
193 #define CSF_CUSTOM_LOCK_2 ((UINT32)0x02000000)
194 #define CSF_CUSTOM_LOCK_3 ((UINT32)0x04000000)
195 #define CSF_CUSTOM_LOCK_4 ((UINT32)0x08000000)
196 #define CSF_CUSTOM_LOCK_5 ((UINT32)0x10000000)
197 #define CSF_CUSTOM_LOCK_6 ((UINT32)0x20000000)
198 #define CSF_CUSTOM_LOCK_7 ((UINT32)0x40000000)
199 #define CSF_CUSTOM_LOCK_8 ((UINT32)0x80000000)
200
201 /**
202 * Client session states
203 */
204 #define SESSION_STATE_INIT 0
205 #define SESSION_STATE_IDLE 1
206 #define SESSION_STATE_PROCESSING 2
207
208 /**
209 * Certificate types
210 */
211 enum CertificateType
212 {
213 CERT_TYPE_TRUSTED_CA = 0,
214 CERT_TYPE_USER = 1,
215 CERT_TYPE_AGENT = 2,
216 CERT_TYPE_SERVER = 3
217 };
218
219 /**
220 * Audit subsystems
221 */
222 #define AUDIT_SECURITY _T("SECURITY")
223 #define AUDIT_OBJECTS _T("OBJECTS")
224 #define AUDIT_SYSCFG _T("SYSCFG")
225 #define AUDIT_CONSOLE _T("CONSOLE")
226
227 #define AUDIT_SYSTEM_SID (-1)
228
229 /**
230 * Event handling subsystem definitions
231 */
232 #include "nms_events.h"
233 #include "nms_actions.h"
234 #include "nms_alarm.h"
235
236 /**
237 * New node information
238 */
239 typedef struct
240 {
241 InetAddress ipAddr;
242 UINT32 zoneUIN;
243 BOOL ignoreFilter;
244 BYTE bMacAddr[MAC_ADDR_LENGTH];
245 } NEW_NODE;
246
247 /**
248 * New node flags
249 */
250 #define NNF_IS_SNMP 0x0001
251 #define NNF_IS_AGENT 0x0002
252 #define NNF_IS_ROUTER 0x0004
253 #define NNF_IS_BRIDGE 0x0008
254 #define NNF_IS_PRINTER 0x0010
255 #define NNF_IS_CDP 0x0020
256 #define NNF_IS_SONMP 0x0040
257 #define NNF_IS_LLDP 0x0080
258
259 /**
260 * Address list element types
261 */
262 #define InetAddressListElement_SUBNET 0
263 #define InetAddressListElement_RANGE 1
264
265 /**
266 * SNMP config global ID
267 */
268 #define SNMP_CONFIG_GLOBAL -1
269
270 /**
271 * IP address list element
272 */
273 class NXCORE_EXPORTABLE InetAddressListElement
274 {
275 private:
276 int m_type;
277 InetAddress m_baseAddress;
278 InetAddress m_endAddress;
279
280 public:
281 InetAddressListElement(NXCPMessage *msg, UINT32 baseId);
282 InetAddressListElement(const InetAddress& baseAddr, const InetAddress& endAddr);
283 InetAddressListElement(const InetAddress& baseAddr, int maskBits);
284 InetAddressListElement(DB_RESULT hResult, int row);
285
286 void fillMessage(NXCPMessage *msg, UINT32 baseId) const;
287
288 bool contains(const InetAddress& addr) const;
289
290 int getType() const { return m_type; }
291 const InetAddress& getBaseAddress() const { return m_baseAddress; }
292 const InetAddress& getEndAddress() const { return m_endAddress; }
293
294 String toString() const;
295 };
296
297 /**
298 * Node information for autodiscovery filter
299 */
300 typedef struct
301 {
302 InetAddress ipAddr;
303 UINT32 dwFlags;
304 int nSNMPVersion;
305 TCHAR szObjectId[MAX_OID_LEN * 4]; // SNMP OID
306 TCHAR szAgentVersion[MAX_AGENT_VERSION_LEN];
307 TCHAR szPlatform[MAX_PLATFORM_NAME_LEN];
308 } DISCOVERY_FILTER_DATA;
309
310 /**
311 * Data update structure for client sessions
312 */
313 typedef struct
314 {
315 UINT32 dwCategory; // Data category - event, network object, etc.
316 UINT32 dwCode; // Data-specific update code
317 void *pData; // Pointer to data block
318 } UPDATE_INFO;
319
320 /**
321 * Mobile device session
322 */
323 class NXCORE_EXPORTABLE MobileDeviceSession
324 {
325 private:
326 SOCKET m_hSocket;
327 Queue *m_pSendQueue;
328 Queue *m_pMessageQueue;
329 int m_id;
330 int m_state;
331 WORD m_wCurrentCmd;
332 UINT32 m_dwUserId;
333 UINT32 m_deviceObjectId;
334 NXCP_BUFFER *m_pMsgBuffer;
335 NXCPEncryptionContext *m_pCtx;
336 BYTE m_challenge[CLIENT_CHALLENGE_SIZE];
337 THREAD m_hWriteThread;
338 THREAD m_hProcessingThread;
339 MUTEX m_mutexSocketWrite;
340 InetAddress m_clientAddr;
341 TCHAR m_szHostName[256]; // IP address of name of conneced host in textual form
342 TCHAR m_szUserName[MAX_SESSION_NAME]; // String in form login_name@host
343 TCHAR m_szClientInfo[96]; // Client app info string
344 UINT32 m_dwEncryptionRqId;
345 UINT32 m_dwEncryptionResult;
346 CONDITION m_condEncryptionSetup;
347 UINT32 m_dwRefCount;
348 bool m_isAuthenticated;
349
350 static THREAD_RESULT THREAD_CALL readThreadStarter(void *);
351 static THREAD_RESULT THREAD_CALL writeThreadStarter(void *);
352 static THREAD_RESULT THREAD_CALL processingThreadStarter(void *);
353
354 void readThread();
355 void writeThread();
356 void processingThread();
357
358 void setupEncryption(NXCPMessage *request);
359 void respondToKeepalive(UINT32 dwRqId);
360 void debugPrintf(int level, const TCHAR *format, ...);
361 void sendServerInfo(UINT32 dwRqId);
362 void login(NXCPMessage *pRequest);
363 void updateDeviceInfo(NXCPMessage *pRequest);
364 void updateDeviceStatus(NXCPMessage *pRequest);
365 void pushData(NXCPMessage *request);
366
367 public:
368 MobileDeviceSession(SOCKET hSocket, const InetAddress& addr);
369 ~MobileDeviceSession();
370
371 void run();
372
373 void postMessage(NXCPMessage *pMsg) { m_pSendQueue->put(pMsg->serialize()); }
374 void sendMessage(NXCPMessage *pMsg);
375
376 int getId() { return m_id; }
377 void setId(int id) { if (m_id == -1) m_id = id; }
378 int getState() { return m_state; }
379 const TCHAR *getUserName() { return m_szUserName; }
380 const TCHAR *getClientInfo() { return m_szClientInfo; }
381 const TCHAR *getHostName() { return m_szHostName; }
382 UINT32 getUserId() { return m_dwUserId; }
383 bool isAuthenticated() { return m_isAuthenticated; }
384 WORD getCurrentCmd() { return m_wCurrentCmd; }
385 int getCipher() { return (m_pCtx == NULL) ? -1 : m_pCtx->getCipher(); }
386 };
387
388 /**
389 * Processing thread starter declaration for client session
390 */
391 #define DECLARE_THREAD_STARTER(func) static void ThreadStarter_##func(void *);
392
393 /**
394 * Class that stores information about file that will be received
395 */
396 class ServerDownloadFileInfo : public DownloadFileInfo
397 {
398 protected:
399 UINT32 m_uploadCommand;
400 UINT32 m_uploadData;
401 uuid m_uploadImageGuid;
402
403 public:
404 ServerDownloadFileInfo(const TCHAR *name, UINT32 uploadCommand, time_t lastModTime = 0);
405 virtual ~ServerDownloadFileInfo();
406
407 virtual void close(bool success);
408
409 void setUploadData(UINT32 data) { m_uploadData = data; }
410 void setImageGuid(const uuid& guid) { m_uploadImageGuid = guid; }
411 void updateAgentPkgDBInfo(const TCHAR *description, const TCHAR *pkgName, const TCHAR *pkgVersion, const TCHAR *platform, const TCHAR *cleanFileName);
412 };
413
414 /**
415 * Client (user) session
416 */
417 class NXCORE_EXPORTABLE ClientSession
418 {
419 private:
420 SOCKET m_hSocket;
421 Queue *m_sendQueue;
422 Queue *m_requestQueue;
423 int m_id;
424 int m_state;
425 WORD m_wCurrentCmd;
426 UINT32 m_dwUserId;
427 UINT64 m_dwSystemAccess; // User's system access rights
428 UINT32 m_dwFlags; // Session flags
429 int m_clientType; // Client system type - desktop, web, mobile, etc.
430 NXCPEncryptionContext *m_pCtx;
431 BYTE m_challenge[CLIENT_CHALLENGE_SIZE];
432 THREAD m_hWriteThread;
433 THREAD m_hProcessingThread;
434 MUTEX m_mutexSocketWrite;
435 MUTEX m_mutexSendObjects;
436 MUTEX m_mutexSendAlarms;
437 MUTEX m_mutexSendActions;
438 MUTEX m_mutexSendAuditLog;
439 MUTEX m_mutexPollerInit;
440 InetAddress m_clientAddr;
441 TCHAR m_workstation[256]; // IP address or name of connected host in textual form
442 TCHAR m_webServerAddress[256]; // IP address or name of web server for web sessions
443 TCHAR m_loginName[MAX_USER_NAME];
444 TCHAR m_sessionName[MAX_SESSION_NAME]; // String in form login_name@host
445 TCHAR m_clientInfo[96]; // Client app info string
446 TCHAR m_language[8]; // Client's desired language
447 time_t m_loginTime;
448 UINT32 m_dwOpenDCIListSize; // Number of open DCI lists
449 UINT32 *m_pOpenDCIList; // List of nodes with DCI lists open
450 UINT32 m_dwNumRecordsToUpload; // Number of records to be uploaded
451 UINT32 m_dwRecordsUploaded;
452 EPRule **m_ppEPPRuleList; // List of loaded EPP rules
453 HashMap<UINT32, ServerDownloadFileInfo> *m_downloadFileMap;
454 VolatileCounter m_refCount;
455 UINT32 m_dwEncryptionRqId;
456 UINT32 m_dwEncryptionResult;
457 CONDITION m_condEncryptionSetup;
458 CONSOLE_CTX m_console; // Server console context
459 StringList m_musicTypeList;
460 ObjectIndex m_agentConn;
461 StringObjectMap<UINT32> *m_subscriptions;
462 MUTEX m_subscriptionLock;
463 HashMap<UINT32, CommandExec> *m_serverCommands;
464
465 static THREAD_RESULT THREAD_CALL readThreadStarter(void *);
466 static THREAD_RESULT THREAD_CALL writeThreadStarter(void *);
467 static THREAD_RESULT THREAD_CALL processingThreadStarter(void *);
468 static void pollerThreadStarter(void *);
469
470 DECLARE_THREAD_STARTER(cancelFileMonitoring)
471 DECLARE_THREAD_STARTER(clearDCIData)
472 DECLARE_THREAD_STARTER(createObject)
473 DECLARE_THREAD_STARTER(executeAction)
474 DECLARE_THREAD_STARTER(executeScript)
475 DECLARE_THREAD_STARTER(executeLibraryScript)
476 DECLARE_THREAD_STARTER(fileManagerControl)
477 DECLARE_THREAD_STARTER(findIpAddress)
478 DECLARE_THREAD_STARTER(findMacAddress)
479 DECLARE_THREAD_STARTER(findHostname)
480 DECLARE_THREAD_STARTER(findNodeConnection)
481 DECLARE_THREAD_STARTER(forceDCIPoll)
482 DECLARE_THREAD_STARTER(forwardToReportingServer)
483 DECLARE_THREAD_STARTER(getAgentFile)
484 DECLARE_THREAD_STARTER(getAlarmEvents)
485 DECLARE_THREAD_STARTER(getAlarms)
486 DECLARE_THREAD_STARTER(getCollectedData)
487 DECLARE_THREAD_STARTER(getPredictedData)
488 DECLARE_THREAD_STARTER(getLocationHistory)
489 DECLARE_THREAD_STARTER(getNetworkPath)
490 DECLARE_THREAD_STARTER(getRoutingTable)
491 DECLARE_THREAD_STARTER(getServerFile)
492 DECLARE_THREAD_STARTER(getServerLogQueryData)
493 DECLARE_THREAD_STARTER(getSwitchForwardingDatabase)
494 DECLARE_THREAD_STARTER(getTableCollectedData)
495 DECLARE_THREAD_STARTER(importConfiguration)
496 DECLARE_THREAD_STARTER(openHelpdeskIssue)
497 DECLARE_THREAD_STARTER(processConsoleCommand)
498 DECLARE_THREAD_STARTER(queryAgentTable)
499 DECLARE_THREAD_STARTER(queryL2Topology)
500 DECLARE_THREAD_STARTER(queryParameter)
501 DECLARE_THREAD_STARTER(queryServerLog)
502 DECLARE_THREAD_STARTER(sendMib)
503 DECLARE_THREAD_STARTER(uploadUserFileToAgent)
504 DECLARE_THREAD_STARTER(getRepositories)
505 DECLARE_THREAD_STARTER(addRepository)
506 DECLARE_THREAD_STARTER(modifyRepository)
507 DECLARE_THREAD_STARTER(deleteRepository)
508
509 void readThread();
510 void writeThread();
511 void processingThread();
512 void pollerThread(DataCollectionTarget *pNode, int iPollType, UINT32 dwRqId);
513
514 void debugPrintf(int level, const TCHAR *format, ...);
515
516 void setupEncryption(NXCPMessage *request);
517 void respondToKeepalive(UINT32 dwRqId);
518 void onFileUpload(BOOL bSuccess);
519 void sendServerInfo(UINT32 dwRqId);
520 void login(NXCPMessage *pRequest);
521 void sendAllObjects(NXCPMessage *pRequest);
522 void sendSelectedObjects(NXCPMessage *pRequest);
523 void getConfigurationVariables(UINT32 dwRqId);
524 void getPublicConfigurationVariable(NXCPMessage *request);
525 void setDefaultConfigurationVariableValues(NXCPMessage *pRequest);
526 void setConfigurationVariable(NXCPMessage *pRequest);
527 void deleteConfigurationVariable(NXCPMessage *pRequest);
528 void sendUserDB(UINT32 dwRqId);
529 void createUser(NXCPMessage *pRequest);
530 void updateUser(NXCPMessage *pRequest);
531 void detachLdapUser(NXCPMessage *pRequest);
532 void deleteUser(NXCPMessage *pRequest);
533 void setPassword(NXCPMessage *request);
534 void validatePassword(NXCPMessage *request);
535 void lockUserDB(UINT32 dwRqId, BOOL bLock);
536 void getAlarmCategories(UINT32 requestId);
537 void modifyAlarmCategory(NXCPMessage *pRequest);
538 void deleteAlarmCategory(NXCPMessage *pRequest);
539 void sendEventDB(NXCPMessage *pRequest);
540 void modifyEventTemplate(NXCPMessage *pRequest);
541 void deleteEventTemplate(NXCPMessage *pRequest);
542 void generateEventCode(UINT32 dwRqId);
543 void modifyObject(NXCPMessage *pRequest);
544 void changeObjectMgmtStatus(NXCPMessage *pRequest);
545 void enterMaintenanceMode(NXCPMessage *request);
546 void leaveMaintenanceMode(NXCPMessage *request);
547 void openNodeDCIList(NXCPMessage *pRequest);
548 void closeNodeDCIList(NXCPMessage *pRequest);
549 void modifyNodeDCI(NXCPMessage *pRequest);
550 void copyDCI(NXCPMessage *pRequest);
551 void applyTemplate(NXCPMessage *pRequest);
552 void getCollectedData(NXCPMessage *pRequest);
553 void getTableCollectedData(NXCPMessage *pRequest);
554 bool getCollectedDataFromDB(NXCPMessage *request, NXCPMessage *response, DataCollectionTarget *object, int dciType);
555 void clearDCIData(NXCPMessage *pRequest);
556 void forceDCIPoll(NXCPMessage *pRequest);
557 void changeDCIStatus(NXCPMessage *pRequest);
558 void getLastValues(NXCPMessage *pRequest);
559 void getLastValuesByDciId(NXCPMessage *pRequest);
560 void getTableLastValues(NXCPMessage *pRequest);
561 void getThresholdSummary(NXCPMessage *request);
562 void openEPP(NXCPMessage *request);
563 void closeEPP(UINT32 dwRqId);
564 void saveEPP(NXCPMessage *pRequest);
565 void processEPPRecord(NXCPMessage *pRequest);
566 void sendMIBTimestamp(UINT32 dwRqId);
567 void sendMib(NXCPMessage *request);
568 void createObject(NXCPMessage *request);
569 void changeObjectBinding(NXCPMessage *request, BOOL bBind);
570 void deleteObject(NXCPMessage *request);
571 void getAlarms(NXCPMessage *request);
572 void getAlarm(NXCPMessage *request);
573 void getAlarmEvents(NXCPMessage *request);
574 void acknowledgeAlarm(NXCPMessage *request);
575 void resolveAlarm(NXCPMessage *request, bool terminate);
576 void bulkResolveAlarms(NXCPMessage *pRequest, bool terminate);
577 void deleteAlarm(NXCPMessage *request);
578 void openHelpdeskIssue(NXCPMessage *request);
579 void getHelpdeskUrl(NXCPMessage *request);
580 void unlinkHelpdeskIssue(NXCPMessage *request);
581 void getAlarmComments(NXCPMessage *pRequest);
582 void updateAlarmComment(NXCPMessage *pRequest);
583 void deleteAlarmComment(NXCPMessage *request);
584 void updateAlarmStatusFlow(NXCPMessage *request);
585 void createAction(NXCPMessage *pRequest);
586 void updateAction(NXCPMessage *pRequest);
587 void deleteAction(NXCPMessage *pRequest);
588 void sendAllActions(UINT32 dwRqId);
589 void forcedNodePoll(NXCPMessage *pRequest);
590 void onTrap(NXCPMessage *pRequest);
591 void onWakeUpNode(NXCPMessage *pRequest);
592 void queryParameter(NXCPMessage *pRequest);
593 void queryAgentTable(NXCPMessage *pRequest);
594 void editTrap(int iOperation, NXCPMessage *pRequest);
595 void LockTrapCfg(UINT32 dwRqId, BOOL bLock);
596 void sendAllTraps(UINT32 dwRqId);
597 void sendAllTraps2(UINT32 dwRqId);
598 void LockPackageDB(UINT32 dwRqId, BOOL bLock);
599 void SendAllPackages(UINT32 dwRqId);
600 void InstallPackage(NXCPMessage *pRequest);
601 void RemovePackage(NXCPMessage *pRequest);
602 void DeployPackage(NXCPMessage *pRequest);
603 void getParametersList(NXCPMessage *pRequest);
604 void getUserVariable(NXCPMessage *pRequest);
605 void setUserVariable(NXCPMessage *pRequest);
606 void copyUserVariable(NXCPMessage *pRequest);
607 void enumUserVariables(NXCPMessage *pRequest);
608 void deleteUserVariable(NXCPMessage *pRequest);
609 void changeObjectZone(NXCPMessage *pRequest);
610 void getAgentConfig(NXCPMessage *pRequest);
611 void updateAgentConfig(NXCPMessage *pRequest);
612 void executeAction(NXCPMessage *pRequest);
613 void getObjectTools(UINT32 requestId);
614 void getObjectToolDetails(NXCPMessage *request);
615 void updateObjectTool(NXCPMessage *pRequest);
616 void deleteObjectTool(NXCPMessage *pRequest);
617 void changeObjectToolStatus(NXCPMessage *pRequest);
618 void generateObjectToolId(UINT32 dwRqId);
619 void execTableTool(NXCPMessage *pRequest);
620 void changeSubscription(NXCPMessage *pRequest);
621 void sendServerStats(UINT32 dwRqId);
622 void sendScriptList(UINT32 dwRqId);
623 void sendScript(NXCPMessage *pRequest);
624 void updateScript(NXCPMessage *pRequest);
625 void renameScript(NXCPMessage *pRequest);
626 void deleteScript(NXCPMessage *pRequest);
627 void SendSessionList(UINT32 dwRqId);
628 void KillSession(NXCPMessage *pRequest);
629 void StartSnmpWalk(NXCPMessage *pRequest);
630 void resolveDCINames(NXCPMessage *pRequest);
631 UINT32 resolveDCIName(UINT32 dwNode, UINT32 dwItem, TCHAR *ppszName);
632 void sendConfigForAgent(NXCPMessage *pRequest);
633 void sendAgentCfgList(UINT32 dwRqId);
634 void OpenAgentConfig(NXCPMessage *pRequest);
635 void SaveAgentConfig(NXCPMessage *pRequest);
636 void DeleteAgentConfig(NXCPMessage *pRequest);
637 void SwapAgentConfigs(NXCPMessage *pRequest);
638 void SendObjectComments(NXCPMessage *pRequest);
639 void updateObjectComments(NXCPMessage *pRequest);
640 void pushDCIData(NXCPMessage *pRequest);
641 void getAddrList(NXCPMessage *request);
642 void setAddrList(NXCPMessage *request);
643 void resetComponent(NXCPMessage *pRequest);
644 void getDCIEventList(NXCPMessage *request);
645 void getDCIScriptList(NXCPMessage *request);
646 void SendDCIInfo(NXCPMessage *pRequest);
647 void sendPerfTabDCIList(NXCPMessage *pRequest);
648 void exportConfiguration(NXCPMessage *pRequest);
649 void importConfiguration(NXCPMessage *pRequest);
650 void sendGraphList(NXCPMessage *request);
651 void saveGraph(NXCPMessage *pRequest);
652 void deleteGraph(NXCPMessage *pRequest);
653 void addCACertificate(NXCPMessage *pRequest);
654 void deleteCertificate(NXCPMessage *pRequest);
655 void updateCertificateComments(NXCPMessage *pRequest);
656 void getCertificateList(UINT32 dwRqId);
657 void queryL2Topology(NXCPMessage *pRequest);
658 void sendSMS(NXCPMessage *pRequest);
659 void SendCommunityList(UINT32 dwRqId);
660 void UpdateCommunityList(NXCPMessage *pRequest);
661 void getPersistantStorage(UINT32 dwRqId);
662 void setPstorageValue(NXCPMessage *pRequest);
663 void deletePstorageValue(NXCPMessage *pRequest);
664 void setConfigCLOB(NXCPMessage *pRequest);
665 void getConfigCLOB(NXCPMessage *pRequest);
666 void registerAgent(NXCPMessage *pRequest);
667 void getServerFile(NXCPMessage *pRequest);
668 void cancelFileMonitoring(NXCPMessage *request);
669 void getAgentFile(NXCPMessage *pRequest);
670 void testDCITransformation(NXCPMessage *pRequest);
671 void sendJobList(UINT32 dwRqId);
672 void cancelJob(NXCPMessage *pRequest);
673 void holdJob(NXCPMessage *pRequest);
674 void unholdJob(NXCPMessage *pRequest);
675 void deployAgentPolicy(NXCPMessage *pRequest, bool uninstallFlag);
676 void getUserCustomAttribute(NXCPMessage *request);
677 void setUserCustomAttribute(NXCPMessage *request);
678 void openServerLog(NXCPMessage *request);
679 void closeServerLog(NXCPMessage *request);
680 void queryServerLog(NXCPMessage *request);
681 void getServerLogQueryData(NXCPMessage *request);
682 void sendUsmCredentials(UINT32 dwRqId);
683 void updateUsmCredentials(NXCPMessage *pRequest);
684 void sendDCIThresholds(NXCPMessage *request);
685 void addClusterNode(NXCPMessage *request);
686 void findNodeConnection(NXCPMessage *request);
687 void findMacAddress(NXCPMessage *request);
688 void findIpAddress(NXCPMessage *request);
689 void findHostname(NXCPMessage *request);
690 void sendLibraryImage(NXCPMessage *request);
691 void updateLibraryImage(NXCPMessage *request);
692 void listLibraryImages(NXCPMessage *request);
693 void deleteLibraryImage(NXCPMessage *request);
694 void executeServerCommand(NXCPMessage *request);
695 void stopServerCommand(NXCPMessage *request);
696 void uploadFileToAgent(NXCPMessage *request);
697 void listServerFileStore(NXCPMessage *request);
698 void processConsoleCommand(NXCPMessage *msg);
699 void openConsole(UINT32 rqId);
700 void closeConsole(UINT32 rqId);
701 void getVlans(NXCPMessage *msg);
702 void receiveFile(NXCPMessage *request);
703 void deleteFile(NXCPMessage *request);
704 void getNetworkPath(NXCPMessage *request);
705 void getNodeComponents(NXCPMessage *request);
706 void getNodeSoftware(NXCPMessage *request);
707 void getWinPerfObjects(NXCPMessage *request);
708 void listMappingTables(NXCPMessage *request);
709 void getMappingTable(NXCPMessage *request);
710 void updateMappingTable(NXCPMessage *request);
711 void deleteMappingTable(NXCPMessage *request);
712 void getWirelessStations(NXCPMessage *request);
713 void getSummaryTables(UINT32 rqId);
714 void getSummaryTableDetails(NXCPMessage *request);
715 void modifySummaryTable(NXCPMessage *request);
716 void deleteSummaryTable(NXCPMessage *request);
717 void querySummaryTable(NXCPMessage *request);
718 void queryAdHocSummaryTable(NXCPMessage *request);
719 void forwardToReportingServer(NXCPMessage *request);
720 void getSubnetAddressMap(NXCPMessage *request);
721 void getEffectiveRights(NXCPMessage *request);
722 void fileManagerControl(NXCPMessage *request);
723 void uploadUserFileToAgent(NXCPMessage *request);
724 void getSwitchForwardingDatabase(NXCPMessage *request);
725 void getRoutingTable(NXCPMessage *request);
726 void getLocationHistory(NXCPMessage *request);
727 void getScreenshot(NXCPMessage *request);
728 void executeScript(NXCPMessage *request);
729 void executeLibraryScript(NXCPMessage *request);
730 void compileScript(NXCPMessage *request);
731 void resyncAgentDciConfiguration(NXCPMessage *request);
732 void cleanAgentDciConfiguration(NXCPMessage *request);
733 void getSchedulerTaskHandlers(NXCPMessage *request);
734 void getScheduledTasks(NXCPMessage *request);
735 void addScheduledTask(NXCPMessage *request);
736 void updateScheduledTask(NXCPMessage *request);
737 void removeScheduledTask(NXCPMessage *request);
738 void getRepositories(NXCPMessage *request);
739 void addRepository(NXCPMessage *request);
740 void modifyRepository(NXCPMessage *request);
741 void deleteRepository(NXCPMessage *request);
742 void getAgentTunnels(NXCPMessage *request);
743 void bindAgentTunnel(NXCPMessage *request);
744 void unbindAgentTunnel(NXCPMessage *request);
745 void getPredictionEngines(NXCPMessage *request);
746 void getPredictedData(NXCPMessage *request);
747 void expandMacros(NXCPMessage *request);
748 #ifdef WITH_ZMQ
749 void zmqManageSubscription(NXCPMessage *request, zmq::SubscriptionType type, bool subscribe);
750 void zmqListSubscriptions(NXCPMessage *request, zmq::SubscriptionType type);
751 #endif
752 void registerServerCommand(CommandExec *command) { m_serverCommands->set(command->getStreamId(), command); }
753
754 void alarmUpdateWorker(Alarm *alarm);
755 void sendActionDBUpdateMessage(NXCP_MESSAGE *msg);
756 void sendObjectUpdate(NetObj *object);
757
758 public:
759 ClientSession(SOCKET hSocket, const InetAddress& addr);
760 ~ClientSession();
761
762 void incRefCount() { InterlockedIncrement(&m_refCount); }
763 void decRefCount() { InterlockedDecrement(&m_refCount); }
764
765 void run();
766
767 void postMessage(NXCPMessage *pMsg) { if (!isTerminated()) m_sendQueue->put(pMsg->serialize((m_dwFlags & CSF_COMPRESSION_ENABLED) != 0)); }
768 bool sendMessage(NXCPMessage *pMsg);
769 void sendRawMessage(NXCP_MESSAGE *pMsg);
770 void sendPollerMsg(UINT32 dwRqId, const TCHAR *pszMsg);
771 BOOL sendFile(const TCHAR *file, UINT32 dwRqId, long offset);
772
773 void writeAuditLog(const TCHAR *subsys, bool success, UINT32 objectId, const TCHAR *format, ...);
774 void writeAuditLogWithValues(const TCHAR *subsys, bool success, UINT32 objectId, const TCHAR *oldValue, const TCHAR *newValue, const TCHAR *format, ...);
775 void writeAuditLogWithValues(const TCHAR *subsys, bool success, UINT32 objectId, json_t *oldValue, json_t *newValue, const TCHAR *format, ...);
776
777 int getId() const { return m_id; }
778 void setId(int id) { if (m_id == -1) m_id = id; }
779
780 int getState() const { return m_state; }
781 const TCHAR *getLoginName() const { return m_loginName; }
782 const TCHAR *getSessionName() const { return m_sessionName; }
783 const TCHAR *getClientInfo() const { return m_clientInfo; }
784 const TCHAR *getWorkstation() const { return m_workstation; }
785 const TCHAR *getWebServerAddress() const { return m_webServerAddress; }
786 UINT32 getUserId() const { return m_dwUserId; }
787 UINT64 getSystemRights() const { return m_dwSystemAccess; }
788 UINT32 getFlags() const { return m_dwFlags; }
789 bool isAuthenticated() const { return (m_dwFlags & CSF_AUTHENTICATED) ? true : false; }
790 bool isTerminated() const { return (m_dwFlags & CSF_TERMINATED) ? true : false; }
791 bool isConsoleOpen() const { return (m_dwFlags & CSF_CONSOLE_OPEN) ? true : false; }
792 bool isCompressionEnabled() const { return (m_dwFlags & CSF_COMPRESSION_ENABLED) ? true : false; }
793 UINT16 getCurrentCmd() const { return m_wCurrentCmd; }
794 int getCipher() const { return (m_pCtx == NULL) ? -1 : m_pCtx->getCipher(); }
795 int getClientType() const { return m_clientType; }
796 time_t getLoginTime() const { return m_loginTime; }
797 bool isSubscribedTo(const TCHAR *channel) const;
798
799 bool checkSysAccessRights(UINT64 requiredAccess) const
800 {
801 return (m_dwUserId == 0) ? true :
802 ((requiredAccess & m_dwSystemAccess) == requiredAccess);
803 }
804
805 void setCustomLock(UINT32 bit, bool value)
806 {
807 if (value)
808 m_dwFlags |= (bit & 0xFF000000);
809 else
810 m_dwFlags &= ~(bit & 0xFF000000);
811 }
812
813 void kill();
814 void notify(UINT32 dwCode, UINT32 dwData = 0);
815
816 void onNewEvent(Event *pEvent);
817 void onSyslogMessage(NX_SYSLOG_RECORD *pRec);
818 void onNewSNMPTrap(NXCPMessage *pMsg);
819 void onObjectChange(NetObj *pObject);
820 void onAlarmUpdate(UINT32 dwCode, const Alarm *alarm);
821 void onActionDBUpdate(UINT32 dwCode, NXC_ACTION *pAction);
822 void onLibraryImageChange(const uuid& guid, bool removed = false);
823 };
824
825 /**
826 * Delayed SQL request
827 */
828 typedef struct
829 {
830 TCHAR *query;
831 int bindCount;
832 BYTE *sqlTypes;
833 TCHAR *bindings[1]; /* actual size determined by bindCount field */
834 } DELAYED_SQL_REQUEST;
835
836 /**
837 * Delayed request for idata_ INSERT
838 */
839 typedef struct
840 {
841 time_t timestamp;
842 UINT32 nodeId;
843 UINT32 dciId;
844 TCHAR value[MAX_RESULT_LENGTH];
845 } DELAYED_IDATA_INSERT;
846
847 /**
848 * Delayed request for raw_dci_values UPDATE
849 */
850 typedef struct
851 {
852 time_t timestamp;
853 UINT32 dciId;
854 TCHAR rawValue[MAX_RESULT_LENGTH];
855 TCHAR transformedValue[MAX_RESULT_LENGTH];
856 } DELAYED_RAW_DATA_UPDATE;
857
858 /**
859 * Graph ACL entry
860 */
861 struct GRAPH_ACL_ENTRY
862 {
863 UINT32 dwGraphId;
864 UINT32 dwUserId;
865 UINT32 dwAccess;
866 };
867
868 /**
869 * Information about graph with name existence and it's ID.
870 */
871 struct GRAPH_ACL_AND_ID
872 {
873 UINT32 graphId;
874 UINT32 status;
875 };
876
877 /**
878 * Thread pool stats
879 */
880 enum ThreadPoolStat
881 {
882 THREAD_POOL_CURR_SIZE,
883 THREAD_POOL_MIN_SIZE,
884 THREAD_POOL_MAX_SIZE,
885 THREAD_POOL_REQUESTS,
886 THREAD_POOL_LOAD,
887 THREAD_POOL_USAGE,
888 THREAD_POOL_LOADAVG_1,
889 THREAD_POOL_LOADAVG_5,
890 THREAD_POOL_LOADAVG_15
891 };
892
893 /**
894 * Server command execution data
895 */
896 class ServerCommandExec : public CommandExec
897 {
898 private:
899 UINT32 m_requestId;
900 ClientSession *m_session;
901
902 virtual void onOutput(const char *text);
903 virtual void endOfOutput();
904
905 public:
906 ServerCommandExec(NXCPMessage *msg, ClientSession *session);
907 ~ServerCommandExec();
908 };
909
910 /**
911 * SNMP Trap parameter map object
912 */
913 class SNMPTrapParameterMapping
914 {
915 private:
916 SNMP_ObjectId *m_objectId; // Trap OID
917 UINT32 m_position; // Trap position
918 UINT32 m_flags;
919 TCHAR m_description[MAX_DB_STRING];
920
921 public:
922 SNMPTrapParameterMapping();
923 SNMPTrapParameterMapping(DB_RESULT mapResult, int row);
924 SNMPTrapParameterMapping(ConfigEntry *entry);
925 SNMPTrapParameterMapping(SNMP_ObjectId *oid, UINT32 flags, TCHAR *description);
926 SNMPTrapParameterMapping(NXCPMessage *msg, UINT32 base);
927 ~SNMPTrapParameterMapping();
928
929 void fillMessage(NXCPMessage *msg, UINT32 base) const;
930
931 SNMP_ObjectId *getOid() const { return m_objectId; }
932 int getPosition() const { return m_position; }
933 bool isPositional() const { return m_objectId == NULL; }
934
935 UINT32 getFlags() const { return m_flags; }
936
937 const TCHAR *getDescription() const { return m_description; }
938 };
939
940 /**
941 * SNMP Trap configuration object
942 */
943 class SNMPTrapConfiguration
944 {
945 private:
946 uuid m_guid; // Trap guid
947 UINT32 m_id; // Entry ID
948 SNMP_ObjectId m_objectId; // Trap OID
949 UINT32 m_eventCode; // Event code
950 ObjectArray<SNMPTrapParameterMapping> m_mappings;
951 TCHAR m_description[MAX_DB_STRING];
952 TCHAR m_userTag[MAX_USERTAG_LENGTH];
953
954 public:
955 SNMPTrapConfiguration();
956 SNMPTrapConfiguration(DB_RESULT trapResult, DB_STATEMENT stmt, int row);
957 SNMPTrapConfiguration(ConfigEntry *entry, const uuid& guid, UINT32 id, UINT32 eventCode);
958 SNMPTrapConfiguration(NXCPMessage *msg);
959 ~SNMPTrapConfiguration();
960
961 void fillMessage(NXCPMessage *msg) const;
962 void fillMessage(NXCPMessage *msg, UINT32 base) const;
963 bool saveParameterMapping(DB_HANDLE hdb);
964 void notifyOnTrapCfgChange(UINT32 code);
965
966 UINT32 getId() const { return m_id; }
967 const uuid& getGuid() const { return m_guid; }
968 const SNMP_ObjectId& getOid() const { return m_objectId; }
969 const SNMPTrapParameterMapping *getParameterMapping(int index) const { return m_mappings.get(index); }
970 int getParameterMappingCount() const { return m_mappings.size(); }
971 UINT32 getEventCode() const { return m_eventCode; }
972 const TCHAR *getDescription() const { return m_description; }
973 const TCHAR *getUserTag() const { return m_userTag; }
974 };
975
976 /**
977 * Watchdog thread state codes
978 */
979 enum WatchdogState
980 {
981 WATCHDOG_UNKNOWN = -1,
982 WATCHDOG_RUNNING = 0,
983 WATCHDOG_SLEEPING = 1,
984 WATCHDOG_NOT_RESPONDING = 2
985 };
986
987 /**
988 * Functions
989 */
990 bool NXCORE_EXPORTABLE ConfigReadStr(const TCHAR *szVar, TCHAR *szBuffer, int iBufSize, const TCHAR *szDefault);
991 bool NXCORE_EXPORTABLE ConfigReadStrEx(DB_HANDLE hdb, const TCHAR *szVar, TCHAR *szBuffer, int iBufSize, const TCHAR *szDefault);
992 #ifdef UNICODE
993 bool NXCORE_EXPORTABLE ConfigReadStrA(const WCHAR *szVar, char *szBuffer, int iBufSize, const char *szDefault);
994 #else
995 #define ConfigReadStrA ConfigReadStr
996 #endif
997 bool NXCORE_EXPORTABLE ConfigReadStrUTF8(const TCHAR *szVar, char *szBuffer, int iBufSize, const char *szDefault);
998 int NXCORE_EXPORTABLE ConfigReadInt(const TCHAR *szVar, int iDefault);
999 int NXCORE_EXPORTABLE ConfigReadIntEx(DB_HANDLE hdb, const TCHAR *szVar, int iDefault);
1000 UINT32 NXCORE_EXPORTABLE ConfigReadULong(const TCHAR *szVar, UINT32 dwDefault);
1001 bool NXCORE_EXPORTABLE ConfigReadByteArray(const TCHAR *pszVar, int *pnArray, int nSize, int nDefault);
1002 bool NXCORE_EXPORTABLE ConfigWriteStr(const TCHAR *szVar, const TCHAR *szValue, bool bCreate, bool isVisible = true, bool needRestart = false);
1003 bool NXCORE_EXPORTABLE ConfigWriteInt(const TCHAR *szVar, int iValue, bool bCreate, bool isVisible = true, bool needRestart = false);
1004 bool NXCORE_EXPORTABLE ConfigWriteULong(const TCHAR *szVar, UINT32 dwValue, bool bCreate, bool isVisible = true, bool needRestart = false);
1005 bool NXCORE_EXPORTABLE ConfigWriteByteArray(const TCHAR *pszVar, int *pnArray, int nSize, bool bCreate, bool isVisible = true, bool needRestart = false);
1006 TCHAR NXCORE_EXPORTABLE *ConfigReadCLOB(const TCHAR *var, const TCHAR *defValue);
1007 bool NXCORE_EXPORTABLE ConfigWriteCLOB(const TCHAR *var, const TCHAR *value, bool bCreate);
1008 bool NXCORE_EXPORTABLE ConfigDelete(const TCHAR *name);
1009
1010 void MetaDataPreLoad();
1011 bool NXCORE_EXPORTABLE MetaDataReadStr(const TCHAR *szVar, TCHAR *szBuffer, int iBufSize, const TCHAR *szDefault);
1012 INT32 NXCORE_EXPORTABLE MetaDataReadInt32(const TCHAR *var, INT32 defaultValue);
1013 bool NXCORE_EXPORTABLE MetaDataWriteStr(const TCHAR *varName, const TCHAR *value);
1014 bool NXCORE_EXPORTABLE MetaDataWriteInt32(const TCHAR *name, INT32 value);
1015
1016 bool NXCORE_EXPORTABLE LoadConfig(int *debugLevel);
1017
1018 void NXCORE_EXPORTABLE Shutdown();
1019 void NXCORE_EXPORTABLE FastShutdown();
1020 BOOL NXCORE_EXPORTABLE Initialize();
1021 THREAD_RESULT NXCORE_EXPORTABLE THREAD_CALL Main(void *);
1022 void NXCORE_EXPORTABLE ShutdownDB();
1023 void InitiateShutdown();
1024
1025 bool NXCORE_EXPORTABLE SleepAndCheckForShutdown(int iSeconds);
1026
1027 void ConsolePrintf(CONSOLE_CTX pCtx, const TCHAR *pszFormat, ...)
1028 #if !defined(UNICODE) && (defined(__GNUC__) || defined(__clang__))
1029 __attribute__ ((format(printf, 2, 3)))
1030 #endif
1031 ;
1032 void ConsoleWrite(CONSOLE_CTX pCtx, const TCHAR *text);
1033 int ProcessConsoleCommand(const TCHAR *pszCmdLine, CONSOLE_CTX pCtx);
1034
1035 void SaveObjects(DB_HANDLE hdb, UINT32 watchdogId, bool saveRuntimeData);
1036 void NXCORE_EXPORTABLE ObjectTransactionStart();
1037 void NXCORE_EXPORTABLE ObjectTransactionEnd();
1038
1039 void NXCORE_EXPORTABLE QueueSQLRequest(const TCHAR *query);
1040 void NXCORE_EXPORTABLE QueueSQLRequest(const TCHAR *query, int bindCount, int *sqlTypes, const TCHAR **values);
1041 void QueueIDataInsert(time_t timestamp, UINT32 nodeId, UINT32 dciId, const TCHAR *value);
1042 void QueueRawDciDataUpdate(time_t timestamp, UINT32 dciId, const TCHAR *rawValue, const TCHAR *transformedValue);
1043 void StartDBWriter();
1044 void StopDBWriter();
1045
1046 void PerfDataStorageRequest(DCItem *dci, time_t timestamp, const TCHAR *value);
1047 void PerfDataStorageRequest(DCTable *dci, time_t timestamp, Table *value);
1048
1049 void DecodeSQLStringAndSetVariable(NXCPMessage *pMsg, UINT32 dwVarId, TCHAR *pszStr);
1050
1051 SNMP_Transport *SnmpCheckCommSettings(UINT32 snmpProxy, const InetAddress& ipAddr, INT16 *version, UINT16 originalPort, SNMP_SecurityContext *originalContext, StringList *customTestOids, UINT32 zoneUIN);
1052 void StrToMac(const TCHAR *pszStr, BYTE *pBuffer);
1053
1054 void InitLocalNetInfo();
1055
1056 ARP_CACHE *GetLocalArpCache();
1057 ARP_CACHE *SnmpGetArpCache(UINT32 dwVersion, SNMP_Transport *pTransport);
1058
1059 InterfaceList *GetLocalInterfaceList();
1060
1061 ROUTING_TABLE *SnmpGetRoutingTable(UINT32 dwVersion, SNMP_Transport *pTransport);
1062
1063 void LoadNetworkDeviceDrivers();
1064 NetworkDeviceDriver *FindDriverForNode(Node *node, SNMP_Transport *pTransport);
1065 NetworkDeviceDriver *FindDriverByName(const TCHAR *name);
1066 void AddDriverSpecificOids(StringList *list);
1067
1068 bool LookupDevicePortLayout(const SNMP_ObjectId& objectId, NDD_MODULE_LAYOUT *layout);
1069
1070 void CheckForMgmtNode();
1071 void CheckPotentialNode(const InetAddress& ipAddr, UINT32 zoneUIN);
1072 Node NXCORE_EXPORTABLE *PollNewNode(const InetAddress& ipAddr, UINT32 creationFlags, UINT16 agentPort,
1073 UINT16 snmpPort, const TCHAR *name, UINT32 agentProxyId, UINT32 snmpProxyId,
1074 UINT32 icmpProxyId, UINT32 sshProxyId, const TCHAR *sshLogin, const TCHAR *sshPassword,
1075 Cluster *cluster, UINT32 zoneUIN, bool doConfPoll, bool discoveredNode);
1076
1077 void NXCORE_EXPORTABLE EnumerateClientSessions(void (*pHandler)(ClientSession *, void *), void *pArg);
1078 void NXCORE_EXPORTABLE NotifyClientSessions(UINT32 dwCode, UINT32 dwData);
1079 void NXCORE_EXPORTABLE NotifyClientSession(UINT32 sessionId, UINT32 dwCode, UINT32 dwData);
1080 void NXCORE_EXPORTABLE NotifyClientGraphUpdate(NXCPMessage *update, UINT32 graphId);
1081 int GetSessionCount(bool includeSystemAccount);
1082 bool IsLoggedIn(UINT32 dwUserId);
1083 bool NXCORE_EXPORTABLE KillClientSession(int id);
1084 void CloseOtherSessions(UINT32 userId, UINT32 thisSession);
1085
1086 void GetSysInfoStr(TCHAR *pszBuffer, int nMaxSize);
1087 InetAddress GetLocalIpAddr();
1088 TCHAR *GetLocalHostName(TCHAR *buffer, size_t bufSize);
1089
1090 InetAddress NXCORE_EXPORTABLE ResolveHostName(UINT32 zoneUIN, const TCHAR *hostname);
1091
1092 BOOL ExecCommand(TCHAR *pszCommand);
1093 BOOL SendMagicPacket(UINT32 dwIpAddr, BYTE *pbMacAddr, int iNumPackets);
1094
1095 BOOL InitIdTable();
1096 UINT32 CreateUniqueId(int iGroup);
1097 QWORD CreateUniqueEventId();
1098 void SaveCurrentFreeId();
1099
1100 void InitMailer();
1101 void ShutdownMailer();
1102 void NXCORE_EXPORTABLE PostMail(const TCHAR *pszRcpt, const TCHAR *pszSubject, const TCHAR *pszText, bool isHtml = false);
1103
1104 void InitSMSSender();
1105 void ShutdownSMSSender();
1106 void NXCORE_EXPORTABLE PostSMS(const TCHAR *pszRcpt, const TCHAR *pszText);
1107
1108 void InitTraps();
1109 void SendTrapsToClient(ClientSession *pSession, UINT32 dwRqId);
1110 void CreateTrapCfgMessage(NXCPMessage *msg);
1111 UINT32 CreateNewTrap(UINT32 *pdwTrapId);
1112 UINT32 UpdateTrapFromMsg(NXCPMessage *pMsg);
1113 UINT32 DeleteTrap(UINT32 dwId);
1114 void CreateTrapExportRecord(String &xml, UINT32 id);
1115 UINT32 ResolveTrapGuid(const uuid& guid);
1116 void AddTrapCfgToList(SNMPTrapConfiguration *trapCfg);
1117
1118 BOOL IsTableTool(UINT32 dwToolId);
1119 BOOL CheckObjectToolAccess(UINT32 dwToolId, UINT32 dwUserId);
1120 UINT32 ExecuteTableTool(UINT32 dwToolId, Node *pNode, UINT32 dwRqId, ClientSession *pSession);
1121 UINT32 DeleteObjectToolFromDB(UINT32 dwToolId);
1122 UINT32 ChangeObjectToolStatus(UINT32 toolId, bool enabled);
1123 UINT32 UpdateObjectToolFromMessage(NXCPMessage *pMsg);
1124 void CreateObjectToolExportRecord(String &xml, UINT32 id);
1125 bool ImportObjectTool(ConfigEntry *config);
1126 UINT32 GetObjectToolsIntoMessage(NXCPMessage *msg, UINT32 userId, bool fullAccess);
1127 UINT32 GetObjectToolDetailsIntoMessage(UINT32 toolId, NXCPMessage *msg);
1128
1129 UINT32 ModifySummaryTable(NXCPMessage *msg, LONG *newId);
1130 UINT32 DeleteSummaryTable(LONG tableId);
1131 Table *QuerySummaryTable(LONG tableId, SummaryTable *adHocDefinition, UINT32 baseObjectId, UINT32 userId, UINT32 *rcc);
1132 bool CreateSummaryTableExportRecord(INT32 id, String &xml);
1133 bool ImportSummaryTable(ConfigEntry *config);
1134
1135 void CreateMessageFromSyslogMsg(NXCPMessage *pMsg, NX_SYSLOG_RECORD *pRec);
1136 void ReinitializeSyslogParser();
1137 void OnSyslogConfigurationChange(const TCHAR *name, const TCHAR *value);
1138
1139 void EscapeString(String &str);
1140
1141 void InitAuditLog();
1142 void NXCORE_EXPORTABLE WriteAuditLog(const TCHAR *subsys, bool isSuccess, UINT32 userId,
1143 const TCHAR *workstation, int sessionId, UINT32 objectId,
1144 const TCHAR *format, ...);
1145 void NXCORE_EXPORTABLE WriteAuditLog2(const TCHAR *subsys, bool isSuccess, UINT32 userId,
1146 const TCHAR *workstation, int sessionId, UINT32 objectId,
1147 const TCHAR *format, va_list args);
1148 void NXCORE_EXPORTABLE WriteAuditLogWithValues(const TCHAR *subsys, bool isSuccess, UINT32 userId,
1149 const TCHAR *workstation, int sessionId, UINT32 objectId,
1150 const TCHAR *oldValue, const TCHAR *newValue,
1151 const TCHAR *format, ...);
1152 void NXCORE_EXPORTABLE WriteAuditLogWithJsonValues(const TCHAR *subsys, bool isSuccess, UINT32 userId,
1153 const TCHAR *workstation, int sessionId, UINT32 objectId,
1154 json_t *oldValue, json_t *newValue,
1155 const TCHAR *format, ...);
1156 void NXCORE_EXPORTABLE WriteAuditLogWithValues2(const TCHAR *subsys, bool isSuccess, UINT32 userId,
1157 const TCHAR *workstation, int sessionId, UINT32 objectId,
1158 const TCHAR *oldValue, const TCHAR *newValue,
1159 const TCHAR *format, va_list args);
1160 void NXCORE_EXPORTABLE WriteAuditLogWithJsonValues2(const TCHAR *subsys, bool isSuccess, UINT32 userId,
1161 const TCHAR *workstation, int sessionId, UINT32 objectId,
1162 json_t *oldValue, json_t *newValue,
1163 const TCHAR *format, va_list args);
1164
1165 bool ValidateConfig(Config *config, UINT32 flags, TCHAR *errorText, int errorTextLen);
1166 UINT32 ImportConfig(Config *config, UINT32 flags);
1167
1168 #ifdef _WITH_ENCRYPTION
1169 X509 *CertificateFromLoginMessage(NXCPMessage *pMsg);
1170 bool ValidateUserCertificate(X509 *cert, const TCHAR *login, const BYTE *challenge,
1171 const BYTE *signature, size_t sigLen, int mappingMethod,
1172 const TCHAR *mappingData);
1173 bool ValidateAgentCertificate(X509 *cert);
1174 void ReloadCertificates();
1175 bool GetCertificateSubjectField(X509 *cert, int nid, TCHAR *buffer, size_t size);
1176 bool GetCertificateCN(X509 *cert, TCHAR *buffer, size_t size);
1177 bool GetCertificateOU(X509 *cert, TCHAR *buffer, size_t size);
1178 String GetCertificateSubjectString(X509 *cert);
1179 bool GetServerCertificateCountry(TCHAR *buffer, size_t size);
1180 bool GetServerCertificateOrganization(TCHAR *buffer, size_t size);
1181 X509 *IssueCertificate(X509_REQ *request, const char *ou, const char *cn, int days);
1182 #endif
1183
1184 #ifndef _WIN32
1185 THREAD_RESULT NXCORE_EXPORTABLE THREAD_CALL SignalHandler(void *);
1186 #endif /* not _WIN32 */
1187
1188 void DbgTestRWLock(RWLOCK hLock, const TCHAR *szName, CONSOLE_CTX console);
1189 void DumpClientSessions(CONSOLE_CTX console);
1190 void DumpMobileDeviceSessions(CONSOLE_CTX console);
1191 void ShowServerStats(CONSOLE_CTX console);
1192 void ShowQueueStats(CONSOLE_CTX console, Queue *pQueue, const TCHAR *pszName);
1193 void ShowThreadPoolPendingQueue(CONSOLE_CTX console, ThreadPool *p, const TCHAR *pszName);
1194 void ShowThreadPool(CONSOLE_CTX console, ThreadPool *p);
1195 LONG GetThreadPoolStat(ThreadPoolStat stat, const TCHAR *param, TCHAR *value);
1196 void DumpProcess(CONSOLE_CTX console);
1197
1198 #define GRAPH_FLAG_TEMPLATE 1
1199
1200 GRAPH_ACL_ENTRY *LoadGraphACL(DB_HANDLE hdb, UINT32 graphId, int *pnACLSize);
1201 GRAPH_ACL_ENTRY *LoadAllGraphACL(DB_HANDLE hdb, int *pnACLSize);
1202 BOOL CheckGraphAccess(GRAPH_ACL_ENTRY *pACL, int nACLSize, UINT32 graphId, UINT32 graphUserId, UINT32 graphDesiredAccess);
1203 UINT32 GetGraphAccessCheckResult(UINT32 graphId, UINT32 graphUserId);
1204 GRAPH_ACL_AND_ID IsGraphNameExists(const TCHAR *graphName);
1205 void FillGraphListMsg(NXCPMessage *msg, UINT32 userId, bool templageGraphs);
1206 void SaveGraph(NXCPMessage *pRequest, UINT32 userId, NXCPMessage *msg);
1207 UINT32 DeleteGraph(UINT32 graphId, UINT32 userId);
1208
1209 #if XMPP_SUPPORTED
1210 void SendXMPPMessage(const TCHAR *rcpt, const TCHAR *text);
1211 #endif
1212
1213 const TCHAR NXCORE_EXPORTABLE *CountryAlphaCode(const TCHAR *code);
1214 const TCHAR NXCORE_EXPORTABLE *CountryName(const TCHAR *code);
1215 const TCHAR NXCORE_EXPORTABLE *CurrencyAlphaCode(const TCHAR *numericCode);
1216 int NXCORE_EXPORTABLE CurrencyExponent(const TCHAR *code);
1217 const TCHAR NXCORE_EXPORTABLE *CurrencyName(const TCHAR *code);
1218
1219 void NXCORE_EXPORTABLE RegisterComponent(const TCHAR *id);
1220 bool NXCORE_EXPORTABLE IsComponentRegistered(const TCHAR *id);
1221
1222 /**
1223 * Watchdog API
1224 */
1225 void WatchdogInit();
1226 void WatchdogShutdown();
1227 UINT32 WatchdogAddThread(const TCHAR *name, time_t notifyInterval);
1228 void WatchdogNotify(UINT32 id);
1229 void WatchdogStartSleep(UINT32 id);
1230 void WatchdogPrintStatus(CONSOLE_CTX console);
1231 WatchdogState WatchdogGetState(const TCHAR *name);
1232 void WatchdogGetThreads(StringList *out);
1233
1234 /**
1235 * Housekeeper control
1236 */
1237 void StartHouseKeeper();
1238 void StopHouseKeeper();
1239 void RunHouseKeeper();
1240
1241 /**
1242 * Alarm category functions
1243 */
1244 void GetAlarmCategories(NXCPMessage *msg);
1245 UINT32 UpdateAlarmCategory(const NXCPMessage *request, UINT32 *returnId);
1246 UINT32 DeleteAlarmCategory(UINT32 id);
1247 bool CheckAlarmCategoryAccess(UINT32 userId, UINT32 categoryId);
1248 void LoadAlarmCategories();
1249
1250 /**
1251 * Alarm summary emails
1252 */
1253 void SendAlarmSummaryEmail(const ScheduledTaskParameters *params);
1254 void EnableAlarmSummaryEmails();
1255
1256 /**
1257 * NXSL script functions
1258 */
1259 UINT32 UpdateScript(const NXCPMessage *request, UINT32 *scriptId);
1260 UINT32 RenameScript(const NXCPMessage *request);
1261 UINT32 DeleteScript(const NXCPMessage *request);
1262
1263 /**
1264 * File monitoring
1265 */
1266 struct MONITORED_FILE
1267 {
1268 TCHAR fileName[MAX_PATH];
1269 ClientSession *session;
1270 UINT32 nodeID;
1271 };
1272
1273 class FileMonitoringList
1274 {
1275 private:
1276 MUTEX m_mutex;
1277 ObjectArray<MONITORED_FILE> m_monitoredFiles;
1278
1279 public:
1280 FileMonitoringList();
1281 ~FileMonitoringList();
1282 void addMonitoringFile(MONITORED_FILE *fileForAdd, Node *obj, AgentConnection *conn);
1283 bool checkDuplicate(MONITORED_FILE *fileForAdd);
1284 ObjectArray<ClientSession>* findClientByFNameAndNodeID(const TCHAR *fileName, UINT32 nodeID);
1285 bool removeMonitoringFile(MONITORED_FILE *fileForRemove);
1286 void removeDisconnectedNode(UINT32 nodeId);
1287
1288 private:
1289 void lock();
1290 void unlock();
1291 };
1292
1293 /**********************
1294 * Distance calculation
1295 **********************/
1296
1297 /**
1298 * Class stores object and distance to it from provided node
1299 */
1300 class ObjectsDistance
1301 {
1302 public:
1303 NetObj *m_obj;
1304 int m_distance;
1305
1306 ObjectsDistance(NetObj *obj, int distance) { m_obj = obj; m_distance = distance; }
1307 ~ObjectsDistance() { m_obj->decRefCount(); }
1308 };
1309
1310 /**
1311 * Calculate nearest objects from current one
1312 * Object ref count will be automatically decreased on array delete
1313 */
1314 ObjectArray<ObjectsDistance> *FindNearestObjects(UINT32 currObjectId, int maxDistance, bool (* filter)(NetObj *object, void *data), void *sortData, int (* calculateRealDistance)(GeoLocation &loc1, GeoLocation &loc2));
1315
1316 /**
1317 * Global variables
1318 */
1319 extern TCHAR NXCORE_EXPORTABLE g_szConfigFile[];
1320 extern TCHAR NXCORE_EXPORTABLE g_szLogFile[];
1321 extern UINT32 g_logRotationMode;
1322 extern UINT64 g_maxLogSize;
1323 extern UINT32 g_logHistorySize;
1324 extern TCHAR g_szDailyLogFileSuffix[64];
1325 extern TCHAR NXCORE_EXPORTABLE g_szDumpDir[];
1326 extern TCHAR NXCORE_EXPORTABLE g_szListenAddress[];
1327 #ifndef _WIN32
1328 extern TCHAR NXCORE_EXPORTABLE g_szPIDFile[];
1329 #endif
1330 extern TCHAR NXCORE_EXPORTABLE g_netxmsdDataDir[];
1331 extern TCHAR NXCORE_EXPORTABLE g_netxmsdLibDir[];
1332 extern UINT32 NXCORE_EXPORTABLE g_processAffinityMask;
1333 extern UINT64 g_serverId;
1334 extern RSA *g_pServerKey;
1335 extern UINT32 g_icmpPingSize;
1336 extern UINT32 g_icmpPingTimeout;
1337 extern UINT32 g_auditFlags;
1338 extern time_t g_serverStartTime;
1339 extern UINT32 g_lockTimeout;
1340 extern UINT32 g_agentCommandTimeout;
1341 extern UINT32 g_thresholdRepeatInterval;
1342 extern int g_requiredPolls;
1343 extern UINT32 g_slmPollingInterval;
1344 extern UINT32 g_offlineDataRelevanceTime;
1345
1346 extern TCHAR g_szDbDriver[];
1347 extern TCHAR g_szDbDrvParams[];
1348 extern TCHAR g_szDbServer[];
1349 extern TCHAR g_szDbLogin[];
1350 extern TCHAR g_szDbPassword[];
1351 extern TCHAR g_szDbName[];
1352 extern TCHAR g_szDbSchema[];
1353 extern DB_DRIVER g_dbDriver;
1354 extern Queue *g_dbWriterQueue;
1355 extern Queue *g_dciDataWriterQueue;
1356 extern Queue *g_dciRawDataWriterQueue;
1357 extern UINT64 g_idataWriteRequests;
1358 extern UINT64 g_rawDataWriteRequests;
1359 extern UINT64 g_otherWriteRequests;
1360
1361 extern int NXCORE_EXPORTABLE g_dbSyntax;
1362 extern FileMonitoringList g_monitoringList;
1363
1364 extern ThreadPool NXCORE_EXPORTABLE *g_mainThreadPool;
1365
1366 #endif /* _nms_core_h_ */