void/ZeroTierOne
2
0
Fork 0
mirror of https://github.com/zerotier/ZeroTierOne.git synced 2025-04-19 21:46:54 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Rip out resolver and use anycast address instead. In the long term existing TCP proxy dies anyway. Fixes static build problem for old Linux versions.

Browse source
This commit is contained in:
Adam Ierymenko 2017-01-26 13:59:20 -08:00
parent 9e488ce322
commit ec0e8a9a43
5 changed files with 5 additions and 290 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
objects.mk
View file

@ -26,7 +26,6 @@ OBJS=\
node/Tag.o \
node/Topology.o \
node/Utils.o \
osdep/BackgroundResolver.o \
osdep/ManagedRoute.o \
osdep/Http.o \
osdep/OSUtils.o \

121
osdep/BackgroundResolver.cpp
View file

@ -1,121 +0,0 @@
/*
* 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/>.
*/
#include "OSUtils.hpp"
#include "Thread.hpp"
#include "BackgroundResolver.hpp"
namespace ZeroTier {
/*
* We can't actually abort a job. This is a legacy characteristic of the
* ancient synchronous resolver APIs. So to abort jobs, we just abandon
* them by setting their parent to null.
*/
class BackgroundResolverJob
{
public:
std::string name;
BackgroundResolver *volatile parent;
Mutex lock;
void threadMain()
throw()
{
std::vector<InetAddress> ips;
try {
ips = OSUtils::resolve(name.c_str());
} catch ( ... ) {}
{
Mutex::Lock _l(lock);
BackgroundResolver *p = parent;
if (p)
p->_postResult(ips);
}
delete this;
}
};
BackgroundResolver::BackgroundResolver(const char *name) :
_name(name),
_job((BackgroundResolverJob *)0),
_callback(0),
_arg((void *)0),
_ips(),
_lock()
{
}
BackgroundResolver::~BackgroundResolver()
{
abort();
}
std::vector<InetAddress> BackgroundResolver::get() const
{
Mutex::Lock _l(_lock);
return _ips;
}
void BackgroundResolver::resolveNow(void (*callback)(BackgroundResolver *,void *),void *arg)
{
Mutex::Lock _l(_lock);
if (_job) {
Mutex::Lock _l2(_job->lock);
_job->parent = (BackgroundResolver *)0;
_job = (BackgroundResolverJob *)0;
}
BackgroundResolverJob *j = new BackgroundResolverJob();
j->name = _name;
j->parent = this;
_job = j;
_callback = callback;
_arg = arg;
_jobThread = Thread::start(j);
}
void BackgroundResolver::abort()
{
Mutex::Lock _l(_lock);
if (_job) {
Mutex::Lock _l2(_job->lock);
_job->parent = (BackgroundResolver *)0;
_job = (BackgroundResolverJob *)0;
}
}
void BackgroundResolver::_postResult(const std::vector<InetAddress> &ips)
{
void (*cb)(BackgroundResolver *,void *);
void *a;
{
Mutex::Lock _l(_lock);
_job = (BackgroundResolverJob *)0;
cb = _callback;
a = _arg;
_ips = ips;
}
if (cb)
cb(this,a);
}
} // namespace ZeroTier

118
osdep/BackgroundResolver.hpp
View file

@ -1,118 +0,0 @@
/*
* 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_BACKGROUNDRESOLVER_HPP
#define ZT_BACKGROUNDRESOLVER_HPP
#include <vector>
#include <string>
#include "../node/Constants.hpp"
#include "../node/Mutex.hpp"
#include "../node/InetAddress.hpp"
#include "../node/NonCopyable.hpp"
#include "Thread.hpp"
namespace ZeroTier {
class BackgroundResolverJob;
/**
* A simple background resolver
*/
class BackgroundResolver : NonCopyable
{
friend class BackgroundResolverJob;
public:
/**
* Construct a new resolver
*
* resolveNow() must be called to actually initiate background resolution.
*
* @param name Name to resolve
*/
BackgroundResolver(const char *name);
~BackgroundResolver();
/**
* @return Most recent resolver results or empty vector if none
*/
std::vector<InetAddress> get() const;
/**
* Launch a background resolve job now
*
* If a resolve job is currently in progress, it is aborted and another
* job is started.
*
* Note that jobs can't actually be aborted due to the limitations of the
* ancient synchronous OS resolver APIs. As a result, in progress jobs
* that are aborted are simply abandoned. Don't call this too frequently
* or background threads might pile up.
*
* @param callback Callback function to receive notification or NULL if none
* @praam arg Second argument to callback function
*/
void resolveNow(void (*callback)(BackgroundResolver *,void *) = 0,void *arg = 0);
/**
* Abort (abandon) any current resolve jobs
*/
void abort();
/**
* @return True if a background job is in progress
*/
inline bool running() const
{
Mutex::Lock _l(_lock);
return (_job != (BackgroundResolverJob *)0);
}
/**
* Wait for pending job to complete (if any)
*/
inline void wait() const
{
Thread t;
{
Mutex::Lock _l(_lock);
if (!_job)
return;
t = _jobThread;
}
Thread::join(t);
}
private:
void _postResult(const std::vector<InetAddress> &ips);
std::string _name;
BackgroundResolverJob *_job;
Thread _jobThread;
void (*_callback)(BackgroundResolver *,void *);
void *_arg;
std::vector<InetAddress> _ips;
Mutex _lock;
};
} // namespace ZeroTier
#endif

