ZeroTierOne/core/Node.hpp

/*
 * Copyright (c)2013-2021 ZeroTier, Inc.
 *
 * Use of this software is governed by the Business Source License included
 * in the LICENSE.TXT file in the project's root directory.
 *
 * Change Date: 2026-01-01
 *
 * On the date above, in accordance with the Business Source License, use
 * of this software will be governed by version 2.0 of the Apache License.
 */
/****/

#ifndef ZT_NODE_HPP
#define ZT_NODE_HPP

#include "Buf.hpp"
#include "CallContext.hpp"
#include "Constants.hpp"
#include "Containers.hpp"
#include "Context.hpp"
#include "InetAddress.hpp"
#include "MAC.hpp"
#include "Mutex.hpp"
#include "Network.hpp"
#include "NetworkController.hpp"
#include "Path.hpp"
#include "Salsa20.hpp"
#include "Store.hpp"

namespace ZeroTier {

/**
 * Implementation of Node object as defined in CAPI
 *
 * The pointer returned by ZT_Node_new() is an instance of this class.
 */
class Node : public NetworkController::Sender {
  public:
    // Get rid of alignment warnings on 32-bit Windows
#ifdef __WINDOWS__
    void *operator new(size_t i) { return _mm_malloc(i, 16); }
    void operator delete(void *p) { _mm_free(p); }
#endif

    Node(void *uPtr, const struct ZT_Node_Callbacks *callbacks, const CallContext &cc);

    virtual ~Node();

    void shutdown(const CallContext &cc);

    ZT_ResultCode processBackgroundTasks(const CallContext &cc, volatile int64_t *nextBackgroundTaskDeadline);

    ZT_ResultCode join(uint64_t nwid, const ZT_Fingerprint *controllerFingerprint, void *uptr, const CallContext &cc);

    ZT_ResultCode leave(uint64_t nwid, void **uptr, const CallContext &cc);

    ZT_ResultCode multicastSubscribe(const CallContext &cc, uint64_t nwid, uint64_t multicastGroup, unsigned long multicastAdi);

    ZT_ResultCode multicastUnsubscribe(const CallContext &cc, uint64_t nwid, uint64_t multicastGroup, unsigned long multicastAdi);

    void status(ZT_NodeStatus *status) const;

    ZT_PeerList *peers(const CallContext &cc) const;

    ZT_VirtualNetworkConfig *networkConfig(uint64_t nwid) const;

    ZT_VirtualNetworkList *networks() const;

    void setNetworkUserPtr(uint64_t nwid, void *ptr);

    void setInterfaceAddresses(const ZT_InterfaceAddress *addrs, unsigned int addrCount);

    ZT_CertificateError addCertificate(const CallContext &cc, unsigned int localTrust, const ZT_Certificate *cert, const void *certData, unsigned int certSize);

    ZT_ResultCode deleteCertificate(const CallContext &cc, const void *serialNo);

    ZT_CertificateList *listCertificates();

    int sendUserMessage(const CallContext &cc, uint64_t dest, uint64_t typeId, const void *data, unsigned int len);

    void setController(void *networkControllerInstance);

    /**
     * Post an event via external callback
     *
     * @param tPtr Thread pointer
     * @param ev Event object
     * @param md Event data or NULL if none
     * @param mdSize Size of event data
     */
    ZT_INLINE void postEvent(void *const tPtr, const ZT_Event ev, const void *const md = nullptr, const unsigned int mdSize = 0) noexcept { m_ctx.cb.eventCallback(reinterpret_cast<ZT_Node *>(this), m_ctx.uPtr, tPtr, ev, md, mdSize); }

    /**
     * Check whether a path should be used for ZeroTier traffic
     *
     * This performs internal checks and also calls out to an external callback if one is defined.
     *
     * @param tPtr Thread pointer
     * @param id Identity of peer
     * @param localSocket Local socket or -1 if unknown
     * @param remoteAddress Remote address
     * @return True if path should be used
     */
    bool filterPotentialPath(void *tPtr, const Identity &id, int64_t localSocket, const InetAddress &remoteAddress);

    /**
     * Query callback for a physical address for a peer
     *
     * @param tPtr Thread pointer
     * @param id Full identity of ZeroTier node
     * @param family Desired address family or -1 for any
     * @param addr Buffer to store address (result paramter)
     * @return True if addr was filled with something
     */
    bool externalPathLookup(void *tPtr, const Identity &id, int family, InetAddress &addr);

    ZT_INLINE const Identity &identity() const noexcept { return m_ctx.identity; }

    ZT_INLINE const Context &context() const noexcept { return m_ctx; }

    // Implementation of NetworkController::Sender interface
    virtual void ncSendConfig(void *tPtr, int64_t clock, int64_t ticks, uint64_t nwid, uint64_t requestPacketId, const Address &destination, const NetworkConfig &nc, bool sendLegacyFormatConfig);
    virtual void ncSendRevocation(void *tPtr, int64_t clock, int64_t ticks, const Address &destination, const RevocationCredential &rev);
    virtual void ncSendError(void *tPtr, int64_t clock, int64_t ticks, uint64_t nwid, uint64_t requestPacketId, const Address &destination, NetworkController::ErrorCode errorCode);

  private:
    Context m_ctx;

    // Data store wrapper
    Store m_store;

    // Pointer to a struct defined in Node that holds instances of core objects.
    void *m_objects;

    // This stores networks for rapid iteration, while RR->networks is the primary lookup.
    Vector<SharedPtr<Network>> m_allNetworks;
    Mutex m_allNetworks_l;

    // These are local interface addresses that have been configured via the API
    // and can be pushed to other nodes.
    Vector<ZT_InterfaceAddress> m_localInterfaceAddresses;
    Mutex m_localInterfaceAddresses_m;

    // This is locked while running processBackgroundTasks().
    Mutex m_backgroundTasksLock;

    // These are locked via _backgroundTasksLock as they're only checked and modified in processBackgroundTasks().
    int64_t m_lastPeerPulse;
    int64_t m_lastHousekeepingRun;
    int64_t m_lastNetworkHousekeepingRun;
    int64_t m_lastTrustStoreUpdate;

    // True if at least one root appears reachable.
    std::atomic<bool> m_online;
};

}   // namespace ZeroTier

#endif