ZeroTierOne/node/Node.cpp

/*
 * Copyright (c)2013-2020 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.
 */
/****/

#include "Node.hpp"

#include "../version.h"
#include "Address.hpp"
#include "Buffer.hpp"
#include "Constants.hpp"
#include "ECC.hpp"
#include "Identity.hpp"
#include "Metrics.hpp"
#include "Multicaster.hpp"
#include "Network.hpp"
#include "NetworkController.hpp"
#include "Packet.hpp"
#include "PacketMultiplexer.hpp"
#include "RuntimeEnvironment.hpp"
#include "SelfAwareness.hpp"
#include "SharedPtr.hpp"
#include "Switch.hpp"
#include "Topology.hpp"
#include "Trace.hpp"

#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// FIXME: remove this suppression and actually fix warnings
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wsign-compare"
#endif

namespace ZeroTier {

/****************************************************************************/
/* Public Node interface (C++, exposed via CAPI bindings)                   */
/****************************************************************************/

Node::Node(void* uptr, void* tptr, const struct ZT_Node_Callbacks* callbacks, int64_t now)
	: _RR(this)
	, RR(&_RR)
	, _uPtr(uptr)
	, _networks(8)
	, _now(now)
	, _lastPingCheck(0)
	, _lastGratuitousPingCheck(0)
	, _lastHousekeepingRun(0)
	, _lastMemoizedTraceSettings(0)
	, _lowBandwidthMode(false)
{
	if (callbacks->version != 0) {
		throw ZT_EXCEPTION_INVALID_ARGUMENT;
	}
	memcpy(&_cb, callbacks, sizeof(ZT_Node_Callbacks));

	// Initialize non-cryptographic PRNG from a good random source
	Utils::getSecureRandom((void*)_prngState, sizeof(_prngState));

	_online = false;

	memset(_expectingRepliesToBucketPtr, 0, sizeof(_expectingRepliesToBucketPtr));
	memset(_expectingRepliesTo, 0, sizeof(_expectingRepliesTo));
	memset(_lastIdentityVerification, 0, sizeof(_lastIdentityVerification));
	memset((void*)(&_stats), 0, sizeof(_stats));

	uint64_t idtmp[2];
	idtmp[0] = 0;
	idtmp[1] = 0;
	char tmp[2048];
	int n = stateObjectGet(tptr, ZT_STATE_OBJECT_IDENTITY_SECRET, idtmp, tmp, sizeof(tmp) - 1);
	if (n > 0) {
		tmp[n] = (char)0;
		if (RR->identity.fromString(tmp)) {
			RR->identity.toString(false, RR->publicIdentityStr);
			RR->identity.toString(true, RR->secretIdentityStr);
		}
		else {
			throw ZT_EXCEPTION_INVALID_IDENTITY;
		}

		if (! RR->identity.locallyValidate()) {
			throw ZT_EXCEPTION_INVALID_IDENTITY;
		}
	}

	if (n <= 0) {
		RR->identity.generate();
		RR->identity.toString(false, RR->publicIdentityStr);
		RR->identity.toString(true, RR->secretIdentityStr);
		idtmp[0] = RR->identity.address().toInt();
		idtmp[1] = 0;
		stateObjectPut(tptr, ZT_STATE_OBJECT_IDENTITY_SECRET, idtmp, RR->secretIdentityStr, (unsigned int)strlen(RR->secretIdentityStr));
		stateObjectPut(tptr, ZT_STATE_OBJECT_IDENTITY_PUBLIC, idtmp, RR->publicIdentityStr, (unsigned int)strlen(RR->publicIdentityStr));
	}
	else {
		idtmp[0] = RR->identity.address().toInt();
		idtmp[1] = 0;
		n = stateObjectGet(tptr, ZT_STATE_OBJECT_IDENTITY_PUBLIC, idtmp, tmp, sizeof(tmp) - 1);
		if ((n > 0) && (n < (int)sizeof(RR->publicIdentityStr)) && (n < (int)sizeof(tmp))) {
			if (memcmp(tmp, RR->publicIdentityStr, n)) {
				stateObjectPut(tptr, ZT_STATE_OBJECT_IDENTITY_PUBLIC, idtmp, RR->publicIdentityStr, (unsigned int)strlen(RR->publicIdentityStr));
			}
		}
	}

	char* m = (char*)0;
	try {
		const unsigned long ts = sizeof(Trace) + (((sizeof(Trace) & 0xf) != 0) ? (16 - (sizeof(Trace) & 0xf)) : 0);
		const unsigned long sws = sizeof(Switch) + (((sizeof(Switch) & 0xf) != 0) ? (16 - (sizeof(Switch) & 0xf)) : 0);
		const unsigned long mcs = sizeof(Multicaster) + (((sizeof(Multicaster) & 0xf) != 0) ? (16 - (sizeof(Multicaster) & 0xf)) : 0);
		const unsigned long topologys = sizeof(Topology) + (((sizeof(Topology) & 0xf) != 0) ? (16 - (sizeof(Topology) & 0xf)) : 0);
		const unsigned long sas = sizeof(SelfAwareness) + (((sizeof(SelfAwareness) & 0xf) != 0) ? (16 - (sizeof(SelfAwareness) & 0xf)) : 0);
		const unsigned long bcs = sizeof(Bond) + (((sizeof(Bond) & 0xf) != 0) ? (16 - (sizeof(Bond) & 0xf)) : 0);
		const unsigned long pms = sizeof(PacketMultiplexer) + (((sizeof(PacketMultiplexer) & 0xf) != 0) ? (16 - (sizeof(PacketMultiplexer) & 0xf)) : 0);

		m = reinterpret_cast<char*>(::malloc(16 + ts + sws + mcs + topologys + sas + bcs + pms));
		if (! m) {
			throw std::bad_alloc();
		}
		RR->rtmem = m;
		while (((uintptr_t)m & 0xf) != 0) {
			++m;
		}

		RR->t = new (m) Trace(RR);
		m += ts;
		RR->sw = new (m) Switch(RR);
		m += sws;
		RR->mc = new (m) Multicaster(RR);
		m += mcs;
		RR->topology = new (m) Topology(RR, tptr);
		m += topologys;
		RR->sa = new (m) SelfAwareness(RR);
		m += sas;
		RR->bc = new (m) Bond(RR);
		m += bcs;
		RR->pm = new (m) PacketMultiplexer(RR);
	}
	catch (...) {
		if (RR->sa) {
			RR->sa->~SelfAwareness();
		}
		if (RR->topology) {
			RR->topology->~Topology();
		}
		if (RR->mc) {
			RR->mc->~Multicaster();
		}
		if (RR->sw) {
			RR->sw->~Switch();
		}
		if (RR->t) {
			RR->t->~Trace();
		}
		if (RR->bc) {
			RR->bc->~Bond();
		}
		if (RR->pm) {
			RR->pm->~PacketMultiplexer();
		}
		::free(m);
		throw;
	}

	postEvent(tptr, ZT_EVENT_UP);
}

Node::~Node()
{
	{
		Mutex::Lock _l(_networks_m);
		_networks.clear();	 // destroy all networks before shutdown
	}
	if (RR->sa) {
		RR->sa->~SelfAwareness();
	}
	if (RR->topology) {
		RR->topology->~Topology();
	}
	if (RR->mc) {
		RR->mc->~Multicaster();
	}
	if (RR->sw) {
		RR->sw->~Switch();
	}
	if (RR->t) {
		RR->t->~Trace();
	}
	if (RR->bc) {
		RR->bc->~Bond();
	}
	if (RR->pm) {
		RR->pm->~PacketMultiplexer();
	}
	::free(RR->rtmem);
}

ZT_ResultCode Node::processWirePacket(void* tptr, int64_t now, int64_t localSocket, const struct sockaddr_storage* remoteAddress, const void* packetData, unsigned int packetLength, volatile int64_t* nextBackgroundTaskDeadline)
{
	_now = now;
	RR->sw->onRemotePacket(tptr, localSocket, *(reinterpret_cast<const InetAddress*>(remoteAddress)), packetData, packetLength);
	return ZT_RESULT_OK;
}

ZT_ResultCode Node::processVirtualNetworkFrame(
	void* tptr,
	int64_t now,
	uint64_t nwid,
	uint64_t sourceMac,
	uint64_t destMac,
	unsigned int etherType,
	unsigned int vlanId,
	const void* frameData,
	unsigned int frameLength,
	volatile int64_t* nextBackgroundTaskDeadline)
{
	_now = now;
	SharedPtr<Network> nw(this->network(nwid));
	if (nw) {
		RR->sw->onLocalEthernet(tptr, nw, MAC(sourceMac), MAC(destMac), etherType, vlanId, frameData, frameLength);
		return ZT_RESULT_OK;
	}
	else {
		return ZT_RESULT_ERROR_NETWORK_NOT_FOUND;
	}
}

void Node::initMultithreading(unsigned int concurrency, bool cpuPinningEnabled)
{
	RR->pm->setUpPostDecodeReceiveThreads(concurrency, cpuPinningEnabled);
}

// Closure used to ping upstream and active/online peers
class _PingPeersThatNeedPing {
  public:
	_PingPeersThatNeedPing(const RuntimeEnvironment* renv, void* tPtr, Hashtable<Address, std::vector<InetAddress> >& alwaysContact, int64_t now)
		: RR(renv)
		, _tPtr(tPtr)
		, _alwaysContact(alwaysContact)
		, _now(now)
		, _bestCurrentUpstream(RR->topology->getUpstreamPeer())
	{
	}

