2013-07-04 20:56:19 +00:00
|
|
|
/*
|
|
|
|
* ZeroTier One - Global Peer to Peer Ethernet
|
|
|
|
* Copyright (C) 2012-2013 ZeroTier Networks LLC
|
|
|
|
*
|
|
|
|
* 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>
|
|
|
|
|
2013-09-17 19:46:56 +00:00
|
|
|
#include "Constants.hpp"
|
2013-07-29 17:56:20 +00:00
|
|
|
#include "RuntimeEnvironment.hpp"
|
|
|
|
#include "NodeConfig.hpp"
|
2013-07-04 20:56:19 +00:00
|
|
|
#include "Network.hpp"
|
|
|
|
#include "Switch.hpp"
|
2013-07-30 15:14:53 +00:00
|
|
|
#include "Packet.hpp"
|
2013-08-06 04:05:39 +00:00
|
|
|
#include "Utils.hpp"
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
namespace ZeroTier {
|
|
|
|
|
2013-09-11 19:09:53 +00:00
|
|
|
void Network::CertificateOfMembership::addParameter(uint64_t id,uint64_t value,uint64_t maxDelta)
|
2013-07-29 17:56:20 +00:00
|
|
|
{
|
2013-09-11 19:09:53 +00:00
|
|
|
_params.push_back(_Parameter(id,value,maxDelta));
|
|
|
|
std::sort(_params.begin(),_params.end(),_SortByIdComparison());
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string Network::CertificateOfMembership::toString() const
|
|
|
|
{
|
|
|
|
uint64_t tmp[3000];
|
|
|
|
unsigned long n = 0;
|
|
|
|
for(std::vector<_Parameter>::const_iterator p(_params.begin());p!=_params.end();++p) {
|
|
|
|
tmp[n++] = Utils::hton(p->id);
|
|
|
|
tmp[n++] = Utils::hton(p->value);
|
|
|
|
tmp[n++] = Utils::hton(p->maxDelta);
|
|
|
|
if (n >= 3000)
|
|
|
|
break; // sanity check -- certificates will never even approach this size
|
2013-07-29 17:56:20 +00:00
|
|
|
}
|
2013-09-11 19:09:53 +00:00
|
|
|
return Utils::hex(tmp,sizeof(uint64_t) * n);
|
2013-07-29 17:56:20 +00:00
|
|
|
}
|
|
|
|
|
2013-09-11 19:09:53 +00:00
|
|
|
void Network::CertificateOfMembership::fromString(const char *s)
|
2013-07-29 17:56:20 +00:00
|
|
|
{
|
2013-09-11 19:09:53 +00:00
|
|
|
std::string tmp(Utils::unhex(s));
|
|
|
|
_params.clear();
|
|
|
|
const char *ptr = tmp.data();
|
|
|
|
unsigned long remaining = tmp.length();
|
|
|
|
while (remaining >= 24) {
|
|
|
|
_Parameter p;
|
|
|
|
p.id = Utils::ntoh(*((const uint64_t *)(ptr)));
|
|
|
|
p.value = Utils::ntoh(*((const uint64_t *)(ptr + 8)));
|
|
|
|
p.maxDelta = Utils::ntoh(*((const uint64_t *)(ptr + 16)));
|
|
|
|
_params.push_back(p);
|
|
|
|
ptr += 24;
|
|
|
|
remaining -= 24;
|
|
|
|
}
|
|
|
|
}
|
2013-07-29 17:56:20 +00:00
|
|
|
|
2013-09-11 19:09:53 +00:00
|
|
|
bool Network::CertificateOfMembership::compare(const CertificateOfMembership &other) const
|
|
|
|
throw()
|
|
|
|
{
|
|
|
|
unsigned long myidx = 0;
|
|
|
|
unsigned long otheridx = 0;
|
|
|
|
|
|
|
|
while (myidx < _params.size()) {
|
|
|
|
// Fail if we're at the end of other, since this means the field is
|
|
|
|
// missing.
|
|
|
|
if (otheridx >= other._params.size())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Seek to corresponding tuple in other, ignoring tuples that
|
|
|
|
// we may not have. If we run off the end of other, the tuple is
|
|
|
|
// missing. This works because tuples are sorted by ID.
|
|
|
|
while (other._params[otheridx].id != _params[myidx].id) {
|
|
|
|
++otheridx;
|
|
|
|
if (otheridx >= other._params.size())
|
2013-07-29 17:56:20 +00:00
|
|
|
return false;
|
2013-09-11 19:09:53 +00:00
|
|
|
}
|
2013-07-29 17:56:20 +00:00
|
|
|
|
2013-09-11 19:09:53 +00:00
|
|
|
// Compare to determine if the absolute value of the difference
|
|
|
|
// between these two parameters is within our maxDelta.
|
|
|
|
uint64_t a = _params[myidx].value;
|
|
|
|
uint64_t b = other._params[myidx].value;
|
|
|
|
if (a >= b) {
|
|
|
|
if ((a - b) > _params[myidx].maxDelta)
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
if ((b - a) > _params[myidx].maxDelta)
|
|
|
|
return false;
|
2013-07-29 17:56:20 +00:00
|
|
|
}
|
2013-09-11 19:09:53 +00:00
|
|
|
|
|
|
|
++myidx;
|
2013-07-29 17:56:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-09-12 16:11:21 +00:00
|
|
|
const Network::MulticastRates::Rate Network::MulticastRates::GLOBAL_DEFAULT_RATE(65535,65535,64);
|
2013-09-04 13:27:56 +00:00
|
|
|
|
2013-08-08 14:41:17 +00:00
|
|
|
const char *Network::statusString(const Status s)
|
|
|
|
throw()
|
|
|
|
{
|
|
|
|
switch(s) {
|
|
|
|
case NETWORK_WAITING_FOR_FIRST_AUTOCONF: return "WAITING_FOR_FIRST_AUTOCONF";
|
|
|
|
case NETWORK_OK: return "OK";
|
|
|
|
case NETWORK_ACCESS_DENIED: return "ACCESS_DENIED";
|
|
|
|
}
|
|
|
|
return "(invalid)";
|
|
|
|
}
|
|
|
|
|
2013-08-06 05:28:56 +00:00
|
|
|
Network::~Network()
|
|
|
|
{
|
2013-08-06 14:15:05 +00:00
|
|
|
delete _tap;
|
|
|
|
|
2013-08-06 05:28:56 +00:00
|
|
|
if (_destroyOnDelete) {
|
2013-09-11 20:17:51 +00:00
|
|
|
std::string confPath(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".conf");
|
|
|
|
std::string mcdbPath(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".mcerts");
|
2013-08-08 14:06:39 +00:00
|
|
|
Utils::rm(confPath);
|
|
|
|
Utils::rm(mcdbPath);
|
2013-08-06 05:28:56 +00:00
|
|
|
} else {
|
|
|
|
// Causes flush of membership certs to disk
|
|
|
|
clean();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-06 14:15:05 +00:00
|
|
|
SharedPtr<Network> Network::newInstance(const RuntimeEnvironment *renv,uint64_t id)
|
|
|
|
throw(std::runtime_error)
|
2013-08-06 05:28:56 +00:00
|
|
|
{
|
2013-09-24 21:35:05 +00:00
|
|
|
// Tag to identify tap device -- used on some OSes like Windows
|
2013-08-21 12:13:48 +00:00
|
|
|
char tag[32];
|
2013-08-30 21:05:43 +00:00
|
|
|
Utils::snprintf(tag,sizeof(tag),"%.16llx",(unsigned long long)id);
|
2013-08-21 12:13:48 +00:00
|
|
|
|
2013-08-06 14:15:05 +00:00
|
|
|
// We construct Network via a static method to ensure that it is immediately
|
|
|
|
// wrapped in a SharedPtr<>. Otherwise if there is traffic on the Ethernet
|
|
|
|
// tap device, a SharedPtr<> wrap can occur in the Ethernet frame handler
|
|
|
|
// that then causes the Network instance to be deleted before it is finished
|
|
|
|
// being constructed. C++ edge cases, how I love thee.
|
|
|
|
SharedPtr<Network> nw(new Network());
|
2013-08-09 21:20:40 +00:00
|
|
|
nw->_ready = false; // disable handling of Ethernet frames during construct
|
2013-08-06 14:15:05 +00:00
|
|
|
nw->_r = renv;
|
2013-08-21 12:13:48 +00:00
|
|
|
nw->_tap = new EthernetTap(renv,tag,renv->identity.address().toMAC(),ZT_IF_MTU,&_CBhandleTapData,nw.ptr());
|
2013-09-24 21:35:05 +00:00
|
|
|
nw->_isOpen = false;
|
2013-08-28 20:01:27 +00:00
|
|
|
memset(nw->_etWhitelist,0,sizeof(nw->_etWhitelist));
|
2013-08-06 14:15:05 +00:00
|
|
|
nw->_id = id;
|
|
|
|
nw->_lastConfigUpdate = 0;
|
|
|
|
nw->_destroyOnDelete = false;
|
|
|
|
if (nw->controller() == renv->identity.address()) // sanity check, this isn't supported for now
|
|
|
|
throw std::runtime_error("cannot add a network for which I am the netconf master");
|
|
|
|
nw->_restoreState();
|
2013-08-09 21:20:40 +00:00
|
|
|
nw->_ready = true; // enable handling of Ethernet frames
|
2013-08-06 14:15:05 +00:00
|
|
|
nw->requestConfiguration();
|
|
|
|
return nw;
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
2013-07-29 17:56:20 +00:00
|
|
|
void Network::setConfiguration(const Network::Config &conf)
|
|
|
|
{
|
2013-07-29 21:11:00 +00:00
|
|
|
Mutex::Lock _l(_lock);
|
2013-09-04 13:27:56 +00:00
|
|
|
try {
|
|
|
|
if (conf.networkId() == _id) { // sanity check
|
|
|
|
_configuration = conf;
|
2013-09-24 21:35:05 +00:00
|
|
|
|
|
|
|
// Grab some things from conf for faster lookup and memoize them
|
2013-09-04 13:27:56 +00:00
|
|
|
_myCertificate = conf.certificateOfMembership();
|
2013-09-07 19:49:38 +00:00
|
|
|
_mcRates = conf.multicastRates();
|
2013-09-24 21:35:05 +00:00
|
|
|
_staticAddresses = conf.staticAddresses();
|
|
|
|
_isOpen = conf.isOpen();
|
|
|
|
|
2013-09-04 13:27:56 +00:00
|
|
|
_lastConfigUpdate = Utils::now();
|
2013-08-06 04:05:39 +00:00
|
|
|
|
2013-09-24 21:35:05 +00:00
|
|
|
_tap->setIps(_staticAddresses);
|
2013-09-04 13:27:56 +00:00
|
|
|
_tap->setDisplayName((std::string("ZeroTier One [") + conf.name() + "]").c_str());
|
2013-08-06 05:28:56 +00:00
|
|
|
|
2013-09-24 21:35:05 +00:00
|
|
|
// Expand ethertype whitelist into fast-lookup bit field
|
2013-09-04 13:27:56 +00:00
|
|
|
memset(_etWhitelist,0,sizeof(_etWhitelist));
|
|
|
|
std::set<unsigned int> wl(conf.etherTypes());
|
|
|
|
for(std::set<unsigned int>::const_iterator t(wl.begin());t!=wl.end();++t)
|
|
|
|
_etWhitelist[*t / 8] |= (unsigned char)(1 << (*t % 8));
|
2013-08-28 20:01:27 +00:00
|
|
|
|
2013-09-24 21:35:05 +00:00
|
|
|
// Save most recent configuration to disk in networks.d
|
2013-09-11 20:17:51 +00:00
|
|
|
std::string confPath(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".conf");
|
2013-09-04 13:27:56 +00:00
|
|
|
if (!Utils::writeFile(confPath.c_str(),conf.toString())) {
|
|
|
|
LOG("error: unable to write network configuration file at: %s",confPath.c_str());
|
|
|
|
}
|
2013-08-06 04:05:39 +00:00
|
|
|
}
|
2013-09-04 13:27:56 +00:00
|
|
|
} catch ( ... ) {
|
2013-09-24 21:35:05 +00:00
|
|
|
// If conf is invalid, reset everything
|
2013-09-04 13:27:56 +00:00
|
|
|
_configuration = Config();
|
2013-09-24 21:35:05 +00:00
|
|
|
|
2013-09-11 19:13:05 +00:00
|
|
|
_myCertificate = CertificateOfMembership();
|
2013-09-24 21:35:05 +00:00
|
|
|
_mcRates = MulticastRates();
|
|
|
|
_staticAddresses.clear();
|
|
|
|
_isOpen = false;
|
|
|
|
|
2013-09-04 13:27:56 +00:00
|
|
|
_lastConfigUpdate = 0;
|
|
|
|
LOG("unexpected exception handling config for network %.16llx, retrying fetch...",(unsigned long long)_id);
|
2013-07-30 15:14:53 +00:00
|
|
|
}
|
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-09-24 21:35:05 +00:00
|
|
|
// FIXME: Right now the 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-09-11 19:13:05 +00:00
|
|
|
void Network::addMembershipCertificate(const Address &peer,const CertificateOfMembership &cert)
|
2013-08-06 04:05:39 +00:00
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
2013-09-24 21:35:05 +00:00
|
|
|
if (!_isOpen)
|
2013-08-06 04:05:39 +00:00
|
|
|
_membershipCertificates[peer] = cert;
|
|
|
|
}
|
|
|
|
|
2013-07-29 21:11:00 +00:00
|
|
|
bool Network::isAllowed(const Address &peer) const
|
|
|
|
{
|
2013-07-30 15:14:53 +00:00
|
|
|
// Exceptions can occur if we do not yet have *our* configuration.
|
2013-07-29 21:11:00 +00:00
|
|
|
try {
|
|
|
|
Mutex::Lock _l(_lock);
|
2013-09-24 21:35:05 +00:00
|
|
|
if (_isOpen)
|
2013-07-29 21:11:00 +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())
|
|
|
|
return false;
|
2013-09-11 19:13:05 +00:00
|
|
|
return _myCertificate.compare(pc->second);
|
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-08-03 16:53:46 +00:00
|
|
|
return false;
|
2013-07-29 21:11:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Network::clean()
|
|
|
|
{
|
2013-09-11 20:17:51 +00:00
|
|
|
std::string mcdbPath(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".mcerts");
|
2013-08-06 14:15:05 +00:00
|
|
|
|
2013-07-29 21:11:00 +00:00
|
|
|
Mutex::Lock _l(_lock);
|
2013-08-08 14:41:17 +00:00
|
|
|
|
2013-09-24 21:35:05 +00:00
|
|
|
if ((!_id)||(_isOpen)) {
|
2013-08-03 16:53:46 +00:00
|
|
|
_membershipCertificates.clear();
|
2013-08-08 14:06:39 +00:00
|
|
|
Utils::rm(mcdbPath);
|
2013-08-06 14:15:05 +00:00
|
|
|
} else {
|
2013-08-06 04:05:39 +00:00
|
|
|
FILE *mcdb = fopen(mcdbPath.c_str(),"wb");
|
|
|
|
bool writeError = false;
|
|
|
|
if (!mcdb) {
|
|
|
|
LOG("error: unable to open membership cert database at: %s",mcdbPath.c_str());
|
|
|
|
} else {
|
|
|
|
if ((writeError)||(fwrite("MCDB0",5,1,mcdb) != 1)) // version
|
|
|
|
writeError = true;
|
|
|
|
}
|
|
|
|
|
2013-09-11 19:13:05 +00:00
|
|
|
for(std::map<Address,CertificateOfMembership>::iterator i=(_membershipCertificates.begin());i!=_membershipCertificates.end();) {
|
|
|
|
if (_myCertificate.compare(i->second)) {
|
2013-08-06 04:05:39 +00:00
|
|
|
if ((!writeError)&&(mcdb)) {
|
|
|
|
char tmp[ZT_ADDRESS_LENGTH];
|
|
|
|
i->first.copyTo(tmp,ZT_ADDRESS_LENGTH);
|
|
|
|
if ((writeError)||(fwrite(tmp,ZT_ADDRESS_LENGTH,1,mcdb) != 1))
|
|
|
|
writeError = true;
|
|
|
|
std::string c(i->second.toString());
|
|
|
|
uint32_t cl = Utils::hton((uint32_t)c.length());
|
|
|
|
if ((writeError)||(fwrite(&cl,sizeof(cl),1,mcdb) != 1))
|
|
|
|
writeError = true;
|
|
|
|
if ((writeError)||(fwrite(c.data(),c.length(),1,mcdb) != 1))
|
|
|
|
writeError = true;
|
|
|
|
}
|
2013-08-03 16:53:46 +00:00
|
|
|
++i;
|
2013-08-06 04:05:39 +00:00
|
|
|
} else _membershipCertificates.erase(i++);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mcdb)
|
|
|
|
fclose(mcdb);
|
|
|
|
if (writeError) {
|
2013-08-08 14:06:39 +00:00
|
|
|
Utils::rm(mcdbPath);
|
2013-08-06 04:05:39 +00:00
|
|
|
LOG("error: unable to write to membership cert database at: %s",mcdbPath.c_str());
|
2013-08-03 16:53:46 +00:00
|
|
|
}
|
2013-07-29 21:11:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-08 14:41:17 +00:00
|
|
|
Network::Status Network::status() const
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_lock);
|
2013-09-04 13:27:56 +00:00
|
|
|
if (_configuration)
|
2013-08-08 14:41:17 +00:00
|
|
|
return NETWORK_OK;
|
|
|
|
return NETWORK_WAITING_FOR_FIRST_AUTOCONF;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2013-08-09 21:20:40 +00:00
|
|
|
if (!((Network *)arg)->_ready)
|
|
|
|
return;
|
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-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-08-06 14:15:05 +00:00
|
|
|
void Network::_restoreState()
|
|
|
|
{
|
2013-09-11 20:17:51 +00:00
|
|
|
std::string confPath(_r->homePath + ZT_PATH_SEPARATOR_S + "networks.d" + ZT_PATH_SEPARATOR_S + idString() + ".conf");
|
2013-08-06 14:15:05 +00:00
|
|
|
std::string confs;
|
|
|
|
if (Utils::readFile(confPath.c_str(),confs)) {
|
|
|
|
try {
|
2013-09-04 13:27:56 +00:00
|
|
|
if (confs.length())
|
|
|
|
setConfiguration(Config(confs));
|
2013-08-06 14:15:05 +00:00
|
|
|
} catch ( ... ) {} // ignore invalid config on disk, we will re-request
|
|
|
|
} else {
|
|
|
|
// If the conf file isn't present, "touch" it so we'll remember
|
|
|
|
// the existence of this network.
|
|
|
|
FILE *tmp = fopen(confPath.c_str(),"w");
|
|
|
|
if (tmp)
|
|
|
|
fclose(tmp);
|
|
|
|
}
|
|
|
|
// TODO: restore membership certs
|
|
|
|
}
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
} // namespace ZeroTier
|