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_ */