	inline void operator()(Topology& t, const SharedPtr<Peer>& p)
	{
		const std::vector<InetAddress>* const alwaysContactEndpoints = _alwaysContact.get(p->address());
		if (alwaysContactEndpoints) {
			ZT_PeerRole role = RR->topology->role(p->address());

			// Contact upstream peers as infrequently as possible
			int roleBasedTimerScale = (role == ZT_PEER_ROLE_LEAF) ? 2 : 16;

			// Unless we don't any have paths to the roots, then we shouldn't wait a long time to contact them
			bool hasPaths = p->paths(RR->node->now()).size() > 0;
			roleBasedTimerScale = (role != ZT_PEER_ROLE_LEAF && ! hasPaths) ? 0 : roleBasedTimerScale;

			if ((RR->node->now() - p->lastSentFullHello()) <= (ZT_PATH_HEARTBEAT_PERIOD * roleBasedTimerScale)) {
				return;
			}

			const unsigned int sent = p->doPingAndKeepalive(_tPtr, _now);
			bool contacted = (sent != 0);

			if ((sent & 0x1) == 0) {   // bit 0x1 == IPv4 sent
				for (unsigned long k = 0, ptr = (unsigned long)RR->node->prng(); k < (unsigned long)alwaysContactEndpoints->size(); ++k) {
					const InetAddress& addr = (*alwaysContactEndpoints)[ptr++ % alwaysContactEndpoints->size()];
					if (addr.ss_family == AF_INET) {
						p->sendHELLO(_tPtr, -1, addr, _now);
						contacted = true;
						break;
					}
				}
			}

			if ((sent & 0x2) == 0) {   // bit 0x2 == IPv6 sent
				for (unsigned long k = 0, ptr = (unsigned long)RR->node->prng(); k < (unsigned long)alwaysContactEndpoints->size(); ++k) {
					const InetAddress& addr = (*alwaysContactEndpoints)[ptr++ % alwaysContactEndpoints->size()];
					if (addr.ss_family == AF_INET6) {
						p->sendHELLO(_tPtr, -1, addr, _now);
						contacted = true;
						break;
					}
				}
			}

			if ((! contacted) && (_bestCurrentUpstream)) {
				const SharedPtr<Path> up(_bestCurrentUpstream->getAppropriatePath(_now, true));
				if (up) {
					p->sendHELLO(_tPtr, up->localSocket(), up->address(), _now);
				}
			}

			_alwaysContact.erase(p->address());	  // after this we'll WHOIS all upstreams that remain
		}
		else if (p->isActive(_now)) {
			p->doPingAndKeepalive(_tPtr, _now);
		}
	}

