You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
308 lines
11 KiB
308 lines
11 KiB
/* |
|
* ZeroTier One - Network Virtualization Everywhere |
|
* Copyright (C) 2011-2016 ZeroTier, Inc. https://www.zerotier.com/ |
|
* |
|
* This program is free software: you can redistribute it and/or modify |
|
* it under the terms of the GNU General Public License as published by |
|
* the Free Software Foundation, either version 3 of the License, or |
|
* (at your option) any later version. |
|
* |
|
* This program is distributed in the hope that it will be useful, |
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
* GNU General Public License for more details. |
|
* |
|
* You should have received a copy of the GNU General Public License |
|
* along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
*/ |
|
|
|
#ifndef ZT_NODE_HPP |
|
#define ZT_NODE_HPP |
|
|
|
#include <stdio.h> |
|
#include <stdlib.h> |
|
#include <string.h> |
|
|
|
#include <map> |
|
|
|
#include "Constants.hpp" |
|
|
|
#include "../include/ZeroTierOne.h" |
|
|
|
#include "RuntimeEnvironment.hpp" |
|
#include "InetAddress.hpp" |
|
#include "Mutex.hpp" |
|
#include "MAC.hpp" |
|
#include "Network.hpp" |
|
#include "Path.hpp" |
|
#include "Salsa20.hpp" |
|
#include "NetworkController.hpp" |
|
|
|
#undef TRACE |
|
#ifdef ZT_TRACE |
|
#define TRACE(f,...) RR->node->postTrace(__FILE__,__LINE__,f,##__VA_ARGS__) |
|
#else |
|
#define TRACE(f,...) {} |
|
#endif |
|
|
|
// Bit mask for "expecting reply" hash |
|
#define ZT_EXPECTING_REPLIES_BUCKET_MASK1 255 |
|
#define ZT_EXPECTING_REPLIES_BUCKET_MASK2 31 |
|
|
|
// Size of PRNG stream buffer |
|
#define ZT_NODE_PRNG_BUF_SIZE 64 |
|
|
|
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: |
|
Node(void *uptr,const struct ZT_Node_Callbacks *callbacks,uint64_t now); |
|
virtual ~Node(); |
|
|
|
// Get rid of alignment warnings on 32-bit Windows and possibly improve performance |
|
#ifdef __WINDOWS__ |
|
void * operator new(size_t i) { return _mm_malloc(i,16); } |
|
void operator delete(void* p) { _mm_free(p); } |
|
#endif |
|
|
|
// Public API Functions ---------------------------------------------------- |
|
|
|
ZT_ResultCode processWirePacket( |
|
uint64_t now, |
|
const struct sockaddr_storage *localAddress, |
|
const struct sockaddr_storage *remoteAddress, |
|
const void *packetData, |
|
unsigned int packetLength, |
|
volatile uint64_t *nextBackgroundTaskDeadline); |
|
ZT_ResultCode processVirtualNetworkFrame( |
|
uint64_t now, |
|
uint64_t nwid, |
|
uint64_t sourceMac, |
|
uint64_t destMac, |
|
unsigned int etherType, |
|
unsigned int vlanId, |
|
const void *frameData, |
|
unsigned int frameLength, |
|
volatile uint64_t *nextBackgroundTaskDeadline); |
|
ZT_ResultCode processBackgroundTasks(uint64_t now,volatile uint64_t *nextBackgroundTaskDeadline); |
|
ZT_ResultCode setRelayPolicy(enum ZT_RelayPolicy rp); |
|
ZT_ResultCode join(uint64_t nwid,void *uptr); |
|
ZT_ResultCode leave(uint64_t nwid,void **uptr); |
|
ZT_ResultCode multicastSubscribe(uint64_t nwid,uint64_t multicastGroup,unsigned long multicastAdi); |
|
ZT_ResultCode multicastUnsubscribe(uint64_t nwid,uint64_t multicastGroup,unsigned long multicastAdi); |
|
uint64_t address() const; |
|
void status(ZT_NodeStatus *status) const; |
|
ZT_PeerList *peers() const; |
|
ZT_VirtualNetworkConfig *networkConfig(uint64_t nwid) const; |
|
ZT_VirtualNetworkList *networks() const; |
|
void freeQueryResult(void *qr); |
|
int addLocalInterfaceAddress(const struct sockaddr_storage *addr); |
|
void clearLocalInterfaceAddresses(); |
|
int sendUserMessage(uint64_t dest,uint64_t typeId,const void *data,unsigned int len); |
|
void setRole(uint64_t ztAddress,ZT_PeerRole role); |
|
void setNetconfMaster(void *networkControllerInstance); |
|
ZT_ResultCode circuitTestBegin(ZT_CircuitTest *test,void (*reportCallback)(ZT_Node *,ZT_CircuitTest *,const ZT_CircuitTestReport *)); |
|
void circuitTestEnd(ZT_CircuitTest *test); |
|
ZT_ResultCode clusterInit( |
|
unsigned int myId, |
|
const struct sockaddr_storage *zeroTierPhysicalEndpoints, |
|
unsigned int numZeroTierPhysicalEndpoints, |
|
int x, |
|
int y, |
|
int z, |
|
void (*sendFunction)(void *,unsigned int,const void *,unsigned int), |
|
void *sendFunctionArg, |
|
int (*addressToLocationFunction)(void *,const struct sockaddr_storage *,int *,int *,int *), |
|
void *addressToLocationFunctionArg); |
|
ZT_ResultCode clusterAddMember(unsigned int memberId); |
|
void clusterRemoveMember(unsigned int memberId); |
|
void clusterHandleIncomingMessage(const void *msg,unsigned int len); |
|
void clusterStatus(ZT_ClusterStatus *cs); |
|
|
|
// Internal functions ------------------------------------------------------ |
|
|
|
inline uint64_t now() const throw() { return _now; } |
|
|
|
inline bool putPacket(const InetAddress &localAddress,const InetAddress &addr,const void *data,unsigned int len,unsigned int ttl = 0) |
|
{ |
|
return (_cb.wirePacketSendFunction( |
|
reinterpret_cast<ZT_Node *>(this), |
|
_uPtr, |
|
reinterpret_cast<const struct sockaddr_storage *>(&localAddress), |
|
reinterpret_cast<const struct sockaddr_storage *>(&addr), |
|
data, |
|
len, |
|
ttl) == 0); |
|
} |
|
|
|
inline void putFrame(uint64_t nwid,void **nuptr,const MAC &source,const MAC &dest,unsigned int etherType,unsigned int vlanId,const void *data,unsigned int len) |
|
{ |
|
_cb.virtualNetworkFrameFunction( |
|
reinterpret_cast<ZT_Node *>(this), |
|
_uPtr, |
|
nwid, |
|
nuptr, |
|
source.toInt(), |
|
dest.toInt(), |
|
etherType, |
|
vlanId, |
|
data, |
|
len); |
|
} |
|
|
|
inline SharedPtr<Network> network(uint64_t nwid) const |
|
{ |
|
Mutex::Lock _l(_networks_m); |
|
return _network(nwid); |
|
} |
|
|
|
inline bool belongsToNetwork(uint64_t nwid) const |
|
{ |
|
Mutex::Lock _l(_networks_m); |
|
for(std::vector< std::pair< uint64_t, SharedPtr<Network> > >::const_iterator i=_networks.begin();i!=_networks.end();++i) { |
|
if (i->first == nwid) |
|
return true; |
|
} |
|
return false; |
|
} |
|
|
|
inline std::vector< SharedPtr<Network> > allNetworks() const |
|
{ |
|
std::vector< SharedPtr<Network> > nw; |
|
Mutex::Lock _l(_networks_m); |
|
nw.reserve(_networks.size()); |
|
for(std::vector< std::pair< uint64_t, SharedPtr<Network> > >::const_iterator i=_networks.begin();i!=_networks.end();++i) |
|
nw.push_back(i->second); |
|
return nw; |
|
} |
|
|
|
inline std::vector<InetAddress> directPaths() const |
|
{ |
|
Mutex::Lock _l(_directPaths_m); |
|
return _directPaths; |
|
} |
|
|
|
inline bool dataStorePut(const char *name,const void *data,unsigned int len,bool secure) { return (_cb.dataStorePutFunction(reinterpret_cast<ZT_Node *>(this),_uPtr,name,data,len,(int)secure) == 0); } |
|
inline bool dataStorePut(const char *name,const std::string &data,bool secure) { return dataStorePut(name,(const void *)data.data(),(unsigned int)data.length(),secure); } |
|
inline void dataStoreDelete(const char *name) { _cb.dataStorePutFunction(reinterpret_cast<ZT_Node *>(this),_uPtr,name,(const void *)0,0,0); } |
|
std::string dataStoreGet(const char *name); |
|
|
|
inline void postEvent(ZT_Event ev,const void *md = (const void *)0) { _cb.eventCallback(reinterpret_cast<ZT_Node *>(this),_uPtr,ev,md); } |
|
|
|
inline int configureVirtualNetworkPort(uint64_t nwid,void **nuptr,ZT_VirtualNetworkConfigOperation op,const ZT_VirtualNetworkConfig *nc) { return _cb.virtualNetworkConfigFunction(reinterpret_cast<ZT_Node *>(this),_uPtr,nwid,nuptr,op,nc); } |
|
|
|
inline bool online() const throw() { return _online; } |
|
inline ZT_RelayPolicy relayPolicy() const { return _relayPolicy; } |
|
|
|
#ifdef ZT_TRACE |
|
void postTrace(const char *module,unsigned int line,const char *fmt,...); |
|
#endif |
|
|
|
bool shouldUsePathForZeroTierTraffic(const Address &ztaddr,const InetAddress &localAddress,const InetAddress &remoteAddress); |
|
inline bool externalPathLookup(const Address &ztaddr,int family,InetAddress &addr) { return ( (_cb.pathLookupFunction) ? (_cb.pathLookupFunction(reinterpret_cast<ZT_Node *>(this),_uPtr,ztaddr.toInt(),family,reinterpret_cast<struct sockaddr_storage *>(&addr)) != 0) : false ); } |
|
|
|
uint64_t prng(); |
|
void postCircuitTestReport(const ZT_CircuitTestReport *report); |
|
void setTrustedPaths(const struct sockaddr_storage *networks,const uint64_t *ids,unsigned int count); |
|
|
|
/** |
|
* Register that we are expecting a reply to a packet ID |
|
* |
|
* @param packetId Packet ID to expect reply to |
|
*/ |
|
inline void expectReplyTo(const uint64_t packetId) |
|
{ |
|
const unsigned long bucket = (unsigned long)(packetId & ZT_EXPECTING_REPLIES_BUCKET_MASK1); |
|
_expectingRepliesTo[bucket][_expectingRepliesToBucketPtr[bucket]++ & ZT_EXPECTING_REPLIES_BUCKET_MASK2] = packetId; |
|
} |
|
|
|
/** |
|
* Check whether a given packet ID is something we are expecting a reply to |
|
* |
|
* @param packetId Packet ID to check |
|
* @return True if we're expecting a reply |
|
*/ |
|
inline bool expectingReplyTo(const uint64_t packetId) const |
|
{ |
|
const unsigned long bucket = (unsigned long)(packetId & ZT_EXPECTING_REPLIES_BUCKET_MASK1); |
|
for(unsigned long i=0;i<=ZT_EXPECTING_REPLIES_BUCKET_MASK2;++i) { |
|
if (_expectingRepliesTo[bucket][i] == packetId) |
|
return true; |
|
} |
|
return false; |
|
} |
|
|
|
/** |
|
* Check whether we should do potentially expensive identity verification (rate limit) |
|
* |
|
* @param now Current time |
|
* @param from Source address of packet |
|
* @return True if within rate limits |
|
*/ |
|
inline bool rateGateIdentityVerification(const uint64_t now,const InetAddress &from) |
|
{ |
|
unsigned long iph = from.rateGateHash(); |
|
if ((now - _lastIdentityVerification[iph]) >= ZT_IDENTITY_VALIDATION_SOURCE_RATE_LIMIT) { |
|
_lastIdentityVerification[iph] = now; |
|
return true; |
|
} |
|
return false; |
|
} |
|
|
|
virtual void ncSendConfig(uint64_t nwid,uint64_t requestPacketId,const Address &destination,const NetworkConfig &nc,bool sendLegacyFormatConfig); |
|
virtual void ncSendError(uint64_t nwid,uint64_t requestPacketId,const Address &destination,NetworkController::ErrorCode errorCode); |
|
|
|
private: |
|
inline SharedPtr<Network> _network(uint64_t nwid) const |
|
{ |
|
// assumes _networks_m is locked |
|
for(std::vector< std::pair< uint64_t, SharedPtr<Network> > >::const_iterator i=_networks.begin();i!=_networks.end();++i) { |
|
if (i->first == nwid) |
|
return i->second; |
|
} |
|
return SharedPtr<Network>(); |
|
} |
|
|
|
RuntimeEnvironment _RR; |
|
RuntimeEnvironment *RR; |
|
void *_uPtr; // _uptr (lower case) is reserved in Visual Studio :P |
|
ZT_Node_Callbacks _cb; |
|
|
|
// For tracking packet IDs to filter out OK/ERROR replies to packets we did not send |
|
uint8_t _expectingRepliesToBucketPtr[ZT_EXPECTING_REPLIES_BUCKET_MASK1 + 1]; |
|
uint64_t _expectingRepliesTo[ZT_EXPECTING_REPLIES_BUCKET_MASK1 + 1][ZT_EXPECTING_REPLIES_BUCKET_MASK2 + 1]; |
|
|
|
// Time of last identity verification indexed by InetAddress.rateGateHash() |
|
uint64_t _lastIdentityVerification[16384]; |
|
|
|
std::vector< std::pair< uint64_t, SharedPtr<Network> > > _networks; |
|
Mutex _networks_m; |
|
|
|
std::vector< ZT_CircuitTest * > _circuitTests; |
|
Mutex _circuitTests_m; |
|
|
|
std::vector<InetAddress> _directPaths; |
|
Mutex _directPaths_m; |
|
|
|
Mutex _backgroundTasksLock; |
|
|
|
unsigned int _prngStreamPtr; |
|
Salsa20 _prng; |
|
uint64_t _prngStream[ZT_NODE_PRNG_BUF_SIZE]; // repeatedly encrypted with _prng to yield a high-quality non-crypto PRNG stream |
|
|
|
uint64_t _now; |
|
uint64_t _lastPingCheck; |
|
uint64_t _lastHousekeepingRun; |
|
ZT_RelayPolicy _relayPolicy; |
|
bool _online; |
|
}; |
|
|
|
} // namespace ZeroTier |
|
|
|
#endif
|
|
|