|
|
@@ -38,19 +38,15 @@
|
|
|
|
|
|
namespace ZeroTier {
|
|
|
|
|
|
-Topology::Topology(const RuntimeEnvironment *renv,bool enablePermanentIdCaching) :
|
|
|
+Topology::Topology(const RuntimeEnvironment *renv) :
|
|
|
RR(renv),
|
|
|
+ _idCacheBase(renv->homePath + ZT_PATH_SEPARATOR_S + "iddb.d"),
|
|
|
_amSupernode(false)
|
|
|
{
|
|
|
- if (enablePermanentIdCaching)
|
|
|
- _idCacheBase = (RR->homePath + ZT_PATH_SEPARATOR_S + "iddb.d");
|
|
|
- _loadPeers();
|
|
|
}
|
|
|
|
|
|
Topology::~Topology()
|
|
|
{
|
|
|
- clean(Utils::now());
|
|
|
- _dumpPeers();
|
|
|
}
|
|
|
|
|
|
void Topology::setSupernodes(const std::map< Identity,std::vector< std::pair<InetAddress,bool> > > &sn)
|
|
|
@@ -108,57 +104,49 @@ SharedPtr<Peer> Topology::addPeer(const SharedPtr<Peer> &peer)
|
|
|
TRACE("BUG: addNewPeer() caught and ignored attempt to add peer for self");
|
|
|
throw std::logic_error("cannot add peer for self");
|
|
|
}
|
|
|
+
|
|
|
uint64_t now = Utils::now();
|
|
|
Mutex::Lock _l(_activePeers_m);
|
|
|
+
|
|
|
SharedPtr<Peer> p(_activePeers.insert(std::pair< Address,SharedPtr<Peer> >(peer->address(),peer)).first->second);
|
|
|
p->use(now);
|
|
|
- saveIdentity(p->identity());
|
|
|
+ _saveIdentity(p->identity());
|
|
|
+
|
|
|
return p;
|
|
|
}
|
|
|
|
|
|
-SharedPtr<Peer> Topology::getPeer(const Address &zta) const
|
|
|
+SharedPtr<Peer> Topology::getPeer(const Address &zta)
|
|
|
{
|
|
|
if (zta == RR->identity.address()) {
|
|
|
TRACE("BUG: ignored attempt to getPeer() for self, returned NULL");
|
|
|
return SharedPtr<Peer>();
|
|
|
}
|
|
|
+
|
|
|
uint64_t now = Utils::now();
|
|
|
Mutex::Lock _l(_activePeers_m);
|
|
|
- std::map< Address,SharedPtr<Peer> >::const_iterator ap(_activePeers.find(zta));
|
|
|
- if ((ap != _activePeers.end())&&(ap->second)) {
|
|
|
- ap->second->use(now);
|
|
|
- return ap->second;
|
|
|
- }
|
|
|
- return SharedPtr<Peer>();
|
|
|
-}
|
|
|
|
|
|
-Identity Topology::getIdentity(const Address &zta)
|
|
|
-{
|
|
|
- SharedPtr<Peer> p(getPeer(zta));
|
|
|
- if (p)
|
|
|
- return p->identity();
|
|
|
- if (_idCacheBase.length()) {
|
|
|
- std::string idcPath(_idCacheBase + ZT_PATH_SEPARATOR_S + zta.toString());
|
|
|
- std::string ids;
|
|
|
- if (Utils::readFile(idcPath.c_str(),ids)) {
|
|
|
- try {
|
|
|
- return Identity(ids);
|
|
|
- } catch ( ... ) {} // ignore invalid IDs
|
|
|
- }
|
|
|
+ SharedPtr<Peer> &ap = _activePeers[zta];
|
|
|
+
|
|
|
+ if (ap) {
|
|
|
+ ap->use(now);
|
|
|
+ return ap;
|
|
|
}
|
|
|
- return Identity();
|
|
|
-}
|
|
|
|
|
|
-void Topology::saveIdentity(const Identity &id)
|
|
|
-{
|
|
|
- if ((id)&&(_idCacheBase.length())) {
|
|
|
- std::string idcPath(_idCacheBase + ZT_PATH_SEPARATOR_S + id.address().toString());
|
|
|
- if (!Utils::fileExists(idcPath.c_str()))
|
|
|
- Utils::writeFile(idcPath.c_str(),id.toString(false));
|
|
|
+ Identity id(_getIdentity(zta));
|
|
|
+ if (id) {
|
|
|
+ try {
|
|
|
+ ap = SharedPtr<Peer>(new Peer(RR->identity,id));
|
|
|
+ ap->use(now);
|
|
|
+ return ap;
|
|
|
+ } catch ( ... ) {} // invalid identity?
|
|
|
}
|
|
|
+
|
|
|
+ _activePeers.erase(zta);
|
|
|
+
|
|
|
+ return SharedPtr<Peer>();
|
|
|
}
|
|
|
|
|
|
-SharedPtr<Peer> Topology::getBestSupernode(const Address *avoid,unsigned int avoidCount,bool strictAvoid) const
|
|
|
+SharedPtr<Peer> Topology::getBestSupernode(const Address *avoid,unsigned int avoidCount,bool strictAvoid)
|
|
|
{
|
|
|
SharedPtr<Peer> bestSupernode;
|
|
|
uint64_t now = Utils::now();
|
|
|
@@ -261,9 +249,9 @@ void Topology::clean(uint64_t now)
|
|
|
Mutex::Lock _l(_activePeers_m);
|
|
|
Mutex::Lock _l2(_supernodes_m);
|
|
|
for(std::map< Address,SharedPtr<Peer> >::iterator p(_activePeers.begin());p!=_activePeers.end();) {
|
|
|
- if (((now - p->second->lastUsed()) >= ZT_PEER_IN_MEMORY_EXPIRATION)&&(!_supernodeAddresses.count(p->second->address())))
|
|
|
+ if (((now - p->second->lastUsed()) >= ZT_PEER_IN_MEMORY_EXPIRATION)&&(!_supernodeAddresses.count(p->second->address()))) {
|
|
|
_activePeers.erase(p++);
|
|
|
- else {
|
|
|
+ } else {
|
|
|
p->second->clean(now);
|
|
|
++p;
|
|
|
}
|
|
|
@@ -288,101 +276,24 @@ bool Topology::authenticateRootTopology(const Dictionary &rt)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-void Topology::_dumpPeers()
|
|
|
+Identity Topology::_getIdentity(const Address &zta)
|
|
|
{
|
|
|
-#ifdef ZT_PEER_SERIALIZATION_VERSION
|
|
|
- Buffer<ZT_PEER_WRITE_BUF_SIZE> buf;
|
|
|
- std::string pdpath(RR->homePath + ZT_PATH_SEPARATOR_S + "peers.persist");
|
|
|
- Mutex::Lock _l(_activePeers_m);
|
|
|
-
|
|
|
- FILE *pd = fopen(pdpath.c_str(),"wb");
|
|
|
- if (!pd)
|
|
|
- return;
|
|
|
- if (fwrite("ZTPD0",5,1,pd) != 1) {
|
|
|
- fclose(pd);
|
|
|
- Utils::rm(pdpath);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- for(std::map< Address,SharedPtr<Peer> >::iterator p(_activePeers.begin());p!=_activePeers.end();++p) {
|
|
|
+ std::string idcPath(_idCacheBase + ZT_PATH_SEPARATOR_S + zta.toString());
|
|
|
+ std::string ids;
|
|
|
+ if (Utils::readFile(idcPath.c_str(),ids)) {
|
|
|
try {
|
|
|
- p->second->serialize(buf);
|
|
|
- if (buf.size() >= (ZT_PEER_WRITE_BUF_SIZE / 2)) {
|
|
|
- if (fwrite(buf.data(),buf.size(),1,pd) != 1) {
|
|
|
- fclose(pd);
|
|
|
- Utils::rm(pdpath);
|
|
|
- buf.burn();
|
|
|
- return;
|
|
|
- }
|
|
|
- buf.clear();
|
|
|
- buf.burn();
|
|
|
- }
|
|
|
- } catch ( ... ) {
|
|
|
- fclose(pd);
|
|
|
- Utils::rm(pdpath);
|
|
|
- buf.burn();
|
|
|
- return;
|
|
|
- }
|
|
|
+ return Identity(ids);
|
|
|
+ } catch ( ... ) {} // ignore invalid IDs
|
|
|
}
|
|
|
-
|
|
|
- if (buf.size()) {
|
|
|
- if (fwrite(buf.data(),buf.size(),1,pd) != 1) {
|
|
|
- fclose(pd);
|
|
|
- Utils::rm(pdpath);
|
|
|
- buf.burn();
|
|
|
- return;
|
|
|
- }
|
|
|
- buf.burn();
|
|
|
- }
|
|
|
-
|
|
|
- fclose(pd);
|
|
|
- buf.burn();
|
|
|
-
|
|
|
- Utils::lockDownFile(pdpath.c_str(),false);
|
|
|
-#endif // ZT_PEER_SERIALIZATION_VERSION
|
|
|
+ return Identity();
|
|
|
}
|
|
|
|
|
|
-void Topology::_loadPeers()
|
|
|
+void Topology::_saveIdentity(const Identity &id)
|
|
|
{
|
|
|
- std::string pdpath(RR->homePath + ZT_PATH_SEPARATOR_S + "peers.persist");
|
|
|
-
|
|
|
-#ifdef ZT_PEER_SERIALIZATION_VERSION
|
|
|
- Buffer<ZT_PEER_WRITE_BUF_SIZE> buf;
|
|
|
- Mutex::Lock _l(_activePeers_m);
|
|
|
-
|
|
|
- _activePeers.clear();
|
|
|
-
|
|
|
- FILE *pd = fopen(pdpath.c_str(),"rb");
|
|
|
- if (!pd)
|
|
|
- return;
|
|
|
-
|
|
|
- try {
|
|
|
- char magic[5];
|
|
|
- if ((fread(magic,5,1,pd) == 1)&&(!memcmp("ZTPD0",magic,5))) {
|
|
|
- long rlen = 0;
|
|
|
- do {
|
|
|
- long rlen = (long)fread(const_cast<char *>(static_cast<const char *>(buf.data())) + buf.size(),1,ZT_PEER_WRITE_BUF_SIZE - buf.size(),pd);
|
|
|
- if (rlen < 0) rlen = 0;
|
|
|
- buf.setSize(buf.size() + (unsigned int)rlen);
|
|
|
- unsigned int ptr = 0;
|
|
|
- while ((ptr < (ZT_PEER_WRITE_BUF_SIZE / 2))&&(ptr < buf.size())) {
|
|
|
- SharedPtr<Peer> p(new Peer());
|
|
|
- ptr += p->deserialize(buf,ptr);
|
|
|
- _activePeers[p->address()] = p;
|
|
|
- saveIdentity(p->identity());
|
|
|
- }
|
|
|
- buf.behead(ptr);
|
|
|
- } while (rlen > 0);
|
|
|
- }
|
|
|
- } catch ( ... ) {
|
|
|
- _activePeers.clear();
|
|
|
+ if (id) {
|
|
|
+ std::string idcPath(_idCacheBase + ZT_PATH_SEPARATOR_S + id.address().toString());
|
|
|
+ Utils::writeFile(idcPath.c_str(),id.toString(false));
|
|
|
}
|
|
|
-
|
|
|
- fclose(pd);
|
|
|
- buf.burn();
|
|
|
-#endif // ZT_PEER_SERIALIZATION_VERSION
|
|
|
-
|
|
|
- Utils::rm(pdpath);
|
|
|
}
|
|
|
|
|
|
} // namespace ZeroTier
|
Adam Ierymenko