  private:
	const RuntimeEnvironment* RR;
	void* _tPtr;
	Hashtable<Address, std::vector<InetAddress> >& _alwaysContact;
	const int64_t _now;
	const SharedPtr<Peer> _bestCurrentUpstream;
};

ZT_ResultCode Node::processBackgroundTasks(void* tptr, int64_t now, volatile int64_t* nextBackgroundTaskDeadline)
{
	_now = now;
	Mutex::Lock bl(_backgroundTasksLock);

	// Process background bond tasks
	unsigned long bondCheckInterval = ZT_PING_CHECK_INTERVAL;
	if (RR->bc->inUse()) {
		bondCheckInterval = std::max(RR->bc->minReqMonitorInterval(), ZT_CORE_TIMER_TASK_GRANULARITY);
		if ((now - _lastGratuitousPingCheck) >= ZT_CORE_TIMER_TASK_GRANULARITY) {
			_lastGratuitousPingCheck = now;
			RR->bc->processBackgroundTasks(tptr, now);
		}
	}

	unsigned long timeUntilNextPingCheck = _lowBandwidthMode ? (ZT_PING_CHECK_INTERVAL * 5) : ZT_PING_CHECK_INTERVAL;
	const int64_t timeSinceLastPingCheck = now - _lastPingCheck;
	if (timeSinceLastPingCheck >= timeUntilNextPingCheck) {
		try {
			_lastPingCheck = now;

			// Get designated VL1 upstreams
			Hashtable<Address, std::vector<InetAddress> > alwaysContact;
			RR->topology->getUpstreamsToContact(alwaysContact);

			// Uncomment to dump stats
			/*
			for(unsigned int i=0;i<32;i++) {
				if (_stats.inVerbCounts[i] > 0)
					printf("%.2x\t%12lld %lld\n",i,(unsigned long long)_stats.inVerbCounts[i],(unsigned long long)_stats.inVerbBytes[i]);
			}
			printf("\n");
			*/

			// Check last receive time on designated upstreams to see if we seem to be online
			int64_t lastReceivedFromUpstream = 0;
			{
				Hashtable<Address, std::vector<InetAddress> >::Iterator i(alwaysContact);
				Address* upstreamAddress = (Address*)0;
				std::vector<InetAddress>* upstreamStableEndpoints = (std::vector<InetAddress>*)0;
				while (i.next(upstreamAddress, upstreamStableEndpoints)) {
					SharedPtr<Peer> p(RR->topology->getPeerNoCache(*upstreamAddress));
					if (p) {
						lastReceivedFromUpstream = std::max(p->lastReceive(), lastReceivedFromUpstream);
					}
				}
			}

			// Clean up any old local controller auth memorizations.
			{
				_localControllerAuthorizations_m.lock();
				Hashtable<_LocalControllerAuth, int64_t>::Iterator i(_localControllerAuthorizations);
				_LocalControllerAuth* k = (_LocalControllerAuth*)0;
				int64_t* v = (int64_t*)0;
				while (i.next(k, v)) {
					if ((*v - now) > (ZT_NETWORK_AUTOCONF_DELAY * 3)) {
						_localControllerAuthorizations.erase(*k);
					}
				}
				_localControllerAuthorizations_m.unlock();
			}

			// Get peers we should stay connected to according to network configs
			// Also get networks and whether they need config so we only have to do one pass over networks
			int timerScale = _lowBandwidthMode ? 64 : 1;
			std::vector<std::pair<SharedPtr<Network>, bool> > networkConfigNeeded;
			{
				Mutex::Lock l(_networks_m);
				Hashtable<uint64_t, SharedPtr<Network> >::Iterator i(_networks);
				uint64_t* nwid = (uint64_t*)0;
				SharedPtr<Network>* network = (SharedPtr<Network>*)0;
				while (i.next(nwid, network)) {
					(*network)->config().alwaysContactAddresses(alwaysContact);
					networkConfigNeeded.push_back(std::pair<SharedPtr<Network>, bool>(*network, (((now - (*network)->lastConfigUpdate()) >= ZT_NETWORK_AUTOCONF_DELAY * timerScale) || (! (*network)->hasConfig()))));
				}
			}

			// Ping active peers, upstreams, and others that we should always contact
			_PingPeersThatNeedPing pfunc(RR, tptr, alwaysContact, now);
			RR->topology->eachPeer<_PingPeersThatNeedPing&>(pfunc);

			// Run WHOIS to create Peer for alwaysContact addresses that could not be contacted
			{
				Hashtable<Address, std::vector<InetAddress> >::Iterator i(alwaysContact);
				Address* upstreamAddress = (Address*)0;
				std::vector<InetAddress>* upstreamStableEndpoints = (std::vector<InetAddress>*)0;
				while (i.next(upstreamAddress, upstreamStableEndpoints)) {
					RR->sw->requestWhois(tptr, now, *upstreamAddress);
				}
			}

			// Refresh network config or broadcast network updates to members as needed
			for (std::vector<std::pair<SharedPtr<Network>, bool> >::const_iterator n(networkConfigNeeded.begin()); n != networkConfigNeeded.end(); ++n) {
				if (n->second) {
					n->first->requestConfiguration(tptr);
				}
				if (! _lowBandwidthMode) {
					n->first->sendUpdatesToMembers(tptr);
				}
			}

			// Update online status, post status change as event
			const bool oldOnline = _online;
			_online = (((now - lastReceivedFromUpstream) < ZT_PEER_ACTIVITY_TIMEOUT) || (RR->topology->amUpstream()));
			if (oldOnline != _online) {
				postEvent(tptr, _online ? ZT_EVENT_ONLINE : ZT_EVENT_OFFLINE);
			}
		}
		catch (...) {
			return ZT_RESULT_FATAL_ERROR_INTERNAL;
		}
	}
	else {
		timeUntilNextPingCheck -= (unsigned long)timeSinceLastPingCheck;
	}

	if ((now - _lastMemoizedTraceSettings) >= (ZT_HOUSEKEEPING_PERIOD / 4)) {
		_lastMemoizedTraceSettings = now;
		RR->t->updateMemoizedSettings();
	}

	if ((now - _lastHousekeepingRun) >= ZT_HOUSEKEEPING_PERIOD) {
		_lastHousekeepingRun = now;
		try {
			RR->topology->doPeriodicTasks(tptr, now);
			RR->sa->clean(now);
			RR->mc->clean(now);
		}
		catch (...) {
			return ZT_RESULT_FATAL_ERROR_INTERNAL;
		}
	}

	try {
		*nextBackgroundTaskDeadline = now + (int64_t)std::max(std::min(bondCheckInterval, std::min(timeUntilNextPingCheck, RR->sw->doTimerTasks(tptr, now))), (unsigned long)ZT_CORE_TIMER_TASK_GRANULARITY);
	}
	catch (...) {
		return ZT_RESULT_FATAL_ERROR_INTERNAL;
	}

	return ZT_RESULT_OK;
}

ZT_ResultCode Node::join(uint64_t nwid, void* uptr, void* tptr)
{
	Mutex::Lock _l(_networks_m);
	SharedPtr<Network>& nw = _networks[nwid];
	if (! nw) {
		nw = SharedPtr<Network>(new Network(RR, tptr, nwid, uptr, (const NetworkConfig*)0));
	}
	return ZT_RESULT_OK;
}

ZT_ResultCode Node::leave(uint64_t nwid, void** uptr, void* tptr)
{
	ZT_VirtualNetworkConfig ctmp;
	void** nUserPtr = (void**)0;
	{
		Mutex::Lock _l(_networks_m);
		SharedPtr<Network>* nw = _networks.get(nwid);
		RR->sw->removeNetworkQoSControlBlock(nwid);
		if (! nw) {
			return ZT_RESULT_OK;
		}
		if (uptr) {
			*uptr = (*nw)->userPtr();
		}
		(*nw)->externalConfig(&ctmp);
		(*nw)->destroy();
		nUserPtr = (*nw)->userPtr();
	}

	if (nUserPtr) {
		RR->node->configureVirtualNetworkPort(tptr, nwid, nUserPtr, ZT_VIRTUAL_NETWORK_CONFIG_OPERATION_DESTROY, &ctmp);
	}

	{
		Mutex::Lock _l(_networks_m);
		_networks.erase(nwid);
	}

	uint64_t tmp[2];
	tmp[0] = nwid;
	tmp[1] = 0;
	RR->node->stateObjectDelete(tptr, ZT_STATE_OBJECT_NETWORK_CONFIG, tmp);

	return ZT_RESULT_OK;
}

ZT_ResultCode Node::multicastSubscribe(void* tptr, uint64_t nwid, uint64_t multicastGroup, unsigned long multicastAdi)
{
	SharedPtr<Network> nw(this->network(nwid));
	if (nw) {
		nw->multicastSubscribe(tptr, MulticastGroup(MAC(multicastGroup), (uint32_t)(multicastAdi & 0xffffffff)));
		return ZT_RESULT_OK;
	}
	else {
		return ZT_RESULT_ERROR_NETWORK_NOT_FOUND;
	}
}

ZT_ResultCode Node::multicastUnsubscribe(uint64_t nwid, uint64_t multicastGroup, unsigned long multicastAdi)
{
	SharedPtr<Network> nw(this->network(nwid));
	if (nw) {
		nw->multicastUnsubscribe(MulticastGroup(MAC(multicastGroup), (uint32_t)(multicastAdi & 0xffffffff)));
		return ZT_RESULT_OK;
	}
	else {
		return ZT_RESULT_ERROR_NETWORK_NOT_FOUND;
	}
}

ZT_ResultCode Node::orbit(void* tptr, uint64_t moonWorldId, uint64_t moonSeed)
{
	RR->topology->addMoon(tptr, moonWorldId, Address(moonSeed));
	return ZT_RESULT_OK;
}

ZT_ResultCode Node::deorbit(void* tptr, uint64_t moonWorldId)
{
	RR->topology->removeMoon(tptr, moonWorldId);
	return ZT_RESULT_OK;
}

uint64_t Node::address() const
{
	return RR->identity.address().toInt();
}

void Node::status(ZT_NodeStatus* status) const
{
	status->address = RR->identity.address().toInt();
	status->publicIdentity = RR->publicIdentityStr;
	status->secretIdentity = RR->secretIdentityStr;
	status->online = _online ? 1 : 0;
}

ZT_PeerList* Node::peers() const
{
	std::vector<std::pair<Address, SharedPtr<Peer> > > peers(RR->topology->allPeers());
	std::sort(peers.begin(), peers.end());

	char* buf = (char*)::malloc(sizeof(ZT_PeerList) + (sizeof(ZT_Peer) * peers.size()));
	if (! buf) {
		return (ZT_PeerList*)0;
	}
	ZT_PeerList* pl = (ZT_PeerList*)buf;
	pl->peers = (ZT_Peer*)(buf + sizeof(ZT_PeerList));

	pl->peerCount = 0;
	for (std::vector<std::pair<Address, SharedPtr<Peer> > >::iterator pi(peers.begin()); pi != peers.end(); ++pi) {
		ZT_Peer* p = &(pl->peers[pl->peerCount++]);
		p->address = pi->second->address().toInt();
		p->isBonded = 0;
		if (pi->second->remoteVersionKnown()) {
			p->versionMajor = pi->second->remoteVersionMajor();
			p->versionMinor = pi->second->remoteVersionMinor();
			p->versionRev = pi->second->remoteVersionRevision();
		}
		else {
			p->versionMajor = -1;
			p->versionMinor = -1;
			p->versionRev = -1;
		}
		p->latency = pi->second->latency(_now);
		if (p->latency >= 0xffff) {
			p->latency = -1;
		}
		p->role = RR->topology->role(pi->second->identity().address());

		std::vector<SharedPtr<Path> > paths(pi->second->paths(_now));
		SharedPtr<Path> bestp(pi->second->getAppropriatePath(_now, false));
		p->pathCount = 0;
		for (std::vector<SharedPtr<Path> >::iterator path(paths.begin()); path != paths.end(); ++path) {
			if ((*path)->valid()) {
				memcpy(&(p->paths[p->pathCount].address), &((*path)->address()), sizeof(struct sockaddr_storage));
				p->paths[p->pathCount].localSocket = (*path)->localSocket();
				p->paths[p->pathCount].localPort = (*path)->localPort();
				p->paths[p->pathCount].lastSend = (*path)->lastOut();
				p->paths[p->pathCount].lastReceive = (*path)->lastIn();
				p->paths[p->pathCount].trustedPathId = RR->topology->getOutboundPathTrust((*path)->address());
				p->paths[p->pathCount].expired = 0;
				p->paths[p->pathCount].preferred = ((*path) == bestp) ? 1 : 0;
				p->paths[p->pathCount].scope = (*path)->ipScope();
				if (pi->second->bond()) {
					p->paths[p->pathCount].latencyMean = (*path)->latencyMean();
					p->paths[p->pathCount].latencyVariance = (*path)->latencyVariance();
					p->paths[p->pathCount].packetLossRatio = (*path)->packetLossRatio();
					p->paths[p->pathCount].packetErrorRatio = (*path)->packetErrorRatio();
					p->paths[p->pathCount].assignedFlowCount = (*path)->assignedFlowCount();
					p->paths[p->pathCount].relativeQuality = (*path)->relativeQuality();
					p->paths[p->pathCount].linkSpeed = (*path)->givenLinkSpeed();
					p->paths[p->pathCount].bonded = (*path)->bonded();
					p->paths[p->pathCount].eligible = (*path)->eligible();
					std::string ifname = std::string((*path)->ifname());
					memset(p->paths[p->pathCount].ifname, 0x0, std::min((int)ifname.length() + 1, ZT_MAX_PHYSIFNAME));
					memcpy(p->paths[p->pathCount].ifname, ifname.c_str(), std::min((int)ifname.length(), ZT_MAX_PHYSIFNAME));
				}
				++p->pathCount;
			}
		}
		if (pi->second->bond()) {
			p->isBonded = pi->second->bond();
			p->bondingPolicy = pi->second->bondingPolicy();
			p->numAliveLinks = pi->second->getNumAliveLinks();
			p->numTotalLinks = pi->second->getNumTotalLinks();
		}
	}

	return pl;
}

ZT_VirtualNetworkConfig* Node::networkConfig(uint64_t nwid) const
{
	Mutex::Lock _l(_networks_m);
	const SharedPtr<Network>* nw = _networks.get(nwid);
	if (nw) {
		ZT_VirtualNetworkConfig* nc = (ZT_VirtualNetworkConfig*)::malloc(sizeof(ZT_VirtualNetworkConfig));
		(*nw)->externalConfig(nc);
		return nc;
	}
	return (ZT_VirtualNetworkConfig*)0;
}

ZT_VirtualNetworkList* Node::networks() const
{
	Mutex::Lock _l(_networks_m);

	char* buf = (char*)::malloc(sizeof(ZT_VirtualNetworkList) + (sizeof(ZT_VirtualNetworkConfig) * _networks.size()));
	if (! buf) {
		return (ZT_VirtualNetworkList*)0;
	}
	ZT_VirtualNetworkList* nl = (ZT_VirtualNetworkList*)buf;
	nl->networks = (ZT_VirtualNetworkConfig*)(buf + sizeof(ZT_VirtualNetworkList));

	nl->networkCount = 0;
	Hashtable<uint64_t, SharedPtr<Network> >::Iterator i(*const_cast<Hashtable<uint64_t, SharedPtr<Network> >*>(&_networks));
	uint64_t* k = (uint64_t*)0;
	SharedPtr<Network>* v = (SharedPtr<Network>*)0;
	while (i.next(k, v)) {
		(*v)->externalConfig(&(nl->networks[nl->networkCount++]));
	}

	return nl;
}

void Node::freeQueryResult(void* qr)
{
	if (qr) {
		::free(qr);
	}
}

int Node::addLocalInterfaceAddress(const struct sockaddr_storage* addr)
{
	if (Path::isAddressValidForPath(*(reinterpret_cast<const InetAddress*>(addr)))) {
		Mutex::Lock _l(_directPaths_m);
		if (std::find(_directPaths.begin(), _directPaths.end(), *(reinterpret_cast<const InetAddress*>(addr))) == _directPaths.end()) {
			_directPaths.push_back(*(reinterpret_cast<const InetAddress*>(addr)));
			return 1;
		}
	}
	return 0;
}

void Node::clearLocalInterfaceAddresses()
{
	Mutex::Lock _l(_directPaths_m);
	_directPaths.clear();
}

int Node::sendUserMessage(void* tptr, uint64_t dest, uint64_t typeId, const void* data, unsigned int len)
{
	try {
		if (RR->identity.address().toInt() != dest) {
			Packet outp(Address(dest), RR->identity.address(), Packet::VERB_USER_MESSAGE);
			outp.append(typeId);
			outp.append(data, len);
			outp.compress();
			RR->sw->send(tptr, outp, true);
			return 1;
		}
	}
	catch (...) {
	}
	return 0;
}

void Node::setNetconfMaster(void* networkControllerInstance)
{
	RR->localNetworkController = reinterpret_cast<NetworkController*>(networkControllerInstance);
	if (networkControllerInstance) {
		RR->localNetworkController->init(RR->identity, this);
	}
}

/****************************************************************************/
/* Node methods used only within node/                                      */
/****************************************************************************/

bool Node::shouldUsePathForZeroTierTraffic(void* tPtr, const Address& ztaddr, const int64_t localSocket, const InetAddress& remoteAddress)
{
	if (! Path::isAddressValidForPath(remoteAddress)) {
		return false;
	}

	if (RR->topology->isProhibitedEndpoint(ztaddr, remoteAddress)) {
		return false;
	}

	{
		Mutex::Lock _l(_networks_m);
		Hashtable<uint64_t, SharedPtr<Network> >::Iterator i(_networks);
		uint64_t* k = (uint64_t*)0;
		SharedPtr<Network>* v = (SharedPtr<Network>*)0;
		while (i.next(k, v)) {
			if ((*v)->hasConfig()) {
				for (unsigned int k = 0; k < (*v)->config().staticIpCount; ++k) {
					if ((*v)->config().staticIps[k].containsAddress(remoteAddress)) {
						return false;
					}
				}
			}
		}
	}

	return ((_cb.pathCheckFunction) ? (_cb.pathCheckFunction(reinterpret_cast<ZT_Node*>(this), _uPtr, tPtr, ztaddr.toInt(), localSocket, reinterpret_cast<const struct sockaddr_storage*>(&remoteAddress)) != 0) : true);
}

uint64_t Node::prng()
{
	// https://en.wikipedia.org/wiki/Xorshift#xorshift.2B
	uint64_t x = _prngState[0];
	const uint64_t y = _prngState[1];
	_prngState[0] = y;
	x ^= x << 23;
	const uint64_t z = x ^ y ^ (x >> 17) ^ (y >> 26);
	_prngState[1] = z;
	return z + y;
}

ZT_ResultCode Node::setPhysicalPathConfiguration(const struct sockaddr_storage* pathNetwork, const ZT_PhysicalPathConfiguration* pathConfig)
{
	RR->topology->setPhysicalPathConfiguration(pathNetwork, pathConfig);
	return ZT_RESULT_OK;
}

World Node::planet() const
{
	return RR->topology->planet();
}

std::vector<World> Node::moons() const
{
	return RR->topology->moons();
}

void Node::ncSendConfig(uint64_t nwid, uint64_t requestPacketId, const Address& destination, const NetworkConfig& nc, bool sendLegacyFormatConfig)
{
	_localControllerAuthorizations_m.lock();
	_localControllerAuthorizations[_LocalControllerAuth(nwid, destination)] = now();
	_localControllerAuthorizations_m.unlock();

	if (destination == RR->identity.address()) {
		SharedPtr<Network> n(network(nwid));
		if (! n) {
			return;
		}
		n->setConfiguration((void*)0, nc, true);
	}
	else {
		Dictionary<ZT_NETWORKCONFIG_DICT_CAPACITY>* dconf = new Dictionary<ZT_NETWORKCONFIG_DICT_CAPACITY>();
		try {
			if (nc.toDictionary(*dconf, sendLegacyFormatConfig)) {
				uint64_t configUpdateId = prng();
				if (! configUpdateId) {
					++configUpdateId;
				}

				const unsigned int totalSize = dconf->sizeBytes();
				unsigned int chunkIndex = 0;
				while (chunkIndex < totalSize) {
					const unsigned int chunkLen = std::min(totalSize - chunkIndex, (unsigned int)(ZT_PROTO_MAX_PACKET_LENGTH - (ZT_PACKET_IDX_PAYLOAD + 256)));
					Packet outp(destination, RR->identity.address(), (requestPacketId) ? Packet::VERB_OK : Packet::VERB_NETWORK_CONFIG);
					if (requestPacketId) {
						outp.append((unsigned char)Packet::VERB_NETWORK_CONFIG_REQUEST);
						outp.append(requestPacketId);
					}

					const unsigned int sigStart = outp.size();
					outp.append(nwid);
					outp.append((uint16_t)chunkLen);
					outp.append((const void*)(dconf->data() + chunkIndex), chunkLen);

					outp.append((uint8_t)0);   // no flags
					outp.append((uint64_t)configUpdateId);
					outp.append((uint32_t)totalSize);
					outp.append((uint32_t)chunkIndex);

					ECC::Signature sig(RR->identity.sign(reinterpret_cast<const uint8_t*>(outp.data()) + sigStart, outp.size() - sigStart));
					outp.append((uint8_t)1);
					outp.append((uint16_t)ZT_ECC_SIGNATURE_LEN);
					outp.append(sig.data, ZT_ECC_SIGNATURE_LEN);

					outp.compress();
					RR->sw->send((void*)0, outp, true);
					chunkIndex += chunkLen;
				}
			}
			delete dconf;
		}
		catch (...) {
			delete dconf;
			throw;
		}
	}
}

void Node::ncSendRevocation(const Address& destination, const Revocation& rev)
{
	if (destination == RR->identity.address()) {
		SharedPtr<Network> n(network(rev.networkId()));
		if (! n) {
			return;
		}
		n->addCredential((void*)0, RR->identity.address(), rev);
	}
	else {
		Packet outp(destination, RR->identity.address(), Packet::VERB_NETWORK_CREDENTIALS);
		outp.append((uint8_t)0x00);
		outp.append((uint16_t)0);
		outp.append((uint16_t)0);
		outp.append((uint16_t)1);
		rev.serialize(outp);
		outp.append((uint16_t)0);
		RR->sw->send((void*)0, outp, true);
	}
}

void Node::ncSendError(uint64_t nwid, uint64_t requestPacketId, const Address& destination, NetworkController::ErrorCode errorCode, const void* errorData, unsigned int errorDataSize)
{
	if (destination == RR->identity.address()) {
		SharedPtr<Network> n(network(nwid));
		if (! n) {
			return;
		}
		switch (errorCode) {
			case NetworkController::NC_ERROR_OBJECT_NOT_FOUND:
			case NetworkController::NC_ERROR_INTERNAL_SERVER_ERROR:
				n->setNotFound(nullptr);
				break;
			case NetworkController::NC_ERROR_ACCESS_DENIED:
				n->setAccessDenied(nullptr);
				break;
			case NetworkController::NC_ERROR_AUTHENTICATION_REQUIRED: {
				// fprintf(stderr, "\n\nGot auth required\n\n");
				break;
			}

			default:
				break;
		}
	}
	else if (requestPacketId) {
		Packet outp(destination, RR->identity.address(), Packet::VERB_ERROR);
		outp.append((unsigned char)Packet::VERB_NETWORK_CONFIG_REQUEST);
		outp.append(requestPacketId);
		switch (errorCode) {
			// case NetworkController::NC_ERROR_OBJECT_NOT_FOUND:
			// case NetworkController::NC_ERROR_INTERNAL_SERVER_ERROR:
			default:
				outp.append((unsigned char)Packet::ERROR_OBJ_NOT_FOUND);
				Metrics::pkt_error_obj_not_found_out++;
				break;
			case NetworkController::NC_ERROR_ACCESS_DENIED:
				outp.append((unsigned char)Packet::ERROR_NETWORK_ACCESS_DENIED_);
				Metrics::pkt_error_network_access_denied_out++;
				break;
			case NetworkController::NC_ERROR_AUTHENTICATION_REQUIRED:
				outp.append((unsigned char)Packet::ERROR_NETWORK_AUTHENTICATION_REQUIRED);
				Metrics::pkt_error_authentication_required_out++;
				break;
		}

		outp.append(nwid);

		if ((errorData) && (errorDataSize > 0) && (errorDataSize <= 0xffff)) {
			outp.append((uint16_t)errorDataSize);
			outp.append(errorData, errorDataSize);
		}

		RR->sw->send((void*)0, outp, true);
	}	// else we can't send an ERROR() in response to nothing, so discard
}

}	// namespace ZeroTier

