2013-07-04 20:56:19 +00:00
|
|
|
/*
|
|
|
|
* ZeroTier One - Global Peer to Peer Ethernet
|
2014-02-16 20:40:22 +00:00
|
|
|
* Copyright (C) 2011-2014 ZeroTier Networks LLC
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
|
|
|
* 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/>.
|
|
|
|
*
|
|
|
|
* --
|
|
|
|
*
|
|
|
|
* ZeroTier may be used and distributed under the terms of the GPLv3, which
|
|
|
|
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
|
|
|
|
*
|
|
|
|
* If you would like to embed ZeroTier into a commercial application or
|
|
|
|
* redistribute it in a modified binary form, please contact ZeroTier Networks
|
|
|
|
* LLC. Start here: http://www.zerotier.com/
|
|
|
|
*/
|
|
|
|
|
2013-12-07 00:49:20 +00:00
|
|
|
#ifndef ZT_TOPOLOGY_HPP
|
|
|
|
#define ZT_TOPOLOGY_HPP
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2013-07-06 18:58:34 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
2013-09-17 19:53:59 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#include <map>
|
|
|
|
#include <set>
|
|
|
|
#include <vector>
|
|
|
|
#include <stdexcept>
|
|
|
|
|
2013-10-05 14:19:12 +00:00
|
|
|
#include "Constants.hpp"
|
2014-08-14 23:52:22 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#include "Address.hpp"
|
2014-08-14 23:52:22 +00:00
|
|
|
#include "Identity.hpp"
|
2013-07-04 20:56:19 +00:00
|
|
|
#include "Peer.hpp"
|
|
|
|
#include "Mutex.hpp"
|
|
|
|
#include "InetAddress.hpp"
|
|
|
|
#include "Utils.hpp"
|
2014-01-29 00:12:24 +00:00
|
|
|
#include "Packet.hpp"
|
2014-01-30 06:04:23 +00:00
|
|
|
#include "Logger.hpp"
|
2014-08-14 23:52:22 +00:00
|
|
|
#include "Dictionary.hpp"
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
namespace ZeroTier {
|
|
|
|
|
|
|
|
class RuntimeEnvironment;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Database of network topology
|
|
|
|
*/
|
2013-08-05 20:06:16 +00:00
|
|
|
class Topology
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
|
|
|
public:
|
2013-10-21 18:12:00 +00:00
|
|
|
Topology(const RuntimeEnvironment *renv,bool enablePermanentIdCaching);
|
2013-08-05 20:06:16 +00:00
|
|
|
~Topology();
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set up supernodes for this network
|
|
|
|
*
|
|
|
|
* @param sn Supernodes for this network
|
|
|
|
*/
|
2014-03-26 22:35:15 +00:00
|
|
|
void setSupernodes(const std::map< Identity,std::vector< std::pair<InetAddress,bool> > > &sn);
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2014-08-14 22:06:18 +00:00
|
|
|
/**
|
|
|
|
* Set up supernodes for this network
|
|
|
|
*
|
|
|
|
* This performs no signature verification of any kind. The caller must
|
|
|
|
* check the signature of the root topology dictionary first.
|
|
|
|
*
|
|
|
|
* @param sn Supernodes dictionary from root-topology
|
|
|
|
*/
|
|
|
|
void setSupernodes(const Dictionary &sn);
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
2013-10-05 14:19:12 +00:00
|
|
|
* Add a peer to database
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
2013-10-05 14:19:12 +00:00
|
|
|
* This will not replace existing peers. In that case the existing peer
|
|
|
|
* record is returned.
|
|
|
|
*
|
|
|
|
* @param peer Peer to add
|
|
|
|
* @return New or existing peer (should replace 'peer')
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-10-05 14:19:12 +00:00
|
|
|
SharedPtr<Peer> addPeer(const SharedPtr<Peer> &peer);
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a peer from its address
|
|
|
|
*
|
|
|
|
* @param zta ZeroTier address of peer
|
|
|
|
* @return Peer or NULL if not found
|
|
|
|
*/
|
2014-06-30 18:31:04 +00:00
|
|
|
SharedPtr<Peer> getPeer(const Address &zta) const;
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2013-10-21 18:12:00 +00:00
|
|
|
/**
|
|
|
|
* Get an identity if cached or available in a peer record
|
|
|
|
*
|
|
|
|
* @param zta ZeroTier address
|
|
|
|
* @return Identity or NULL-identity if not found
|
|
|
|
*/
|
|
|
|
Identity getIdentity(const Address &zta);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Save identity in permanent store, or do nothing if disabled
|
|
|
|
*
|
|
|
|
* This is called automatically by addPeer(), so it should not need to be
|
|
|
|
* called manually anywhere else. The private part of the identity, if
|
|
|
|
* present, is NOT cached by this.
|
|
|
|
*
|
|
|
|
* @param id Identity to save
|
|
|
|
*/
|
|
|
|
void saveIdentity(const Identity &id);
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
|
|
|
* @return Vector of peers that are supernodes
|
|
|
|
*/
|
|
|
|
inline std::vector< SharedPtr<Peer> > supernodePeers() const
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_supernodes_m);
|
|
|
|
return _supernodePeers;
|
|
|
|
}
|
|
|
|
|
2014-09-12 23:57:37 +00:00
|
|
|
/**
|
|
|
|
* @return Number of supernodes
|
|
|
|
*/
|
|
|
|
inline unsigned int numSupernodes() const
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_supernodes_m);
|
|
|
|
return _supernodePeers.size();
|
|
|
|
}
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
|
|
|
* Get the current favorite supernode
|
|
|
|
*
|
|
|
|
* @return Supernode with lowest latency or NULL if none
|
|
|
|
*/
|
|
|
|
inline SharedPtr<Peer> getBestSupernode() const
|
|
|
|
{
|
2013-07-12 20:40:59 +00:00
|
|
|
return getBestSupernode((const Address *)0,0,false);
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the best supernode, avoiding supernodes listed in an array
|
|
|
|
*
|
|
|
|
* This will get the best supernode (lowest latency, etc.) but will
|
|
|
|
* try to avoid the listed supernodes, only using them if no others
|
|
|
|
* are available.
|
|
|
|
*
|
|
|
|
* @param avoid Nodes to avoid
|
|
|
|
* @param avoidCount Number of nodes to avoid
|
2013-07-12 20:40:59 +00:00
|
|
|
* @param strictAvoid If false, consider avoided supernodes anyway if no non-avoid supernodes are available
|
2013-07-04 20:56:19 +00:00
|
|
|
* @return Supernode or NULL if none
|
|
|
|
*/
|
2013-07-12 20:40:59 +00:00
|
|
|
SharedPtr<Peer> getBestSupernode(const Address *avoid,unsigned int avoidCount,bool strictAvoid) const;
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @param zta ZeroTier address
|
|
|
|
* @return True if this is a designated supernode
|
|
|
|
*/
|
|
|
|
inline bool isSupernode(const Address &zta) const
|
|
|
|
throw()
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_supernodes_m);
|
|
|
|
return (_supernodeAddresses.count(zta) > 0);
|
|
|
|
}
|
|
|
|
|
2014-01-29 22:09:12 +00:00
|
|
|
/**
|
|
|
|
* @return Set of supernode addresses
|
|
|
|
*/
|
|
|
|
inline std::set<Address> supernodeAddresses() const
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_supernodes_m);
|
|
|
|
return _supernodeAddresses;
|
|
|
|
}
|
|
|
|
|
2013-07-23 17:23:55 +00:00
|
|
|
/**
|
|
|
|
* @return True if this node's identity is in the supernode set
|
|
|
|
*/
|
|
|
|
inline bool amSupernode() const { return _amSupernode; }
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
2013-10-05 14:19:12 +00:00
|
|
|
* Clean and flush database
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
|
|
|
void clean();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Apply a function or function object to all peers
|
|
|
|
*
|
2014-09-17 19:54:39 +00:00
|
|
|
* Note: explicitly template this by reference if you want the object
|
|
|
|
* passed by reference instead of copied.
|
|
|
|
*
|
2013-07-04 20:56:19 +00:00
|
|
|
* @param f Function to apply
|
|
|
|
* @tparam F Function or function object type
|
|
|
|
*/
|
|
|
|
template<typename F>
|
|
|
|
inline void eachPeer(F f)
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_activePeers_m);
|
|
|
|
for(std::map< Address,SharedPtr<Peer> >::const_iterator p(_activePeers.begin());p!=_activePeers.end();++p)
|
|
|
|
f(*this,p->second);
|
|
|
|
}
|
|
|
|
|
2014-04-03 21:36:52 +00:00
|
|
|
/**
|
|
|
|
* Apply a function or function object to all supernode peers
|
|
|
|
*
|
2014-09-17 19:54:39 +00:00
|
|
|
* Note: explicitly template this by reference if you want the object
|
|
|
|
* passed by reference instead of copied.
|
|
|
|
*
|
2014-04-03 21:36:52 +00:00
|
|
|
* @param f Function to apply
|
|
|
|
* @tparam F Function or function object type
|
|
|
|
*/
|
|
|
|
template<typename F>
|
|
|
|
inline void eachSupernodePeer(F f)
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_supernodes_m);
|
|
|
|
for(std::vector< SharedPtr<Peer> >::const_iterator p(_supernodePeers.begin());p!=_supernodePeers.end();++p)
|
|
|
|
f(*this,*p);
|
|
|
|
}
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
2014-04-10 00:08:35 +00:00
|
|
|
* Pings all peers that need a ping sent, excluding supernodes
|
|
|
|
*
|
|
|
|
* Ordinary peers are pinged if we haven't heard from them recently. Receive
|
|
|
|
* time rather than send time as OK is returned on success and we want to
|
|
|
|
* keep trying if a packet is lost. Ordinary peers are subject to a frame
|
|
|
|
* inactivity timeout. We give up if we haven't actually transferred any
|
|
|
|
* data to them recently, and eventually Topology purges them from memory.
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-10-02 20:12:10 +00:00
|
|
|
class PingPeersThatNeedPing
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
|
|
|
public:
|
2014-04-02 01:39:10 +00:00
|
|
|
PingPeersThatNeedPing(const RuntimeEnvironment *renv,uint64_t now) throw() :
|
2013-10-02 20:12:10 +00:00
|
|
|
_now(now),
|
2014-01-30 22:23:52 +00:00
|
|
|
_supernodeAddresses(renv->topology->supernodeAddresses()),
|
2014-04-02 01:39:10 +00:00
|
|
|
_r(renv) {}
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
inline void operator()(Topology &t,const SharedPtr<Peer> &p)
|
|
|
|
{
|
2014-04-03 21:36:52 +00:00
|
|
|
/* For ordinary nodes we ping if they've sent us a frame recently,
|
|
|
|
* otherwise they are stale and we let the link die.
|
|
|
|
*
|
|
|
|
* Note that we measure ping time from time of last receive rather
|
|
|
|
* than time of last send in order to only count full round trips. */
|
|
|
|
if ( (!_supernodeAddresses.count(p->address())) &&
|
|
|
|
((_now - p->lastFrame()) < ZT_PEER_PATH_ACTIVITY_TIMEOUT) &&
|
2014-04-10 00:08:35 +00:00
|
|
|
((_now - p->lastDirectReceive()) >= ZT_PEER_DIRECT_PING_DELAY) ) {
|
2014-04-03 21:36:52 +00:00
|
|
|
p->sendPing(_r,_now);
|
|
|
|
}
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
uint64_t _now;
|
2014-01-30 22:23:52 +00:00
|
|
|
std::set<Address> _supernodeAddresses;
|
2013-10-02 20:12:10 +00:00
|
|
|
const RuntimeEnvironment *_r;
|
2013-07-04 20:56:19 +00:00
|
|
|
};
|
|
|
|
|
2014-04-03 21:36:52 +00:00
|
|
|
/**
|
2014-04-10 00:08:35 +00:00
|
|
|
* Ping peers that need ping according to supernode rules
|
|
|
|
*
|
|
|
|
* Supernodes ping aggressively if a ping is unanswered and they are not
|
|
|
|
* subject to the activity timeout. In other words: we assume they are
|
|
|
|
* always there and always try to reach them.
|
|
|
|
*
|
|
|
|
* The ultimate rate limit for this is controlled up in the Node main loop.
|
2014-04-03 21:36:52 +00:00
|
|
|
*/
|
|
|
|
class PingSupernodesThatNeedPing
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
PingSupernodesThatNeedPing(const RuntimeEnvironment *renv,uint64_t now) throw() :
|
|
|
|
_now(now),
|
|
|
|
_r(renv) {}
|
|
|
|
|
|
|
|
inline void operator()(Topology &t,const SharedPtr<Peer> &p)
|
|
|
|
{
|
|
|
|
/* For supernodes we always ping even if no frames have been seen, and
|
|
|
|
* we ping aggressively if pings are unanswered. The limit to this
|
|
|
|
* frequency is set in the main loop to no more than ZT_STARTUP_AGGRO. */
|
2014-04-10 00:08:35 +00:00
|
|
|
|
|
|
|
uint64_t lp = 0;
|
|
|
|
uint64_t lr = 0;
|
|
|
|
p->lastPingAndDirectReceive(lp,lr);
|
|
|
|
if ( (lr < _r->timeOfLastResynchronize) || ((lr < lp)&&((lp - lr) >= ZT_PING_UNANSWERED_AFTER)) || ((_now - lr) >= ZT_PEER_DIRECT_PING_DELAY) )
|
2014-04-03 21:36:52 +00:00
|
|
|
p->sendPing(_r,_now);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
uint64_t _now;
|
|
|
|
const RuntimeEnvironment *_r;
|
|
|
|
};
|
|
|
|
|
2014-04-10 00:08:35 +00:00
|
|
|
/**
|
|
|
|
* Computes most recent timestamp of direct packet receive over a list of peers
|
|
|
|
*/
|
|
|
|
class FindMostRecentDirectReceiveTimestamp
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
FindMostRecentDirectReceiveTimestamp(uint64_t &ts) throw() : _ts(ts) {}
|
|
|
|
inline void operator()(Topology &t,const SharedPtr<Peer> &p) throw() { _ts = std::max(p->lastDirectReceive(),_ts); }
|
|
|
|
private:
|
|
|
|
uint64_t &_ts;
|
|
|
|
};
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
2014-01-29 00:12:24 +00:00
|
|
|
* Function object to forget direct links to active peers and then ping them indirectly
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2014-01-29 00:12:24 +00:00
|
|
|
class ResetActivePeers
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
|
|
|
public:
|
2014-01-29 00:12:24 +00:00
|
|
|
ResetActivePeers(const RuntimeEnvironment *renv,uint64_t now) throw() :
|
2013-10-02 20:12:10 +00:00
|
|
|
_now(now),
|
2014-01-30 06:04:23 +00:00
|
|
|
_supernode(renv->topology->getBestSupernode()),
|
|
|
|
_supernodeAddresses(renv->topology->supernodeAddresses()),
|
2014-01-29 00:12:24 +00:00
|
|
|
_r(renv) {}
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
inline void operator()(Topology &t,const SharedPtr<Peer> &p)
|
|
|
|
{
|
2014-04-03 23:19:41 +00:00
|
|
|
p->clearPaths(false); // false means don't forget 'fixed' paths e.g. supernodes
|
|
|
|
|
|
|
|
Packet outp(p->address(),_r->identity.address(),Packet::VERB_NOP);
|
|
|
|
outp.armor(p->key(),false); // no need to encrypt a NOP
|
|
|
|
|
|
|
|
if (_supernodeAddresses.count(p->address())) {
|
|
|
|
// Send NOP directly to supernodes
|
|
|
|
p->send(_r,outp.data(),outp.size(),_now);
|
|
|
|
} else {
|
|
|
|
// Send NOP indirectly to regular peers if still active, triggering a new RENDEZVOUS
|
2014-03-21 20:46:55 +00:00
|
|
|
if (((_now - p->lastFrame()) < ZT_PEER_PATH_ACTIVITY_TIMEOUT)&&(_supernode)) {
|
2014-01-30 23:26:12 +00:00
|
|
|
TRACE("sending reset NOP to %s",p->address().toString().c_str());
|
|
|
|
_supernode->send(_r,outp.data(),outp.size(),_now);
|
|
|
|
}
|
2013-10-02 20:12:10 +00:00
|
|
|
}
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
uint64_t _now;
|
2014-01-29 00:12:24 +00:00
|
|
|
SharedPtr<Peer> _supernode;
|
2014-01-29 22:09:12 +00:00
|
|
|
std::set<Address> _supernodeAddresses;
|
2013-10-02 20:12:10 +00:00
|
|
|
const RuntimeEnvironment *_r;
|
2013-07-04 20:56:19 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function object to collect peers with any known direct path
|
|
|
|
*/
|
2013-10-02 20:12:10 +00:00
|
|
|
class CollectPeersWithActiveDirectPath
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
|
|
|
public:
|
2013-10-02 20:12:10 +00:00
|
|
|
CollectPeersWithActiveDirectPath(std::vector< SharedPtr<Peer> > &v,uint64_t now) throw() :
|
|
|
|
_now(now),
|
2014-01-29 00:12:24 +00:00
|
|
|
_v(v) {}
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
inline void operator()(Topology &t,const SharedPtr<Peer> &p)
|
|
|
|
{
|
2013-10-02 20:12:10 +00:00
|
|
|
if (p->hasActiveDirectPath(_now))
|
2013-07-04 20:56:19 +00:00
|
|
|
_v.push_back(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2013-10-02 20:12:10 +00:00
|
|
|
uint64_t _now;
|
2013-07-04 20:56:19 +00:00
|
|
|
std::vector< SharedPtr<Peer> > &_v;
|
|
|
|
};
|
|
|
|
|
2014-08-14 23:52:22 +00:00
|
|
|
/**
|
|
|
|
* Validate a root topology dictionary against the identities specified in Defaults
|
|
|
|
*
|
|
|
|
* @param rt Root topology dictionary
|
|
|
|
* @return True if dictionary signature is valid
|
|
|
|
*/
|
|
|
|
static bool authenticateRootTopology(const Dictionary &rt);
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
private:
|
|
|
|
const RuntimeEnvironment *const _r;
|
|
|
|
|
2013-10-21 15:15:47 +00:00
|
|
|
void _dumpPeers();
|
|
|
|
void _loadPeers();
|
|
|
|
|
2013-10-21 18:12:00 +00:00
|
|
|
std::string _idCacheBase; // empty if identity caching disabled
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
std::map< Address,SharedPtr<Peer> > _activePeers;
|
|
|
|
Mutex _activePeers_m;
|
|
|
|
|
2014-03-26 22:35:15 +00:00
|
|
|
std::map< Identity,std::vector< std::pair<InetAddress,bool> > > _supernodes;
|
2013-07-04 20:56:19 +00:00
|
|
|
std::set< Address > _supernodeAddresses;
|
|
|
|
std::vector< SharedPtr<Peer> > _supernodePeers;
|
|
|
|
Mutex _supernodes_m;
|
|
|
|
|
2013-07-23 17:23:55 +00:00
|
|
|
// Set to true if my identity is in _supernodes
|
|
|
|
volatile bool _amSupernode;
|
2013-07-04 20:56:19 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace ZeroTier
|
|
|
|
|
|
|
|
#endif
|