2015-02-24 20:28:58 +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/>.
|
|
|
|
*/
|
|
|
|
|
2015-04-15 22:12:09 +00:00
|
|
|
#ifndef ZT_SQLITENETWORKCONTROLLER_HPP
|
|
|
|
#define ZT_SQLITENETWORKCONTROLLER_HPP
|
2015-02-24 20:28:58 +00:00
|
|
|
|
|
|
|
#include <stdint.h>
|
2015-03-12 21:03:53 +00:00
|
|
|
|
2015-02-24 20:28:58 +00:00
|
|
|
#include <string>
|
|
|
|
#include <map>
|
|
|
|
#include <vector>
|
2016-08-16 23:46:08 +00:00
|
|
|
#include <set>
|
2016-08-25 18:26:45 +00:00
|
|
|
#include <list>
|
2015-02-24 20:28:58 +00:00
|
|
|
|
2015-02-24 22:17:57 +00:00
|
|
|
#include "../node/Constants.hpp"
|
2016-08-12 18:30:27 +00:00
|
|
|
|
2015-04-15 22:12:09 +00:00
|
|
|
#include "../node/NetworkController.hpp"
|
2015-02-24 22:17:57 +00:00
|
|
|
#include "../node/Mutex.hpp"
|
2016-08-16 21:05:17 +00:00
|
|
|
#include "../node/Utils.hpp"
|
2016-08-25 18:26:45 +00:00
|
|
|
#include "../node/Address.hpp"
|
2016-08-16 23:46:08 +00:00
|
|
|
#include "../node/InetAddress.hpp"
|
2016-08-16 21:05:17 +00:00
|
|
|
|
|
|
|
#include "../osdep/OSUtils.hpp"
|
2016-08-25 18:26:45 +00:00
|
|
|
#include "../osdep/Thread.hpp"
|
2016-11-10 21:57:01 +00:00
|
|
|
#include "../osdep/BlockingQueue.hpp"
|
2015-04-21 23:41:35 +00:00
|
|
|
|
2016-08-16 21:05:17 +00:00
|
|
|
#include "../ext/json/json.hpp"
|
2015-10-08 20:25:38 +00:00
|
|
|
|
2016-11-04 22:18:31 +00:00
|
|
|
#include "JSONDB.hpp"
|
|
|
|
|
2016-11-10 21:57:01 +00:00
|
|
|
// Number of background threads to start -- not actually started until needed
|
|
|
|
#define ZT_EMBEDDEDNETWORKCONTROLLER_BACKGROUND_THREAD_COUNT 2
|
|
|
|
|
2015-02-24 22:17:57 +00:00
|
|
|
namespace ZeroTier {
|
2015-02-24 20:28:58 +00:00
|
|
|
|
2015-10-06 22:56:18 +00:00
|
|
|
class Node;
|
|
|
|
|
2016-08-17 17:42:32 +00:00
|
|
|
class EmbeddedNetworkController : public NetworkController
|
2015-02-24 20:28:58 +00:00
|
|
|
{
|
|
|
|
public:
|
2016-08-17 17:42:32 +00:00
|
|
|
EmbeddedNetworkController(Node *node,const char *dbPath);
|
|
|
|
virtual ~EmbeddedNetworkController();
|
2015-03-13 20:53:15 +00:00
|
|
|
|
2016-11-10 19:54:47 +00:00
|
|
|
virtual void init(const Identity &signingId,Sender *sender);
|
|
|
|
|
|
|
|
virtual void request(
|
|
|
|
uint64_t nwid,
|
2015-02-24 20:28:58 +00:00
|
|
|
const InetAddress &fromAddr,
|
2016-11-10 19:54:47 +00:00
|
|
|
uint64_t requestPacketId,
|
2015-03-18 23:10:48 +00:00
|
|
|
const Identity &identity,
|
2016-11-10 19:54:47 +00:00
|
|
|
const Dictionary<ZT_NETWORKCONFIG_METADATA_DICT_CAPACITY> &metaData);
|
2015-02-24 20:28:58 +00:00
|
|
|
|
2015-05-16 23:09:28 +00:00
|
|
|
unsigned int handleControlPlaneHttpGET(
|
2015-04-21 23:41:35 +00:00
|
|
|
const std::vector<std::string> &path,
|
|
|
|
const std::map<std::string,std::string> &urlArgs,
|
|
|
|
const std::map<std::string,std::string> &headers,
|
|
|
|
const std::string &body,
|
|
|
|
std::string &responseBody,
|
|
|
|
std::string &responseContentType);
|
2015-05-16 23:09:28 +00:00
|
|
|
unsigned int handleControlPlaneHttpPOST(
|
2015-04-21 23:41:35 +00:00
|
|
|
const std::vector<std::string> &path,
|
|
|
|
const std::map<std::string,std::string> &urlArgs,
|
|
|
|
const std::map<std::string,std::string> &headers,
|
|
|
|
const std::string &body,
|
|
|
|
std::string &responseBody,
|
|
|
|
std::string &responseContentType);
|
2015-05-16 23:09:28 +00:00
|
|
|
unsigned int handleControlPlaneHttpDELETE(
|
2015-04-21 23:41:35 +00:00
|
|
|
const std::vector<std::string> &path,
|
|
|
|
const std::map<std::string,std::string> &urlArgs,
|
|
|
|
const std::map<std::string,std::string> &headers,
|
|
|
|
const std::string &body,
|
|
|
|
std::string &responseBody,
|
|
|
|
std::string &responseContentType);
|
|
|
|
|
2016-11-10 21:57:01 +00:00
|
|
|
void threadMain()
|
|
|
|
throw();
|
|
|
|
|
2015-02-24 20:28:58 +00:00
|
|
|
private:
|
2015-10-08 20:25:38 +00:00
|
|
|
static void _circuitTestCallback(ZT_Node *node,ZT_CircuitTest *test,const ZT_CircuitTestReport *report);
|
2016-11-10 21:57:01 +00:00
|
|
|
void _request(
|
|
|
|
uint64_t nwid,
|
|
|
|
const InetAddress &fromAddr,
|
|
|
|
uint64_t requestPacketId,
|
|
|
|
const Identity &identity,
|
|
|
|
const Dictionary<ZT_NETWORKCONFIG_METADATA_DICT_CAPACITY> &metaData);
|
|
|
|
|
|
|
|
struct _RQEntry
|
|
|
|
{
|
|
|
|
uint64_t nwid;
|
|
|
|
uint64_t requestPacketId;
|
|
|
|
InetAddress fromAddr;
|
|
|
|
Identity identity;
|
|
|
|
Dictionary<ZT_NETWORKCONFIG_METADATA_DICT_CAPACITY> metaData;
|
|
|
|
};
|
|
|
|
BlockingQueue<_RQEntry *> _queue;
|
|
|
|
|
|
|
|
Thread _threads[ZT_EMBEDDEDNETWORKCONTROLLER_BACKGROUND_THREAD_COUNT];
|
|
|
|
bool _threadsStarted;
|
|
|
|
Mutex _threads_m;
|
2015-10-08 20:25:38 +00:00
|
|
|
|
2016-08-18 19:59:48 +00:00
|
|
|
// Gathers a bunch of statistics about members of a network, IP assignments, etc. that we need in various places
|
|
|
|
// This does lock _networkMemberCache_m
|
|
|
|
struct _NetworkMemberInfo
|
2016-08-16 23:46:08 +00:00
|
|
|
{
|
2016-08-23 20:02:59 +00:00
|
|
|
_NetworkMemberInfo() : authorizedMemberCount(0),activeMemberCount(0),totalMemberCount(0),mostRecentDeauthTime(0) {}
|
2016-08-18 19:59:48 +00:00
|
|
|
std::set<Address> activeBridges;
|
|
|
|
std::set<InetAddress> allocatedIps;
|
|
|
|
unsigned long authorizedMemberCount;
|
|
|
|
unsigned long activeMemberCount;
|
|
|
|
unsigned long totalMemberCount;
|
2016-08-23 20:02:59 +00:00
|
|
|
uint64_t mostRecentDeauthTime;
|
2016-11-09 20:34:20 +00:00
|
|
|
uint64_t nmiTimestamp; // time this NMI structure was computed
|
2016-08-18 19:59:48 +00:00
|
|
|
};
|
2016-11-09 20:34:20 +00:00
|
|
|
std::map<uint64_t,_NetworkMemberInfo> _nmiCache;
|
|
|
|
Mutex _nmiCache_m;
|
2016-08-18 19:59:48 +00:00
|
|
|
void _getNetworkMemberInfo(uint64_t now,uint64_t nwid,_NetworkMemberInfo &nmi);
|
|
|
|
|
2016-11-10 20:54:43 +00:00
|
|
|
void _pushMemberUpdate(uint64_t now,uint64_t nwid,const nlohmann::json &member);
|
|
|
|
|
2016-08-18 21:37:56 +00:00
|
|
|
// These init objects with default and static/informational fields
|
|
|
|
inline void _initMember(nlohmann::json &member)
|
|
|
|
{
|
|
|
|
if (!member.count("authorized")) member["authorized"] = false;
|
2016-09-15 20:17:37 +00:00
|
|
|
if (!member.count("authHistory")) member["authHistory"] = nlohmann::json::array();
|
2016-08-23 20:02:59 +00:00
|
|
|
if (!member.count("ipAssignments")) member["ipAssignments"] = nlohmann::json::array();
|
2016-08-18 21:37:56 +00:00
|
|
|
if (!member.count("recentLog")) member["recentLog"] = nlohmann::json::array();
|
|
|
|
if (!member.count("activeBridge")) member["activeBridge"] = false;
|
|
|
|
if (!member.count("tags")) member["tags"] = nlohmann::json::array();
|
|
|
|
if (!member.count("capabilities")) member["capabilities"] = nlohmann::json::array();
|
|
|
|
if (!member.count("creationTime")) member["creationTime"] = OSUtils::now();
|
2016-08-25 00:05:43 +00:00
|
|
|
if (!member.count("noAutoAssignIps")) member["noAutoAssignIps"] = false;
|
2016-08-25 23:08:40 +00:00
|
|
|
if (!member.count("revision")) member["revision"] = 0ULL;
|
2016-11-15 22:06:25 +00:00
|
|
|
if (!member.count("lastDeauthorizedTime")) member["lastDeauthorizedTime"] = 0ULL;
|
|
|
|
if (!member.count("lastAuthorizedTime")) member["lastAuthorizedTime"] = 0ULL;
|
2016-08-18 21:37:56 +00:00
|
|
|
member["objtype"] = "member";
|
|
|
|
}
|
|
|
|
inline void _initNetwork(nlohmann::json &network)
|
|
|
|
{
|
|
|
|
if (!network.count("private")) network["private"] = true;
|
|
|
|
if (!network.count("creationTime")) network["creationTime"] = OSUtils::now();
|
|
|
|
if (!network.count("name")) network["name"] = "";
|
|
|
|
if (!network.count("multicastLimit")) network["multicastLimit"] = (uint64_t)32;
|
2016-11-09 21:26:14 +00:00
|
|
|
if (!network.count("enableBroadcast")) network["enableBroadcast"] = true;
|
2016-08-18 21:37:56 +00:00
|
|
|
if (!network.count("v4AssignMode")) network["v4AssignMode"] = {{"zt",false}};
|
|
|
|
if (!network.count("v6AssignMode")) network["v6AssignMode"] = {{"rfc4193",false},{"zt",false},{"6plane",false}};
|
|
|
|
if (!network.count("authTokens")) network["authTokens"] = nlohmann::json::array();
|
|
|
|
if (!network.count("capabilities")) network["capabilities"] = nlohmann::json::array();
|
2016-09-30 20:04:26 +00:00
|
|
|
if (!network.count("ipAssignmentPools")) network["ipAssignmentPools"] = nlohmann::json::array();
|
2016-08-18 21:37:56 +00:00
|
|
|
if (!network.count("rules")) {
|
|
|
|
// If unspecified, rules are set to allow anything and behave like a flat L2 segment
|
2016-10-12 19:30:32 +00:00
|
|
|
network["rules"] = {{
|
2016-08-18 21:37:56 +00:00
|
|
|
{ "not",false },
|
2016-11-04 22:52:01 +00:00
|
|
|
{ "or", false },
|
2016-08-18 21:37:56 +00:00
|
|
|
{ "type","ACTION_ACCEPT" }
|
2016-10-12 19:30:32 +00:00
|
|
|
}};
|
2016-08-18 21:37:56 +00:00
|
|
|
}
|
|
|
|
network["objtype"] = "network";
|
|
|
|
}
|
2016-08-18 19:59:48 +00:00
|
|
|
inline void _addNetworkNonPersistedFields(nlohmann::json &network,uint64_t now,const _NetworkMemberInfo &nmi)
|
|
|
|
{
|
|
|
|
network["clock"] = now;
|
|
|
|
network["authorizedMemberCount"] = nmi.authorizedMemberCount;
|
|
|
|
network["activeMemberCount"] = nmi.activeMemberCount;
|
|
|
|
network["totalMemberCount"] = nmi.totalMemberCount;
|
2016-08-16 23:46:08 +00:00
|
|
|
}
|
2016-09-29 21:48:39 +00:00
|
|
|
inline void _addMemberNonPersistedFields(nlohmann::json &member,uint64_t now)
|
|
|
|
{
|
|
|
|
member["clock"] = now;
|
|
|
|
}
|
2016-08-16 23:46:08 +00:00
|
|
|
|
2016-11-04 22:48:23 +00:00
|
|
|
JSONDB _db;
|
|
|
|
Mutex _db_m;
|
|
|
|
|
2016-08-12 18:30:27 +00:00
|
|
|
Node *const _node;
|
2016-08-16 21:05:17 +00:00
|
|
|
std::string _path;
|
2015-07-22 21:01:49 +00:00
|
|
|
|
2016-11-10 19:54:47 +00:00
|
|
|
NetworkController::Sender *_sender;
|
|
|
|
Identity _signingId;
|
|
|
|
|
2016-01-26 20:42:44 +00:00
|
|
|
struct _CircuitTestEntry
|
|
|
|
{
|
|
|
|
ZT_CircuitTest *test;
|
|
|
|
std::string jsonResults;
|
|
|
|
};
|
|
|
|
std::map< uint64_t,_CircuitTestEntry > _circuitTests;
|
2016-08-16 21:05:17 +00:00
|
|
|
Mutex _circuitTests_m;
|
2015-10-08 20:25:38 +00:00
|
|
|
|
2016-02-04 22:39:43 +00:00
|
|
|
std::map< std::pair<uint64_t,uint64_t>,uint64_t > _lastRequestTime;
|
2016-08-16 21:05:17 +00:00
|
|
|
Mutex _lastRequestTime_m;
|
2015-02-24 20:28:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace ZeroTier
|
|
|
|
|
|
|
|
#endif
|