/****************************************************************************/
/* CAPI bindings                                                            */
/****************************************************************************/

extern "C" {

enum ZT_ResultCode ZT_Node_new(ZT_Node** node, void* uptr, void* tptr, const struct ZT_Node_Callbacks* callbacks, int64_t now)
{
	*node = (ZT_Node*)0;
	try {
		*node = reinterpret_cast<ZT_Node*>(new ZeroTier::Node(uptr, tptr, callbacks, now));
		return ZT_RESULT_OK;
	}
	catch (std::bad_alloc& exc) {
		return ZT_RESULT_FATAL_ERROR_OUT_OF_MEMORY;
	}
	catch (std::runtime_error& exc) {
		return ZT_RESULT_FATAL_ERROR_DATA_STORE_FAILED;
	}
	catch (...) {
		return ZT_RESULT_FATAL_ERROR_INTERNAL;
	}
}

void ZT_Node_delete(ZT_Node* node)
{
	try {
		delete (reinterpret_cast<ZeroTier::Node*>(node));
	}
	catch (...) {
	}
}

enum ZT_ResultCode
ZT_Node_processWirePacket(ZT_Node* node, void* tptr, int64_t now, int64_t localSocket, const struct sockaddr_storage* remoteAddress, const void* packetData, unsigned int packetLength, volatile int64_t* nextBackgroundTaskDeadline)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->processWirePacket(tptr, now, localSocket, remoteAddress, packetData, packetLength, nextBackgroundTaskDeadline);
	}
	catch (std::bad_alloc& exc) {
		return ZT_RESULT_FATAL_ERROR_OUT_OF_MEMORY;
	}
	catch (...) {
		return ZT_RESULT_OK;   // "OK" since invalid packets are simply dropped, but the system is still up
	}
}

