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-08-06 04:05:39 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
2013-07-29 17:56:20 +00:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <math.h>
|
|
|
|
|
2014-04-07 22:39:33 +00:00
|
|
|
#include "Constants.hpp"
|
2013-10-18 16:01:48 +00:00
|
|
|
#include "Network.hpp"
|
2013-07-29 17:56:20 +00:00
|
|
|
#include "RuntimeEnvironment.hpp"
|
|
|
|
#include "NodeConfig.hpp"
|
2013-07-04 20:56:19 +00:00
|
|
|
#include "Switch.hpp"
|
2013-07-30 15:14:53 +00:00
|
|
|
#include "Packet.hpp"
|
2013-10-16 21:47:26 +00:00
|
|
|
#include "Buffer.hpp"
|
2014-07-31 21:09:32 +00:00
|
|
|
#include "EthernetTap.hpp"
|
|
|
|
#include "EthernetTapFactory.hpp"
|
2014-08-13 00:20:34 +00:00
|
|
|
#include "RoutingTable.hpp"
|
2013-10-16 21:47:26 +00:00
|
|
|
|
2013-10-21 15:15:47 +00:00
|
|
|
#define ZT_NETWORK_CERT_WRITE_BUF_SIZE 131072
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
namespace ZeroTier {
|
|
|
|
|
2014-05-23 22:13:34 +00:00
|
|
|
const ZeroTier::MulticastGroup Network::BROADCAST(ZeroTier::MAC(0xff),0);
|
|
|
|
|
2013-08-08 14:41:17 +00:00
|
|
|
const char *Network::statusString(const Status s)
|
|
|
|
throw()
|
|
|
|
{
|
|
|
|
switch(s) {
|
2014-01-28 07:13:36 +00:00
|
|
|
case NETWORK_INITIALIZING: return "INITIALIZING";
|
2013-08-08 14:41:17 +00:00
|
|
|
case NETWORK_WAITING_FOR_FIRST_AUTOCONF: return "WAITING_FOR_FIRST_AUTOCONF";
|
|
|
|
case NETWORK_OK: return "OK";
|
|
|
|
case NETWORK_ACCESS_DENIED: return "ACCESS_DENIED";
|
2013-10-16 21:47:26 +00:00
|
|
|
case NETWORK_NOT_FOUND: return "NOT_FOUND";
|
2014-01-28 07:16:15 +00:00
|
|
|
case NETWORK_INITIALIZATION_FAILED: return "INITIALIZATION_FAILED";
|
2014-06-27 00:05:07 +00:00
|
|
|
case NETWORK_NO_MORE_DEVICES: return "NO_MORE_DEVICES";
|
2013-08-08 14:41:17 +00:00
|
|
|
}
|
|
|
|
return "(invalid)";
|
|
|
|
}
|
|
|
|
|
2013-08-06 05:28:56 +00:00
|
|
|
Network::~Network()
|
|
|
|
{
|
2014-08-22 01:07:27 +00:00
|
|
|
_lock.lock();
|
|
|
|
if ((_setupThread)&&(!_destroyed)) {
|
|
|
|
_lock.unlock();
|
|
|
|
Thread::join(_setupThread);
|
|
|
|
} else _lock.unlock();
|
2014-01-28 07:13:36 +00:00
|
|
|
|
2014-08-22 00:49:05 +00:00
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
if (_tap)
|
|
|
|
_r->tapFactory->close(_tap,_destroyed);
|
|
|
|
}
|
2014-01-27 06:47:08 +00:00
|
|
|
|
2014-08-22 00:49:05 +00:00
|
|
|
if (_destroyed) {
|
2013-10-16 21:47:26 +00:00
|
|
|
Utils::rm(std::string(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".conf"));
|
|
|
|
Utils::rm(std::string(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".mcerts"));
|
2013-08-06 05:28:56 +00:00
|
|
|
} else {
|
|
|
|
clean();
|
2013-10-16 21:47:26 +00:00
|
|
|
_dumpMulticastCerts();
|
2013-08-06 05:28:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-11 22:21:59 +00:00
|
|
|
SharedPtr<Network> Network::newInstance(const RuntimeEnvironment *renv,NodeConfig *nc,uint64_t id)
|
2013-08-06 05:28:56 +00:00
|
|
|
{
|
2013-08-06 14:15:05 +00:00
|
|
|
SharedPtr<Network> nw(new Network());
|
2013-10-18 16:01:48 +00:00
|
|
|
nw->_id = id;
|
2014-02-11 22:21:59 +00:00
|
|
|
nw->_nc = nc;
|
2014-05-23 21:32:31 +00:00
|
|
|
nw->_mac.fromAddress(renv->identity.address(),id);
|
2013-08-06 14:15:05 +00:00
|
|
|
nw->_r = renv;
|
2014-01-28 07:13:36 +00:00
|
|
|
nw->_tap = (EthernetTap *)0;
|
2014-06-27 00:05:07 +00:00
|
|
|
nw->_enabled = true;
|
2013-08-06 14:15:05 +00:00
|
|
|
nw->_lastConfigUpdate = 0;
|
2014-08-22 00:49:05 +00:00
|
|
|
nw->_destroyed = false;
|
2014-01-28 07:13:36 +00:00
|
|
|
nw->_netconfFailure = NETCONF_FAILURE_NONE;
|
|
|
|
|
2014-07-31 21:09:32 +00:00
|
|
|
if (nw->controller() == renv->identity.address()) // TODO: fix Switch to allow packets to self
|
2013-10-16 21:47:26 +00:00
|
|
|
throw std::runtime_error("cannot join a network for which I am the netconf master");
|
2014-01-28 07:13:36 +00:00
|
|
|
|
2014-07-31 21:09:32 +00:00
|
|
|
try {
|
|
|
|
nw->_restoreState();
|
|
|
|
nw->requestConfiguration();
|
|
|
|
} catch ( ... ) {
|
|
|
|
nw->_lastConfigUpdate = 0; // call requestConfiguration() again
|
|
|
|
}
|
2013-10-18 16:01:48 +00:00
|
|
|
|
2013-08-06 14:15:05 +00:00
|
|
|
return nw;
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
2014-06-13 21:06:34 +00:00
|
|
|
bool Network::updateMulticastGroups()
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
EthernetTap *t = _tap;
|
|
|
|
if (t) {
|
|
|
|
// Grab current groups from the local tap
|
2014-07-31 21:09:32 +00:00
|
|
|
bool updated = t->updateMulticastGroups(_multicastGroups);
|
2014-06-13 21:06:34 +00:00
|
|
|
|
|
|
|
// Merge in learned groups from any hosts bridged in behind us
|
|
|
|
for(std::map<MulticastGroup,uint64_t>::const_iterator mg(_bridgedMulticastGroups.begin());mg!=_bridgedMulticastGroups.end();++mg)
|
|
|
|
_multicastGroups.insert(mg->first);
|
|
|
|
|
|
|
|
// Add or remove BROADCAST group based on broadcast enabled netconf flag
|
|
|
|
if ((_config)&&(_config->enableBroadcast())) {
|
|
|
|
if (_multicastGroups.count(BROADCAST))
|
|
|
|
return updated;
|
|
|
|
else {
|
|
|
|
_multicastGroups.insert(BROADCAST);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (_multicastGroups.count(BROADCAST)) {
|
|
|
|
_multicastGroups.erase(BROADCAST);
|
|
|
|
return true;
|
|
|
|
} else return updated;
|
|
|
|
}
|
|
|
|
} else return false;
|
|
|
|
}
|
|
|
|
|
2014-01-28 07:13:36 +00:00
|
|
|
bool Network::setConfiguration(const Dictionary &conf,bool saveToDisk)
|
2013-07-29 17:56:20 +00:00
|
|
|
{
|
2014-01-28 07:13:36 +00:00
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
|
2014-08-22 00:49:05 +00:00
|
|
|
if (_destroyed)
|
|
|
|
return false;
|
|
|
|
|
2013-09-04 13:27:56 +00:00
|
|
|
try {
|
2014-07-31 21:09:32 +00:00
|
|
|
SharedPtr<NetworkConfig> newConfig(new NetworkConfig(conf)); // throws if invalid
|
2013-10-18 16:01:48 +00:00
|
|
|
if ((newConfig->networkId() == _id)&&(newConfig->issuedTo() == _r->identity.address())) {
|
|
|
|
_config = newConfig;
|
2013-09-24 21:35:05 +00:00
|
|
|
|
2013-10-18 16:01:48 +00:00
|
|
|
_lastConfigUpdate = Utils::now();
|
2014-01-28 07:13:36 +00:00
|
|
|
_netconfFailure = NETCONF_FAILURE_NONE;
|
2013-10-16 21:47:26 +00:00
|
|
|
|
|
|
|
if (saveToDisk) {
|
|
|
|
std::string confPath(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".conf");
|
|
|
|
if (!Utils::writeFile(confPath.c_str(),conf.toString())) {
|
|
|
|
LOG("error: unable to write network configuration file at: %s",confPath.c_str());
|
2014-01-26 18:32:12 +00:00
|
|
|
} else {
|
|
|
|
Utils::lockDownFile(confPath.c_str(),false);
|
2013-10-16 21:47:26 +00:00
|
|
|
}
|
2013-09-04 13:27:56 +00:00
|
|
|
}
|
2014-01-28 07:13:36 +00:00
|
|
|
|
2014-07-31 21:09:32 +00:00
|
|
|
EthernetTap *t = _tap;
|
|
|
|
if (t) {
|
|
|
|
char fname[1024];
|
|
|
|
_mkNetworkFriendlyName(fname,sizeof(fname));
|
|
|
|
t->setIps(newConfig->staticIps());
|
|
|
|
t->setFriendlyName(fname);
|
|
|
|
} else {
|
|
|
|
if (!_setupThread)
|
|
|
|
_setupThread = Thread::start<Network>(this);
|
|
|
|
}
|
|
|
|
|
2014-01-28 07:13:36 +00:00
|
|
|
return true;
|
2013-10-18 16:01:48 +00:00
|
|
|
} else {
|
|
|
|
LOG("ignored invalid configuration for network %.16llx (configuration contains mismatched network ID or issued-to address)",(unsigned long long)_id);
|
2013-08-06 04:05:39 +00:00
|
|
|
}
|
2013-10-18 16:01:48 +00:00
|
|
|
} catch (std::exception &exc) {
|
|
|
|
LOG("ignored invalid configuration for network %.16llx (%s)",(unsigned long long)_id,exc.what());
|
2013-09-04 13:27:56 +00:00
|
|
|
} catch ( ... ) {
|
2013-10-18 16:01:48 +00:00
|
|
|
LOG("ignored invalid configuration for network %.16llx (unknown exception)",(unsigned long long)_id);
|
2013-07-30 15:14:53 +00:00
|
|
|
}
|
2014-01-28 07:13:36 +00:00
|
|
|
|
|
|
|
return false;
|
2013-07-29 17:56:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Network::requestConfiguration()
|
|
|
|
{
|
2013-08-05 20:06:16 +00:00
|
|
|
if (controller() == _r->identity.address()) {
|
2013-10-16 21:47:26 +00:00
|
|
|
// netconf master cannot be a member of its own nets
|
2013-08-05 20:06:16 +00:00
|
|
|
LOG("unable to request network configuration for network %.16llx: I am the network master, cannot query self",(unsigned long long)_id);
|
|
|
|
return;
|
|
|
|
}
|
2013-09-24 21:35:05 +00:00
|
|
|
|
2013-08-05 20:06:16 +00:00
|
|
|
TRACE("requesting netconf for network %.16llx from netconf master %s",(unsigned long long)_id,controller().toString().c_str());
|
2013-07-30 15:14:53 +00:00
|
|
|
Packet outp(controller(),_r->identity.address(),Packet::VERB_NETWORK_CONFIG_REQUEST);
|
|
|
|
outp.append((uint64_t)_id);
|
2013-08-06 04:05:39 +00:00
|
|
|
outp.append((uint16_t)0); // no meta-data
|
2013-07-30 15:14:53 +00:00
|
|
|
_r->sw->send(outp,true);
|
2013-07-29 17:56:20 +00:00
|
|
|
}
|
|
|
|
|
2013-10-16 21:47:26 +00:00
|
|
|
void Network::addMembershipCertificate(const CertificateOfMembership &cert)
|
2013-08-06 04:05:39 +00:00
|
|
|
{
|
2013-10-25 17:43:04 +00:00
|
|
|
if (!cert) // sanity check
|
|
|
|
return;
|
|
|
|
|
2013-08-06 04:05:39 +00:00
|
|
|
Mutex::Lock _l(_lock);
|
2013-10-17 10:41:52 +00:00
|
|
|
|
2013-10-16 21:47:26 +00:00
|
|
|
// We go ahead and accept certs provisionally even if _isOpen is true, since
|
|
|
|
// that might be changed in short order if the user is fiddling in the UI.
|
|
|
|
// These will be purged on clean() for open networks eventually.
|
2013-10-17 10:41:52 +00:00
|
|
|
|
|
|
|
CertificateOfMembership &old = _membershipCertificates[cert.issuedTo()];
|
2013-10-25 17:43:04 +00:00
|
|
|
if (cert.timestamp() >= old.timestamp()) {
|
2014-03-20 20:21:58 +00:00
|
|
|
//TRACE("got new certificate for %s on network %.16llx",cert.issuedTo().toString().c_str(),cert.networkId());
|
2013-10-17 10:41:52 +00:00
|
|
|
old = cert;
|
2013-10-25 17:43:04 +00:00
|
|
|
}
|
2013-08-06 04:05:39 +00:00
|
|
|
}
|
|
|
|
|
2013-07-29 21:11:00 +00:00
|
|
|
bool Network::isAllowed(const Address &peer) const
|
|
|
|
{
|
|
|
|
try {
|
|
|
|
Mutex::Lock _l(_lock);
|
2013-10-18 16:01:48 +00:00
|
|
|
|
|
|
|
if (!_config)
|
|
|
|
return false;
|
2014-06-14 20:24:19 +00:00
|
|
|
if (_config->isPublic())
|
2013-10-18 16:01:48 +00:00
|
|
|
return true;
|
|
|
|
|
2013-09-11 19:13:05 +00:00
|
|
|
std::map<Address,CertificateOfMembership>::const_iterator pc(_membershipCertificates.find(peer));
|
2013-07-29 21:11:00 +00:00
|
|
|
if (pc == _membershipCertificates.end())
|
2013-10-16 21:47:26 +00:00
|
|
|
return false; // no certificate on file
|
2013-10-18 16:01:48 +00:00
|
|
|
return _config->com().agreesWith(pc->second); // is other cert valid against ours?
|
2013-07-29 21:11:00 +00:00
|
|
|
} catch (std::exception &exc) {
|
|
|
|
TRACE("isAllowed() check failed for peer %s: unexpected exception: %s",peer.toString().c_str(),exc.what());
|
|
|
|
} catch ( ... ) {
|
|
|
|
TRACE("isAllowed() check failed for peer %s: unexpected exception: unknown exception",peer.toString().c_str());
|
|
|
|
}
|
2013-10-16 21:47:26 +00:00
|
|
|
return false; // default position on any failure
|
2013-07-29 21:11:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Network::clean()
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
2014-08-22 00:49:05 +00:00
|
|
|
|
|
|
|
if (_destroyed)
|
|
|
|
return;
|
|
|
|
|
2014-06-13 21:06:34 +00:00
|
|
|
uint64_t now = Utils::now();
|
2014-01-28 07:13:36 +00:00
|
|
|
|
2014-06-14 20:24:19 +00:00
|
|
|
if ((_config)&&(_config->isPublic())) {
|
2013-10-16 21:47:26 +00:00
|
|
|
// Open (public) networks do not track certs or cert pushes at all.
|
2013-08-03 16:53:46 +00:00
|
|
|
_membershipCertificates.clear();
|
2013-10-16 21:47:26 +00:00
|
|
|
_lastPushedMembershipCertificate.clear();
|
2013-10-18 16:01:48 +00:00
|
|
|
} else if (_config) {
|
2013-10-16 21:47:26 +00:00
|
|
|
// Clean certificates that are no longer valid from the cache.
|
|
|
|
for(std::map<Address,CertificateOfMembership>::iterator c=(_membershipCertificates.begin());c!=_membershipCertificates.end();) {
|
2013-10-18 16:01:48 +00:00
|
|
|
if (_config->com().agreesWith(c->second))
|
2013-10-16 21:47:26 +00:00
|
|
|
++c;
|
|
|
|
else _membershipCertificates.erase(c++);
|
2013-08-06 04:05:39 +00:00
|
|
|
}
|
|
|
|
|
2013-10-16 21:47:26 +00:00
|
|
|
// Clean entries from the last pushed tracking map if they're so old as
|
|
|
|
// to be no longer relevant.
|
2014-06-13 21:06:34 +00:00
|
|
|
uint64_t forgetIfBefore = now - (_config->com().timestampMaxDelta() * 3ULL);
|
2013-10-16 21:47:26 +00:00
|
|
|
for(std::map<Address,uint64_t>::iterator lp(_lastPushedMembershipCertificate.begin());lp!=_lastPushedMembershipCertificate.end();) {
|
|
|
|
if (lp->second < forgetIfBefore)
|
|
|
|
_lastPushedMembershipCertificate.erase(lp++);
|
|
|
|
else ++lp;
|
2013-08-03 16:53:46 +00:00
|
|
|
}
|
2013-07-29 21:11:00 +00:00
|
|
|
}
|
2014-06-13 21:06:34 +00:00
|
|
|
|
|
|
|
// Clean learned multicast groups if we haven't heard from them in a while
|
|
|
|
for(std::map<MulticastGroup,uint64_t>::iterator mg(_bridgedMulticastGroups.begin());mg!=_bridgedMulticastGroups.end();) {
|
|
|
|
if ((now - mg->second) > (ZT_MULTICAST_LIKE_EXPIRE * 2))
|
|
|
|
_bridgedMulticastGroups.erase(mg++);
|
|
|
|
else ++mg;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Network::Status Network::status() const
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
2014-08-22 00:49:05 +00:00
|
|
|
switch(_netconfFailure) {
|
|
|
|
case NETCONF_FAILURE_ACCESS_DENIED:
|
|
|
|
return NETWORK_ACCESS_DENIED;
|
|
|
|
case NETCONF_FAILURE_NOT_FOUND:
|
|
|
|
return NETWORK_NOT_FOUND;
|
|
|
|
case NETCONF_FAILURE_NONE:
|
|
|
|
return ((_lastConfigUpdate > 0) ? ((_tap) ? NETWORK_OK : NETWORK_INITIALIZING) : NETWORK_WAITING_FOR_FIRST_AUTOCONF);
|
|
|
|
//case NETCONF_FAILURE_INIT_FAILED:
|
|
|
|
default:
|
|
|
|
return NETWORK_INITIALIZATION_FAILED;
|
|
|
|
}
|
2013-07-29 21:11:00 +00:00
|
|
|
}
|
|
|
|
|
2013-07-09 18:06:55 +00:00
|
|
|
void Network::_CBhandleTapData(void *arg,const MAC &from,const MAC &to,unsigned int etherType,const Buffer<4096> &data)
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
2014-06-27 00:05:07 +00:00
|
|
|
if ((!((Network *)arg)->_enabled)||(((Network *)arg)->status() != NETWORK_OK))
|
2013-08-09 21:20:40 +00:00
|
|
|
return;
|
2013-10-16 21:47:26 +00:00
|
|
|
|
2013-07-09 18:06:55 +00:00
|
|
|
const RuntimeEnvironment *_r = ((Network *)arg)->_r;
|
2013-08-27 22:00:07 +00:00
|
|
|
if (_r->shutdownInProgress)
|
|
|
|
return;
|
2013-10-16 21:47:26 +00:00
|
|
|
|
2013-07-09 18:06:55 +00:00
|
|
|
try {
|
|
|
|
_r->sw->onLocalEthernet(SharedPtr<Network>((Network *)arg),from,to,etherType,data);
|
|
|
|
} catch (std::exception &exc) {
|
|
|
|
TRACE("unexpected exception handling local packet: %s",exc.what());
|
|
|
|
} catch ( ... ) {
|
|
|
|
TRACE("unexpected exception handling local packet");
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-07 21:00:53 +00:00
|
|
|
void Network::_pushMembershipCertificate(const Address &peer,bool force,uint64_t now)
|
|
|
|
{
|
2013-10-24 20:57:26 +00:00
|
|
|
uint64_t pushTimeout = _config->com().timestampMaxDelta() / 2;
|
|
|
|
if (!pushTimeout)
|
2013-10-16 21:47:26 +00:00
|
|
|
return; // still waiting on my own cert
|
2013-10-24 20:57:26 +00:00
|
|
|
if (pushTimeout > 1000)
|
|
|
|
pushTimeout -= 1000;
|
2013-10-07 21:00:53 +00:00
|
|
|
|
|
|
|
uint64_t &lastPushed = _lastPushedMembershipCertificate[peer];
|
2013-10-24 20:57:26 +00:00
|
|
|
if ((force)||((now - lastPushed) > pushTimeout)) {
|
2013-10-07 21:00:53 +00:00
|
|
|
lastPushed = now;
|
2013-10-25 17:43:04 +00:00
|
|
|
TRACE("pushing membership cert for %.16llx to %s",(unsigned long long)_id,peer.toString().c_str());
|
2013-10-07 21:00:53 +00:00
|
|
|
|
|
|
|
Packet outp(peer,_r->identity.address(),Packet::VERB_NETWORK_MEMBERSHIP_CERTIFICATE);
|
2013-10-18 16:01:48 +00:00
|
|
|
_config->com().serialize(outp);
|
2013-10-07 21:00:53 +00:00
|
|
|
_r->sw->send(outp,true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-31 21:09:32 +00:00
|
|
|
// Ethernet tap creation thread -- required on some platforms where tap
|
|
|
|
// creation may be time consuming (e.g. Windows).
|
2014-01-28 07:13:36 +00:00
|
|
|
void Network::threadMain()
|
2014-01-28 07:16:15 +00:00
|
|
|
throw()
|
2014-01-28 07:13:36 +00:00
|
|
|
{
|
2014-07-31 21:09:32 +00:00
|
|
|
char fname[1024],lcentry[128];
|
|
|
|
Utils::snprintf(lcentry,sizeof(lcentry),"_dev_for_%.16llx",(unsigned long long)_id);
|
2014-02-11 22:21:59 +00:00
|
|
|
|
2014-08-08 02:08:41 +00:00
|
|
|
EthernetTap *t = (EthernetTap *)0;
|
2014-01-28 07:13:36 +00:00
|
|
|
try {
|
2014-07-31 21:09:32 +00:00
|
|
|
std::string desiredDevice(_nc->getLocalConfig(lcentry));
|
|
|
|
_mkNetworkFriendlyName(fname,sizeof(fname));
|
|
|
|
|
|
|
|
t = _r->tapFactory->open(_mac,ZT_IF_MTU,ZT_DEFAULT_IF_METRIC,_id,(desiredDevice.length() > 0) ? desiredDevice.c_str() : (const char *)0,fname,_CBhandleTapData,this);
|
|
|
|
|
|
|
|
std::string dn(t->deviceName());
|
|
|
|
if ((dn.length())&&(dn != desiredDevice))
|
2014-02-11 22:21:59 +00:00
|
|
|
_nc->putLocalConfig(lcentry,dn);
|
2014-01-28 07:13:36 +00:00
|
|
|
} catch (std::exception &exc) {
|
2014-07-31 21:09:32 +00:00
|
|
|
delete t;
|
|
|
|
t = (EthernetTap *)0;
|
2014-01-28 07:13:36 +00:00
|
|
|
LOG("network %.16llx failed to initialize: %s",_id,exc.what());
|
|
|
|
_netconfFailure = NETCONF_FAILURE_INIT_FAILED;
|
|
|
|
} catch ( ... ) {
|
2014-07-31 21:09:32 +00:00
|
|
|
delete t;
|
|
|
|
t = (EthernetTap *)0;
|
2014-01-28 07:13:36 +00:00
|
|
|
LOG("network %.16llx failed to initialize: unknown error",_id);
|
|
|
|
_netconfFailure = NETCONF_FAILURE_INIT_FAILED;
|
|
|
|
}
|
|
|
|
|
2014-07-31 21:09:32 +00:00
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
if (_tap) // the tap creation thread can technically be re-launched, though this isn't done right now
|
2014-08-22 00:49:05 +00:00
|
|
|
_r->tapFactory->close(_tap,false);
|
2014-07-31 21:09:32 +00:00
|
|
|
_tap = t;
|
|
|
|
if (t) {
|
|
|
|
if (_config)
|
|
|
|
t->setIps(_config->staticIps());
|
|
|
|
t->setEnabled(_enabled);
|
|
|
|
}
|
2014-01-28 07:13:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-11 00:18:59 +00:00
|
|
|
void Network::learnBridgeRoute(const MAC &mac,const Address &addr)
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
_bridgeRoutes[mac] = addr;
|
|
|
|
|
|
|
|
// If _bridgeRoutes exceeds sanity limit, trim worst offenders until below -- denial of service circuit breaker
|
|
|
|
while (_bridgeRoutes.size() > ZT_MAX_BRIDGE_ROUTES) {
|
|
|
|
std::map<Address,unsigned long> counts;
|
|
|
|
Address maxAddr;
|
|
|
|
unsigned long maxCount = 0;
|
|
|
|
for(std::map<MAC,Address>::iterator br(_bridgeRoutes.begin());br!=_bridgeRoutes.end();++br) {
|
|
|
|
unsigned long c = ++counts[br->second];
|
|
|
|
if (c > maxCount) {
|
|
|
|
maxCount = c;
|
|
|
|
maxAddr = br->second;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for(std::map<MAC,Address>::iterator br(_bridgeRoutes.begin());br!=_bridgeRoutes.end();) {
|
|
|
|
if (br->second == maxAddr)
|
|
|
|
_bridgeRoutes.erase(br++);
|
|
|
|
else ++br;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-27 00:05:07 +00:00
|
|
|
void Network::setEnabled(bool enabled)
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
_enabled = enabled;
|
2014-07-31 21:09:32 +00:00
|
|
|
if (_tap)
|
|
|
|
_tap->setEnabled(enabled);
|
2014-06-27 00:05:07 +00:00
|
|
|
}
|
|
|
|
|
2014-08-22 00:49:05 +00:00
|
|
|
void Network::destroy()
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
|
|
|
|
_enabled = false;
|
|
|
|
_destroyed = true;
|
|
|
|
|
2014-08-22 01:07:27 +00:00
|
|
|
if (_setupThread)
|
|
|
|
Thread::join(_setupThread);
|
|
|
|
_setupThread = Thread();
|
2014-08-22 00:49:05 +00:00
|
|
|
|
|
|
|
if (_tap)
|
|
|
|
_r->tapFactory->close(_tap,true);
|
|
|
|
_tap = (EthernetTap *)0;
|
|
|
|
}
|
|
|
|
|
2013-08-06 14:15:05 +00:00
|
|
|
void Network::_restoreState()
|
|
|
|
{
|
2013-10-16 21:47:26 +00:00
|
|
|
Buffer<ZT_NETWORK_CERT_WRITE_BUF_SIZE> buf;
|
|
|
|
|
|
|
|
std::string idstr(idString());
|
|
|
|
std::string confPath(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idstr + ".conf");
|
|
|
|
std::string mcdbPath(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idstr + ".mcerts");
|
|
|
|
|
|
|
|
// Read configuration file containing last config from netconf master
|
|
|
|
{
|
|
|
|
std::string confs;
|
|
|
|
if (Utils::readFile(confPath.c_str(),confs)) {
|
|
|
|
try {
|
|
|
|
if (confs.length())
|
2013-10-18 16:01:48 +00:00
|
|
|
setConfiguration(Dictionary(confs),false);
|
2013-10-16 21:47:26 +00:00
|
|
|
} catch ( ... ) {} // ignore invalid config on disk, we will re-request from netconf master
|
|
|
|
} else {
|
|
|
|
// If the conf file isn't present, "touch" it so we'll remember
|
|
|
|
// the existence of this network.
|
2014-07-31 21:09:32 +00:00
|
|
|
FILE *tmp = fopen(confPath.c_str(),"w");
|
2013-10-16 21:47:26 +00:00
|
|
|
if (tmp)
|
|
|
|
fclose(tmp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read most recent multicast cert dump
|
2014-06-14 20:24:19 +00:00
|
|
|
if ((_config)&&(!_config->isPublic())&&(Utils::fileExists(mcdbPath.c_str()))) {
|
2013-10-16 21:47:26 +00:00
|
|
|
CertificateOfMembership com;
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
|
|
|
|
_membershipCertificates.clear();
|
|
|
|
|
2013-10-17 10:41:52 +00:00
|
|
|
FILE *mcdb = fopen(mcdbPath.c_str(),"rb");
|
|
|
|
if (mcdb) {
|
|
|
|
try {
|
|
|
|
char magic[6];
|
|
|
|
if ((fread(magic,6,1,mcdb) == 1)&&(!memcmp("ZTMCD0",magic,6))) {
|
2013-10-18 16:01:48 +00:00
|
|
|
long rlen = 0;
|
|
|
|
do {
|
2013-10-17 10:41:52 +00:00
|
|
|
long rlen = (long)fread(buf.data() + buf.size(),1,ZT_NETWORK_CERT_WRITE_BUF_SIZE - buf.size(),mcdb);
|
2013-10-18 16:01:48 +00:00
|
|
|
if (rlen < 0) rlen = 0;
|
2013-10-17 10:41:52 +00:00
|
|
|
buf.setSize(buf.size() + (unsigned int)rlen);
|
|
|
|
unsigned int ptr = 0;
|
|
|
|
while ((ptr < (ZT_NETWORK_CERT_WRITE_BUF_SIZE / 2))&&(ptr < buf.size())) {
|
|
|
|
ptr += com.deserialize(buf,ptr);
|
|
|
|
if (com.issuedTo())
|
|
|
|
_membershipCertificates[com.issuedTo()] = com;
|
|
|
|
}
|
|
|
|
if (ptr) {
|
|
|
|
memmove(buf.data(),buf.data() + ptr,buf.size() - ptr);
|
|
|
|
buf.setSize(buf.size() - ptr);
|
|
|
|
}
|
2013-10-18 16:01:48 +00:00
|
|
|
} while (rlen > 0);
|
2013-10-17 10:41:52 +00:00
|
|
|
fclose(mcdb);
|
|
|
|
} else {
|
|
|
|
fclose(mcdb);
|
|
|
|
Utils::rm(mcdbPath);
|
2013-10-16 21:47:26 +00:00
|
|
|
}
|
2013-10-17 10:41:52 +00:00
|
|
|
} catch ( ... ) {
|
|
|
|
// Membership cert dump file invalid. We'll re-learn them off the net.
|
|
|
|
_membershipCertificates.clear();
|
|
|
|
fclose(mcdb);
|
|
|
|
Utils::rm(mcdbPath);
|
2013-10-16 21:47:26 +00:00
|
|
|
}
|
|
|
|
}
|
2013-08-06 14:15:05 +00:00
|
|
|
}
|
2013-10-16 21:47:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Network::_dumpMulticastCerts()
|
|
|
|
{
|
|
|
|
Buffer<ZT_NETWORK_CERT_WRITE_BUF_SIZE> buf;
|
|
|
|
std::string mcdbPath(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".mcerts");
|
|
|
|
Mutex::Lock _l(_lock);
|
|
|
|
|
2013-10-18 16:01:48 +00:00
|
|
|
if (!_config)
|
|
|
|
return;
|
|
|
|
|
2014-06-14 20:24:19 +00:00
|
|
|
if ((!_id)||(_config->isPublic())) {
|
2013-10-16 21:47:26 +00:00
|
|
|
Utils::rm(mcdbPath);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
FILE *mcdb = fopen(mcdbPath.c_str(),"wb");
|
|
|
|
if (!mcdb)
|
|
|
|
return;
|
|
|
|
if (fwrite("ZTMCD0",6,1,mcdb) != 1) {
|
2013-10-21 15:15:47 +00:00
|
|
|
fclose(mcdb);
|
2013-10-16 21:47:26 +00:00
|
|
|
Utils::rm(mcdbPath);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for(std::map<Address,CertificateOfMembership>::iterator c=(_membershipCertificates.begin());c!=_membershipCertificates.end();++c) {
|
|
|
|
try {
|
|
|
|
c->second.serialize(buf);
|
|
|
|
if (buf.size() >= (ZT_NETWORK_CERT_WRITE_BUF_SIZE / 2)) {
|
|
|
|
if (fwrite(buf.data(),buf.size(),1,mcdb) != 1) {
|
|
|
|
fclose(mcdb);
|
|
|
|
Utils::rm(mcdbPath);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
buf.clear();
|
|
|
|
}
|
|
|
|
} catch ( ... ) {
|
|
|
|
// Sanity check... no cert will ever be big enough to overflow buf
|
|
|
|
fclose(mcdb);
|
|
|
|
Utils::rm(mcdbPath);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (buf.size()) {
|
|
|
|
if (fwrite(buf.data(),buf.size(),1,mcdb) != 1) {
|
|
|
|
fclose(mcdb);
|
|
|
|
Utils::rm(mcdbPath);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fclose(mcdb);
|
2014-01-26 18:32:12 +00:00
|
|
|
Utils::lockDownFile(mcdbPath.c_str(),false);
|
2013-08-06 14:15:05 +00:00
|
|
|
}
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
} // namespace ZeroTier
|