6ba2ffca9f688fa66c9e3b7e775c9e5d9d269f5f
[public/netxms.git] / src / server / include / nms_objects.h
1 /*
2 ** NetXMS - Network Management System
3 ** Copyright (C) 2003-2017 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_objects.h
20 **
21 **/
22
23 #ifndef _nms_objects_h_
24 #define _nms_objects_h_
25
26 #include <nms_agent.h>
27 #include <netxms_maps.h>
28 #include <geolocation.h>
29 #include <jansson.h>
30 #include "nxcore_jobs.h"
31 #include "nms_topo.h"
32
33 /**
34 * Forward declarations of classes
35 */
36 class ClientSession;
37 class Queue;
38 class DataCollectionTarget;
39
40 /**
41 * Global variables used by inline methods
42 */
43 extern UINT32 g_dwDiscoveryPollingInterval;
44 extern UINT32 g_dwStatusPollingInterval;
45 extern UINT32 g_dwConfigurationPollingInterval;
46 extern UINT32 g_dwRoutingTableUpdateInterval;
47 extern UINT32 g_dwTopologyPollingInterval;
48 extern UINT32 g_dwConditionPollingInterval;
49 extern UINT32 g_instancePollingInterval;
50 extern INT16 g_defaultAgentCacheMode;
51
52 /**
53 * Utility functions used by inline methods
54 */
55 bool NXCORE_EXPORTABLE ExecuteQueryOnObject(DB_HANDLE hdb, UINT32 objectId, const TCHAR *query);
56
57 /**
58 * Constants
59 */
60 #define MAX_INTERFACES 4096
61 #define MAX_ATTR_NAME_LEN 128
62 #define INVALID_INDEX 0xFFFFFFFF
63
64 /**
65 * Last events
66 */
67 #define MAX_LAST_EVENTS 8
68
69 #define LAST_EVENT_NODE_DOWN 0
70 #define LAST_EVENT_AGENT_DOWN 1
71
72 /**
73 * Built-in object IDs
74 */
75 #define BUILTIN_OID_NETWORK 1
76 #define BUILTIN_OID_SERVICEROOT 2
77 #define BUILTIN_OID_TEMPLATEROOT 3
78 #define BUILTIN_OID_ZONE0 4
79 #define BUILTIN_OID_POLICYROOT 5
80 #define BUILTIN_OID_NETWORKMAPROOT 6
81 #define BUILTIN_OID_DASHBOARDROOT 7
82 #define BUILTIN_OID_BUSINESSSERVICEROOT 9
83
84 /**
85 * "All zones" pseudo-ID
86 */
87 #define ALL_ZONES ((UINT32)0xFFFFFFFF)
88
89 class AgentTunnel;
90
91 /**
92 * Extended agent connection
93 */
94 class NXCORE_EXPORTABLE AgentConnectionEx : public AgentConnection
95 {
96 protected:
97 UINT32 m_nodeId;
98 AgentTunnel *m_tunnel;
99 AgentTunnel *m_proxyTunnel;
100
101 virtual AbstractCommChannel *createChannel();
102 virtual void onTrap(NXCPMessage *msg);
103 virtual void onSyslogMessage(NXCPMessage *pMsg);
104 virtual void onDataPush(NXCPMessage *msg);
105 virtual void onFileMonitoringData(NXCPMessage *msg);
106 virtual void onSnmpTrap(NXCPMessage *pMsg);
107 virtual UINT32 processCollectedData(NXCPMessage *msg);
108 virtual UINT32 processBulkCollectedData(NXCPMessage *request, NXCPMessage *response);
109 virtual bool processCustomMessage(NXCPMessage *msg);
110
111 virtual ~AgentConnectionEx();
112
113 public:
114 AgentConnectionEx(UINT32 nodeId, const InetAddress& ipAddr, WORD port = AGENT_LISTEN_PORT, int authMethod = AUTH_NONE, const TCHAR *secret = NULL, bool allowCompression = true);
115 AgentConnectionEx(UINT32 nodeId, AgentTunnel *tunnel, int authMethod = AUTH_NONE, const TCHAR *secret = NULL, bool allowCompression = true);
116
117 UINT32 deployPolicy(AgentPolicy *policy);
118 UINT32 uninstallPolicy(AgentPolicy *policy);
119
120 void setTunnel(AgentTunnel *tunnel);
121
122 using AgentConnection::setProxy;
123 void setProxy(AgentTunnel *tunnel, int authMethod, const TCHAR *secret);
124 };
125
126 /**
127 * Poller types
128 */
129 enum PollerType
130 {
131 POLLER_TYPE_STATUS = 0,
132 POLLER_TYPE_CONFIGURATION = 1,
133 POLLER_TYPE_INSTANCE_DISCOVERY = 2,
134 POLLER_TYPE_ROUTING_TABLE = 3,
135 POLLER_TYPE_DISCOVERY = 4,
136 POLLER_TYPE_BUSINESS_SERVICE = 5,
137 POLLER_TYPE_CONDITION = 6,
138 POLLER_TYPE_TOPOLOGY = 7
139 };
140
141 /**
142 * Poller information
143 */
144 class NXCORE_EXPORTABLE PollerInfo
145 {
146 private:
147 PollerType m_type;
148 NetObj *m_object;
149 TCHAR m_status[128];
150
151 public:
152 PollerInfo(PollerType type, NetObj *object) { m_type = type; m_object = object; _tcscpy(m_status, _T("awaiting execution")); }
153 ~PollerInfo();
154
155 PollerType getType() const { return m_type; }
156 NetObj *getObject() const { return m_object; }
157 const TCHAR *getStatus() const { return m_status; }
158
159 void startExecution() { _tcscpy(m_status, _T("started")); }
160 void setStatus(const TCHAR *status) { nx_strncpy(m_status, status, 128); }
161 };
162
163 /**
164 * Status poll types
165 */
166 enum StatusPollType
167 {
168 POLL_ICMP_PING = 0,
169 POLL_SNMP = 1,
170 POLL_NATIVE_AGENT =2
171 };
172
173 /**
174 * Auto bind/apply decisions
175 */
176 enum AutoBindDecision
177 {
178 AutoBindDecision_Ignore = -1,
179 AutoBindDecision_Unbind = 0,
180 AutoBindDecision_Bind = 1
181 };
182
183 /**
184 * Zone types
185 */
186 #define ZONE_TYPE_PASSIVE 0
187 #define ZONE_TYPE_ACTIVE 1
188
189 /**
190 * Template update types
191 */
192 #define APPLY_TEMPLATE 0
193 #define REMOVE_TEMPLATE 1
194
195 /**
196 * Queued template update information
197 */
198 struct TEMPLATE_UPDATE_INFO
199 {
200 int updateType;
201 Template *pTemplate;
202 UINT32 targetId;
203 bool removeDCI;
204 };
205
206 /**
207 * Object index element
208 */
209 struct INDEX_ELEMENT
210 {
211 QWORD key;
212 NetObj *object;
213 };
214
215 /**
216 * Object index
217 */
218 class NXCORE_EXPORTABLE ObjectIndex
219 {
220 private:
221 int m_size;
222 int m_allocated;
223 INDEX_ELEMENT *m_elements;
224 RWLOCK m_lock;
225
226 int findElement(QWORD key);
227
228 public:
229 ObjectIndex();
230 ~ObjectIndex();
231
232 bool put(QWORD key, NetObj *object);
233 void remove(QWORD key);
234 NetObj *get(QWORD key);
235 NetObj *find(bool (*comparator)(NetObj *, void *), void *data);
236 ObjectArray<NetObj> *findObjects(bool (*comparator)(NetObj *, void *), void *data);
237
238 int size();
239 ObjectArray<NetObj> *getObjects(bool updateRefCount, bool (*filter)(NetObj *, void *) = NULL, void *userData = NULL);
240
241 void forEach(void (*callback)(NetObj *, void *), void *data);
242 };
243
244 struct InetAddressIndexEntry;
245
246 /**
247 * Object index by IP address
248 */
249 class NXCORE_EXPORTABLE InetAddressIndex
250 {
251 private:
252 InetAddressIndexEntry *m_root;
253 RWLOCK m_lock;
254
255 public:
256 InetAddressIndex();
257 ~InetAddressIndex();
258
259 bool put(const InetAddress& addr, NetObj *object);
260 bool put(const InetAddressList *addrList, NetObj *object);
261 void remove(const InetAddress& addr);
262 void remove(const InetAddressList *addrList);
263 NetObj *get(const InetAddress& addr);
264 NetObj *find(bool (*comparator)(NetObj *, void *), void *data);
265
266 int size();
267 ObjectArray<NetObj> *getObjects(bool updateRefCount, bool (*filter)(NetObj *, void *) = NULL, void *userData = NULL);
268
269 void forEach(void (*callback)(const InetAddress&, NetObj *, void *), void *data);
270 };
271
272 /**
273 * Node component
274 */
275 class Component
276 {
277 protected:
278 UINT32 m_index;
279 UINT32 m_class;
280 UINT32 m_ifIndex;
281 TCHAR *m_name;
282 TCHAR *m_description;
283 TCHAR *m_model;
284 TCHAR *m_serial;
285 TCHAR *m_vendor;
286 TCHAR *m_firmware;
287 UINT32 m_parentIndex;
288 ObjectArray<Component> m_childs;
289
290 public:
291 Component(UINT32 index, const TCHAR *name);
292 virtual ~Component();
293
294 UINT32 updateFromSnmp(SNMP_Transport *snmp);
295 void buildTree(ObjectArray<Component> *elements);
296
297 UINT32 getIndex() { return m_index; }
298 UINT32 getParentIndex() { return m_parentIndex; }
299 NXSL_Array *getChildrenForNXSL();
300
301 UINT32 getClass() { return m_class; }
302 const TCHAR *getFirmware() { return m_firmware; }
303 const TCHAR *getModel() { return m_model; }
304 const TCHAR *getName() { return m_name; }
305 const TCHAR *getSerial() { return m_serial; }
306 const TCHAR *getVendor() { return m_vendor; }
307
308 UINT32 fillMessage(NXCPMessage *msg, UINT32 baseId);
309
310 void print(CONSOLE_CTX console, int level);
311 };
312
313 /**
314 * Node component tree
315 */
316 class ComponentTree : public RefCountObject
317 {
318 private:
319 Component *m_root;
320
321 public:
322 ComponentTree(Component *root);
323 virtual ~ComponentTree();
324
325 void fillMessage(NXCPMessage *msg, UINT32 baseId);
326 void print(CONSOLE_CTX console) { if (m_root != NULL) m_root->print(console, 0); }
327
328 bool isEmpty() { return m_root == NULL; }
329 Component *getRoot() { return m_root; }
330 };
331
332 /**
333 * Software package information
334 */
335 class SoftwarePackage
336 {
337 private:
338 TCHAR *m_name;
339 TCHAR *m_version;
340 TCHAR *m_vendor;
341 time_t m_date;
342 TCHAR *m_url;
343 TCHAR *m_description;
344
345 SoftwarePackage();
346
347 public:
348 ~SoftwarePackage();
349
350 void fillMessage(NXCPMessage *msg, UINT32 baseId) const;
351
352 const TCHAR *getName() const { return m_name; }
353 const TCHAR *getVersion() const { return m_version; }
354
355 static SoftwarePackage *createFromTableRow(const Table *table, int row);
356 };
357
358 /**
359 * Summary table flags
360 */
361 #define SUMMARY_TABLE_MULTI_INSTANCE 0x0001
362 #define SUMMARY_TABLE_TABLE_DCI_SOURCE 0x0002
363
364 /**
365 * Summary table column flags
366 */
367 #define COLUMN_DEFINITION_REGEXP_MATCH 0x0001
368 #define COLUMN_DEFINITION_MULTIVALUED 0x0002
369
370 /**
371 * Object modification flags
372 */
373 #define MODIFY_RUNTIME 0x0000
374 #define MODIFY_OTHER 0x0001
375 #define MODIFY_CUSTOM_ATTRIBUTES 0x0002
376 #define MODIFY_DATA_COLLECTION 0x0004
377 #define MODIFY_RELATIONS 0x0008
378 #define MODIFY_COMMON_PROPERTIES 0x0010
379 #define MODIFY_ACCESS_LIST 0x0020
380 #define MODIFY_NODE_PROPERTIES 0x0040
381 #define MODIFY_INTERFACE_PROPERTIES 0x0080
382 #define MODIFIED_CLUSTER_RESOURCES 0x0100
383 #define MODIFY_MAP_CONTENT 0x0200
384 #define MODIFY_SENSOR_PROPERTIES 0x0400
385 #define MODIFY_ALL 0xFFFF
386
387 /**
388 * Column definition for DCI summary table
389 */
390 class NXCORE_EXPORTABLE SummaryTableColumn
391 {
392 public:
393 TCHAR m_name[MAX_DB_STRING];
394 TCHAR m_dciName[MAX_PARAM_NAME];
395 UINT32 m_flags;
396 TCHAR m_separator[16];
397
398 SummaryTableColumn(NXCPMessage *msg, UINT32 baseId);
399 SummaryTableColumn(TCHAR *configStr);
400
401 void createExportRecord(String &xml, int id);
402 };
403
404 /**
405 * DCI summary table class
406 */
407 class NXCORE_EXPORTABLE SummaryTable
408 {
409 private:
410 INT32 m_id;
411 uuid m_guid;
412 TCHAR m_title[MAX_DB_STRING];
413 UINT32 m_flags;
414 ObjectArray<SummaryTableColumn> *m_columns;
415 TCHAR *m_filterSource;
416 NXSL_VM *m_filter;
417 AggregationFunction m_aggregationFunction;
418 time_t m_periodStart;
419 time_t m_periodEnd;
420 TCHAR m_menuPath[MAX_DB_STRING];
421 TCHAR m_tableDciName[MAX_PARAM_NAME];
422
423 SummaryTable(INT32 id, DB_RESULT hResult);
424
425 public:
426 static SummaryTable *loadFromDB(INT32 id, UINT32 *rcc);
427
428 SummaryTable(NXCPMessage *msg);
429 ~SummaryTable();
430
431 bool filter(DataCollectionTarget *node);
432 Table *createEmptyResultTable();
433
434 int getNumColumns() const { return m_columns->size(); }
435 SummaryTableColumn *getColumn(int index) const { return m_columns->get(index); }
436 AggregationFunction getAggregationFunction() const { return m_aggregationFunction; }
437 const TCHAR *getTableDciName() const { return m_tableDciName; }
438 time_t getPeriodStart() const { return m_periodStart; }
439 time_t getPeriodEnd() const { return m_periodEnd; }
440 bool isMultiInstance() const { return (m_flags & SUMMARY_TABLE_MULTI_INSTANCE) ? true : false; }
441 bool isTableDciSource() const { return (m_flags & SUMMARY_TABLE_TABLE_DCI_SOURCE) ? true : false; }
442
443 void createExportRecord(String &xml) const;
444 };
445
446 /**
447 * Object-associated URL
448 */
449 class NXCORE_EXPORTABLE ObjectUrl
450 {
451 private:
452 UINT32 m_id;
453 TCHAR *m_url;
454 TCHAR *m_description;
455
456 public:
457 ObjectUrl(NXCPMessage *msg, UINT32 baseId);
458 ObjectUrl(DB_RESULT hResult, int row);
459 ~ObjectUrl();
460
461 void fillMessage(NXCPMessage *msg, UINT32 baseId);
462
463 UINT32 getId() const { return m_id; }
464 const TCHAR *getUrl() const { return m_url; }
465 const TCHAR *getDescription() const { return m_description; }
466
467 json_t *toJson() const;
468 };
469
470 /**
471 * Base class for network objects
472 */
473 class NXCORE_EXPORTABLE NetObj
474 {
475 DISABLE_COPY_CTOR(NetObj)
476
477 private:
478 static void onObjectDeleteCallback(NetObj *object, void *data);
479
480 void getFullChildListInternal(ObjectIndex *list, bool eventSourceOnly);
481
482 protected:
483 UINT32 m_id;
484 uuid m_guid;
485 time_t m_timestamp; // Last change time stamp
486 UINT32 m_dwRefCount; // Number of references. Object can be destroyed only when this counter is zero
487 TCHAR m_name[MAX_OBJECT_NAME];
488 TCHAR *m_comments; // User comments
489 int m_status;
490 int m_statusCalcAlg; // Status calculation algorithm
491 int m_statusPropAlg; // Status propagation algorithm
492 int m_fixedStatus; // Status if propagation is "Fixed"
493 int m_statusShift; // Shift value for "shifted" status propagation
494 int m_statusTranslation[4];
495 int m_statusSingleThreshold;
496 int m_statusThresholds[4];
497 UINT32 m_flags;
498 UINT32 m_runtimeFlags;
499 UINT32 m_state;
500 UINT32 m_modified;
501 bool m_isDeleted;
502 bool m_isHidden;
503 bool m_isSystem;
504 bool m_maintenanceMode;
505 UINT64 m_maintenanceEventId;
506 uuid m_image;
507 MUTEX m_mutexProperties; // Object data access mutex
508 MUTEX m_mutexRefCount; // Reference counter access mutex
509 RWLOCK m_rwlockParentList; // Lock for parent list
510 RWLOCK m_rwlockChildList; // Lock for child list
511 GeoLocation m_geoLocation;
512 PostalAddress *m_postalAddress;
513 ClientSession *m_pollRequestor;
514 UINT32 m_submapId; // Map object which should be open on drill-down request
515 IntegerArray<UINT32> *m_dashboards; // Dashboards associated with this object
516 ObjectArray<ObjectUrl> *m_urls; // URLs associated with this object
517
518 ObjectArray<NetObj> *m_childList; // Array of pointers to child objects
519 ObjectArray<NetObj> *m_parentList; // Array of pointers to parent objects
520
521 AccessList *m_accessList;
522 bool m_inheritAccessRights;
523 MUTEX m_mutexACL;
524
525 IntegerArray<UINT32> *m_trustedNodes;
526
527 StringMap m_customAttributes;
528 StringObjectMap<ModuleData> *m_moduleData;
529
530 void lockProperties() const { MutexLock(m_mutexProperties); }
531 void unlockProperties() const { MutexUnlock(m_mutexProperties); }
532 void lockACL() { MutexLock(m_mutexACL); }
533 void unlockACL() { MutexUnlock(m_mutexACL); }
534 void lockParentList(bool writeLock)
535 {
536 if (writeLock)
537 RWLockWriteLock(m_rwlockParentList, INFINITE);
538 else
539 RWLockReadLock(m_rwlockParentList, INFINITE);
540 }
541 void unlockParentList() { RWLockUnlock(m_rwlockParentList); }
542 void lockChildList(bool writeLock)
543 {
544 if (writeLock)
545 RWLockWriteLock(m_rwlockChildList, INFINITE);
546 else
547 RWLockReadLock(m_rwlockChildList, INFINITE);
548 }
549 void unlockChildList() { RWLockUnlock(m_rwlockChildList); }
550
551 void setModified(UINT32 flags, bool notify = true); // Used to mark object as modified
552
553 bool loadACLFromDB(DB_HANDLE hdb);
554 bool saveACLToDB(DB_HANDLE hdb);
555 bool loadCommonProperties(DB_HANDLE hdb);
556 bool saveCommonProperties(DB_HANDLE hdb);
557 bool loadTrustedNodes(DB_HANDLE hdb);
558 bool saveTrustedNodes(DB_HANDLE hdb);
559 bool executeQueryOnObject(DB_HANDLE hdb, const TCHAR *query) { return ExecuteQueryOnObject(hdb, m_id, query); }
560
561 virtual void prepareForDeletion();
562 virtual void onObjectDelete(UINT32 dwObjectId);
563
564 virtual void fillMessageInternal(NXCPMessage *msg);
565 virtual void fillMessageInternalStage2(NXCPMessage *msg);
566 virtual UINT32 modifyFromMessageInternal(NXCPMessage *msg);
567
568 void addLocationToHistory();
569 bool isLocationTableExists(DB_HANDLE hdb);
570 bool createLocationHistoryTable(DB_HANDLE hdb);
571
572 public:
573 NetObj();
574 virtual ~NetObj();
575
576 virtual int getObjectClass() const { return OBJECT_GENERIC; }
577 virtual const TCHAR *getObjectClassName() const;
578
579 UINT32 getId() const { return m_id; }
580 const TCHAR *getName() const { return m_name; }
581 int getStatus() const { return m_status; }
582 UINT32 getState() const { return m_state; }
583 UINT32 getRuntimeFlags() const { return m_runtimeFlags; }
584 UINT32 getFlags() const { return m_flags; }
585 int getPropagatedStatus();
586 time_t getTimeStamp() const { return m_timestamp; }
587 const uuid& getGuid() const { return m_guid; }
588 const TCHAR *getComments() const { return CHECK_NULL_EX(m_comments); }
589
590 const GeoLocation& getGeoLocation() const { return m_geoLocation; }
591 void setGeoLocation(const GeoLocation& geoLocation);
592
593 const PostalAddress *getPostalAddress() const { return m_postalAddress; }
594 void setPostalAddress(PostalAddress * addr) { lockProperties(); delete m_postalAddress; m_postalAddress = addr; setModified(MODIFY_COMMON_PROPERTIES); unlockProperties(); }
595
596 const uuid& getMapImage() { return m_image; }
597 void setMapImage(const uuid& image) { lockProperties(); m_image = image; setModified(MODIFY_COMMON_PROPERTIES); unlockProperties(); }
598
599 bool isModified() const { return m_modified != 0; }
600 bool isDeleted() const { return m_isDeleted; }
601 bool isOrphaned() const { return m_parentList->size() == 0; }
602 bool isEmpty() const { return m_childList->size() == 0; }
603
604 bool isSystem() const { return m_isSystem; }
605 void setSystemFlag(bool flag) { m_isSystem = flag; }
606 void setFlag(UINT32 flag) { lockProperties(); m_flags |= flag; setModified(MODIFY_COMMON_PROPERTIES); unlockProperties(); }
607 void clearFlag(UINT32 flag) { lockProperties(); m_flags &= ~flag; setModified(MODIFY_COMMON_PROPERTIES); unlockProperties(); }
608
609 UINT32 getRefCount();
610 void incRefCount();
611 void decRefCount();
612
613 bool isChild(UINT32 id);
614 bool isTrustedNode(UINT32 id);
615
616 void addChild(NetObj *object); // Add reference to child object
617 void addParent(NetObj *object); // Add reference to parent object
618
619 void deleteChild(NetObj *object); // Delete reference to child object
620 void deleteParent(NetObj *object); // Delete reference to parent object
621
622 void deleteObject(NetObj *initiator = NULL); // Prepare object for deletion
623
624 bool isHidden() { return m_isHidden; }
625 void hide();
626 void unhide();
627 void markAsModified(UINT32 flags) { lockProperties(); setModified(flags); unlockProperties(); } // external API to mark object as modified
628
629 virtual bool saveToDatabase(DB_HANDLE hdb);
630 virtual bool saveRuntimeData(DB_HANDLE hdb);
631 virtual bool deleteFromDatabase(DB_HANDLE hdb);
632 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
633 virtual void linkObjects();
634
635 void setId(UINT32 dwId) { m_id = dwId; setModified(MODIFY_ALL); }
636 void generateGuid() { m_guid = uuid::generate(); }
637 void setName(const TCHAR *pszName) { lockProperties(); _tcslcpy(m_name, pszName, MAX_OBJECT_NAME); setModified(MODIFY_COMMON_PROPERTIES); unlockProperties(); }
638 void resetStatus() { m_status = STATUS_UNKNOWN; setModified(MODIFY_RUNTIME); }
639 void setComments(TCHAR *text); /* text must be dynamically allocated */
640
641 bool isInMaintenanceMode() const { return m_maintenanceMode; }
642 UINT64 getMaintenanceEventId() const { return m_maintenanceEventId; }
643 virtual void enterMaintenanceMode();
644 virtual void leaveMaintenanceMode();
645
646 void fillMessage(NXCPMessage *msg);
647 UINT32 modifyFromMessage(NXCPMessage *msg);
648
649 virtual void postModify();
650
651 void commentsToMessage(NXCPMessage *pMsg);
652
653 virtual void setMgmtStatus(BOOL bIsManaged);
654 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
655
656 UINT32 getUserRights(UINT32 dwUserId);
657 BOOL checkAccessRights(UINT32 dwUserId, UINT32 dwRequiredRights);
658 void dropUserAccess(UINT32 dwUserId);
659
660 void addChildNodesToList(ObjectArray<Node> *nodeList, UINT32 dwUserId);
661 void addChildDCTargetsToList(ObjectArray<DataCollectionTarget> *dctList, UINT32 dwUserId);
662
663 TCHAR *getCustomAttribute(const TCHAR *name, TCHAR *buffer, size_t size) const;
664 TCHAR *getCustomAttributeCopy(const TCHAR *name) const;
665 NXSL_Value *getCustomAttributeForNXSL(const TCHAR *name) const;
666 NXSL_Value *getCustomAttributesForNXSL() const;
667 void setCustomAttribute(const TCHAR *name, const TCHAR *value);
668 void setCustomAttributePV(const TCHAR *name, TCHAR *value);
669 void deleteCustomAttribute(const TCHAR *name);
670
671 virtual NXSL_Value *createNXSLObject();
672
673 ModuleData *getModuleData(const TCHAR *module);
674 void setModuleData(const TCHAR *module, ModuleData *data);
675
676 ObjectArray<NetObj> *getParentList(int typeFilter);
677 ObjectArray<NetObj> *getChildList(int typeFilter);
678 ObjectArray<NetObj> *getFullChildList(bool eventSourceOnly, bool updateRefCount);
679
680 NetObj *findChildObject(const TCHAR *name, int typeFilter);
681 Node *findChildNode(const InetAddress& addr);
682
683 int getChildCount() { return m_childList->size(); }
684 int getParentCount() { return m_parentList->size(); }
685
686 virtual NXSL_Array *getParentsForNXSL();
687 virtual NXSL_Array *getChildrenForNXSL();
688
689 virtual bool showThresholdSummary();
690 virtual bool isEventSource();
691 virtual bool isDataCollectionTarget();
692
693 void setStatusCalculation(int method, int arg1 = 0, int arg2 = 0, int arg3 = 0, int arg4 = 0);
694 void setStatusPropagation(int method, int arg1 = 0, int arg2 = 0, int arg3 = 0, int arg4 = 0);
695
696 void sendPollerMsg(UINT32 dwRqId, const TCHAR *pszFormat, ...);
697
698 virtual json_t *toJson();
699
700 // Debug methods
701 const TCHAR *dbgGetParentList(TCHAR *szBuffer);
702 const TCHAR *dbgGetChildList(TCHAR *szBuffer);
703
704 static const TCHAR *getObjectClassName(int objectClass);
705 TCHAR *expandText(const TCHAR *textTemplate, const Alarm *alarm, const Event *event, const TCHAR *userName, const StringMap *inputFields);
706 };
707
708 /**
709 * Get object's reference count
710 */
711 inline UINT32 NetObj::getRefCount()
712 {
713 UINT32 dwRefCount;
714
715 MutexLock(m_mutexRefCount);
716 dwRefCount = m_dwRefCount;
717 MutexUnlock(m_mutexRefCount);
718 return dwRefCount;
719 }
720
721 /**
722 * Increment object's reference count
723 */
724 inline void NetObj::incRefCount()
725 {
726 MutexLock(m_mutexRefCount);
727 m_dwRefCount++;
728 MutexUnlock(m_mutexRefCount);
729 }
730
731 /**
732 * Decrement object's reference count
733 */
734 inline void NetObj::decRefCount()
735 {
736 MutexLock(m_mutexRefCount);
737 if (m_dwRefCount > 0)
738 m_dwRefCount--;
739 MutexUnlock(m_mutexRefCount);
740 }
741
742 /**
743 * Data collection template class
744 */
745 class NXCORE_EXPORTABLE Template : public NetObj
746 {
747 protected:
748 ObjectArray<DCObject> *m_dcObjects;
749 int m_dciLockStatus;
750 UINT32 m_dwVersion;
751 bool m_dciListModified;
752 TCHAR m_szCurrDCIOwner[MAX_SESSION_NAME];
753 TCHAR *m_applyFilterSource;
754 NXSL_Program *m_applyFilter;
755 RWLOCK m_dciAccessLock;
756
757 virtual void prepareForDeletion();
758
759 virtual void fillMessageInternal(NXCPMessage *pMsg);
760 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
761
762 virtual void onDataCollectionChange();
763
764 void loadItemsFromDB(DB_HANDLE hdb);
765 void destroyItems();
766 void updateInstanceDiscoveryItems(DCItem *dci);
767
768 void lockDciAccess(bool writeLock) { if (writeLock) { RWLockWriteLock(m_dciAccessLock, INFINITE); } else { RWLockReadLock(m_dciAccessLock, INFINITE); } }
769 void unlockDciAccess() { RWLockUnlock(m_dciAccessLock); }
770
771 void deleteChildDCIs(UINT32 dcObjectId);
772 void destroyItem(DCObject *object, int index);
773
774 public:
775 Template();
776 Template(const TCHAR *pszName);
777 Template(ConfigEntry *config);
778 virtual ~Template();
779
780 virtual int getObjectClass() const { return OBJECT_TEMPLATE; }
781
782 virtual bool saveToDatabase(DB_HANDLE hdb);
783 virtual bool deleteFromDatabase(DB_HANDLE hdb);
784 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
785
786 virtual json_t *toJson();
787
788 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
789
790 int getVersionMajor() { return m_dwVersion >> 16; }
791 int getVersionMinor() { return m_dwVersion & 0xFFFF; }
792
793 int getItemCount() { return m_dcObjects->size(); }
794 bool addDCObject(DCObject *object, bool alreadyLocked = false);
795 bool updateDCObject(UINT32 dwItemId, NXCPMessage *pMsg, UINT32 *pdwNumMaps, UINT32 **ppdwMapIndex, UINT32 **ppdwMapId);
796 bool deleteDCObject(UINT32 dcObjectId, bool needLock);
797 bool setItemStatus(UINT32 dwNumItems, UINT32 *pdwItemList, int iStatus);
798 int getItemType(UINT32 dwItemId);
799 DCObject *getDCObjectById(UINT32 itemId, bool lock = true);
800 DCObject *getDCObjectByGUID(const uuid& guid, bool lock = true);
801 DCObject *getDCObjectByTemplateId(UINT32 tmplItemId);
802 DCObject *getDCObjectByIndex(int index);
803 DCObject *getDCObjectByName(const TCHAR *name);
804 DCObject *getDCObjectByDescription(const TCHAR *description);
805 NXSL_Value *getAllDCObjectsForNXSL(const TCHAR *name, const TCHAR *description);
806 bool lockDCIList(int sessionId, const TCHAR *pszNewOwner, TCHAR *pszCurrOwner);
807 bool unlockDCIList(int sessionId);
808 void setDCIModificationFlag() { m_dciListModified = true; }
809 void sendItemsToClient(ClientSession *pSession, UINT32 dwRqId);
810 bool isLockedBySession(int sessionId) { return m_dciLockStatus == sessionId; }
811 IntegerArray<UINT32> *getDCIEventsList();
812 StringSet *getDCIScriptList();
813
814 BOOL applyToTarget(DataCollectionTarget *pNode);
815 AutoBindDecision isApplicable(DataCollectionTarget *object);
816 bool isAutoApplyEnabled() { return (m_flags & TF_AUTO_APPLY) ? true : false; }
817 bool isAutoRemoveEnabled() { return ((m_flags & (TF_AUTO_APPLY | TF_AUTO_REMOVE)) == (TF_AUTO_APPLY | TF_AUTO_REMOVE)) ? true : false; }
818 void setAutoApplyFilter(const TCHAR *filter);
819 void queueUpdate();
820 void queueRemoveFromTarget(UINT32 targetId, bool removeDCI);
821
822 void createExportRecord(String &str);
823 void updateFromImport(ConfigEntry *config);
824
825 bool enumDCObjects(bool (* pfCallback)(DCObject *, UINT32, void *), void *pArg);
826 void associateItems();
827
828 UINT32 getLastValues(NXCPMessage *msg, bool objectTooltipOnly, bool overviewOnly, bool includeNoValueObjects);
829 };
830
831 class Cluster;
832
833 /**
834 * Interface class
835 */
836 class NXCORE_EXPORTABLE Interface : public NetObj
837 {
838 protected:
839 UINT32 m_parentInterfaceId;
840 UINT32 m_index;
841 BYTE m_macAddr[MAC_ADDR_LENGTH];
842 InetAddressList m_ipAddressList;
843 TCHAR m_description[MAX_DB_STRING]; // Interface description - value of ifDescr for SNMP, equals to name for NetXMS agent
844 TCHAR m_alias[MAX_DB_STRING]; // Interface alias - value of ifAlias for SNMP, empty for NetXMS agent
845 UINT32 m_type;
846 UINT32 m_mtu;
847 UINT64 m_speed;
848 UINT32 m_bridgePortNumber; // 802.1D port number
849 UINT32 m_slotNumber; // Vendor/device specific slot number
850 UINT32 m_portNumber; // Vendor/device specific port number
851 UINT32 m_peerNodeId; // ID of peer node object, or 0 if unknown
852 UINT32 m_peerInterfaceId; // ID of peer interface object, or 0 if unknown
853 LinkLayerProtocol m_peerDiscoveryProtocol; // Protocol used to discover peer node
854 INT16 m_adminState; // interface administrative state
855 INT16 m_operState; // interface operational state
856 INT16 m_pendingOperState;
857 INT16 m_confirmedOperState;
858 INT16 m_dot1xPaeAuthState; // 802.1x port auth state
859 INT16 m_dot1xBackendAuthState; // 802.1x backend auth state
860 UINT64 m_lastDownEventId;
861 int m_pendingStatus;
862 int m_statusPollCount;
863 int m_operStatePollCount;
864 int m_requiredPollCount;
865 UINT32 m_zoneUIN;
866 UINT32 m_pingTime;
867 time_t m_pingLastTimeStamp;
868 int m_ifTableSuffixLen;
869 UINT32 *m_ifTableSuffix;
870
871 void icmpStatusPoll(UINT32 rqId, UINT32 nodeIcmpProxy, Cluster *cluster, InterfaceAdminState *adminState, InterfaceOperState *operState);
872 void paeStatusPoll(UINT32 rqId, SNMP_Transport *pTransport, Node *node);
873
874 protected:
875 virtual void onObjectDelete(UINT32 dwObjectId);
876
877 virtual void fillMessageInternal(NXCPMessage *pMsg);
878 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
879
880 void setExpectedStateInternal(int state);
881
882 public:
883 Interface();
884 Interface(const InetAddressList& addrList, UINT32 zoneUIN, bool bSyntheticMask);
885 Interface(const TCHAR *name, const TCHAR *descr, UINT32 index, const InetAddressList& addrList, UINT32 ifType, UINT32 zoneUIN);
886 virtual ~Interface();
887
888 virtual int getObjectClass() const { return OBJECT_INTERFACE; }
889 virtual bool saveToDatabase(DB_HANDLE hdb);
890 virtual bool deleteFromDatabase(DB_HANDLE hdb);
891 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
892
893 virtual NXSL_Value *createNXSLObject();
894
895 virtual json_t *toJson();
896
897 Node *getParentNode();
898 UINT32 getParentNodeId();
899 UINT32 getParentInterfaceId() const { return m_parentInterfaceId; }
900
901 const InetAddressList *getIpAddressList() { return &m_ipAddressList; }
902 const InetAddress& getFirstIpAddress();
903 UINT32 getZoneUIN() const { return m_zoneUIN; }
904 UINT32 getIfIndex() const { return m_index; }
905 UINT32 getIfType() const { return m_type; }
906 UINT32 getMTU() const { return m_mtu; }
907 UINT64 getSpeed() const { return m_speed; }
908 UINT32 getBridgePortNumber() const { return m_bridgePortNumber; }
909 UINT32 getSlotNumber() const { return m_slotNumber; }
910 UINT32 getPortNumber() const { return m_portNumber; }
911 UINT32 getPeerNodeId() const { return m_peerNodeId; }
912 UINT32 getPeerInterfaceId() const { return m_peerInterfaceId; }
913 LinkLayerProtocol getPeerDiscoveryProtocol() const { return m_peerDiscoveryProtocol; }
914 int getExpectedState() const { return (int)((m_flags & IF_EXPECTED_STATE_MASK) >> 28); }
915 int getAdminState() const { return (int)m_adminState; }
916 int getOperState() const { return (int)m_operState; }
917 int getConfirmedOperState() const { return (int)m_confirmedOperState; }
918 int getDot1xPaeAuthState() const { return (int)m_dot1xPaeAuthState; }
919 int getDot1xBackendAuthState() const { return (int)m_dot1xBackendAuthState; }
920 const TCHAR *getDescription() const { return m_description; }
921 const TCHAR *getAlias() const { return m_alias; }
922 const BYTE *getMacAddr() const { return m_macAddr; }
923 int getIfTableSuffixLen() const { return m_ifTableSuffixLen; }
924 const UINT32 *getIfTableSuffix() const { return m_ifTableSuffix; }
925 UINT32 getPingTime();
926 bool isSyntheticMask() const { return (m_flags & IF_SYNTHETIC_MASK) ? true : false; }
927 bool isPhysicalPort() const { return (m_flags & IF_PHYSICAL_PORT) ? true : false; }
928 bool isLoopback() const { return (m_flags & IF_LOOPBACK) ? true : false; }
929 bool isManuallyCreated() const { return (m_flags & IF_CREATED_MANUALLY) ? true : false; }
930 bool isExcludedFromTopology() const { return (m_flags & (IF_EXCLUDE_FROM_TOPOLOGY | IF_LOOPBACK)) ? true : false; }
931 bool isFake() const { return (m_index == 1) &&
932 (m_type == IFTYPE_OTHER) &&
933 !_tcscmp(m_name, _T("unknown")); }
934 bool isSubInterface() const { return m_parentInterfaceId != 0; }
935
936 UINT64 getLastDownEventId() const { return m_lastDownEventId; }
937 void setLastDownEventId(UINT64 id) { m_lastDownEventId = id; }
938
939 void setMacAddr(const BYTE *macAddr, bool updateMacDB);
940 void setIpAddress(const InetAddress& addr);
941 void setBridgePortNumber(UINT32 bpn) { m_bridgePortNumber = bpn; setModified(MODIFY_INTERFACE_PROPERTIES); }
942 void setSlotNumber(UINT32 slot) { m_slotNumber = slot; setModified(MODIFY_INTERFACE_PROPERTIES); }
943 void setPortNumber(UINT32 port) { m_portNumber = port; setModified(MODIFY_INTERFACE_PROPERTIES); }
944 void setPhysicalPortFlag(bool isPhysical) { if (isPhysical) m_flags |= IF_PHYSICAL_PORT; else m_flags &= ~IF_PHYSICAL_PORT; setModified(MODIFY_INTERFACE_PROPERTIES); }
945 void setManualCreationFlag(bool isManual) { if (isManual) m_flags |= IF_CREATED_MANUALLY; else m_flags &= ~IF_CREATED_MANUALLY; setModified(MODIFY_INTERFACE_PROPERTIES); }
946 void setPeer(Node *node, Interface *iface, LinkLayerProtocol protocol, bool reflection);
947 void clearPeer() { lockProperties(); m_peerNodeId = 0; m_peerInterfaceId = 0; m_peerDiscoveryProtocol = LL_PROTO_UNKNOWN; setModified(MODIFY_INTERFACE_PROPERTIES); unlockProperties(); }
948 void setDescription(const TCHAR *descr) { lockProperties(); nx_strncpy(m_description, descr, MAX_DB_STRING); setModified(MODIFY_INTERFACE_PROPERTIES); unlockProperties(); }
949 void setAlias(const TCHAR *alias) { lockProperties(); nx_strncpy(m_alias, alias, MAX_DB_STRING); setModified(MODIFY_INTERFACE_PROPERTIES); unlockProperties(); }
950 void addIpAddress(const InetAddress& addr);
951 void deleteIpAddress(InetAddress addr);
952 void setNetMask(const InetAddress& addr);
953 void setMTU(int mtu) { m_mtu = mtu; setModified(MODIFY_INTERFACE_PROPERTIES); }
954 void setSpeed(UINT64 speed) { m_speed = speed; setModified(MODIFY_INTERFACE_PROPERTIES); }
955 void setIfTableSuffix(int len, const UINT32 *suffix) { lockProperties(); free(m_ifTableSuffix); m_ifTableSuffixLen = len; m_ifTableSuffix = (len > 0) ? (UINT32 *)nx_memdup(suffix, len * sizeof(UINT32)) : NULL; setModified(MODIFY_INTERFACE_PROPERTIES); unlockProperties(); }
956 void setParentInterface(UINT32 parentInterfaceId) { m_parentInterfaceId = parentInterfaceId; setModified(MODIFY_INTERFACE_PROPERTIES); }
957
958 void updateZoneUIN();
959
960 void statusPoll(ClientSession *session, UINT32 rqId, Queue *eventQueue, Cluster *cluster, SNMP_Transport *snmpTransport, UINT32 nodeIcmpProxy);
961
962 UINT32 wakeUp();
963 void setExpectedState(int state) { lockProperties(); setExpectedStateInternal(state); unlockProperties(); }
964 void setExcludeFromTopology(bool excluded);
965 void updatePingData();
966 };
967
968 /**
969 * Network service class
970 */
971 class NXCORE_EXPORTABLE NetworkService : public NetObj
972 {
973 protected:
974 int m_serviceType; // SSH, POP3, etc.
975 Node *m_hostNode; // Pointer to node object which hosts this service
976 UINT32 m_pollerNode; // ID of node object which is used for polling
977 // If 0, m_pHostNode->m_dwPollerNode will be used
978 UINT16 m_proto; // Protocol (TCP, UDP, etc.)
979 UINT16 m_port; // TCP or UDP port number
980 InetAddress m_ipAddress;
981 TCHAR *m_request; // Service-specific request
982 TCHAR *m_response; // Service-specific expected response
983 int m_pendingStatus;
984 int m_pollCount;
985 int m_requiredPollCount;
986 UINT32 m_responseTime; // Response time from last poll
987
988 virtual void onObjectDelete(UINT32 dwObjectId);
989
990 virtual void fillMessageInternal(NXCPMessage *pMsg);
991 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
992
993 public:
994 NetworkService();
995 NetworkService(int iServiceType, WORD wProto, WORD wPort,
996 TCHAR *pszRequest, TCHAR *pszResponse,
997 Node *pHostNode = NULL, UINT32 dwPollerNode = 0);
998 virtual ~NetworkService();
999
1000 virtual int getObjectClass() const { return OBJECT_NETWORKSERVICE; }
1001
1002 virtual json_t *toJson();
1003
1004 virtual bool saveToDatabase(DB_HANDLE hdb);
1005 virtual bool deleteFromDatabase(DB_HANDLE hdb);
1006 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
1007
1008 void statusPoll(ClientSession *session, UINT32 rqId, Node *pollerNode, Queue *eventQueue);
1009
1010 UINT32 getResponseTime() { return m_responseTime; }
1011 };
1012
1013 /**
1014 * VPN connector class
1015 */
1016 class NXCORE_EXPORTABLE VPNConnector : public NetObj
1017 {
1018 protected:
1019 UINT32 m_dwPeerGateway; // Object ID of peer gateway
1020 ObjectArray<InetAddress> *m_localNetworks;
1021 ObjectArray<InetAddress> *m_remoteNetworks;
1022
1023 virtual void fillMessageInternal(NXCPMessage *pMsg);
1024 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
1025
1026 Node *getParentNode();
1027
1028 public:
1029 VPNConnector();
1030 VPNConnector(bool hidden);
1031 virtual ~VPNConnector();
1032
1033 virtual int getObjectClass() const { return OBJECT_VPNCONNECTOR; }
1034
1035 virtual json_t *toJson();
1036
1037 virtual bool saveToDatabase(DB_HANDLE hdb);
1038 virtual bool deleteFromDatabase(DB_HANDLE hdb);
1039 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
1040
1041 bool isLocalAddr(const InetAddress& addr);
1042 bool isRemoteAddr(const InetAddress& addr);
1043 UINT32 getPeerGatewayId() const { return m_dwPeerGateway; }
1044 InetAddress getPeerGatewayAddr();
1045 };
1046
1047 /**
1048 * Data collection proxy information structure
1049 */
1050 struct ProxyInfo
1051 {
1052 UINT32 proxyId;
1053 NXCPMessage *msg;
1054 UINT32 fieldId;
1055 UINT32 count;
1056 UINT32 nodeInfoFieldId;
1057 UINT32 nodeInfoCount;
1058 };
1059
1060 /**
1061 * Common base class for all objects capable of collecting data
1062 */
1063 class NXCORE_EXPORTABLE DataCollectionTarget : public Template
1064 {
1065 protected:
1066 IntegerArray<UINT32> *m_deletedItems;
1067 IntegerArray<UINT32> *m_deletedTables;
1068 UINT32 m_pingTime;
1069 time_t m_pingLastTimeStamp;
1070 time_t m_lastConfigurationPoll;
1071 time_t m_lastStatusPoll;
1072 time_t m_lastInstancePoll;
1073 MUTEX m_hPollerMutex;
1074
1075 virtual void fillMessageInternal(NXCPMessage *pMsg);
1076 virtual void fillMessageInternalStage2(NXCPMessage *pMsg);
1077 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
1078
1079 virtual bool isDataCollectionDisabled();
1080 virtual void updatePingData();
1081
1082 virtual void statusPoll(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1083 virtual void configurationPoll(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1084 virtual void instanceDiscoveryPoll(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1085
1086 virtual StringMap *getInstanceList(DCObject *dco);
1087 void doInstanceDiscovery(UINT32 requestId);
1088 bool updateInstances(DCObject *root, StringMap *instances, UINT32 requestId);
1089
1090 void pollerLock() { MutexLock(m_hPollerMutex); }
1091 void pollerUnlock() { MutexUnlock(m_hPollerMutex); }
1092
1093 NetObj *objectFromParameter(const TCHAR *param);
1094
1095 NXSL_VM *runDataCollectionScript(const TCHAR *param, DataCollectionTarget *targetObject);
1096
1097 void applyUserTemplates();
1098 void updateContainerMembership();
1099
1100 void getItemDciValuesSummary(SummaryTable *tableDefinition, Table *tableData);
1101 void getTableDciValuesSummary(SummaryTable *tableDefinition, Table *tableData);
1102
1103 void addProxyDataCollectionElement(ProxyInfo *info, const DCObject *dco);
1104 void addProxySnmpTarget(ProxyInfo *info, const Node *node);
1105 virtual void collectProxyInfo(ProxyInfo *info);
1106 static void collectProxyInfoCallback(NetObj *object, void *data);
1107
1108 public:
1109 DataCollectionTarget();
1110 DataCollectionTarget(const TCHAR *name);
1111 virtual ~DataCollectionTarget();
1112
1113 virtual bool deleteFromDatabase(DB_HANDLE hdb);
1114
1115 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
1116 virtual bool isDataCollectionTarget();
1117
1118 virtual void enterMaintenanceMode();
1119 virtual void leaveMaintenanceMode();
1120
1121 virtual UINT32 getInternalItem(const TCHAR *param, size_t bufSize, TCHAR *buffer);
1122 virtual UINT32 getScriptItem(const TCHAR *param, size_t bufSize, TCHAR *buffer, DataCollectionTarget *targetObject);
1123 virtual UINT32 getScriptTable(const TCHAR *param, Table **result, DataCollectionTarget *targetObject);
1124
1125 virtual UINT32 getEffectiveSourceNode(DCObject *dco);
1126
1127 virtual json_t *toJson();
1128
1129 UINT32 getListFromScript(const TCHAR *param, StringList **list, DataCollectionTarget *targetObject);
1130 UINT32 getStringMapFromScript(const TCHAR *param, StringMap **map, DataCollectionTarget *targetObject);
1131
1132 UINT32 getTableLastValues(UINT32 dciId, NXCPMessage *msg);
1133 UINT32 getThresholdSummary(NXCPMessage *msg, UINT32 baseId);
1134 UINT32 getPerfTabDCIList(NXCPMessage *pMsg);
1135 void getDciValuesSummary(SummaryTable *tableDefinition, Table *tableData);
1136
1137 void updateDciCache();
1138 void updateDCItemCacheSize(UINT32 dciId, UINT32 conditionId = 0);
1139 void cleanDCIData(DB_HANDLE hdb);
1140 void queueItemsForPolling();
1141 bool processNewDCValue(DCObject *dco, time_t currTime, const void *value);
1142 void scheduleItemDataCleanup(UINT32 dciId);
1143 void scheduleTableDataCleanup(UINT32 dciId);
1144
1145 bool applyTemplateItem(UINT32 dwTemplateId, DCObject *dcObject);
1146 void cleanDeletedTemplateItems(UINT32 dwTemplateId, UINT32 dwNumItems, UINT32 *pdwItemList);
1147 virtual void unbindFromTemplate(UINT32 dwTemplateId, bool removeDCI);
1148
1149 virtual bool isEventSource();
1150
1151 int getMostCriticalDCIStatus();
1152
1153 UINT32 getPingTime();
1154 void setNewNodeFlag() { m_runtimeFlags |= DCDF_POLL_NEW_NODE; }
1155
1156 void statusPollWorkerEntry(PollerInfo *poller);
1157 void statusPollWorkerEntry(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1158 void statusPollPollerEntry(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1159 virtual bool isReadyForStatusPoll();
1160 void lockForStatusPoll();
1161 void unlockForStatusPoll();
1162
1163 void configurationPollWorkerEntry(PollerInfo *poller);
1164 void configurationPollWorkerEntry(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1165 virtual bool isReadyForConfigurationPoll();
1166 void lockForConfigurationPoll();
1167 void unlockForConfigurationPoll();
1168
1169 void instanceDiscoveryPollWorkerEntry(PollerInfo *poller);
1170 void instanceDiscoveryPollWorkerEntry(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1171 virtual bool isReadyForInstancePoll();
1172 void lockForInstancePoll();
1173 void unlockForInstancePoll();
1174
1175 void executeHookScript(const TCHAR *hookName);
1176 };
1177
1178 inline bool DataCollectionTarget::isReadyForInstancePoll()
1179 {
1180 if (m_isDeleted)
1181 return false;
1182 return (m_status != STATUS_UNMANAGED) &&
1183 (!(m_flags & DCF_DISABLE_CONF_POLL)) &&
1184 (!(m_runtimeFlags & DCDF_QUEUED_FOR_INSTANCE_POLL)) &&
1185 (!(m_runtimeFlags & DCDF_DELETE_IN_PROGRESS)) &&
1186 (m_runtimeFlags & DCDF_CONFIGURATION_POLL_PASSED) &&
1187 (!(m_runtimeFlags & DCDF_POLL_NEW_NODE)) &&
1188 ((UINT32)(time(NULL) - m_lastInstancePoll) > g_instancePollingInterval);
1189
1190 }
1191
1192 inline void DataCollectionTarget::lockForInstancePoll()
1193 {
1194 lockProperties();
1195 m_runtimeFlags |= DCDF_QUEUED_FOR_INSTANCE_POLL;
1196 unlockProperties();
1197 }
1198
1199 inline void DataCollectionTarget::unlockForInstancePoll()
1200 {
1201 lockProperties();
1202 m_runtimeFlags &= ~DCDF_QUEUED_FOR_INSTANCE_POLL;
1203 unlockProperties();
1204 }
1205
1206 inline bool DataCollectionTarget::isReadyForConfigurationPoll()
1207 {
1208
1209 if (m_isDeleted)
1210 return false;
1211 if (m_runtimeFlags & DCDF_FORCE_CONFIGURATION_POLL)
1212 {
1213 m_runtimeFlags &= ~DCDF_FORCE_CONFIGURATION_POLL;
1214 return true;
1215 }
1216 return (m_status != STATUS_UNMANAGED) &&
1217 (!(m_flags & DCF_DISABLE_CONF_POLL)) &&
1218 (!(m_runtimeFlags & DCDF_QUEUED_FOR_CONFIGURATION_POLL)) &&
1219 (!(m_runtimeFlags & DCDF_DELETE_IN_PROGRESS)) &&
1220 ((UINT32)(time(NULL) - m_lastConfigurationPoll) > g_dwConfigurationPollingInterval);
1221 }
1222
1223 inline void DataCollectionTarget::lockForConfigurationPoll()
1224 {
1225 lockProperties();
1226 m_runtimeFlags |= DCDF_QUEUED_FOR_CONFIGURATION_POLL;
1227 unlockProperties();
1228 }
1229
1230 inline void DataCollectionTarget::unlockForConfigurationPoll()
1231 {
1232 lockProperties();
1233 m_runtimeFlags &= ~DCDF_QUEUED_FOR_CONFIGURATION_POLL;
1234 unlockProperties();
1235 }
1236
1237 inline bool DataCollectionTarget::isReadyForStatusPoll()
1238 {
1239 if (m_isDeleted)
1240 return false;
1241 if (m_runtimeFlags & DCDF_FORCE_STATUS_POLL)
1242 {
1243 m_runtimeFlags &= ~DCDF_FORCE_STATUS_POLL;
1244 return true;
1245 }
1246 return (m_status != STATUS_UNMANAGED) &&
1247 (!(m_flags & DCF_DISABLE_STATUS_POLL)) &&
1248 (!(m_runtimeFlags & DCDF_QUEUED_FOR_STATUS_POLL)) &&
1249 (!(m_runtimeFlags & DCDF_DELETE_IN_PROGRESS)) &&
1250 (!(m_runtimeFlags & DCDF_POLL_NEW_NODE)) &&
1251 ((UINT32)(time(NULL) - m_lastStatusPoll) > g_dwStatusPollingInterval);
1252 }
1253 inline void DataCollectionTarget::lockForStatusPoll()
1254 {
1255 lockProperties();
1256 m_runtimeFlags |= DCDF_QUEUED_FOR_STATUS_POLL;
1257 unlockProperties();
1258 }
1259
1260 inline void DataCollectionTarget::unlockForStatusPoll()
1261 {
1262 lockProperties();
1263 m_runtimeFlags &= ~DCDF_QUEUED_FOR_STATUS_POLL;
1264 unlockProperties();
1265 }
1266
1267 /**
1268 * Mobile device class
1269 */
1270 class NXCORE_EXPORTABLE MobileDevice : public DataCollectionTarget
1271 {
1272 protected:
1273 time_t m_lastReportTime;
1274 TCHAR *m_deviceId;
1275 TCHAR *m_vendor;
1276 TCHAR *m_model;
1277 TCHAR *m_serialNumber;
1278 TCHAR *m_osName;
1279 TCHAR *m_osVersion;
1280 TCHAR *m_userId;
1281 LONG m_batteryLevel;
1282 InetAddress m_ipAddress;
1283
1284 virtual void fillMessageInternal(NXCPMessage *pMsg);
1285 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
1286
1287 public:
1288 MobileDevice();
1289 MobileDevice(const TCHAR *name, const TCHAR *deviceId);
1290 virtual ~MobileDevice();
1291
1292 virtual int getObjectClass() const { return OBJECT_MOBILEDEVICE; }
1293
1294 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
1295 virtual bool saveToDatabase(DB_HANDLE hdb);
1296 virtual bool deleteFromDatabase(DB_HANDLE hdb);
1297
1298 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
1299
1300 virtual NXSL_Value *createNXSLObject();
1301
1302 virtual json_t *toJson();
1303
1304 void updateSystemInfo(NXCPMessage *msg);
1305 void updateStatus(NXCPMessage *msg);
1306
1307 const TCHAR *getDeviceId() { return CHECK_NULL_EX(m_deviceId); }
1308 const TCHAR *getVendor() { return CHECK_NULL_EX(m_vendor); }
1309 const TCHAR *getModel() { return CHECK_NULL_EX(m_model); }
1310 const TCHAR *getSerialNumber() { return CHECK_NULL_EX(m_serialNumber); }
1311 const TCHAR *getOsName() { return CHECK_NULL_EX(m_osName); }
1312 const TCHAR *getOsVersion() { return CHECK_NULL_EX(m_osVersion); }
1313 const TCHAR *getUserId() { return CHECK_NULL_EX(m_userId); }
1314 const LONG getBatteryLevel() { return m_batteryLevel; }
1315
1316 virtual UINT32 getInternalItem(const TCHAR *param, size_t bufSize, TCHAR *buffer);
1317
1318 virtual bool isReadyForStatusPoll() { return false; }
1319 virtual bool isReadyForConfigurationPoll() { return false; }
1320 virtual bool isReadyForInstancePoll() { return false; }
1321 };
1322
1323 /**
1324 * Access point class
1325 */
1326 class NXCORE_EXPORTABLE AccessPoint : public DataCollectionTarget
1327 {
1328 protected:
1329 UINT32 m_index;
1330 InetAddress m_ipAddress;
1331 UINT32 m_nodeId;
1332 BYTE m_macAddr[MAC_ADDR_LENGTH];
1333 TCHAR *m_vendor;
1334 TCHAR *m_model;
1335 TCHAR *m_serialNumber;
1336 ObjectArray<RadioInterfaceInfo> *m_radioInterfaces;
1337 AccessPointState m_apState;
1338 AccessPointState m_prevState;
1339
1340 virtual void fillMessageInternal(NXCPMessage *pMsg);
1341 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
1342
1343 virtual void updatePingData();
1344
1345 public:
1346 AccessPoint();
1347 AccessPoint(const TCHAR *name, UINT32 index, const BYTE *macAddr);
1348 virtual ~AccessPoint();
1349
1350 virtual int getObjectClass() const { return OBJECT_ACCESSPOINT; }
1351
1352 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
1353 virtual bool saveToDatabase(DB_HANDLE hdb);
1354 virtual bool deleteFromDatabase(DB_HANDLE hdb);
1355
1356 virtual json_t *toJson();
1357
1358 void statusPollFromController(ClientSession *session, UINT32 rqId, Queue *eventQueue, Node *controller, SNMP_Transport *snmpTransport);
1359
1360 UINT32 getIndex() { return m_index; }
1361 const BYTE *getMacAddr() { return m_macAddr; }
1362 const InetAddress& getIpAddress() { return m_ipAddress; }
1363 bool isMyRadio(int rfIndex);
1364 bool isMyRadio(const BYTE *macAddr);
1365 void getRadioName(int rfIndex, TCHAR *buffer, size_t bufSize);
1366 AccessPointState getState() { return m_apState; }
1367 Node *getParentNode();
1368
1369 void attachToNode(UINT32 nodeId);
1370 void setIpAddress(const InetAddress& addr) { lockProperties(); m_ipAddress = addr; setModified(MODIFY_OTHER); unlockProperties(); }
1371 void updateRadioInterfaces(const ObjectArray<RadioInterfaceInfo> *ri);
1372 void updateInfo(const TCHAR *vendor, const TCHAR *model, const TCHAR *serialNumber);
1373 void updateState(AccessPointState state);
1374
1375 virtual bool isReadyForStatusPoll() { return false; }
1376 virtual bool isReadyForConfigurationPoll() { return false; }
1377 virtual bool isReadyForInstancePoll() { return false; }
1378 };
1379
1380 /**
1381 * Cluster class
1382 */
1383 class NXCORE_EXPORTABLE Cluster : public DataCollectionTarget
1384 {
1385 protected:
1386 UINT32 m_dwClusterType;
1387 ObjectArray<InetAddress> *m_syncNetworks;
1388 UINT32 m_dwNumResources;
1389 CLUSTER_RESOURCE *m_pResourceList;
1390 UINT32 m_zoneUIN;
1391
1392 virtual void fillMessageInternal(NXCPMessage *pMsg);
1393 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
1394
1395 virtual void onDataCollectionChange();
1396
1397 virtual void statusPoll(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1398 virtual void configurationPoll(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1399
1400 UINT32 getResourceOwnerInternal(UINT32 id, const TCHAR *name);
1401
1402 public:
1403 Cluster();
1404 Cluster(const TCHAR *pszName, UINT32 zoneUIN);
1405 virtual ~Cluster();
1406
1407 virtual int getObjectClass() const { return OBJECT_CLUSTER; }
1408 virtual bool saveToDatabase(DB_HANDLE hdb);
1409 virtual bool deleteFromDatabase(DB_HANDLE hdb);
1410 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
1411 virtual bool showThresholdSummary();
1412
1413 virtual bool isReadyForInstancePoll() { return false; }
1414
1415 virtual void unbindFromTemplate(UINT32 dwTemplateId, bool removeDCI);
1416
1417 virtual NXSL_Value *createNXSLObject();
1418
1419 virtual json_t *toJson();
1420
1421 bool isSyncAddr(const InetAddress& addr);
1422 bool isVirtualAddr(const InetAddress& addr);
1423 bool isResourceOnNode(UINT32 dwResource, UINT32 dwNode);
1424 UINT32 getResourceOwner(UINT32 resourceId) { return getResourceOwnerInternal(resourceId, NULL); }
1425 UINT32 getResourceOwner(const TCHAR *resourceName) { return getResourceOwnerInternal(0, resourceName); }
1426 UINT32 getZoneUIN() const { return m_zoneUIN; }
1427
1428 UINT32 collectAggregatedData(DCItem *item, TCHAR *buffer);
1429 UINT32 collectAggregatedData(DCTable *table, Table **result);
1430
1431 NXSL_Array *getNodesForNXSL();
1432 };
1433
1434 /**
1435 * Chassis (represents physical chassis)
1436 */
1437 class NXCORE_EXPORTABLE Chassis : public DataCollectionTarget
1438 {
1439 protected:
1440 UINT32 m_controllerId;
1441 INT16 m_rackHeight;
1442 INT16 m_rackPosition;
1443 UINT32 m_rackId;
1444 uuid m_rackImage;
1445
1446 virtual void fillMessageInternal(NXCPMessage *msg);
1447 virtual UINT32 modifyFromMessageInternal(NXCPMessage *request);
1448
1449 virtual void onDataCollectionChange();
1450 virtual void collectProxyInfo(ProxyInfo *info);
1451
1452 void updateRackBinding();
1453 void updateControllerBinding();
1454
1455 public:
1456 Chassis();
1457 Chassis(const TCHAR *name, UINT32 controllerId);
1458 virtual ~Chassis();
1459
1460 virtual int getObjectClass() const { return OBJECT_CHASSIS; }
1461 virtual bool saveToDatabase(DB_HANDLE hdb);
1462 virtual bool deleteFromDatabase(DB_HANDLE hdb);
1463 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
1464 virtual void linkObjects();
1465 virtual bool showThresholdSummary();
1466 virtual UINT32 getEffectiveSourceNode(DCObject *dco);
1467
1468 virtual bool isReadyForStatusPoll() { return false; }
1469 virtual bool isReadyForConfigurationPoll() { return false; }
1470 virtual bool isReadyForInstancePoll() { return false; }
1471
1472 virtual NXSL_Value *createNXSLObject();
1473
1474 virtual json_t *toJson();
1475
1476 UINT32 getControllerId() const { return m_controllerId; }
1477 UINT32 getRackId() const { return m_rackId; }
1478 INT16 getRackHeight() const { return m_rackHeight; }
1479 INT16 getRackPosition() const { return m_rackPosition; }
1480 bool bindUnderController() { return (m_flags & CHF_BIND_UNDER_CONTROLLER) ? true : false; }
1481
1482 void setBindUnderController(bool doBind);
1483 };
1484
1485 /**
1486 * Sensor communication protocol type
1487 */
1488 #define SENSOR_PROTO_UNKNOWN 0
1489 #define COMM_LORAWAN 1
1490 #define COMM_DLMS 2
1491
1492 /**
1493 * Sensor device class
1494 */
1495 #define SENSOR_CLASS_UNKNOWN 0
1496 #define SENSOR_UPS 1
1497 #define SENSOR_WATER_METER 2
1498 #define SENSOR_ELECTR_METER 3
1499
1500 /**
1501 * Mobile device class
1502 */
1503 class NXCORE_EXPORTABLE Sensor : public DataCollectionTarget
1504 {
1505 protected:
1506 MacAddress m_macAddress;
1507 UINT32 m_deviceClass; // Internal device class UPS, meeter
1508 TCHAR *m_vendor; //Vendoer name lorawan...
1509 UINT32 m_commProtocol; // lorawan, dlms, dlms throuht other protocols
1510 TCHAR *m_xmlConfig; //protocol specific configuration
1511 TCHAR *m_xmlRegConfig; //protocol specific registration configuration (cannot be changed afterwards)
1512 TCHAR *m_serialNumber; //Device serial number
1513 TCHAR *m_deviceAddress; //in case lora - lorawan id
1514 TCHAR *m_metaType;//brief type hot water, elecrticety
1515 TCHAR *m_description; //brief description
1516 time_t m_lastConnectionTime;
1517 UINT32 m_frameCount; //zero when no info
1518 INT32 m_signalStrenght; //+1 when no information(cannot be +)
1519 INT32 m_signalNoise; //*10 from origin number //MAX_INT32 when no value
1520 UINT32 m_frequency; //*10 from origin number // 0 when no value
1521 UINT32 m_proxyNodeId;
1522
1523 virtual void fillMessageInternal(NXCPMessage *msg);
1524 virtual UINT32 modifyFromMessageInternal(NXCPMessage *request);
1525
1526 virtual void statusPoll(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1527 virtual void configurationPoll(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1528
1529 virtual StringMap *getInstanceList(DCObject *dco);
1530
1531 void calculateStatus(BOOL bForcedRecalc = FALSE);
1532
1533 Sensor(TCHAR *name, UINT32 flags, MacAddress macAddress, UINT32 deviceClass, TCHAR *vendor,
1534 UINT32 commProtocol, TCHAR *xmlRegConfig, TCHAR *xmlConfig, TCHAR *serialNumber, TCHAR *deviceAddress,
1535 TCHAR *metaType, TCHAR *description, UINT32 proxyNode);
1536 static Sensor *registerLoraDevice(Sensor *sensor);
1537
1538 public:
1539 Sensor();
1540
1541 virtual ~Sensor();
1542 static Sensor *createSensor(TCHAR *name, NXCPMessage *msg);
1543
1544 virtual int getObjectClass() const { return OBJECT_SENSOR; }
1545
1546 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
1547 virtual bool saveToDatabase(DB_HANDLE hdb);
1548 virtual bool deleteFromDatabase(DB_HANDLE hdb);
1549 virtual void prepareForDeletion();
1550
1551 virtual NXSL_Value *createNXSLObject();
1552 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
1553
1554 const TCHAR *getXmlConfig() const { return m_xmlConfig; }
1555 const TCHAR *getXmlRegConfig() const { return m_xmlRegConfig; }
1556 UINT32 getProxyNodeId() const { return m_proxyNodeId; }
1557 const TCHAR *getDeviceAddress() const { return m_deviceAddress; }
1558 const MacAddress getMacAddress() const { return m_macAddress; }
1559 time_t getLastContact() const { return m_lastConnectionTime; }
1560 UINT32 getSensorClass() const { return m_deviceClass; }
1561 const TCHAR *getVendor() const { return m_vendor; }
1562 UINT32 getCommProtocol() const { return m_commProtocol; }
1563 const TCHAR *getSerialNumber() const { return m_serialNumber; }
1564 const TCHAR *getMetaType() const { return m_metaType; }
1565 const TCHAR *getDescription() const { return m_description; }
1566 UINT32 getFrameCount() const { return m_frameCount; }
1567
1568 UINT32 getItemFromAgent(const TCHAR *szParam, UINT32 dwBufSize, TCHAR *szBuffer);
1569 UINT32 getListFromAgent(const TCHAR *name, StringList **list);
1570
1571 void setProvisoned() { m_state |= SSF_PROVISIONED; }
1572
1573 virtual json_t *toJson();
1574
1575 AgentConnectionEx *getAgentConnection();
1576
1577 void checkDlmsConverterAccessibility();
1578 void prepareDlmsDciParameters(String &parameter);
1579 void prepareLoraDciParameters(String &parameter);
1580 };
1581
1582 class Subnet;
1583 struct ProxyInfo;
1584
1585 /**
1586 * Node subtypes
1587 */
1588 enum NodeType
1589 {
1590 NODE_TYPE_UNKNOWN = 0,
1591 NODE_TYPE_PHYSICAL = 1,
1592 NODE_TYPE_VIRTUAL = 2,
1593 NODE_TYPE_CONTROLLER = 3
1594 };
1595
1596 /**
1597 * Node agent compression modes
1598 */
1599 enum NodeAgentCompressionMode
1600 {
1601 NODE_AGENT_COMPRESSION_DEFAULT = 0,
1602 NODE_AGENT_COMPRESSION_ENABLED = 1,
1603 NODE_AGENT_COMPRESSION_DISABLED = 2
1604 };
1605
1606 /**
1607 * Routing loop event information
1608 */
1609 class RoutingLoopEvent
1610 {
1611 private:
1612 InetAddress m_address;
1613 UINT32 m_nodeId;
1614 UINT64 m_eventId;
1615
1616 public:
1617 RoutingLoopEvent(const InetAddress& address, UINT32 nodeId, UINT64 eventId)
1618 {
1619 m_address = address;
1620 m_nodeId = nodeId;
1621 m_eventId = eventId;
1622 }
1623
1624 const InetAddress& getAddress() const { return m_address; }
1625 UINT32 getNodeId() const { return m_nodeId; }
1626 UINT64 getEventId() const { return m_eventId; }
1627 };
1628
1629 /**
1630 * Proxy types
1631 */
1632 enum ProxyType
1633 {
1634 SNMP_PROXY = 0,
1635 SENSOR_PROXY = 1,
1636 ZONE_PROXY = 2,
1637 MAX_PROXY_TYPE = 3
1638 };
1639
1640 /**
1641 * Node
1642 */
1643 class NXCORE_EXPORTABLE Node : public DataCollectionTarget
1644 {
1645 friend class Subnet;
1646
1647 private:
1648 /**
1649 * Delete agent connection
1650 */
1651 void deleteAgentConnection()
1652 {
1653 if (m_agentConnection != NULL)
1654 {
1655 m_agentConnection->decRefCount();
1656 m_agentConnection = NULL;
1657 }
1658 }
1659
1660 void onSnmpProxyChange(UINT32 oldProxy);
1661
1662 static void onDataCollectionChangeAsyncCallback(void *arg);
1663
1664 protected:
1665 InetAddress m_ipAddress;
1666 TCHAR m_primaryName[MAX_DNS_NAME];
1667 uuid m_tunnelId;
1668 UINT32 m_capabilities;
1669 NodeType m_type;
1670 TCHAR m_subType[MAX_NODE_SUBTYPE_LENGTH];
1671 int m_pendingState;
1672 UINT32 m_pollCountAgent;
1673 UINT32 m_pollCountSNMP;
1674 UINT32 m_pollCountAllDown;
1675 UINT32 m_requiredPollCount;
1676 UINT32 m_zoneUIN;
1677 UINT16 m_agentPort;
1678 INT16 m_agentAuthMethod;
1679 INT16 m_agentCacheMode;
1680 INT16 m_agentCompressionMode; // agent compression mode (enabled/disabled/default)
1681 TCHAR m_szSharedSecret[MAX_SECRET_LENGTH];
1682 INT16 m_iStatusPollType;
1683 INT16 m_snmpVersion;
1684 UINT16 m_snmpPort;
1685 UINT16 m_nUseIfXTable;
1686 SNMP_SecurityContext *m_snmpSecurity;
1687 TCHAR m_agentVersion[MAX_AGENT_VERSION_LEN];
1688 TCHAR m_platformName[MAX_PLATFORM_NAME_LEN];
1689 TCHAR m_snmpObjectId[MAX_OID_LEN * 4];
1690 TCHAR *m_sysDescription; // Agent's System.Uname or SNMP sysDescr
1691 TCHAR *m_sysName; // SNMP sysName
1692 TCHAR *m_sysLocation; // SNMP sysLocation
1693 TCHAR *m_sysContact; // SNMP sysContact
1694 TCHAR *m_lldpNodeId; // lldpLocChassisId combined with lldpLocChassisIdSubtype, or NULL for non-LLDP nodes
1695 ObjectArray<LLDP_LOCAL_PORT_INFO> *m_lldpLocalPortInfo;
1696 NetworkDeviceDriver *m_driver;
1697 DriverData *m_driverData;
1698 ObjectArray<AgentParameterDefinition> *m_paramList; // List of supported parameters
1699 ObjectArray<AgentTableDefinition> *m_tableList; // List of supported tables
1700 time_t m_lastDiscoveryPoll;
1701 time_t m_lastTopologyPoll;
1702 time_t m_lastRTUpdate;
1703 time_t m_failTimeSNMP;
1704 time_t m_failTimeAgent;
1705 time_t m_downSince;
1706 time_t m_bootTime;
1707 time_t m_agentUpTime;
1708 time_t m_lastAgentCommTime;
1709 time_t m_lastAgentConnectAttempt;
1710 MUTEX m_hAgentAccessMutex;
1711 MUTEX m_hSmclpAccessMutex;
1712 MUTEX m_mutexRTAccess;
1713 MUTEX m_mutexTopoAccess;
1714 AgentConnectionEx *m_agentConnection;
1715 ObjectLock<AgentConnectionEx> *m_proxyConnections;
1716 SMCLP_Connection *m_smclpConnection;
1717 UINT64 m_lastAgentTrapId; // ID of last received agent trap
1718 UINT64 m_lastAgentPushRequestId; // ID of last received agent push request
1719 UINT32 m_lastSNMPTrapId;
1720 UINT64 m_lastSyslogMessageId; // ID of last received syslog message
1721 UINT32 m_pollerNode; // Node used for network service polling
1722 UINT32 m_agentProxy; // Node used as proxy for agent connection
1723 UINT32 m_snmpProxy; // Node used as proxy for SNMP requests
1724 UINT32 m_icmpProxy; // Node used as proxy for ICMP ping
1725 UINT64 m_lastEvents[MAX_LAST_EVENTS];
1726 ObjectArray<RoutingLoopEvent> *m_routingLoopEvents;
1727 ROUTING_TABLE *m_pRoutingTable;
1728 ForwardingDatabase *m_fdb;
1729 LinkLayerNeighbors *m_linkLayerNeighbors;
1730 VlanList *m_vlans;
1731 VrrpInfo *m_vrrpInfo;
1732 ObjectArray<WirelessStationInfo> *m_wirelessStations;
1733 int m_adoptedApCount;
1734 int m_totalApCount;
1735 BYTE m_baseBridgeAddress[MAC_ADDR_LENGTH]; // Bridge base address (dot1dBaseBridgeAddress in bridge MIB)
1736 NetworkMapObjectList *m_topology;
1737 time_t m_topologyRebuildTimestamp;
1738 ServerJobQueue *m_jobQueue;
1739 ComponentTree *m_components; // Hardware components
1740 ObjectArray<SoftwarePackage> *m_softwarePackages; // installed software packages
1741 ObjectArray<WinPerfObject> *m_winPerfObjects; // Windows performance objects
1742 AgentConnection *m_fileUpdateConn;
1743 INT16 m_rackHeight;
1744 INT16 m_rackPosition;
1745 UINT32 m_rackId;
1746 uuid m_rackImage;
1747 UINT32 m_chassisId;
1748 INT64 m_syslogMessageCount;
1749 INT64 m_snmpTrapCount;
1750 TCHAR m_sshLogin[MAX_SSH_LOGIN_LEN];
1751 TCHAR m_sshPassword[MAX_SSH_PASSWORD_LEN];
1752 UINT32 m_sshProxy;
1753 UINT32 m_portNumberingScheme;
1754 UINT32 m_portRowCount;
1755
1756 virtual void statusPoll(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1757 virtual void configurationPoll(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1758 virtual void topologyPoll(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1759 virtual void routingTablePoll(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1760
1761 virtual bool isDataCollectionDisabled();
1762 virtual void collectProxyInfo(ProxyInfo *info);
1763
1764 virtual void prepareForDeletion();
1765 virtual void onObjectDelete(UINT32 dwObjectId);
1766
1767 virtual void fillMessageInternal(NXCPMessage *pMsg);
1768 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
1769
1770 virtual void updatePingData();
1771
1772 virtual void onDataCollectionChange();
1773
1774 virtual StringMap *getInstanceList(DCObject *dco);
1775
1776 void agentLock() { MutexLock(m_hAgentAccessMutex); }
1777 void agentUnlock() { MutexUnlock(m_hAgentAccessMutex); }
1778
1779 void smclpLock() { MutexLock(m_hSmclpAccessMutex); }
1780 void smclpUnlock() { MutexUnlock(m_hSmclpAccessMutex); }
1781
1782 void routingTableLock() { MutexLock(m_mutexRTAccess); }
1783 void routingTableUnlock() { MutexUnlock(m_mutexRTAccess); }
1784
1785 BOOL checkSNMPIntegerValue(SNMP_Transport *pTransport, const TCHAR *pszOID, int nValue);
1786 void checkOSPFSupport(SNMP_Transport *pTransport);
1787 void addVrrpInterfaces(InterfaceList *ifList);
1788 BOOL resolveName(BOOL useOnlyDNS);
1789 void setPrimaryIPAddress(const InetAddress& addr);
1790
1791 bool setAgentProxy(AgentConnectionEx *conn);
1792 bool isAgentCompressionAllowed();
1793
1794 UINT32 getInterfaceCount(Interface **ppInterface);
1795
1796 void checkInterfaceNames(InterfaceList *pIfList);
1797 bool filterInterface(InterfaceInfo *info);
1798 Subnet *createSubnet(InetAddress& baseAddr, bool syntheticMask);
1799 void checkAgentPolicyBinding(AgentConnection *conn);
1800 void updatePrimaryIpAddr();
1801 bool confPollAgent(UINT32 dwRqId);
1802 bool confPollSnmp(UINT32 dwRqId);
1803 NodeType detectNodeType();
1804 bool updateSoftwarePackages(PollerInfo *poller, UINT32 requestId);
1805 bool querySnmpSysProperty(SNMP_Transport *snmp, const TCHAR *oid, const TCHAR *propName, UINT32 pollRqId, TCHAR **value);
1806 void checkBridgeMib(SNMP_Transport *pTransport);
1807 void checkIfXTable(SNMP_Transport *pTransport);
1808 bool checkNetworkPath(UINT32 requestId);
1809 bool checkNetworkPathLayer2(UINT32 requestId, bool secondPass);
1810 bool checkNetworkPathLayer3(UINT32 requestId, bool secondPass);
1811 bool checkNetworkPathElement(UINT32 nodeId, const TCHAR *nodeType, bool isProxy, UINT32 requestId, bool secondPass);
1812
1813 void syncDataCollectionWithAgent(AgentConnectionEx *conn);
1814
1815 bool updateInterfaceConfiguration(UINT32 rqid, int maskBits);
1816 bool deleteDuplicateInterfaces(UINT32 rqid);
1817 void updatePhysicalContainerBinding(int containerClass, UINT32 containerId);
1818
1819 bool connectToAgent(UINT32 *error = NULL, UINT32 *socketError = NULL, bool *newConnection = NULL, bool forceConnect = false);
1820 void setLastAgentCommTime() { m_lastAgentCommTime = time(NULL); }
1821
1822 void buildIPTopologyInternal(NetworkMapObjectList &topology, int nDepth, UINT32 seedObject, bool vpnLink, bool includeEndNodes);
1823
1824 public:
1825 Node();
1826 Node(const InetAddress& addr, UINT32 flags, UINT32 capabilities, UINT32 agentProxy, UINT32 snmpProxy, UINT32 icmpProxy, UINT32 sshProxy, UINT32 zoneUIN);
1827 virtual ~Node();
1828
1829 virtual int getObjectClass() const { return OBJECT_NODE; }
1830
1831 virtual bool saveToDatabase(DB_HANDLE hdb);
1832 virtual bool saveRuntimeData(DB_HANDLE hdb);
1833 virtual bool deleteFromDatabase(DB_HANDLE hdb);
1834 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
1835
1836 virtual bool isReadyForStatusPoll();
1837 virtual bool isReadyForDiscoveryPoll();
1838 virtual bool isReadyForRoutePoll();
1839 virtual bool isReadyForTopologyPoll();
1840
1841 virtual NXSL_Value *createNXSLObject();
1842
1843 virtual json_t *toJson();
1844
1845 Cluster *getMyCluster();
1846
1847 const InetAddress& getIpAddress() const { return m_ipAddress; }
1848 UINT32 getZoneUIN() const { return m_zoneUIN; }
1849 NodeType getType() const { return m_type; }
1850 const TCHAR *getSubType() const { return m_subType; }
1851
1852 UINT32 getCapabilities() { return m_capabilities; }
1853 void setCapabilities(UINT32 flag) { lockProperties(); m_capabilities |= flag; setModified(MODIFY_NODE_PROPERTIES); unlockProperties(); }
1854 void clearCapabilities(UINT32 flag) { lockProperties(); m_capabilities &= ~flag; setModified(MODIFY_NODE_PROPERTIES); unlockProperties(); }
1855 void setLocalMgmtFlag() { setCapabilities(NC_IS_LOCAL_MGMT); }
1856 void clearLocalMgmtFlag() { clearCapabilities(NC_IS_LOCAL_MGMT); }
1857
1858 void setType(NodeType type, const TCHAR *subType) { lockProperties(); m_type = type; nx_strncpy(m_subType, subType, MAX_NODE_SUBTYPE_LENGTH); unlockProperties(); }
1859
1860 bool isSNMPSupported() const { return m_capabilities & NC_IS_SNMP ? true : false; }
1861 bool isNativeAgent() const { return m_capabilities & NC_IS_NATIVE_AGENT ? true : false; }
1862 bool isBridge() const { return m_capabilities & NC_IS_BRIDGE ? true : false; }
1863 bool isRouter() const { return m_capabilities & NC_IS_ROUTER ? true : false; }
1864 bool isLocalManagement() const { return m_capabilities & NC_IS_LOCAL_MGMT ? true : false; }
1865 bool isPerVlanFdbSupported() const { return (m_driver != NULL) ? m_driver->isPerVlanFdbSupported() : false; }
1866 bool isWirelessController() const { return m_capabilities & NC_IS_WIFI_CONTROLLER ? true : false; }
1867
1868 const TCHAR *getAgentVersion() const { return m_agentVersion; }
1869 const TCHAR *getPlatformName() const { return m_platformName; }
1870 INT16 getSNMPVersion() const { return m_snmpVersion; }
1871 UINT16 getSNMPPort() const { return m_snmpPort; }
1872 const TCHAR *getSNMPObjectId() const { return m_snmpObjectId; }
1873 const TCHAR *getSysName() const { return CHECK_NULL_EX(m_sysName); }
1874 const TCHAR *getSysDescription() const { return CHECK_NULL_EX(m_sysDescription); }
1875 const TCHAR *getSysContact() const { return CHECK_NULL_EX(m_sysContact); }
1876 const TCHAR *getSysLocation() const { return CHECK_NULL_EX(m_sysLocation); }
1877 time_t getBootTime() const { return m_bootTime; }
1878 const TCHAR *getLLDPNodeId() const { return m_lldpNodeId; }
1879 const BYTE *getBridgeId() const { return m_baseBridgeAddress; }
1880 const TCHAR *getDriverName() const { return (m_driver != NULL) ? m_driver->getName() : _T("GENERIC"); }
1881 UINT16 getAgentPort() const { return m_agentPort; }
1882 INT16 getAgentAuthMethod() const { return m_agentAuthMethod; }
1883 INT16 getAgentCacheMode() const { return (m_state & NSF_CACHE_MODE_NOT_SUPPORTED) ? AGENT_CACHE_OFF : ((m_agentCacheMode == AGENT_CACHE_DEFAULT) ? g_defaultAgentCacheMode : m_agentCacheMode); }
1884 const TCHAR *getSharedSecret() const { return m_szSharedSecret; }
1885 UINT32 getRackId() const { return m_rackId; }
1886 INT16 getRackHeight() const { return m_rackHeight; }
1887 INT16 getRackPosition() const { return m_rackPosition; }
1888 bool hasFileUpdateConnection() const { lockProperties(); bool result = (m_fileUpdateConn != NULL); unlockProperties(); return result; }
1889 UINT32 getIcmpProxy() const { return m_icmpProxy; }
1890 const TCHAR *getSshLogin() const { return m_sshLogin; }
1891 const TCHAR *getSshPassword() const { return m_sshPassword; }
1892 UINT32 getSshProxy() const { return m_sshProxy; }
1893 time_t getLastAgentCommTime() const { return m_lastAgentCommTime; }
1894 const TCHAR *getPrimaryName() const { return m_primaryName; }
1895 const uuid& getTunnelId() const { return m_tunnelId; }
1896 void setNewTunnelBindFlag() { m_runtimeFlags |= NDF_NEW_TUNNEL_BIND; }
1897 void removeNewTunnelBindFlag() { m_runtimeFlags &= ~NDF_NEW_TUNNEL_BIND; }
1898
1899 bool isDown() { return (m_state & DCSF_UNREACHABLE) ? true : false; }
1900 time_t getDownTime() const { return m_downSince; }
1901
1902 void addInterface(Interface *pInterface) { addChild(pInterface); pInterface->addParent(this); }
1903 Interface *createNewInterface(InterfaceInfo *ifInfo, bool manuallyCreated, bool fakeInterface);
1904 Interface *createNewInterface(const InetAddress& ipAddr, BYTE *macAddr, bool fakeInterface);
1905 void deleteInterface(Interface *iface);
1906
1907 void setPrimaryName(const TCHAR *name) { nx_strncpy(m_primaryName, name, MAX_DNS_NAME); }
1908 void setAgentPort(UINT16 port) { m_agentPort = port; }
1909 void setSnmpPort(UINT16 port) { m_snmpPort = port; }
1910 void setSshCredentials(const TCHAR *login, const TCHAR *password);
1911 void changeIPAddress(const InetAddress& ipAddr);
1912 void changeZone(UINT32 newZone);
1913 void setTunnelId(const uuid& tunnelId);
1914 void setFileUpdateConnection(AgentConnection *conn);
1915 void clearDataCollectionConfigFromAgent(AgentConnectionEx *conn);
1916 void forceSyncDataCollectionConfig();
1917 void relatedNodeDataCollectionChanged() { onDataCollectionChange(); }
1918
1919 ARP_CACHE *getArpCache();
1920 InterfaceList *getInterfaceList();
1921 Interface *findInterfaceByIndex(UINT32 ifIndex);
1922 Interface *findInterfaceByName(const TCHAR *name);
1923 Interface *findInterfaceByMAC(const BYTE *macAddr);
1924 Interface *findInterfaceByIP(const InetAddress& addr);
1925 Interface *findInterfaceBySlotAndPort(UINT32 slot, UINT32 port);
1926 Interface *findBridgePort(UINT32 bridgePortNumber);
1927 AccessPoint *findAccessPointByMAC(const BYTE *macAddr);
1928 AccessPoint *findAccessPointByBSSID(const BYTE *bssid);
1929 AccessPoint *findAccessPointByRadioId(int rfIndex);
1930 ObjectArray<WirelessStationInfo> *getWirelessStations();
1931 bool isMyIP(const InetAddress& addr);
1932 void getInterfaceStatusFromSNMP(SNMP_Transport *pTransport, UINT32 dwIndex, int ifTableSuffixLen, UINT32 *ifTableSuffix, InterfaceAdminState *adminState, InterfaceOperState *operState);
1933 void getInterfaceStatusFromAgent(UINT32 dwIndex, InterfaceAdminState *adminState, InterfaceOperState *operState);
1934 ROUTING_TABLE *getRoutingTable();
1935 ROUTING_TABLE *getCachedRoutingTable() { return m_pRoutingTable; }
1936 LinkLayerNeighbors *getLinkLayerNeighbors();
1937 VlanList *getVlans();
1938 bool getNextHop(const InetAddress& srcAddr, const InetAddress& destAddr, InetAddress *nextHop, InetAddress *route, UINT32 *ifIndex, bool *isVpn, TCHAR *name);
1939 bool getOutwardInterface(const InetAddress& destAddr, InetAddress *srcAddr, UINT32 *srcIfIndex);
1940 ComponentTree *getComponents();
1941 bool getLldpLocalPortInfo(UINT32 idType, BYTE *id, size_t idLen, LLDP_LOCAL_PORT_INFO *port);
1942 void showLLDPInfo(CONSOLE_CTX console);
1943
1944 void setRecheckCapsFlag() { m_runtimeFlags |= NDF_RECHECK_CAPABILITIES; }
1945 void setDiscoveryPollTimeStamp();
1946 void topologyPollWorkerEntry(PollerInfo *poller);
1947 void topologyPollWorkerEntry(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1948 void resolveVlanPorts(VlanList *vlanList);
1949 void updateInterfaceNames(ClientSession *pSession, UINT32 dwRqId);
1950 void routingTablePollWorkerEntry(PollerInfo *poller);
1951 void routingTablePollWorkerEntry(PollerInfo *poller, ClientSession *session, UINT32 rqId);
1952 void checkSubnetBinding();
1953 AccessPointState getAccessPointState(AccessPoint *ap, SNMP_Transport *snmpTransport);
1954 void setChassis(UINT32 chassisId);
1955
1956 void lockForDiscoveryPoll();
1957 void lockForRoutePoll();
1958 void lockForTopologyPoll();
1959 void forceConfigurationPoll() { m_runtimeFlags |= DCDF_FORCE_CONFIGURATION_POLL; }
1960
1961 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
1962
1963 bool checkAgentTrapId(UINT64 id);
1964 bool checkSNMPTrapId(UINT32 id);
1965 bool checkSyslogMessageId(UINT64 id);
1966 bool checkAgentPushRequestId(UINT64 id);
1967
1968 bool connectToSMCLP();
1969
1970 virtual UINT32 getInternalItem(const TCHAR *param, size_t bufSize, TCHAR *buffer);
1971
1972 UINT32 getItemFromSNMP(WORD port, const TCHAR *param, size_t bufSize, TCHAR *buffer, int interpretRawValue);
1973 UINT32 getTableFromSNMP(WORD port, const TCHAR *oid, ObjectArray<DCTableColumn> *columns, Table **table);
1974 UINT32 getListFromSNMP(WORD port, const TCHAR *oid, StringList **list);
1975 UINT32 getOIDSuffixListFromSNMP(WORD port, const TCHAR *oid, StringMap **values);
1976 UINT32 getItemFromCheckPointSNMP(const TCHAR *szParam, UINT32 dwBufSize, TCHAR *szBuffer);
1977 UINT32 getItemFromAgent(const TCHAR *szParam, UINT32 dwBufSize, TCHAR *szBuffer);
1978 UINT32 getTableFromAgent(const TCHAR *name, Table **table);
1979 UINT32 getListFromAgent(const TCHAR *name, StringList **list);
1980 UINT32 getItemForClient(int iOrigin, UINT32 userId, const TCHAR *pszParam, TCHAR *pszBuffer, UINT32 dwBufSize);
1981 UINT32 getTableForClient(const TCHAR *name, Table **table);
1982 UINT32 getItemFromSMCLP(const TCHAR *param, UINT32 bufSize, TCHAR *buffer);
1983
1984 virtual NXSL_Array *getParentsForNXSL();
1985 virtual NXSL_Array *getTemplatesForNXSL();
1986 NXSL_Array *getInterfacesForNXSL();
1987
1988 void openParamList(ObjectArray<AgentParameterDefinition> **paramList);
1989 void closeParamList() { unlockProperties(); }
1990
1991 void openTableList(ObjectArray<AgentTableDefinition> **tableList);
1992 void closeTableList() { unlockProperties(); }
1993
1994 AgentConnectionEx *createAgentConnection(bool sendServerId = false);
1995 AgentConnectionEx *acquireProxyConnection(ProxyType type, bool validate = false);
1996 AgentConnectionEx *getConnectionToZoneNodeProxy(bool validate = false);
1997 SNMP_Transport *createSnmpTransport(WORD port = 0, const TCHAR *context = NULL);
1998 SNMP_SecurityContext *getSnmpSecurityContext() const;
1999 UINT32 getEffectiveSnmpProxy() const;
2000
2001 void writeParamListToMessage(NXCPMessage *pMsg, WORD flags);
2002 void writeWinPerfObjectsToMessage(NXCPMessage *msg);
2003 void writePackageListToMessage(NXCPMessage *msg);
2004 void writeWsListToMessage(NXCPMessage *msg);
2005
2006 UINT32 wakeUp();
2007
2008 void addService(NetworkService *pNetSrv) { addChild(pNetSrv); pNetSrv->addParent(this); }
2009 UINT32 checkNetworkService(UINT32 *pdwStatus, const InetAddress& ipAddr, int iServiceType, WORD wPort = 0,
2010 WORD wProto = 0, TCHAR *pszRequest = NULL, TCHAR *pszResponse = NULL, UINT32 *responseTime = NULL);
2011
2012 UINT64 getLastEventId(int index) { return ((index >= 0) && (index < MAX_LAST_EVENTS)) ? m_lastEvents[index] : 0; }
2013 void setLastEventId(int index, UINT64 eventId) { if ((index >= 0) && (index < MAX_LAST_EVENTS)) m_lastEvents[index] = eventId; }
2014 void setRoutingLoopEvent(const InetAddress& address, UINT32 nodeId, UINT64 eventId);
2015
2016 UINT32 callSnmpEnumerate(const TCHAR *pszRootOid,
2017 UINT32 (* pHandler)(SNMP_Variable *, SNMP_Transport *, void *), void *pArg, const TCHAR *context = NULL);
2018
2019 NetworkMapObjectList *getL2Topology();
2020 NetworkMapObjectList *buildL2Topology(UINT32 *pdwStatus, int radius, bool includeEndNodes);
2021 ForwardingDatabase *getSwitchForwardingDatabase();
2022 NetObj *findConnectionPoint(UINT32 *localIfId, BYTE *localMacAddr, int *type);
2023 void addHostConnections(LinkLayerNeighbors *nbs);
2024 void addExistingConnections(LinkLayerNeighbors *nbs);
2025
2026 NetworkMapObjectList *buildIPTopology(UINT32 *pdwStatus, int radius, bool includeEndNodes);
2027
2028 ServerJobQueue *getJobQueue() { return m_jobQueue; }
2029 int getJobCount(const TCHAR *type = NULL) { return m_jobQueue->getJobCount(type); }
2030
2031 DriverData *getDriverData() { return m_driverData; }
2032 void setDriverData(DriverData *data) { m_driverData = data; }
2033
2034 void incSyslogMessageCount();
2035 void incSnmpTrapCount();
2036
2037 static const TCHAR *typeName(NodeType type);
2038
2039 UINT32 getRequiredPolls() const { return m_requiredPollCount; }
2040 };
2041
2042 /**
2043 * Set timestamp of last discovery poll to current time
2044 */
2045 inline void Node::setDiscoveryPollTimeStamp()
2046 {
2047 m_lastDiscoveryPoll = time(NULL);
2048 m_runtimeFlags &= ~NDF_QUEUED_FOR_DISCOVERY_POLL;
2049 }
2050
2051 inline bool Node::isReadyForStatusPoll()
2052 {
2053 if (m_isDeleted)
2054 return false;
2055 if (m_runtimeFlags & DCDF_FORCE_STATUS_POLL)
2056 {
2057 m_runtimeFlags &= ~DCDF_FORCE_STATUS_POLL;
2058 return true;
2059 }
2060 return (m_status != STATUS_UNMANAGED) &&
2061 (!(m_flags & DCF_DISABLE_STATUS_POLL)) &&
2062 (!(m_runtimeFlags & DCDF_QUEUED_FOR_STATUS_POLL)) &&
2063 (!(m_runtimeFlags & DCDF_DELETE_IN_PROGRESS)) &&
2064 (getMyCluster() == NULL) &&
2065 (!(m_runtimeFlags & DCDF_POLL_NEW_NODE)) &&
2066 ((UINT32)(time(NULL) - m_lastStatusPoll) > g_dwStatusPollingInterval);
2067 }
2068
2069 inline bool Node::isReadyForDiscoveryPoll()
2070 {
2071 if (m_isDeleted)
2072 return false;
2073 return (g_flags & AF_ENABLE_NETWORK_DISCOVERY) &&
2074 (m_status != STATUS_UNMANAGED) &&
2075 (!(m_flags & NF_DISABLE_DISCOVERY_POLL)) &&
2076 (!(m_runtimeFlags & NDF_QUEUED_FOR_DISCOVERY_POLL)) &&
2077 (!(m_runtimeFlags & DCDF_DELETE_IN_PROGRESS)) &&
2078 (m_runtimeFlags & DCDF_CONFIGURATION_POLL_PASSED) &&
2079 (!(m_runtimeFlags & DCDF_POLL_NEW_NODE)) &&
2080 ((UINT32)(time(NULL) - m_lastDiscoveryPoll) > g_dwDiscoveryPollingInterval);
2081 }
2082
2083 inline bool Node::isReadyForRoutePoll()
2084 {
2085 if (m_isDeleted)
2086 return false;
2087 return (m_status != STATUS_UNMANAGED) &&
2088 (!(m_flags & NF_DISABLE_ROUTE_POLL)) &&
2089 (!(m_runtimeFlags & NDF_QUEUED_FOR_ROUTE_POLL)) &&
2090 (!(m_runtimeFlags & DCDF_DELETE_IN_PROGRESS)) &&
2091 (m_runtimeFlags & DCDF_CONFIGURATION_POLL_PASSED) &&
2092 (!(m_runtimeFlags & DCDF_POLL_NEW_NODE)) &&
2093 ((UINT32)(time(NULL) - m_lastRTUpdate) > g_dwRoutingTableUpdateInterval);
2094 }
2095
2096 inline bool Node::isReadyForTopologyPoll()
2097 {
2098 if (m_isDeleted)
2099 return false;
2100 return (m_status != STATUS_UNMANAGED) &&
2101 (!(m_flags & NF_DISABLE_TOPOLOGY_POLL)) &&
2102 (!(m_runtimeFlags & NDF_QUEUED_FOR_TOPOLOGY_POLL)) &&
2103 (!(m_runtimeFlags & DCDF_DELETE_IN_PROGRESS)) &&
2104 (m_runtimeFlags & DCDF_CONFIGURATION_POLL_PASSED) &&
2105 (!(m_runtimeFlags & DCDF_POLL_NEW_NODE)) &&
2106 ((UINT32)(time(NULL) - m_lastTopologyPoll) > g_dwTopologyPollingInterval);
2107 }
2108
2109 inline void Node::lockForDiscoveryPoll()
2110 {
2111 lockProperties();
2112 m_runtimeFlags |= NDF_QUEUED_FOR_DISCOVERY_POLL;
2113 unlockProperties();
2114 }
2115
2116 inline void Node::lockForTopologyPoll()
2117 {
2118 lockProperties();
2119 m_runtimeFlags |= NDF_QUEUED_FOR_TOPOLOGY_POLL;
2120 unlockProperties();
2121 }
2122
2123 inline void Node::lockForRoutePoll()
2124 {
2125 lockProperties();
2126 m_runtimeFlags |= NDF_QUEUED_FOR_ROUTE_POLL;
2127 unlockProperties();
2128 }
2129
2130 /**
2131 * Subnet
2132 */
2133 class NXCORE_EXPORTABLE Subnet : public NetObj
2134 {
2135 friend void Node::buildIPTopologyInternal(NetworkMapObjectList &topology, int nDepth, UINT32 seedSubnet, bool vpnLink, bool includeEndNodes);
2136
2137 protected:
2138 InetAddress m_ipAddress;
2139 UINT32 m_zoneUIN;
2140 bool m_bSyntheticMask;
2141
2142 virtual void prepareForDeletion();
2143
2144 virtual void fillMessageInternal(NXCPMessage *pMsg);
2145
2146 void buildIPTopologyInternal(NetworkMapObjectList &topology, int nDepth, UINT32 seedNode, bool includeEndNodes);
2147
2148 public:
2149 Subnet();
2150 Subnet(const InetAddress& addr, UINT32 zoneUIN, bool bSyntheticMask);
2151 virtual ~Subnet();
2152
2153 virtual int getObjectClass() const { return OBJECT_SUBNET; }
2154
2155 virtual bool saveToDatabase(DB_HANDLE hdb);
2156 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2157 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2158
2159 virtual json_t *toJson();
2160
2161 void addNode(Node *node) { addChild(node); node->addParent(this); calculateCompoundStatus(TRUE); }
2162
2163 virtual bool showThresholdSummary();
2164
2165 const InetAddress& getIpAddress() const { return m_ipAddress; }
2166 UINT32 getZoneUIN() const { return m_zoneUIN; }
2167 bool isSyntheticMask() const { return m_bSyntheticMask; }
2168
2169 void setCorrectMask(const InetAddress& addr);
2170
2171 bool findMacAddress(const InetAddress& ipAddr, BYTE *macAddr);
2172
2173 UINT32 *buildAddressMap(int *length);
2174 };
2175
2176 /**
2177 * Universal root object
2178 */
2179 class NXCORE_EXPORTABLE UniversalRoot : public NetObj
2180 {
2181 using NetObj::loadFromDatabase;
2182
2183 public:
2184 UniversalRoot();
2185 virtual ~UniversalRoot();
2186
2187 virtual bool saveToDatabase(DB_HANDLE hdb);
2188 void loadFromDatabase(DB_HANDLE hdb);
2189 virtual void linkObjects();
2190 void linkObject(NetObj *pObject) { addChild(pObject); pObject->addParent(this); }
2191 };
2192
2193 /**
2194 * Service root
2195 */
2196 class NXCORE_EXPORTABLE ServiceRoot : public UniversalRoot
2197 {
2198 public:
2199 ServiceRoot();
2200 virtual ~ServiceRoot();
2201
2202 virtual int getObjectClass() const { return OBJECT_SERVICEROOT; }
2203
2204 virtual bool showThresholdSummary();
2205 };
2206
2207 /**
2208 * Template root
2209 */
2210 class NXCORE_EXPORTABLE TemplateRoot : public UniversalRoot
2211 {
2212 public:
2213 TemplateRoot();
2214 virtual ~TemplateRoot();
2215
2216 virtual int getObjectClass() const { return OBJECT_TEMPLATEROOT; }
2217 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
2218 };
2219
2220 /**
2221 * Generic container object
2222 */
2223 class NXCORE_EXPORTABLE Container : public NetObj
2224 {
2225 private:
2226 UINT32 *m_pdwChildIdList;
2227 UINT32 m_dwChildIdListSize;
2228
2229 protected:
2230 NXSL_Program *m_bindFilter;
2231 TCHAR *m_bindFilterSource;
2232
2233 virtual void fillMessageInternal(NXCPMessage *msg);
2234 virtual UINT32 modifyFromMessageInternal(NXCPMessage *request);
2235
2236 void setAutoBindFilterInternal(const TCHAR *script);
2237
2238 public:
2239 Container();
2240 Container(const TCHAR *pszName, UINT32 dwCategory);
2241 virtual ~Container();
2242
2243 virtual int getObjectClass() const { return OBJECT_CONTAINER; }
2244
2245 virtual bool saveToDatabase(DB_HANDLE hdb);
2246 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2247 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2248 virtual void linkObjects();
2249
2250 virtual bool showThresholdSummary();
2251
2252 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
2253
2254 virtual json_t *toJson();
2255
2256 virtual NXSL_Value *createNXSLObject();
2257
2258 void linkObject(NetObj *pObject) { addChild(pObject); pObject->addParent(this); }
2259
2260 AutoBindDecision isSuitableForObject(NetObj *object);
2261 bool isAutoBindEnabled() const { return (m_flags & CF_AUTO_BIND) ? true : false; }
2262 bool isAutoUnbindEnabled() const { return ((m_flags & (CF_AUTO_BIND | CF_AUTO_UNBIND)) == (CF_AUTO_BIND | CF_AUTO_UNBIND)) ? true : false; }
2263 const TCHAR *getAutoBindScriptSource() const { return m_bindFilterSource; }
2264
2265 void setAutoBindFilter(const TCHAR *script) { lockProperties(); setAutoBindFilterInternal(script); unlockProperties(); }
2266 void setAutoBindMode(bool doBind, bool doUnbind);
2267 };
2268
2269 /**
2270 * Template group object
2271 */
2272 class NXCORE_EXPORTABLE TemplateGroup : public Container
2273 {
2274 public:
2275 TemplateGroup() : Container() { }
2276 TemplateGroup(const TCHAR *pszName) : Container(pszName, 0) { m_status = STATUS_NORMAL; }
2277 virtual ~TemplateGroup() { }
2278
2279 virtual int getObjectClass() const { return OBJECT_TEMPLATEGROUP; }
2280 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
2281
2282 virtual bool showThresholdSummary();
2283 };
2284
2285 /**
2286 * Rack object
2287 */
2288 class NXCORE_EXPORTABLE Rack : public Container
2289 {
2290 protected:
2291 int m_height; // Rack height in units
2292 bool m_topBottomNumbering;
2293
2294 virtual void fillMessageInternal(NXCPMessage *pMsg);
2295 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
2296
2297 public:
2298 Rack();
2299 Rack(const TCHAR *name, int height);
2300 virtual ~Rack();
2301
2302 virtual int getObjectClass() const { return OBJECT_RACK; }
2303
2304 virtual bool saveToDatabase(DB_HANDLE hdb);
2305 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2306 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2307
2308 virtual json_t *toJson();
2309 };
2310
2311 /**
2312 * Zone object
2313 */
2314 class NXCORE_EXPORTABLE Zone : public NetObj
2315 {
2316 protected:
2317 UINT32 m_uin;
2318 UINT32 m_proxyNodeId;
2319 InetAddressIndex *m_idxNodeByAddr;
2320 InetAddressIndex *m_idxInterfaceByAddr;
2321 InetAddressIndex *m_idxSubnetByAddr;
2322
2323 virtual void fillMessageInternal(NXCPMessage *msg);
2324 virtual UINT32 modifyFromMessageInternal(NXCPMessage *request);
2325
2326 public:
2327 Zone();
2328 Zone(UINT32 uin, const TCHAR *name);
2329 virtual ~Zone();
2330
2331 virtual int getObjectClass() const { return OBJECT_ZONE; }
2332
2333 virtual bool saveToDatabase(DB_HANDLE hdb);
2334 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2335 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2336
2337 virtual bool showThresholdSummary();
2338
2339 virtual NXSL_Value *createNXSLObject();
2340
2341 virtual json_t *toJson();
2342
2343 UINT32 getUIN() const { return m_uin; }
2344 UINT32 getProxyNodeId() const { return m_proxyNodeId; }
2345
2346 void addSubnet(Subnet *pSubnet) { addChild(pSubnet); pSubnet->addParent(this); }
2347
2348 void addToIndex(Subnet *subnet) { m_idxSubnetByAddr->put(subnet->getIpAddress(), subnet); }
2349 void addToIndex(Interface *iface) { m_idxInterfaceByAddr->put(iface->getIpAddressList(), iface); }
2350 void addToIndex(const InetAddress& addr, Interface *iface) { m_idxInterfaceByAddr->put(addr, iface); }
2351 void addToIndex(Node *node) { m_idxNodeByAddr->put(node->getIpAddress(), node); }
2352 void removeFromIndex(Subnet *subnet) { m_idxSubnetByAddr->remove(subnet->getIpAddress()); }
2353 void removeFromIndex(Interface *iface);
2354 void removeFromInterfaceIndex(const InetAddress& addr) { m_idxInterfaceByAddr->remove(addr); }
2355 void removeFromIndex(Node *node) { m_idxNodeByAddr->remove(node->getIpAddress()); }
2356 void updateInterfaceIndex(const InetAddress& oldIp, const InetAddress& newIp, Interface *iface);
2357 Subnet *getSubnetByAddr(const InetAddress& ipAddr) { return (Subnet *)m_idxSubnetByAddr->get(ipAddr); }
2358 Interface *getInterfaceByAddr(const InetAddress& ipAddr) { return (Interface *)m_idxInterfaceByAddr->get(ipAddr); }
2359 Node *getNodeByAddr(const InetAddress& ipAddr) { return (Node *)m_idxNodeByAddr->get(ipAddr); }
2360 Subnet *findSubnet(bool (*comparator)(NetObj *, void *), void *data) { return (Subnet *)m_idxSubnetByAddr->find(comparator, data); }
2361 Interface *findInterface(bool (*comparator)(NetObj *, void *), void *data) { return (Interface *)m_idxInterfaceByAddr->find(comparator, data); }
2362 Node *findNode(bool (*comparator)(NetObj *, void *), void *data) { return (Node *)m_idxNodeByAddr->find(comparator, data); }
2363 void forEachSubnet(void (*callback)(const InetAddress& addr, NetObj *, void *), void *data) { m_idxSubnetByAddr->forEach(callback, data); }
2364 ObjectArray<NetObj> *getSubnets(bool updateRefCount) { return m_idxSubnetByAddr->getObjects(updateRefCount); }
2365 void dumpInterfaceIndex(CONSOLE_CTX console);
2366 void dumpNodeIndex(CONSOLE_CTX console);
2367 void dumpSubnetIndex(CONSOLE_CTX console);
2368 };
2369
2370 /**
2371 * Entire network
2372 */
2373 class NXCORE_EXPORTABLE Network : public NetObj
2374 {
2375 using NetObj::loadFromDatabase;
2376
2377 public:
2378 Network();
2379 virtual ~Network();
2380
2381 virtual int getObjectClass() const { return OBJECT_NETWORK; }
2382 virtual bool saveToDatabase(DB_HANDLE hdb);
2383
2384 virtual bool showThresholdSummary();
2385
2386 void AddSubnet(Subnet *pSubnet) { addChild(pSubnet); pSubnet->addParent(this); }
2387 void AddZone(Zone *pZone) { addChild(pZone); pZone->addParent(this); }
2388 void loadFromDatabase(DB_HANDLE hdb);
2389 };
2390
2391 /**
2392 * Condition
2393 */
2394 class NXCORE_EXPORTABLE ConditionObject : public NetObj
2395 {
2396 protected:
2397 UINT32 m_dciCount;
2398 INPUT_DCI *m_dciList;
2399 TCHAR *m_scriptSource;
2400 NXSL_VM *m_script;
2401 UINT32 m_activationEventCode;
2402 UINT32 m_deactivationEventCode;
2403 UINT32 m_sourceObject;
2404 int m_activeStatus;
2405 int m_inactiveStatus;
2406 bool m_isActive;
2407 time_t m_lastPoll;
2408 bool m_queuedForPolling;
2409
2410 virtual void fillMessageInternal(NXCPMessage *pMsg);
2411 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
2412
2413 public:
2414 ConditionObject();
2415 ConditionObject(bool hidden);
2416 virtual ~ConditionObject();
2417
2418 virtual int getObjectClass() const { return OBJECT_CONDITION; }
2419
2420 virtual bool saveToDatabase(DB_HANDLE hdb);
2421 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2422 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2423
2424 virtual json_t *toJson();
2425
2426 void lockForPoll();
2427 void doPoll(PollerInfo *poller);
2428 void check();
2429
2430 bool isReadyForPoll()
2431 {
2432 return ((m_status != STATUS_UNMANAGED) &&
2433 (!m_queuedForPolling) && (!m_isDeleted) &&
2434 ((UINT32)time(NULL) - (UINT32)m_lastPoll > g_dwConditionPollingInterval));
2435 }
2436
2437 int getCacheSizeForDCI(UINT32 itemId, bool noLock);
2438 };
2439
2440 /**
2441 * Generic agent policy object
2442 */
2443 class NXCORE_EXPORTABLE AgentPolicy : public NetObj
2444 {
2445 protected:
2446 UINT32 m_version;
2447 int m_policyType;
2448
2449 bool savePolicyCommonProperties(DB_HANDLE hdb);
2450
2451 virtual void fillMessageInternal(NXCPMessage *pMsg);
2452 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
2453
2454 public:
2455 AgentPolicy(int type);
2456 AgentPolicy(const TCHAR *name, int type);
2457
2458 virtual int getObjectClass() const { return OBJECT_AGENTPOLICY; }
2459
2460 virtual bool saveToDatabase(DB_HANDLE hdb);
2461 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2462 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2463
2464 virtual json_t *toJson();
2465
2466 virtual bool createDeploymentMessage(NXCPMessage *msg);
2467 virtual bool createUninstallMessage(NXCPMessage *msg);
2468
2469 void linkNode(Node *node) { addChild(node); node->addParent(this); }
2470 void unlinkNode(Node *node) { deleteChild(node); node->deleteParent(this); }
2471 };
2472
2473 /**
2474 * Agent config policy object
2475 */
2476 class NXCORE_EXPORTABLE AgentPolicyConfig : public AgentPolicy
2477 {
2478 protected:
2479 TCHAR *m_fileContent;
2480
2481 virtual void fillMessageInternal(NXCPMessage *pMsg);
2482 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
2483
2484 public:
2485 AgentPolicyConfig();
2486 AgentPolicyConfig(const TCHAR *name);
2487 virtual ~AgentPolicyConfig();
2488
2489 virtual int getObjectClass() const { return OBJECT_AGENTPOLICY_CONFIG; }
2490
2491 virtual bool saveToDatabase(DB_HANDLE hdb);
2492 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2493 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2494
2495 virtual json_t *toJson();
2496
2497 virtual bool createDeploymentMessage(NXCPMessage *msg);
2498 virtual bool createUninstallMessage(NXCPMessage *msg);
2499 };
2500
2501 /**
2502 * Log parser configuration policy object
2503 */
2504 class NXCORE_EXPORTABLE AgentPolicyLogParser : public AgentPolicy
2505 {
2506 protected:
2507 TCHAR *m_fileContent;
2508
2509 virtual void fillMessageInternal(NXCPMessage *pMsg);
2510 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
2511 public:
2512 AgentPolicyLogParser();
2513 AgentPolicyLogParser(const TCHAR *name);
2514 virtual ~AgentPolicyLogParser();
2515
2516 virtual int getObjectClass() const { return OBJECT_AGENTPOLICY_LOGPARSER; }
2517
2518 virtual bool saveToDatabase(DB_HANDLE hdb);
2519 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2520 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2521
2522 virtual json_t *toJson();
2523
2524 virtual bool createDeploymentMessage(NXCPMessage *msg);
2525 virtual bool createUninstallMessage(NXCPMessage *msg);
2526 };
2527
2528 /**
2529 * Policy group object
2530 */
2531 class NXCORE_EXPORTABLE PolicyGroup : public Container
2532 {
2533 public:
2534 PolicyGroup() : Container() { }
2535 PolicyGroup(const TCHAR *pszName) : Container(pszName, 0) { }
2536 virtual ~PolicyGroup() { }
2537
2538 virtual int getObjectClass() const { return OBJECT_POLICYGROUP; }
2539 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
2540
2541 virtual bool showThresholdSummary();
2542 };
2543
2544 /**
2545 * Policy root
2546 */
2547 class NXCORE_EXPORTABLE PolicyRoot : public UniversalRoot
2548 {
2549 public:
2550 PolicyRoot();
2551 virtual ~PolicyRoot();
2552
2553 virtual int getObjectClass() const { return OBJECT_POLICYROOT; }
2554 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
2555 };
2556
2557 /**
2558 * Network map root
2559 */
2560 class NXCORE_EXPORTABLE NetworkMapRoot : public UniversalRoot
2561 {
2562 public:
2563 NetworkMapRoot();
2564 virtual ~NetworkMapRoot();
2565
2566 virtual int getObjectClass() const { return OBJECT_NETWORKMAPROOT; }
2567 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
2568 };
2569
2570 /**
2571 * Network map group object
2572 */
2573 class NXCORE_EXPORTABLE NetworkMapGroup : public Container
2574 {
2575 public:
2576 NetworkMapGroup() : Container() { }
2577 NetworkMapGroup(const TCHAR *pszName) : Container(pszName, 0) { }
2578 virtual ~NetworkMapGroup() { }
2579
2580 virtual int getObjectClass() const { return OBJECT_NETWORKMAPGROUP; }
2581 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
2582
2583 virtual bool showThresholdSummary();
2584 };
2585
2586 /**
2587 * Network map object
2588 */
2589 class NXCORE_EXPORTABLE NetworkMap : public NetObj
2590 {
2591 protected:
2592 int m_mapType;
2593 IntegerArray<UINT32> *m_seedObjects;
2594 int m_discoveryRadius;
2595 int m_layout;
2596 int m_backgroundColor;
2597 int m_defaultLinkColor;
2598 int m_defaultLinkRouting;
2599 int m_objectDisplayMode;
2600 uuid m_background;
2601 double m_backgroundLatitude;
2602 double m_backgroundLongitude;
2603 int m_backgroundZoom;
2604 UINT32 m_nextElementId;
2605 ObjectArray<NetworkMapElement> *m_elements;
2606 ObjectArray<NetworkMapLink> *m_links;
2607 TCHAR *m_filterSource;
2608 NXSL_VM *m_filter;
2609
2610 virtual void fillMessageInternal(NXCPMessage *pMsg);
2611 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
2612
2613 void updateObjects(NetworkMapObjectList *objects);
2614 UINT32 objectIdFromElementId(UINT32 eid);
2615 UINT32 elementIdFromObjectId(UINT32 eid);
2616
2617 void setFilter(const TCHAR *filter);
2618
2619 public:
2620 NetworkMap();
2621 NetworkMap(int type, IntegerArray<UINT32> *seeds);
2622 virtual ~NetworkMap();
2623
2624 virtual int getObjectClass() const { return OBJECT_NETWORKMAP; }
2625 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
2626
2627 virtual bool saveToDatabase(DB_HANDLE hdb);
2628 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2629 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2630
2631 virtual void onObjectDelete(UINT32 dwObjectId);
2632
2633 virtual json_t *toJson();
2634
2635 void updateContent();
2636
2637 int getBackgroundColor() { return m_backgroundColor; }
2638 void setBackgroundColor(int color) { m_backgroundColor = color; }
2639
2640 bool isAllowedOnMap(NetObj *object);
2641 };
2642
2643 /**
2644 * Dashboard tree root
2645 */
2646 class NXCORE_EXPORTABLE DashboardRoot : public UniversalRoot
2647 {
2648 public:
2649 DashboardRoot();
2650 virtual ~DashboardRoot();
2651
2652 virtual int getObjectClass() const { return OBJECT_DASHBOARDROOT; }
2653 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
2654 };
2655
2656 /**
2657 * Dashboard element
2658 */
2659 class NXCORE_EXPORTABLE DashboardElement
2660 {
2661 public:
2662 int m_type;
2663 TCHAR *m_data;
2664 TCHAR *m_layout;
2665
2666 DashboardElement() { m_data = NULL; m_layout = NULL; }
2667 ~DashboardElement() { free(m_data); free(m_layout); }
2668
2669 json_t *toJson()
2670 {
2671 json_t *root = json_object();
2672 json_object_set_new(root, "type", json_integer(m_type));
2673 json_object_set_new(root, "data", json_string_t(m_data));
2674 json_object_set_new(root, "layout", json_string_t(m_layout));
2675 return root;
2676 }
2677 };
2678
2679 /**
2680 * Dashboard object
2681 */
2682 class NXCORE_EXPORTABLE Dashboard : public Container
2683 {
2684 protected:
2685 int m_numColumns;
2686 UINT32 m_options;
2687 ObjectArray<DashboardElement> *m_elements;
2688
2689 virtual void fillMessageInternal(NXCPMessage *pMsg);
2690 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
2691
2692 public:
2693 Dashboard();
2694 Dashboard(const TCHAR *name);
2695 virtual ~Dashboard();
2696
2697 virtual int getObjectClass() const { return OBJECT_DASHBOARD; }
2698 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
2699
2700 virtual bool saveToDatabase(DB_HANDLE hdb);
2701 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2702 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2703
2704 virtual json_t *toJson();
2705
2706 virtual bool showThresholdSummary();
2707 };
2708
2709 /**
2710 * Dashboard group object
2711 */
2712 class NXCORE_EXPORTABLE DashboardGroup : public Container
2713 {
2714 public:
2715 DashboardGroup() : Container() { }
2716 DashboardGroup(const TCHAR *pszName) : Container(pszName, 0) { }
2717 virtual ~DashboardGroup() { }
2718
2719 virtual int getObjectClass() const { return OBJECT_DASHBOARDGROUP; }
2720 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
2721
2722 virtual bool showThresholdSummary();
2723 };
2724
2725 /**
2726 * SLM check object
2727 */
2728 class NXCORE_EXPORTABLE SlmCheck : public NetObj
2729 {
2730 protected:
2731 static NXSL_VariableSystem m_nxslConstants;
2732
2733 Threshold *m_threshold;
2734 enum CheckType { check_undefined = 0, check_script = 1, check_threshold = 2 } m_type;
2735 TCHAR *m_script;
2736 NXSL_VM *m_pCompiledScript;
2737 TCHAR m_reason[256];
2738 bool m_isTemplate;
2739 UINT32 m_templateId;
2740 UINT32 m_currentTicketId;
2741
2742 virtual void onObjectDelete(UINT32 objectId);
2743
2744 virtual void fillMessageInternal(NXCPMessage *pMsg);
2745 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
2746
2747 void setScript(const TCHAR *script);
2748 UINT32 getOwnerId();
2749 NXSL_Value *getNodeObjectForNXSL();
2750 bool insertTicket();
2751 void closeTicket();
2752 void setReason(const TCHAR *reason) { nx_strncpy(m_reason, CHECK_NULL_EX(reason), 256); }
2753 void compileScript();
2754
2755 public:
2756 SlmCheck();
2757 SlmCheck(const TCHAR *name, bool isTemplate);
2758 SlmCheck(SlmCheck *tmpl);
2759 virtual ~SlmCheck();
2760
2761 static void init();
2762
2763 virtual int getObjectClass() const { return OBJECT_SLMCHECK; }
2764
2765 virtual bool saveToDatabase(DB_HANDLE hdb);
2766 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2767 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2768
2769 virtual void postModify();
2770
2771 void execute();
2772 void updateFromTemplate(SlmCheck *tmpl);
2773
2774 bool isTemplate() { return m_isTemplate; }
2775 UINT32 getTemplateId() { return m_templateId; }
2776 const TCHAR *getReason() { return m_reason; }
2777 };
2778
2779 /**
2780 * Service container - common logic for BusinessService, NodeLink and BusinessServiceRoot
2781 */
2782 class NXCORE_EXPORTABLE ServiceContainer : public Container
2783 {
2784 enum Period { DAY, WEEK, MONTH };
2785
2786 protected:
2787 time_t m_prevUptimeUpdateTime;
2788 int m_prevUptimeUpdateStatus;
2789 double m_uptimeDay;
2790 double m_uptimeWeek;
2791 double m_uptimeMonth;
2792 INT32 m_downtimeDay;
2793 INT32 m_downtimeWeek;
2794 INT32 m_downtimeMonth;
2795 INT32 m_prevDiffDay;
2796 INT32 m_prevDiffWeek;
2797 INT32 m_prevDiffMonth;
2798
2799 static INT32 logRecordId;
2800 static INT32 getSecondsInMonth();
2801 static INT32 getSecondsInPeriod(Period period) { return period == MONTH ? getSecondsInMonth() : (period == WEEK ? (3600 * 24 * 7) : (3600 * 24)); }
2802 static INT32 getSecondsSinceBeginningOf(Period period, time_t *beginTime = NULL);
2803
2804 virtual void fillMessageInternal(NXCPMessage *pMsg);
2805 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
2806
2807 void initServiceContainer();
2808 BOOL addHistoryRecord();
2809 double getUptimeFromDBFor(Period period, INT32 *downtime);
2810
2811 public:
2812 ServiceContainer();
2813 ServiceContainer(const TCHAR *pszName);
2814
2815 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2816 virtual bool saveToDatabase(DB_HANDLE hdb);
2817 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2818
2819 virtual void calculateCompoundStatus(BOOL bForcedRecalc = FALSE);
2820 virtual void setStatus(int newStatus);
2821
2822 virtual bool showThresholdSummary();
2823
2824 void initUptimeStats();
2825 void updateUptimeStats(time_t currentTime = 0, BOOL updateChilds = FALSE);
2826 };
2827
2828 /**
2829 * Business service root
2830 */
2831 class NXCORE_EXPORTABLE BusinessServiceRoot : public ServiceContainer
2832 {
2833 using ServiceContainer::loadFromDatabase;
2834
2835 public:
2836 BusinessServiceRoot();
2837 virtual ~BusinessServiceRoot();
2838
2839 virtual int getObjectClass() const { return OBJECT_BUSINESSSERVICEROOT; }
2840
2841 virtual bool saveToDatabase(DB_HANDLE hdb);
2842 void loadFromDatabase(DB_HANDLE hdb);
2843
2844 virtual void linkObjects();
2845
2846 void linkObject(NetObj *pObject) { addChild(pObject); pObject->addParent(this); }
2847 };
2848
2849 /**
2850 * Business service object
2851 */
2852 class NXCORE_EXPORTABLE BusinessService : public ServiceContainer
2853 {
2854 protected:
2855 bool m_busy;
2856 bool m_pollingDisabled;
2857 time_t m_lastPollTime;
2858 int m_lastPollStatus;
2859
2860 virtual void prepareForDeletion();
2861
2862 virtual void fillMessageInternal(NXCPMessage *pMsg);
2863 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
2864
2865 public:
2866 BusinessService();
2867 BusinessService(const TCHAR *name);
2868 virtual ~BusinessService();
2869
2870 virtual int getObjectClass() const { return OBJECT_BUSINESSSERVICE; }
2871
2872 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2873 virtual bool saveToDatabase(DB_HANDLE hdb);
2874 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2875
2876 bool isReadyForPolling();
2877 void lockForPolling();
2878 void poll(PollerInfo *poller);
2879 void poll(ClientSession *pSession, UINT32 dwRqId, PollerInfo *poller);
2880
2881 void getApplicableTemplates(ServiceContainer *target, ObjectArray<SlmCheck> *templates);
2882 };
2883
2884 /**
2885 * Node link object for business service
2886 */
2887 class NXCORE_EXPORTABLE NodeLink : public ServiceContainer
2888 {
2889 protected:
2890 UINT32 m_nodeId;
2891
2892 virtual void onObjectDelete(UINT32 dwObjectId);
2893
2894 virtual void fillMessageInternal(NXCPMessage *pMsg);
2895 virtual UINT32 modifyFromMessageInternal(NXCPMessage *pRequest);
2896
2897 void applyTemplate(SlmCheck *tmpl);
2898
2899 public:
2900 NodeLink();
2901 NodeLink(const TCHAR *name, UINT32 nodeId);
2902 virtual ~NodeLink();
2903
2904 virtual int getObjectClass() const { return OBJECT_NODELINK; }
2905
2906 virtual bool saveToDatabase(DB_HANDLE hdb);
2907 virtual bool deleteFromDatabase(DB_HANDLE hdb);
2908 virtual bool loadFromDatabase(DB_HANDLE hdb, UINT32 id);
2909
2910 void execute();
2911 void applyTemplates();
2912
2913 UINT32 getNodeId() { return m_nodeId; }
2914 };
2915
2916 /**
2917 * Get IP address for object
2918 */
2919 inline const InetAddress& GetObjectIpAddress(NetObj *object)
2920 {
2921 if (object->getObjectClass() == OBJECT_NODE)
2922 return ((Node *)object)->getIpAddress();
2923 if (object->getObjectClass() == OBJECT_SUBNET)
2924 return ((Subnet *)object)->getIpAddress();
2925 if (object->getObjectClass() == OBJECT_ACCESSPOINT)
2926 return ((AccessPoint *)object)->getIpAddress();
2927 if (object->getObjectClass() == OBJECT_INTERFACE)
2928 return ((Interface *)object)->getIpAddressList()->getFirstUnicastAddress();
2929 return InetAddress::INVALID;
2930 }
2931
2932 /**
2933 * Functions
2934 */
2935 void ObjectsInit();
2936
2937 void NXCORE_EXPORTABLE NetObjInsert(NetObj *object, bool newObject, bool importedObject);
2938 void NetObjDeleteFromIndexes(NetObj *object);
2939 void NetObjDelete(NetObj *object);
2940
2941 void UpdateInterfaceIndex(const InetAddress& oldIpAddr, const InetAddress& newIpAddr, Interface *iface);
2942 ComponentTree *BuildComponentTree(Node *node, SNMP_Transport *snmp);
2943
2944 void NXCORE_EXPORTABLE MacDbAddAccessPoint(AccessPoint *ap);
2945 void NXCORE_EXPORTABLE MacDbAddInterface(Interface *iface);
2946 void NXCORE_EXPORTABLE MacDbAddObject(const BYTE *macAddr, NetObj *object);
2947 void NXCORE_EXPORTABLE MacDbRemove(const BYTE *macAddr);
2948 NetObj NXCORE_EXPORTABLE *MacDbFind(const BYTE *macAddr);
2949
2950 NetObj NXCORE_EXPORTABLE *FindObjectById(UINT32 dwId, int objClass = -1);
2951 NetObj NXCORE_EXPORTABLE *FindObjectByName(const TCHAR *name, int objClass = -1);
2952 NetObj NXCORE_EXPORTABLE *FindObjectByGUID(const uuid& guid, int objClass = -1);
2953 NetObj NXCORE_EXPORTABLE *FindObject(bool (* comparator)(NetObj *, void *), void *userData, int objClass = -1);
2954 const TCHAR NXCORE_EXPORTABLE *GetObjectName(DWORD id, const TCHAR *defaultName);
2955 Template NXCORE_EXPORTABLE *FindTemplateByName(const TCHAR *pszName);
2956 Node NXCORE_EXPORTABLE *FindNodeByIP(UINT32 zoneUIN, const InetAddress& ipAddr);
2957 Node NXCORE_EXPORTABLE *FindNodeByIP(UINT32 zoneUIN, const InetAddressList *ipAddrList);
2958 Node NXCORE_EXPORTABLE *FindNodeByMAC(const BYTE *macAddr);
2959 Node NXCORE_EXPORTABLE *FindNodeByBridgeId(const BYTE *bridgeId);
2960 Node NXCORE_EXPORTABLE *FindNodeByLLDPId(const TCHAR *lldpId);
2961 Node NXCORE_EXPORTABLE *FindNodeBySysName(const TCHAR *sysName);
2962 ObjectArray<NetObj> *FindNodesByHostname(TCHAR *hostname, UINT32 zoneUIN);
2963 Interface NXCORE_EXPORTABLE *FindInterfaceByIP(UINT32 zoneUIN, const InetAddress& ipAddr);
2964 Interface NXCORE_EXPORTABLE *FindInterfaceByMAC(const BYTE *macAddr);
2965 Interface NXCORE_EXPORTABLE *FindInterfaceByDescription(const TCHAR *description);
2966 Subnet NXCORE_EXPORTABLE *FindSubnetByIP(UINT32 zoneUIN, const InetAddress& ipAddr);
2967 Subnet NXCORE_EXPORTABLE *FindSubnetForNode(UINT32 zoneUIN, const InetAddress& nodeAddr);
2968 MobileDevice NXCORE_EXPORTABLE *FindMobileDeviceByDeviceID(const TCHAR *deviceId);
2969 AccessPoint NXCORE_EXPORTABLE *FindAccessPointByMAC(const BYTE *macAddr);
2970 UINT32 NXCORE_EXPORTABLE FindLocalMgmtNode();
2971 Zone NXCORE_EXPORTABLE *FindZoneByUIN(UINT32 zoneUIN);
2972 UINT32 FindUnusedZoneUIN();
2973 bool NXCORE_EXPORTABLE IsClusterIP(UINT32 zoneUIN, const InetAddress& ipAddr);
2974 bool NXCORE_EXPORTABLE IsParentObject(UINT32 object1, UINT32 object2);
2975
2976 BOOL LoadObjects();
2977 void DumpObjects(CONSOLE_CTX pCtx, const TCHAR *filter);
2978
2979 bool NXCORE_EXPORTABLE CreateObjectAccessSnapshot(UINT32 userId, int objClass);
2980
2981 void DeleteUserFromAllObjects(UINT32 dwUserId);
2982
2983 bool IsValidParentClass(int childClass, int parentClass);
2984 bool IsAgentPolicyObject(NetObj *object);
2985 bool IsEventSource(int objectClass);
2986
2987 int DefaultPropagatedStatus(int iObjectStatus);
2988 int GetDefaultStatusCalculation(int *pnSingleThreshold, int **ppnThresholds);
2989
2990 PollerInfo *RegisterPoller(PollerType type, NetObj *object);
2991 void ShowPollers(CONSOLE_CTX console);
2992
2993 /**
2994 * Global variables
2995 */
2996 extern Network NXCORE_EXPORTABLE *g_pEntireNet;
2997 extern ServiceRoot NXCORE_EXPORTABLE *g_pServiceRoot;
2998 extern TemplateRoot NXCORE_EXPORTABLE *g_pTemplateRoot;
2999 extern PolicyRoot NXCORE_EXPORTABLE *g_pPolicyRoot;
3000 extern NetworkMapRoot NXCORE_EXPORTABLE *g_pMapRoot;
3001 extern DashboardRoot NXCORE_EXPORTABLE *g_pDashboardRoot;
3002 extern BusinessServiceRoot NXCORE_EXPORTABLE *g_pBusinessServiceRoot;
3003
3004 extern UINT32 NXCORE_EXPORTABLE g_dwMgmtNode;
3005 extern BOOL g_bModificationsLocked;
3006 extern Queue g_templateUpdateQueue;
3007
3008 extern ObjectIndex NXCORE_EXPORTABLE g_idxObjectById;
3009 extern InetAddressIndex NXCORE_EXPORTABLE g_idxSubnetByAddr;
3010 extern InetAddressIndex NXCORE_EXPORTABLE g_idxInterfaceByAddr;
3011 extern InetAddressIndex NXCORE_EXPORTABLE g_idxNodeByAddr;
3012 extern ObjectIndex NXCORE_EXPORTABLE g_idxZoneByUIN;
3013 extern ObjectIndex NXCORE_EXPORTABLE g_idxNodeById;
3014 extern ObjectIndex NXCORE_EXPORTABLE g_idxNetMapById;
3015 extern ObjectIndex NXCORE_EXPORTABLE g_idxChassisById;
3016 extern ObjectIndex NXCORE_EXPORTABLE g_idxClusterById;
3017 extern ObjectIndex NXCORE_EXPORTABLE g_idxMobileDeviceById;
3018 extern ObjectIndex NXCORE_EXPORTABLE g_idxAccessPointById;
3019 extern ObjectIndex NXCORE_EXPORTABLE g_idxConditionById;
3020 extern ObjectIndex NXCORE_EXPORTABLE g_idxServiceCheckById;
3021 extern ObjectIndex NXCORE_EXPORTABLE g_idxSensorById;
3022
3023 #endif /* _nms_objects_h_ */