enum ZT_ResultCode ZT_Node_processVirtualNetworkFrame(
	ZT_Node* node,
	void* tptr,
	int64_t now,
	uint64_t nwid,
	uint64_t sourceMac,
	uint64_t destMac,
	unsigned int etherType,
	unsigned int vlanId,
	const void* frameData,
	unsigned int frameLength,
	volatile int64_t* nextBackgroundTaskDeadline)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->processVirtualNetworkFrame(tptr, now, nwid, sourceMac, destMac, etherType, vlanId, frameData, frameLength, nextBackgroundTaskDeadline);
	}
	catch (std::bad_alloc& exc) {
		return ZT_RESULT_FATAL_ERROR_OUT_OF_MEMORY;
	}
	catch (...) {
		return ZT_RESULT_FATAL_ERROR_INTERNAL;
	}
}

enum ZT_ResultCode ZT_Node_processBackgroundTasks(ZT_Node* node, void* tptr, int64_t now, volatile int64_t* nextBackgroundTaskDeadline)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->processBackgroundTasks(tptr, now, nextBackgroundTaskDeadline);
	}
	catch (std::bad_alloc& exc) {
		return ZT_RESULT_FATAL_ERROR_OUT_OF_MEMORY;
	}
	catch (...) {
		return ZT_RESULT_FATAL_ERROR_INTERNAL;
	}
}