28
osdep/OSUtils.cpp
View file

@ -256,34 +256,6 @@ int64_t OSUtils::getFileSize(const char *path)
return -1;
}
std::vector<InetAddress> OSUtils::resolve(const char *name)
{
std::vector<InetAddress> r;
std::vector<InetAddress>::iterator i;
InetAddress tmp;
struct addrinfo *ai = (struct addrinfo *)0,*p;
if (!getaddrinfo(name,(const char *)0,(const struct addrinfo *)0,&ai)) {
try {
p = ai;
while (p) {
if ((p->ai_addr)&&((p->ai_addr->sa_family == AF_INET)||(p->ai_addr->sa_family == AF_INET6))) {
tmp = *(p->ai_addr);
for(i=r.begin();i!=r.end();++i) {
if (i->ipsEqual(tmp))
goto skip_add_inetaddr;
}
r.push_back(tmp);
}
skip_add_inetaddr:
p = p->ai_next;
}
} catch ( ... ) {}
freeaddrinfo(ai);
}
std::sort(r.begin(),r.end());
return r;
}
bool OSUtils::readFile(const char *path,std::string &buf)
{
char tmp[1024];

27
service/OneService.cpp
View file

@ -43,7 +43,6 @@
#include "../osdep/Thread.hpp"
#include "../osdep/OSUtils.hpp"
#include "../osdep/Http.hpp"
#include "../osdep/BackgroundResolver.hpp"
#include "../osdep/PortMapper.hpp"
#include "../osdep/Binder.hpp"
#include "../osdep/ManagedRoute.hpp"
@ -136,9 +135,8 @@ namespace ZeroTier { typedef BSDEthernetTap EthernetTap; }
// Path under ZT1 home for controller database if controller is enabled
#define ZT_CONTROLLER_DB_PATH "controller.d"
// TCP fallback relay host -- geo-distributed using Amazon Route53 geo-aware DNS
#define ZT_TCP_FALLBACK_RELAY "tcp-fallback.zerotier.com"
#define ZT_TCP_FALLBACK_RELAY_PORT 443
// TCP fallback relay (run by ZeroTier, Inc. -- this will eventually go away)
#define ZT_TCP_FALLBACK_RELAY "204.80.128.1/443"
// Frequency at which we re-resolve the TCP fallback relay
#define ZT_TCP_FALLBACK_RERESOLVE_DELAY 86400000
@ -263,7 +261,6 @@ public:
// begin member variables --------------------------------------------------
const std::string _homePath;
BackgroundResolver _tcpFallbackResolver;
EmbeddedNetworkController *_controller;
Phy<OneServiceImpl *> _phy;
Node *_node;
@ -368,7 +365,6 @@ public:
OneServiceImpl(const char *hp,unsigned int port) :
_homePath((hp) ? hp : ".")
,_tcpFallbackResolver(ZT_TCP_FALLBACK_RELAY)
,_controller((EmbeddedNetworkController *)0)
,_phy(this,false,true)
,_node((Node *)0)
@ -710,7 +706,6 @@ public:
uint64_t clockShouldBe = OSUtils::now();
_lastRestart = clockShouldBe;
uint64_t lastTapMulticastGroupCheck = 0;
uint64_t lastTcpFallbackResolve = 0;
uint64_t lastBindRefresh = 0;
uint64_t lastUpdateCheck = clockShouldBe;
uint64_t lastLocalInterfaceAddressCheck = (clockShouldBe - ZT_LOCAL_INTERFACE_CHECK_INTERVAL) + 15000; // do this in 15s to give portmapper time to configure and other things time to settle
@ -765,11 +760,6 @@ public:
dl = _nextBackgroundTaskDeadline;
}
if ((now - lastTcpFallbackResolve) >= ZT_TCP_FALLBACK_RERESOLVE_DELAY) {
lastTcpFallbackResolve = now;
_tcpFallbackResolver.resolveNow();
}
if ((_tcpFallbackTunnel)&&((now - _lastDirectReceiveFromGlobal) < (ZT_TCP_FALLBACK_AFTER / 2)))
_phy.close(_tcpFallbackTunnel->sock);
@ -1617,16 +1607,9 @@ public:
_tcpFallbackTunnel->writeBuf.append(reinterpret_cast<const char *>(reinterpret_cast<const void *>(&(reinterpret_cast<const struct sockaddr_in *>(addr)->sin_port))),2);
_tcpFallbackTunnel->writeBuf.append((const char *)data,len);
} else if (((now - _lastSendToGlobalV4) < ZT_TCP_FALLBACK_AFTER)&&((now - _lastSendToGlobalV4) > (ZT_PING_CHECK_INVERVAL / 2))) {
std::vector<InetAddress> tunnelIps(_tcpFallbackResolver.get());
if (tunnelIps.empty()) {
if (!_tcpFallbackResolver.running())
_tcpFallbackResolver.resolveNow();
} else {
bool connected = false;
InetAddress addr(tunnelIps[(unsigned long)now % tunnelIps.size()]);
addr.setPort(ZT_TCP_FALLBACK_RELAY_PORT);
_phy.tcpConnect(reinterpret_cast<const struct sockaddr *>(&addr),connected);
}
bool connected = false;
const InetAddress addr(ZT_TCP_FALLBACK_RELAY);
_phy.tcpConnect(reinterpret_cast<const struct sockaddr *>(&addr),connected);
}
}
_lastSendToGlobalV4 = now;