2016-11-03 21:17:46 +00:00
|
|
|
/*
|
|
|
|
* ZeroTier One - Network Virtualization Everywhere
|
|
|
|
* Copyright (C) 2011-2015 ZeroTier, Inc.
|
|
|
|
*
|
|
|
|
* 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/>.
|
|
|
|
*/
|
|
|
|
|
2017-07-18 20:57:37 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdint.h>
|
2017-07-18 22:59:11 +00:00
|
|
|
#ifndef _WIN32
|
2017-07-18 20:57:37 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/select.h>
|
|
|
|
#endif
|
|
|
|
|
2016-11-03 21:17:46 +00:00
|
|
|
#include "JSONDB.hpp"
|
2017-08-16 21:14:49 +00:00
|
|
|
#include "EmbeddedNetworkController.hpp"
|
2017-04-19 00:37:44 +00:00
|
|
|
|
2016-11-03 21:17:46 +00:00
|
|
|
namespace ZeroTier {
|
|
|
|
|
2016-11-04 22:34:49 +00:00
|
|
|
static const nlohmann::json _EMPTY_JSON(nlohmann::json::object());
|
2017-04-19 00:37:44 +00:00
|
|
|
|
2017-08-16 21:14:49 +00:00
|
|
|
JSONDB::JSONDB(const std::string &basePath,EmbeddedNetworkController *parent) :
|
|
|
|
_parent(parent),
|
2017-04-26 17:35:59 +00:00
|
|
|
_basePath(basePath),
|
2017-07-18 20:57:37 +00:00
|
|
|
_rawInput(-1),
|
|
|
|
_rawOutput(-1),
|
2017-07-19 21:13:17 +00:00
|
|
|
_summaryThreadRun(true),
|
|
|
|
_dataReady(false)
|
2017-04-19 00:37:44 +00:00
|
|
|
{
|
2017-07-18 20:57:37 +00:00
|
|
|
#ifndef __WINDOWS__
|
2017-08-16 21:14:49 +00:00
|
|
|
if (_basePath == "-") {
|
|
|
|
// If base path is "-" we run in Central harnessed mode. We read pseudo-http-requests from stdin and write
|
|
|
|
// them to stdout.
|
2017-07-18 20:57:37 +00:00
|
|
|
_rawInput = STDIN_FILENO;
|
|
|
|
_rawOutput = STDOUT_FILENO;
|
|
|
|
fcntl(_rawInput,F_SETFL,O_NONBLOCK);
|
2017-04-19 00:37:44 +00:00
|
|
|
} else {
|
2017-08-16 21:14:49 +00:00
|
|
|
#endif
|
2017-07-18 20:57:37 +00:00
|
|
|
// Default mode of operation is to store files in the filesystem
|
2017-04-19 00:37:44 +00:00
|
|
|
OSUtils::mkdir(_basePath.c_str());
|
|
|
|
OSUtils::lockDownFile(_basePath.c_str(),true); // networks might contain auth tokens, etc., so restrict directory permissions
|
2017-08-16 21:14:49 +00:00
|
|
|
#ifndef __WINDOWS__
|
2017-04-19 00:37:44 +00:00
|
|
|
}
|
2017-08-16 21:14:49 +00:00
|
|
|
#endif
|
2017-04-26 13:48:08 +00:00
|
|
|
|
2017-07-19 21:13:17 +00:00
|
|
|
_networks_m.lock(); // locked until data is loaded, etc.
|
|
|
|
|
2017-07-18 20:57:37 +00:00
|
|
|
if (_rawInput < 0) {
|
2017-08-16 21:14:49 +00:00
|
|
|
_load(basePath);
|
|
|
|
_dataReady = true;
|
|
|
|
_networks_m.unlock();
|
2017-07-19 21:13:17 +00:00
|
|
|
} else {
|
2017-08-16 21:14:49 +00:00
|
|
|
// In harnessed mode we leave the lock locked and wait for our initial DB from Central.
|
2017-07-19 21:13:17 +00:00
|
|
|
_summaryThread = Thread::start(this);
|
2017-04-26 19:17:43 +00:00
|
|
|
}
|
2017-04-26 13:48:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
JSONDB::~JSONDB()
|
|
|
|
{
|
2017-04-26 17:35:59 +00:00
|
|
|
Thread t;
|
2017-04-26 13:48:08 +00:00
|
|
|
{
|
|
|
|
Mutex::Lock _l(_summaryThread_m);
|
2017-04-26 17:35:59 +00:00
|
|
|
_summaryThreadRun = false;
|
|
|
|
t = _summaryThread;
|
2017-04-26 13:48:08 +00:00
|
|
|
}
|
2017-04-26 17:35:59 +00:00
|
|
|
if (t)
|
|
|
|
Thread::join(t);
|
2017-04-19 00:37:44 +00:00
|
|
|
}
|
2016-11-03 21:17:46 +00:00
|
|
|
|
2017-03-02 00:33:34 +00:00
|
|
|
bool JSONDB::writeRaw(const std::string &n,const std::string &obj)
|
|
|
|
{
|
2017-07-18 20:57:37 +00:00
|
|
|
if (_rawOutput >= 0) {
|
|
|
|
#ifndef __WINDOWS__
|
|
|
|
if (obj.length() > 0) {
|
|
|
|
Mutex::Lock _l(_rawLock);
|
2017-07-19 22:06:23 +00:00
|
|
|
//fprintf(stderr,"%s\n",obj.c_str());
|
2017-07-19 21:13:17 +00:00
|
|
|
if ((long)write(_rawOutput,obj.data(),obj.length()) == (long)obj.length()) {
|
|
|
|
if (write(_rawOutput,"\n",1) == 1)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
} else return true;
|
2017-07-18 20:57:37 +00:00
|
|
|
#endif
|
|
|
|
return false;
|
2017-04-19 00:37:44 +00:00
|
|
|
} else {
|
|
|
|
const std::string path(_genPath(n,true));
|
|
|
|
if (!path.length())
|
|
|
|
return false;
|
|
|
|
return OSUtils::writeFile(path.c_str(),obj);
|
|
|
|
}
|
2017-03-02 00:33:34 +00:00
|
|
|
}
|
|
|
|
|
2017-04-27 07:59:36 +00:00
|
|
|
bool JSONDB::hasNetwork(const uint64_t networkId) const
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_networks_m);
|
2017-04-28 02:36:03 +00:00
|
|
|
return (_networks.find(networkId) != _networks.end());
|
2017-04-27 07:59:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool JSONDB::getNetwork(const uint64_t networkId,nlohmann::json &config) const
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_networks_m);
|
2017-04-28 02:36:03 +00:00
|
|
|
const std::unordered_map<uint64_t,_NW>::const_iterator i(_networks.find(networkId));
|
2017-04-27 07:59:36 +00:00
|
|
|
if (i == _networks.end())
|
|
|
|
return false;
|
2017-04-28 02:36:03 +00:00
|
|
|
config = nlohmann::json::from_msgpack(i->second.config);
|
2017-04-27 07:59:36 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool JSONDB::getNetworkSummaryInfo(const uint64_t networkId,NetworkSummaryInfo &ns) const
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_networks_m);
|
2017-04-28 02:36:03 +00:00
|
|
|
const std::unordered_map<uint64_t,_NW>::const_iterator i(_networks.find(networkId));
|
2017-04-27 07:59:36 +00:00
|
|
|
if (i == _networks.end())
|
|
|
|
return false;
|
|
|
|
ns = i->second.summaryInfo;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
int JSONDB::getNetworkAndMember(const uint64_t networkId,const uint64_t nodeId,nlohmann::json &networkConfig,nlohmann::json &memberConfig,NetworkSummaryInfo &ns) const
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_networks_m);
|
2017-04-28 02:36:03 +00:00
|
|
|
const std::unordered_map<uint64_t,_NW>::const_iterator i(_networks.find(networkId));
|
2017-04-27 07:59:36 +00:00
|
|
|
if (i == _networks.end())
|
|
|
|
return 0;
|
2017-04-28 02:36:03 +00:00
|
|
|
const std::unordered_map< uint64_t,std::vector<uint8_t> >::const_iterator j(i->second.members.find(nodeId));
|
2017-04-27 07:59:36 +00:00
|
|
|
if (j == i->second.members.end())
|
|
|
|
return 1;
|
2017-04-28 02:36:03 +00:00
|
|
|
networkConfig = nlohmann::json::from_msgpack(i->second.config);
|
|
|
|
memberConfig = nlohmann::json::from_msgpack(j->second);
|
2017-04-27 07:59:36 +00:00
|
|
|
ns = i->second.summaryInfo;
|
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool JSONDB::getNetworkMember(const uint64_t networkId,const uint64_t nodeId,nlohmann::json &memberConfig) const
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_networks_m);
|
2017-04-28 02:36:03 +00:00
|
|
|
const std::unordered_map<uint64_t,_NW>::const_iterator i(_networks.find(networkId));
|
2017-04-27 07:59:36 +00:00
|
|
|
if (i == _networks.end())
|
|
|
|
return false;
|
2017-04-28 02:36:03 +00:00
|
|
|
const std::unordered_map< uint64_t,std::vector<uint8_t> >::const_iterator j(i->second.members.find(nodeId));
|
2017-04-27 07:59:36 +00:00
|
|
|
if (j == i->second.members.end())
|
|
|
|
return false;
|
2017-04-28 02:36:03 +00:00
|
|
|
memberConfig = nlohmann::json::from_msgpack(j->second);
|
2017-04-27 07:59:36 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-04-26 13:48:08 +00:00
|
|
|
void JSONDB::saveNetwork(const uint64_t networkId,const nlohmann::json &networkConfig)
|
2016-11-03 21:17:46 +00:00
|
|
|
{
|
2017-04-27 07:59:36 +00:00
|
|
|
char n[64];
|
2017-07-06 23:11:11 +00:00
|
|
|
OSUtils::ztsnprintf(n,sizeof(n),"network/%.16llx",(unsigned long long)networkId);
|
2017-07-19 21:13:17 +00:00
|
|
|
writeRaw(n,OSUtils::jsonDump(networkConfig,-1));
|
2017-04-25 02:16:36 +00:00
|
|
|
{
|
2017-04-26 13:48:08 +00:00
|
|
|
Mutex::Lock _l(_networks_m);
|
2017-08-16 21:14:49 +00:00
|
|
|
_NW &nw = _networks[networkId];
|
|
|
|
nw.config = nlohmann::json::to_msgpack(networkConfig);
|
2017-04-25 02:16:36 +00:00
|
|
|
}
|
2017-04-26 19:17:43 +00:00
|
|
|
_recomputeSummaryInfo(networkId);
|
2016-11-03 21:17:46 +00:00
|
|
|
}
|
|
|
|
|
2017-04-26 13:48:08 +00:00
|
|
|
void JSONDB::saveNetworkMember(const uint64_t networkId,const uint64_t nodeId,const nlohmann::json &memberConfig)
|
2016-11-03 21:17:46 +00:00
|
|
|
{
|
2017-04-26 13:48:08 +00:00
|
|
|
char n[256];
|
2017-07-06 23:11:11 +00:00
|
|
|
OSUtils::ztsnprintf(n,sizeof(n),"network/%.16llx/member/%.10llx",(unsigned long long)networkId,(unsigned long long)nodeId);
|
2017-07-19 21:13:17 +00:00
|
|
|
writeRaw(n,OSUtils::jsonDump(memberConfig,-1));
|
2017-04-26 13:48:08 +00:00
|
|
|
{
|
|
|
|
Mutex::Lock _l(_networks_m);
|
2017-08-16 21:14:49 +00:00
|
|
|
std::vector<uint8_t> &m = _networks[networkId].members[nodeId];
|
|
|
|
m = nlohmann::json::to_msgpack(memberConfig);
|
2017-07-14 21:33:36 +00:00
|
|
|
_members[nodeId].insert(networkId);
|
2017-04-25 03:51:02 +00:00
|
|
|
}
|
2017-04-26 13:48:08 +00:00
|
|
|
_recomputeSummaryInfo(networkId);
|
|
|
|
}
|
2017-04-24 16:09:04 +00:00
|
|
|
|
2017-04-26 13:48:08 +00:00
|
|
|
nlohmann::json JSONDB::eraseNetwork(const uint64_t networkId)
|
|
|
|
{
|
2017-08-16 21:14:49 +00:00
|
|
|
if (_rawOutput >= 0) {
|
|
|
|
// In harnessed mode, DB deletes occur in the Central database and we do
|
|
|
|
// not need to erase files.
|
|
|
|
} else {
|
2017-04-26 13:48:08 +00:00
|
|
|
std::vector<uint64_t> memberIds;
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_networks_m);
|
2017-04-28 02:36:03 +00:00
|
|
|
const std::unordered_map<uint64_t,_NW>::iterator i(_networks.find(networkId));
|
2017-04-26 13:48:08 +00:00
|
|
|
if (i == _networks.end())
|
|
|
|
return _EMPTY_JSON;
|
2017-04-28 02:36:03 +00:00
|
|
|
for(std::unordered_map< uint64_t,std::vector<uint8_t> >::iterator m(i->second.members.begin());m!=i->second.members.end();++m)
|
2017-04-26 13:48:08 +00:00
|
|
|
memberIds.push_back(m->first);
|
|
|
|
}
|
|
|
|
for(std::vector<uint64_t>::iterator m(memberIds.begin());m!=memberIds.end();++m)
|
|
|
|
eraseNetworkMember(networkId,*m,false);
|
2016-11-03 21:17:46 +00:00
|
|
|
|
2017-08-16 21:14:49 +00:00
|
|
|
char n[256];
|
|
|
|
OSUtils::ztsnprintf(n,sizeof(n),"network/%.16llx",(unsigned long long)networkId);
|
2017-04-19 00:37:44 +00:00
|
|
|
const std::string path(_genPath(n,false));
|
2017-04-26 13:48:08 +00:00
|
|
|
if (path.length())
|
|
|
|
OSUtils::rm(path.c_str());
|
2017-04-19 00:37:44 +00:00
|
|
|
}
|
2016-11-03 21:17:46 +00:00
|
|
|
|
2017-08-16 21:14:49 +00:00
|
|
|
// This also erases all members from the memory cache
|
2017-04-25 03:51:02 +00:00
|
|
|
{
|
2017-04-26 13:48:08 +00:00
|
|
|
Mutex::Lock _l(_networks_m);
|
|
|
|
std::unordered_map<uint64_t,_NW>::iterator i(_networks.find(networkId));
|
|
|
|
if (i == _networks.end())
|
|
|
|
return _EMPTY_JSON; // sanity check, shouldn't happen
|
2017-04-28 02:36:03 +00:00
|
|
|
nlohmann::json tmp(nlohmann::json::from_msgpack(i->second.config));
|
2017-04-26 13:48:08 +00:00
|
|
|
_networks.erase(i);
|
|
|
|
return tmp;
|
2016-11-03 21:17:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-26 13:48:08 +00:00
|
|
|
nlohmann::json JSONDB::eraseNetworkMember(const uint64_t networkId,const uint64_t nodeId,bool recomputeSummaryInfo)
|
2016-11-04 22:18:31 +00:00
|
|
|
{
|
2017-07-18 20:57:37 +00:00
|
|
|
if (_rawOutput >= 0) {
|
2017-08-16 21:14:49 +00:00
|
|
|
// In harnessed mode, DB deletes occur in Central and we do not remove files.
|
2017-04-26 13:48:08 +00:00
|
|
|
} else {
|
2017-08-16 21:14:49 +00:00
|
|
|
char n[256];
|
|
|
|
OSUtils::ztsnprintf(n,sizeof(n),"network/%.16llx/member/%.10llx",(unsigned long long)networkId,(unsigned long long)nodeId);
|
2017-04-26 13:48:08 +00:00
|
|
|
const std::string path(_genPath(n,false));
|
|
|
|
if (path.length())
|
|
|
|
OSUtils::rm(path.c_str());
|
|
|
|
}
|
|
|
|
|
2017-04-25 03:51:02 +00:00
|
|
|
{
|
2017-04-26 13:48:08 +00:00
|
|
|
Mutex::Lock _l(_networks_m);
|
2017-07-14 21:33:36 +00:00
|
|
|
_members[nodeId].erase(networkId);
|
2017-04-26 13:48:08 +00:00
|
|
|
std::unordered_map<uint64_t,_NW>::iterator i(_networks.find(networkId));
|
|
|
|
if (i == _networks.end())
|
|
|
|
return _EMPTY_JSON;
|
2017-04-28 02:36:03 +00:00
|
|
|
std::unordered_map< uint64_t,std::vector<uint8_t> >::iterator j(i->second.members.find(nodeId));
|
2017-04-26 13:48:08 +00:00
|
|
|
if (j == i->second.members.end())
|
|
|
|
return _EMPTY_JSON;
|
|
|
|
nlohmann::json tmp(j->second);
|
|
|
|
i->second.members.erase(j);
|
|
|
|
if (recomputeSummaryInfo)
|
|
|
|
_recomputeSummaryInfo(networkId);
|
|
|
|
return tmp;
|
2017-04-25 03:51:02 +00:00
|
|
|
}
|
|
|
|
}
|
2016-11-04 22:18:31 +00:00
|
|
|
|
2017-04-26 13:48:08 +00:00
|
|
|
void JSONDB::threadMain()
|
|
|
|
throw()
|
2017-04-25 03:51:02 +00:00
|
|
|
{
|
2017-07-18 20:57:37 +00:00
|
|
|
#ifndef __WINDOWS__
|
|
|
|
fd_set readfds,nullfds;
|
|
|
|
char *const readbuf = (_rawInput >= 0) ? (new char[1048576]) : (char *)0;
|
|
|
|
std::string rawInputBuf;
|
|
|
|
FD_ZERO(&readfds);
|
|
|
|
FD_ZERO(&nullfds);
|
2017-07-19 21:13:17 +00:00
|
|
|
struct timeval tv;
|
2017-07-18 20:57:37 +00:00
|
|
|
#endif
|
|
|
|
|
2017-04-26 17:35:59 +00:00
|
|
|
std::vector<uint64_t> todo;
|
2017-07-18 20:57:37 +00:00
|
|
|
|
2017-04-26 17:35:59 +00:00
|
|
|
while (_summaryThreadRun) {
|
2017-07-18 20:57:37 +00:00
|
|
|
#ifndef __WINDOWS__
|
|
|
|
if (_rawInput < 0) {
|
|
|
|
Thread::sleep(25);
|
|
|
|
} else {
|
2017-07-19 21:13:17 +00:00
|
|
|
// In IPC mode we wait but also select() on STDIN to read database updates
|
2017-07-18 20:57:37 +00:00
|
|
|
FD_SET(_rawInput,&readfds);
|
|
|
|
tv.tv_sec = 0;
|
|
|
|
tv.tv_usec = 25000;
|
|
|
|
select(_rawInput+1,&readfds,&nullfds,&nullfds,&tv);
|
|
|
|
if (FD_ISSET(_rawInput,&readfds)) {
|
|
|
|
const long rn = (long)read(_rawInput,readbuf,1048576);
|
2017-07-19 21:13:17 +00:00
|
|
|
bool gotMessage = false;
|
2017-07-18 20:57:37 +00:00
|
|
|
for(long i=0;i<rn;++i) {
|
2017-07-19 21:13:17 +00:00
|
|
|
if ((readbuf[i] != '\n')&&(readbuf[i] != '\r')&&(readbuf[i] != 0)) { // compatible with nodeJS IPC
|
2017-07-18 20:57:37 +00:00
|
|
|
rawInputBuf.push_back(readbuf[i]);
|
|
|
|
} else if (rawInputBuf.length() > 0) {
|
2017-07-19 21:13:17 +00:00
|
|
|
try {
|
|
|
|
const nlohmann::json obj(OSUtils::jsonParse(rawInputBuf));
|
|
|
|
gotMessage = true;
|
2017-08-16 21:14:49 +00:00
|
|
|
|
2017-07-19 21:13:17 +00:00
|
|
|
if (!_dataReady) {
|
|
|
|
_dataReady = true;
|
|
|
|
_networks_m.unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (obj.is_array()) {
|
|
|
|
for(unsigned long i=0;i<obj.size();++i)
|
2017-08-17 20:10:10 +00:00
|
|
|
_addOrUpdate(obj[i]);
|
2017-07-19 21:13:17 +00:00
|
|
|
} else if (obj.is_object()) {
|
2017-08-17 20:10:10 +00:00
|
|
|
_addOrUpdate(obj);
|
2017-07-19 21:13:17 +00:00
|
|
|
}
|
|
|
|
} catch ( ... ) {} // ignore malformed JSON
|
2017-08-16 21:14:49 +00:00
|
|
|
|
2017-07-18 20:57:37 +00:00
|
|
|
rawInputBuf.clear();
|
|
|
|
}
|
|
|
|
}
|
2017-07-19 21:13:17 +00:00
|
|
|
if (!gotMessage) // select() again immediately until we get at least one full message
|
|
|
|
continue;
|
2017-07-18 20:57:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
Thread::sleep(25);
|
|
|
|
#endif
|
2017-04-26 17:35:59 +00:00
|
|
|
|
2017-04-26 13:48:08 +00:00
|
|
|
{
|
2017-04-26 17:35:59 +00:00
|
|
|
Mutex::Lock _l(_summaryThread_m);
|
|
|
|
if (_summaryThreadToDo.empty())
|
|
|
|
continue;
|
|
|
|
else _summaryThreadToDo.swap(todo);
|
|
|
|
}
|
|
|
|
|
2017-08-16 21:14:49 +00:00
|
|
|
if (!_dataReady) { // sanity check
|
2017-07-19 21:13:17 +00:00
|
|
|
_dataReady = true;
|
|
|
|
_networks_m.unlock();
|
|
|
|
}
|
|
|
|
|
2017-10-02 22:52:57 +00:00
|
|
|
const int64_t now = OSUtils::now();
|
2017-07-19 21:13:17 +00:00
|
|
|
try {
|
2017-04-26 13:48:08 +00:00
|
|
|
Mutex::Lock _l(_networks_m);
|
2017-07-19 21:13:17 +00:00
|
|
|
for(std::vector<uint64_t>::iterator ii(todo.begin());ii!=todo.end();++ii) {
|
|
|
|
const uint64_t networkId = *ii;
|
|
|
|
std::unordered_map<uint64_t,_NW>::iterator n(_networks.find(networkId));
|
|
|
|
if (n != _networks.end()) {
|
|
|
|
NetworkSummaryInfo &ns = n->second.summaryInfo;
|
|
|
|
ns.activeBridges.clear();
|
|
|
|
ns.allocatedIps.clear();
|
|
|
|
ns.authorizedMemberCount = 0;
|
|
|
|
ns.activeMemberCount = 0;
|
|
|
|
ns.totalMemberCount = 0;
|
|
|
|
ns.mostRecentDeauthTime = 0;
|
|
|
|
|
|
|
|
for(std::unordered_map< uint64_t,std::vector<uint8_t> >::const_iterator m(n->second.members.begin());m!=n->second.members.end();++m) {
|
|
|
|
try {
|
|
|
|
nlohmann::json member(nlohmann::json::from_msgpack(m->second));
|
|
|
|
|
|
|
|
if (OSUtils::jsonBool(member["authorized"],false)) {
|
|
|
|
++ns.authorizedMemberCount;
|
|
|
|
|
|
|
|
try {
|
|
|
|
const nlohmann::json &mlog = member["recentLog"];
|
|
|
|
if ((mlog.is_array())&&(mlog.size() > 0)) {
|
|
|
|
const nlohmann::json &mlog1 = mlog[0];
|
|
|
|
if (mlog1.is_object()) {
|
|
|
|
if ((now - OSUtils::jsonInt(mlog1["ts"],0ULL)) < (ZT_NETWORK_AUTOCONF_DELAY * 2))
|
|
|
|
++ns.activeMemberCount;
|
|
|
|
}
|
2017-04-26 13:48:08 +00:00
|
|
|
}
|
2017-07-19 21:13:17 +00:00
|
|
|
} catch ( ... ) {}
|
|
|
|
|
|
|
|
try {
|
|
|
|
if (OSUtils::jsonBool(member["activeBridge"],false))
|
|
|
|
ns.activeBridges.push_back(Address(m->first));
|
|
|
|
} catch ( ... ) {}
|
|
|
|
|
|
|
|
try {
|
|
|
|
const nlohmann::json &mips = member["ipAssignments"];
|
|
|
|
if (mips.is_array()) {
|
|
|
|
for(unsigned long i=0;i<mips.size();++i) {
|
|
|
|
InetAddress mip(OSUtils::jsonString(mips[i],"").c_str());
|
|
|
|
if ((mip.ss_family == AF_INET)||(mip.ss_family == AF_INET6))
|
|
|
|
ns.allocatedIps.push_back(mip);
|
|
|
|
}
|
2017-04-26 13:48:08 +00:00
|
|
|
}
|
2017-07-19 21:13:17 +00:00
|
|
|
} catch ( ... ) {}
|
|
|
|
} else {
|
|
|
|
try {
|
2017-10-02 22:52:57 +00:00
|
|
|
ns.mostRecentDeauthTime = std::max(ns.mostRecentDeauthTime,(int64_t)OSUtils::jsonInt(member["lastDeauthorizedTime"],0LL));
|
2017-07-19 21:13:17 +00:00
|
|
|
} catch ( ... ) {}
|
|
|
|
}
|
|
|
|
++ns.totalMemberCount;
|
|
|
|
} catch ( ... ) {}
|
|
|
|
}
|
2017-04-26 13:48:08 +00:00
|
|
|
|
2017-07-19 21:13:17 +00:00
|
|
|
std::sort(ns.activeBridges.begin(),ns.activeBridges.end());
|
|
|
|
std::sort(ns.allocatedIps.begin(),ns.allocatedIps.end());
|
2017-04-26 13:48:08 +00:00
|
|
|
|
2017-07-19 21:13:17 +00:00
|
|
|
n->second.summaryInfoLastComputed = now;
|
|
|
|
}
|
2017-04-26 13:48:08 +00:00
|
|
|
}
|
2017-07-19 21:13:17 +00:00
|
|
|
} catch ( ... ) {}
|
2017-04-26 17:35:59 +00:00
|
|
|
|
|
|
|
todo.clear();
|
2017-04-19 00:37:44 +00:00
|
|
|
}
|
2017-07-18 20:57:37 +00:00
|
|
|
|
2017-07-19 21:13:17 +00:00
|
|
|
if (!_dataReady) // sanity check
|
|
|
|
_networks_m.unlock();
|
|
|
|
|
2017-07-18 20:57:37 +00:00
|
|
|
#ifndef __WINDOWS__
|
|
|
|
delete [] readbuf;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2017-08-17 20:10:10 +00:00
|
|
|
bool JSONDB::_addOrUpdate(const nlohmann::json &j)
|
2017-07-18 20:57:37 +00:00
|
|
|
{
|
|
|
|
try {
|
|
|
|
if (j.is_object()) {
|
|
|
|
std::string id(OSUtils::jsonString(j["id"],"0"));
|
2017-08-17 20:10:10 +00:00
|
|
|
const std::string objtype(OSUtils::jsonString(j["objtype"],""));
|
2017-07-18 20:57:37 +00:00
|
|
|
if ((id.length() == 16)&&(objtype == "network")) {
|
2017-08-17 20:10:10 +00:00
|
|
|
|
2017-07-18 20:57:37 +00:00
|
|
|
const uint64_t nwid = Utils::hexStrToU64(id.c_str());
|
|
|
|
if (nwid) {
|
2017-08-16 21:14:49 +00:00
|
|
|
bool update;
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_networks_m);
|
|
|
|
_NW &nw = _networks[nwid];
|
|
|
|
update = !nw.config.empty();
|
|
|
|
nw.config = nlohmann::json::to_msgpack(j);
|
|
|
|
}
|
|
|
|
if (update)
|
|
|
|
_parent->onNetworkUpdate(nwid);
|
|
|
|
_recomputeSummaryInfo(nwid);
|
2017-07-18 20:57:37 +00:00
|
|
|
return true;
|
|
|
|
}
|
2017-08-17 20:10:10 +00:00
|
|
|
|
2017-07-18 20:57:37 +00:00
|
|
|
} else if ((id.length() == 10)&&(objtype == "member")) {
|
2017-08-17 20:10:10 +00:00
|
|
|
|
2017-07-18 20:57:37 +00:00
|
|
|
const uint64_t mid = Utils::hexStrToU64(id.c_str());
|
|
|
|
const uint64_t nwid = Utils::hexStrToU64(OSUtils::jsonString(j["nwid"],"0").c_str());
|
|
|
|
if ((mid)&&(nwid)) {
|
2017-08-17 20:10:10 +00:00
|
|
|
bool update = false;
|
|
|
|
bool deauth = false;
|
2017-08-16 21:14:49 +00:00
|
|
|
{
|
|
|
|
Mutex::Lock _l(_networks_m);
|
|
|
|
std::vector<uint8_t> &m = _networks[nwid].members[mid];
|
2017-08-17 20:10:10 +00:00
|
|
|
if (!m.empty()) {
|
|
|
|
update = true;
|
|
|
|
nlohmann::json oldm(nlohmann::json::from_msgpack(m));
|
|
|
|
deauth = ((OSUtils::jsonBool(oldm["authorized"],false))&&(!OSUtils::jsonBool(j["authorized"],false)));
|
|
|
|
}
|
2017-08-16 21:14:49 +00:00
|
|
|
m = nlohmann::json::to_msgpack(j);
|
|
|
|
_members[mid].insert(nwid);
|
|
|
|
}
|
2017-08-17 20:10:10 +00:00
|
|
|
if (update) {
|
2017-08-16 21:14:49 +00:00
|
|
|
_parent->onNetworkMemberUpdate(nwid,mid);
|
2017-08-17 20:10:10 +00:00
|
|
|
if (deauth)
|
|
|
|
_parent->onNetworkMemberDeauthorize(nwid,mid);
|
|
|
|
}
|
2017-08-16 21:14:49 +00:00
|
|
|
_recomputeSummaryInfo(nwid);
|
2017-07-18 20:57:37 +00:00
|
|
|
return true;
|
|
|
|
}
|
2017-08-17 20:10:10 +00:00
|
|
|
|
|
|
|
} else if (objtype == "_delete") { // pseudo-object-type, only used in Central harnessed mode
|
|
|
|
|
|
|
|
const std::string deleteType(OSUtils::jsonString(j["deleteType"],""));
|
|
|
|
id = OSUtils::jsonString(j["deleteId"],"");
|
|
|
|
if ((deleteType == "network")&&(id.length() == 16)) {
|
|
|
|
eraseNetwork(Utils::hexStrToU64(id.c_str()));
|
|
|
|
} else if ((deleteType == "member")&&(id.length() == 10)) {
|
|
|
|
const std::string networkId(OSUtils::jsonString(j["deleteNetworkId"],""));
|
|
|
|
const uint64_t nwid = Utils::hexStrToU64(networkId.c_str());
|
|
|
|
const uint64_t mid = Utils::hexStrToU64(id.c_str());
|
|
|
|
if (networkId.length() == 16)
|
|
|
|
eraseNetworkMember(nwid,mid,true);
|
|
|
|
_parent->onNetworkMemberDeauthorize(nwid,mid);
|
|
|
|
}
|
|
|
|
|
2017-07-18 20:57:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} catch ( ... ) {}
|
|
|
|
return false;
|
2016-11-04 22:18:31 +00:00
|
|
|
}
|
|
|
|
|
2017-04-26 13:48:08 +00:00
|
|
|
bool JSONDB::_load(const std::string &p)
|
2016-11-04 22:18:31 +00:00
|
|
|
{
|
2017-07-18 20:57:37 +00:00
|
|
|
// This is not used in stdin/stdout mode. Instead data is populated by
|
|
|
|
// sending it all to stdin.
|
|
|
|
|
2017-08-16 21:14:49 +00:00
|
|
|
std::vector<std::string> dl(OSUtils::listDirectory(p.c_str(),true));
|
|
|
|
for(std::vector<std::string>::const_iterator di(dl.begin());di!=dl.end();++di) {
|
|
|
|
if ((di->length() > 5)&&(di->substr(di->length() - 5) == ".json")) {
|
|
|
|
std::string buf;
|
|
|
|
if (OSUtils::readFile((p + ZT_PATH_SEPARATOR_S + *di).c_str(),buf)) {
|
|
|
|
try {
|
2017-08-17 20:10:10 +00:00
|
|
|
_addOrUpdate(OSUtils::jsonParse(buf));
|
2017-08-16 21:14:49 +00:00
|
|
|
} catch ( ... ) {}
|
2017-04-19 00:37:44 +00:00
|
|
|
}
|
2017-08-16 21:14:49 +00:00
|
|
|
} else {
|
|
|
|
this->_load((p + ZT_PATH_SEPARATOR_S + *di));
|
2016-11-04 22:18:31 +00:00
|
|
|
}
|
|
|
|
}
|
2017-08-16 21:14:49 +00:00
|
|
|
|
|
|
|
return true;
|
2016-11-04 22:18:31 +00:00
|
|
|
}
|
|
|
|
|
2017-04-26 13:48:08 +00:00
|
|
|
void JSONDB::_recomputeSummaryInfo(const uint64_t networkId)
|
|
|
|
{
|
|
|
|
Mutex::Lock _l(_summaryThread_m);
|
2017-04-26 17:35:59 +00:00
|
|
|
if (std::find(_summaryThreadToDo.begin(),_summaryThreadToDo.end(),networkId) == _summaryThreadToDo.end())
|
|
|
|
_summaryThreadToDo.push_back(networkId);
|
2017-04-26 13:48:08 +00:00
|
|
|
if (!_summaryThread)
|
|
|
|
_summaryThread = Thread::start(this);
|
|
|
|
}
|
|
|
|
|
2016-11-03 21:17:46 +00:00
|
|
|
std::string JSONDB::_genPath(const std::string &n,bool create)
|
|
|
|
{
|
2016-11-18 23:49:28 +00:00
|
|
|
std::vector<std::string> pt(OSUtils::split(n.c_str(),"/","",""));
|
2016-11-03 21:17:46 +00:00
|
|
|
if (pt.size() == 0)
|
|
|
|
return std::string();
|
|
|
|
|
|
|
|
std::string p(_basePath);
|
|
|
|
if (create) OSUtils::mkdir(p.c_str());
|
2017-01-13 23:19:59 +00:00
|
|
|
for(unsigned long i=0,j=(unsigned long)(pt.size()-1);i<j;++i) {
|
2017-08-16 21:14:49 +00:00
|
|
|
p.push_back(ZT_PATH_SEPARATOR);
|
2016-11-03 21:17:46 +00:00
|
|
|
p.append(pt[i]);
|
|
|
|
if (create) OSUtils::mkdir(p.c_str());
|
|
|
|
}
|
|
|
|
|
2017-08-16 21:14:49 +00:00
|
|
|
p.push_back(ZT_PATH_SEPARATOR);
|
2016-11-03 21:17:46 +00:00
|
|
|
p.append(pt[pt.size()-1]);
|
|
|
|
p.append(".json");
|
|
|
|
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace ZeroTier
|