enum ZT_ResultCode ZT_Node_join(ZT_Node* node, uint64_t nwid, void* uptr, void* tptr)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->join(nwid, uptr, tptr);
	}
	catch (std::bad_alloc& exc) {
		return ZT_RESULT_FATAL_ERROR_OUT_OF_MEMORY;
	}
	catch (...) {
		return ZT_RESULT_FATAL_ERROR_INTERNAL;
	}
}

enum ZT_ResultCode ZT_Node_leave(ZT_Node* node, uint64_t nwid, void** uptr, void* tptr)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->leave(nwid, uptr, tptr);
	}
	catch (std::bad_alloc& exc) {
		return ZT_RESULT_FATAL_ERROR_OUT_OF_MEMORY;
	}
	catch (...) {
		return ZT_RESULT_FATAL_ERROR_INTERNAL;
	}
}

enum ZT_ResultCode ZT_Node_multicastSubscribe(ZT_Node* node, void* tptr, uint64_t nwid, uint64_t multicastGroup, unsigned long multicastAdi)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->multicastSubscribe(tptr, nwid, multicastGroup, multicastAdi);
	}
	catch (std::bad_alloc& exc) {
		return ZT_RESULT_FATAL_ERROR_OUT_OF_MEMORY;
	}
	catch (...) {
		return ZT_RESULT_FATAL_ERROR_INTERNAL;
	}
}

