/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2019 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 .
*
* --
*
* You can be released from the requirements of the license by purchasing
* a commercial license. Buying such a license is mandatory as soon as you
* develop commercial closed-source software that incorporates or links
* directly against ZeroTier software without disclosing the source code
* of your own application.
*/
#ifndef ZT_TOPOLOGY_HPP
#define ZT_TOPOLOGY_HPP
#include
#include
#include
#include
#include
#include
#include "Constants.hpp"
#include "../include/ZeroTierOne.h"
#include "Address.hpp"
#include "Identity.hpp"
#include "Peer.hpp"
#include "Path.hpp"
#include "Mutex.hpp"
#include "InetAddress.hpp"
#include "Hashtable.hpp"
namespace ZeroTier {
class RuntimeEnvironment;
/**
* Database of network topology
*/
class Topology
{
public:
inline Topology(const RuntimeEnvironment *renv,void *tPtr) :
RR(renv),
_numConfiguredPhysicalPaths(0) {}
inline ~Topology() {}
/**
* Add a peer to database
*
* This will not replace existing peers. In that case the existing peer
* record is returned.
*
* @param tPtr Thread pointer to be handed through to any callbacks called as a result of this call
* @param peer Peer to add
* @return New or existing peer (should replace 'peer')
*/
inline SharedPtr addPeer(void *tPtr,const SharedPtr &peer)
{
SharedPtr np;
{
Mutex::Lock _l(_peers_m);
SharedPtr &hp = _peers[peer->address()];
if (!hp)
hp = peer;
np = hp;
}
return np;
}
/**
* Get a peer from its address
*
* @param tPtr Thread pointer to be handed through to any callbacks called as a result of this call
* @param zta ZeroTier address of peer
* @return Peer or NULL if not found
*/
inline SharedPtr getPeer(void *tPtr,const Address &zta) const
{
if (zta == RR->identity.address())
return SharedPtr();
Mutex::Lock _l(_peers_m);
const SharedPtr *const ap = _peers.get(zta);
return ((ap) ? *ap : SharedPtr());
}
/**
* @param tPtr Thread pointer to be handed through to any callbacks called as a result of this call
* @param zta ZeroTier address of peer
* @return Identity or NULL identity if not found
*/
inline Identity getIdentity(void *tPtr,const Address &zta)
{
if (zta == RR->identity.address()) {
return RR->identity;
} else {
Mutex::Lock _l(_peers_m);
const SharedPtr *const ap = _peers.get(zta);
if (ap)
return (*ap)->identity();
}
return Identity();
}
/**
* Get a peer only if it is presently in memory (no disk cache)
*
* This also does not update the lastUsed() time for peers, which means
* that it won't prevent them from falling out of RAM. This is currently
* used in the Cluster code to update peer info without forcing all peers
* across the entire cluster to remain in memory cache.
*
* @param zta ZeroTier address
*/
inline SharedPtr getPeerNoCache(const Address &zta)
{
Mutex::Lock _l(_peers_m);
const SharedPtr *const ap = _peers.get(zta);
if (ap)
return *ap;
return SharedPtr();
}
/**
* Get a Path object for a given local and remote physical address, creating if needed
*
* @param l Local socket
* @param r Remote address
* @return Pointer to canonicalized Path object
*/
inline SharedPtr getPath(const int64_t l,const InetAddress &r)
{
Mutex::Lock _l(_paths_m);
SharedPtr &p = _paths[Path::HashKey(l,r)];
if (!p)
p.set(new Path(l,r));
return p;
}
inline SharedPtr getUpstreamPeer() const
{
// TODO
return SharedPtr();
}
inline bool isUpstream(const Identity &id) const
{
// TODO
return false;
}
inline ZT_PeerRole role(const Address &ztaddr) const
{
// TODO
return ZT_PEER_ROLE_LEAF;
}
inline void getAlwaysContact(Hashtable< Address,std::vector > &eps) const
{
// TODO
}
inline std::vector upstreamAddresses() const
{
// TODO
return std::vector();
}
inline void doPeriodicTasks(void *tPtr,int64_t now)
{
{
Mutex::Lock _l1(_peers_m);
Hashtable< Address,SharedPtr >::Iterator i(_peers);
Address *a = (Address *)0;
SharedPtr *p = (SharedPtr *)0;
while (i.next(a,p)) {
if (!(*p)->isAlive(now)) {
_peers.erase(*a);
}
}
}
{
Mutex::Lock _l(_paths_m);
Hashtable< Path::HashKey,SharedPtr >::Iterator i(_paths);
Path::HashKey *k = (Path::HashKey *)0;
SharedPtr *p = (SharedPtr *)0;
while (i.next(k,p)) {
if (p->references() <= 1)
_paths.erase(*k);
}
}
}
/**
* @param now Current time
* @return Number of peers with active direct paths
*/
inline unsigned long countActive(int64_t now) const
{
unsigned long cnt = 0;
Mutex::Lock _l(_peers_m);
Hashtable< Address,SharedPtr >::Iterator i(const_cast(this)->_peers);
Address *a = (Address *)0;
SharedPtr *p = (SharedPtr *)0;
while (i.next(a,p)) {
const SharedPtr pp((*p)->getAppropriatePath(now,false));
if (pp)
++cnt;
}
return cnt;
}
/**
* Apply a function or function object to all peers
*
* @param f Function to apply
* @tparam F Function or function object type
*/
template
inline void eachPeer(F f)
{
Mutex::Lock _l(_peers_m);
Hashtable< Address,SharedPtr >::Iterator i(_peers);
Address *a = (Address *)0;
SharedPtr *p = (SharedPtr *)0;
while (i.next(a,p)) {
f(*this,*((const SharedPtr *)p));
}
}
/**
* @return All peers by address (unsorted)
*/
inline std::vector< std::pair< Address,SharedPtr > > allPeers() const
{
Mutex::Lock _l(_peers_m);
return _peers.entries();
}
/**
* Get info about a path
*
* The supplied result variables are not modified if no special config info is found.
*
* @param physicalAddress Physical endpoint address
* @param mtu Variable set to MTU
* @param trustedPathId Variable set to trusted path ID
*/
inline void getOutboundPathInfo(const InetAddress &physicalAddress,unsigned int &mtu,uint64_t &trustedPathId)
{
for(unsigned int i=0,j=_numConfiguredPhysicalPaths;i cpaths;
for(unsigned int i=0,j=_numConfiguredPhysicalPaths;i ZT_MAX_PHYSMTU)
pc.mtu = ZT_MAX_PHYSMTU;
cpaths[*(reinterpret_cast(pathNetwork))] = pc;
} else {
cpaths.erase(*(reinterpret_cast(pathNetwork)));
}
unsigned int cnt = 0;
for(std::map::const_iterator i(cpaths.begin());((i!=cpaths.end())&&(cntfirst;
_physicalPathConfig[cnt].second = i->second;
++cnt;
}
_numConfiguredPhysicalPaths = cnt;
}
}
private:
const RuntimeEnvironment *const RR;
std::pair _physicalPathConfig[ZT_MAX_CONFIGURABLE_PATHS];
unsigned int _numConfiguredPhysicalPaths;
Hashtable< Address,SharedPtr > _peers;
Mutex _peers_m;
Hashtable< Path::HashKey,SharedPtr > _paths;
Mutex _paths_m;
};
} // namespace ZeroTier
#endif