enum ZT_ResultCode ZT_Node_multicastUnsubscribe(ZT_Node* node, uint64_t nwid, uint64_t multicastGroup, unsigned long multicastAdi)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->multicastUnsubscribe(nwid, multicastGroup, multicastAdi);
	}
	catch (std::bad_alloc& exc) {
		return ZT_RESULT_FATAL_ERROR_OUT_OF_MEMORY;
	}
	catch (...) {
		return ZT_RESULT_FATAL_ERROR_INTERNAL;
	}
}

enum ZT_ResultCode ZT_Node_orbit(ZT_Node* node, void* tptr, uint64_t moonWorldId, uint64_t moonSeed)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->orbit(tptr, moonWorldId, moonSeed);
	}
	catch (...) {
		return ZT_RESULT_FATAL_ERROR_INTERNAL;
	}
}

enum ZT_ResultCode ZT_Node_deorbit(ZT_Node* node, void* tptr, uint64_t moonWorldId)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->deorbit(tptr, moonWorldId);
	}
	catch (...) {
		return ZT_RESULT_FATAL_ERROR_INTERNAL;
	}
}

uint64_t ZT_Node_address(ZT_Node* node)
{
	return reinterpret_cast<ZeroTier::Node*>(node)->address();
}

void ZT_Node_status(ZT_Node* node, ZT_NodeStatus* status)
{
	try {
		reinterpret_cast<ZeroTier::Node*>(node)->status(status);
	}
	catch (...) {
	}
}

ZT_PeerList* ZT_Node_peers(ZT_Node* node)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->peers();
	}
	catch (...) {
		return (ZT_PeerList*)0;
	}
}

ZT_VirtualNetworkConfig* ZT_Node_networkConfig(ZT_Node* node, uint64_t nwid)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->networkConfig(nwid);
	}
	catch (...) {
		return (ZT_VirtualNetworkConfig*)0;
	}
}

ZT_VirtualNetworkList* ZT_Node_networks(ZT_Node* node)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->networks();
	}
	catch (...) {
		return (ZT_VirtualNetworkList*)0;
	}
}

void ZT_Node_freeQueryResult(ZT_Node* node, void* qr)
{
	try {
		reinterpret_cast<ZeroTier::Node*>(node)->freeQueryResult(qr);
	}
	catch (...) {
	}
}

int ZT_Node_addLocalInterfaceAddress(ZT_Node* node, const struct sockaddr_storage* addr)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->addLocalInterfaceAddress(addr);
	}
	catch (...) {
		return 0;
	}
}

void ZT_Node_clearLocalInterfaceAddresses(ZT_Node* node)
{
	try {
		reinterpret_cast<ZeroTier::Node*>(node)->clearLocalInterfaceAddresses();
	}
	catch (...) {
	}
}

int ZT_Node_sendUserMessage(ZT_Node* node, void* tptr, uint64_t dest, uint64_t typeId, const void* data, unsigned int len)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->sendUserMessage(tptr, dest, typeId, data, len);
	}
	catch (...) {
		return 0;
	}
}

void ZT_Node_setNetconfMaster(ZT_Node* node, void* networkControllerInstance)
{
	try {
		reinterpret_cast<ZeroTier::Node*>(node)->setNetconfMaster(networkControllerInstance);
	}
	catch (...) {
	}
}

enum ZT_ResultCode ZT_Node_setPhysicalPathConfiguration(ZT_Node* node, const struct sockaddr_storage* pathNetwork, const ZT_PhysicalPathConfiguration* pathConfig)
{
	try {
		return reinterpret_cast<ZeroTier::Node*>(node)->setPhysicalPathConfiguration(pathNetwork, pathConfig);
	}
	catch (...) {
		return ZT_RESULT_FATAL_ERROR_INTERNAL;
	}
}

void ZT_version(int* major, int* minor, int* revision)
{
	if (major) {
		*major = ZEROTIER_ONE_VERSION_MAJOR;
	}
	if (minor) {
		*minor = ZEROTIER_ONE_VERSION_MINOR;
	}
	if (revision) {
		*revision = ZEROTIER_ONE_VERSION_REVISION;
	}
}

}	// extern "C"