mirror of
https://github.com/ZeroTier/ZeroTierOne
synced 2025-08-21 05:43:59 -07:00
Merge branch 'dev' into netbsd-support
This commit is contained in:
Adam Ierymenko
GitHub
commit
42ec780a6f
682 changed files with 119343 additions and 39556 deletions
|
|
@ -1,160 +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_CLUSTERDEFINITION_HPP
|
||||
#define ZT_CLUSTERDEFINITION_HPP
|
||||
|
||||
#ifdef ZT_ENABLE_CLUSTER
|
||||
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
|
||||
#include "../node/Constants.hpp"
|
||||
#include "../node/Utils.hpp"
|
||||
#include "../node/NonCopyable.hpp"
|
||||
#include "../osdep/OSUtils.hpp"
|
||||
|
||||
#include "ClusterGeoIpService.hpp"
|
||||
|
||||
namespace ZeroTier {
|
||||
|
||||
/**
|
||||
* Parser for cluster definition file
|
||||
*/
|
||||
class ClusterDefinition : NonCopyable
|
||||
{
|
||||
public:
|
||||
struct MemberDefinition
|
||||
{
|
||||
MemberDefinition() : id(0),x(0),y(0),z(0) { name[0] = (char)0; }
|
||||
|
||||
unsigned int id;
|
||||
int x,y,z;
|
||||
char name[256];
|
||||
InetAddress clusterEndpoint;
|
||||
std::vector<InetAddress> zeroTierEndpoints;
|
||||
};
|
||||
|
||||
/**
|
||||
* Load and initialize cluster definition and GeoIP data if any
|
||||
*
|
||||
* @param myAddress My ZeroTier address
|
||||
* @param pathToClusterFile Path to cluster definition file
|
||||
* @throws std::runtime_error Invalid cluster definition or unable to load data
|
||||
*/
|
||||
ClusterDefinition(uint64_t myAddress,const char *pathToClusterFile)
|
||||
{
|
||||
std::string cf;
|
||||
if (!OSUtils::readFile(pathToClusterFile,cf))
|
||||
return;
|
||||
|
||||
char myAddressStr[64];
|
||||
Utils::snprintf(myAddressStr,sizeof(myAddressStr),"%.10llx",myAddress);
|
||||
|
||||
std::vector<std::string> lines(Utils::split(cf.c_str(),"\r\n","",""));
|
||||
for(std::vector<std::string>::iterator l(lines.begin());l!=lines.end();++l) {
|
||||
std::vector<std::string> fields(Utils::split(l->c_str()," \t","",""));
|
||||
if ((fields.size() < 5)||(fields[0][0] == '#')||(fields[0] != myAddressStr))
|
||||
continue;
|
||||
|
||||
// <address> geo <CSV path> <ip start column> <ip end column> <latitutde column> <longitude column>
|
||||
if (fields[1] == "geo") {
|
||||
if ((fields.size() >= 7)&&(OSUtils::fileExists(fields[2].c_str()))) {
|
||||
int ipStartColumn = Utils::strToInt(fields[3].c_str());
|
||||
int ipEndColumn = Utils::strToInt(fields[4].c_str());
|
||||
int latitudeColumn = Utils::strToInt(fields[5].c_str());
|
||||
int longitudeColumn = Utils::strToInt(fields[6].c_str());
|
||||
if (_geo.load(fields[2].c_str(),ipStartColumn,ipEndColumn,latitudeColumn,longitudeColumn) <= 0)
|
||||
throw std::runtime_error(std::string("failed to load geo-ip data from ")+fields[2]);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
// <address> <ID> <name> <backplane IP/port(s)> <ZT frontplane IP/port(s)> <x,y,z>
|
||||
int id = Utils::strToUInt(fields[1].c_str());
|
||||
if ((id < 0)||(id > ZT_CLUSTER_MAX_MEMBERS))
|
||||
throw std::runtime_error(std::string("invalid cluster member ID: ")+fields[1]);
|
||||
MemberDefinition &md = _md[id];
|
||||
|
||||
md.id = (unsigned int)id;
|
||||
if (fields.size() >= 6) {
|
||||
std::vector<std::string> xyz(Utils::split(fields[5].c_str(),",","",""));
|
||||
md.x = (xyz.size() > 0) ? Utils::strToInt(xyz[0].c_str()) : 0;
|
||||
md.y = (xyz.size() > 1) ? Utils::strToInt(xyz[1].c_str()) : 0;
|
||||
md.z = (xyz.size() > 2) ? Utils::strToInt(xyz[2].c_str()) : 0;
|
||||
}
|
||||
Utils::scopy(md.name,sizeof(md.name),fields[2].c_str());
|
||||
md.clusterEndpoint.fromString(fields[3]);
|
||||
if (!md.clusterEndpoint)
|
||||
continue;
|
||||
std::vector<std::string> zips(Utils::split(fields[4].c_str(),",","",""));
|
||||
for(std::vector<std::string>::iterator zip(zips.begin());zip!=zips.end();++zip) {
|
||||
InetAddress i;
|
||||
i.fromString(*zip);
|
||||
if (i)
|
||||
md.zeroTierEndpoints.push_back(i);
|
||||
}
|
||||
|
||||
_ids.push_back((unsigned int)id);
|
||||
}
|
||||
|
||||
std::sort(_ids.begin(),_ids.end());
|
||||
}
|
||||
|
||||
/**
|
||||
* @return All member definitions in this cluster by ID (ID is array index)
|
||||
*/
|
||||
inline const MemberDefinition &operator[](unsigned int id) const throw() { return _md[id]; }
|
||||
|
||||
/**
|
||||
* @return Number of members in this cluster
|
||||
*/
|
||||
inline unsigned int size() const throw() { return (unsigned int)_ids.size(); }
|
||||
|
||||
/**
|
||||
* @return IDs of members in this cluster sorted by ID
|
||||
*/
|
||||
inline const std::vector<unsigned int> &ids() const throw() { return _ids; }
|
||||
|
||||
/**
|
||||
* @return GeoIP service for this cluster
|
||||
*/
|
||||
inline ClusterGeoIpService &geo() throw() { return _geo; }
|
||||
|
||||
/**
|
||||
* @return A vector (new copy) containing all cluster members
|
||||
*/
|
||||
inline std::vector<MemberDefinition> members() const
|
||||
{
|
||||
std::vector<MemberDefinition> m;
|
||||
for(std::vector<unsigned int>::const_iterator i(_ids.begin());i!=_ids.end();++i)
|
||||
m.push_back(_md[*i]);
|
||||
return m;
|
||||
}
|
||||
|
||||
private:
|
||||
MemberDefinition _md[ZT_CLUSTER_MAX_MEMBERS];
|
||||
std::vector<unsigned int> _ids;
|
||||
ClusterGeoIpService _geo;
|
||||
};
|
||||
|
||||
} // namespace ZeroTier
|
||||
|
||||
#endif // ZT_ENABLE_CLUSTER
|
||||
|
||||
#endif
|
||||
|
|
@ -1,235 +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/>.
|
||||
*/
|
||||
|
||||
#ifdef ZT_ENABLE_CLUSTER
|
||||
|
||||
#include <math.h>
|
||||
|
||||
#include <cmath>
|
||||
|
||||
#include "ClusterGeoIpService.hpp"
|
||||
|
||||
#include "../node/Utils.hpp"
|
||||
#include "../osdep/OSUtils.hpp"
|
||||
|
||||
#define ZT_CLUSTERGEOIPSERVICE_FILE_MODIFICATION_CHECK_EVERY 10000
|
||||
|
||||
namespace ZeroTier {
|
||||
|
||||
ClusterGeoIpService::ClusterGeoIpService() :
|
||||
_pathToCsv(),
|
||||
_ipStartColumn(-1),
|
||||
_ipEndColumn(-1),
|
||||
_latitudeColumn(-1),
|
||||
_longitudeColumn(-1),
|
||||
_lastFileCheckTime(0),
|
||||
_csvModificationTime(0),
|
||||
_csvFileSize(0)
|
||||
{
|
||||
}
|
||||
|
||||
ClusterGeoIpService::~ClusterGeoIpService()
|
||||
{
|
||||
}
|
||||
|
||||
bool ClusterGeoIpService::locate(const InetAddress &ip,int &x,int &y,int &z)
|
||||
{
|
||||
Mutex::Lock _l(_lock);
|
||||
|
||||
if ((_pathToCsv.length() > 0)&&((OSUtils::now() - _lastFileCheckTime) > ZT_CLUSTERGEOIPSERVICE_FILE_MODIFICATION_CHECK_EVERY)) {
|
||||
_lastFileCheckTime = OSUtils::now();
|
||||
if ((_csvFileSize != OSUtils::getFileSize(_pathToCsv.c_str()))||(_csvModificationTime != OSUtils::getLastModified(_pathToCsv.c_str())))
|
||||
_load(_pathToCsv.c_str(),_ipStartColumn,_ipEndColumn,_latitudeColumn,_longitudeColumn);
|
||||
}
|
||||
|
||||
/* We search by looking up the upper bound of the sorted vXdb vectors
|
||||
* and then iterating down for a matching IP range. We stop when we hit
|
||||
* the beginning or an entry whose start and end are before the IP we
|
||||
* are searching. */
|
||||
|
||||
if ((ip.ss_family == AF_INET)&&(_v4db.size() > 0)) {
|
||||
_V4E key;
|
||||
key.start = Utils::ntoh((uint32_t)(reinterpret_cast<const struct sockaddr_in *>(&ip)->sin_addr.s_addr));
|
||||
std::vector<_V4E>::const_iterator i(std::upper_bound(_v4db.begin(),_v4db.end(),key));
|
||||
while (i != _v4db.begin()) {
|
||||
--i;
|
||||
if ((key.start >= i->start)&&(key.start <= i->end)) {
|
||||
x = i->x;
|
||||
y = i->y;
|
||||
z = i->z;
|
||||
//printf("%s : %f,%f %d,%d,%d\n",ip.toIpString().c_str(),i->lat,i->lon,x,y,z);
|
||||
return true;
|
||||
} else if ((key.start > i->start)&&(key.start > i->end))
|
||||
break;
|
||||
}
|
||||
} else if ((ip.ss_family == AF_INET6)&&(_v6db.size() > 0)) {
|
||||
_V6E key;
|
||||
memcpy(key.start,reinterpret_cast<const struct sockaddr_in6 *>(&ip)->sin6_addr.s6_addr,16);
|
||||
std::vector<_V6E>::const_iterator i(std::upper_bound(_v6db.begin(),_v6db.end(),key));
|
||||
while (i != _v6db.begin()) {
|
||||
--i;
|
||||
const int s_vs_s = memcmp(key.start,i->start,16);
|
||||
const int s_vs_e = memcmp(key.start,i->end,16);
|
||||
if ((s_vs_s >= 0)&&(s_vs_e <= 0)) {
|
||||
x = i->x;
|
||||
y = i->y;
|
||||
z = i->z;
|
||||
//printf("%s : %f,%f %d,%d,%d\n",ip.toIpString().c_str(),i->lat,i->lon,x,y,z);
|
||||
return true;
|
||||
} else if ((s_vs_s > 0)&&(s_vs_e > 0))
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void ClusterGeoIpService::_parseLine(const char *line,std::vector<_V4E> &v4db,std::vector<_V6E> &v6db,int ipStartColumn,int ipEndColumn,int latitudeColumn,int longitudeColumn)
|
||||
{
|
||||
std::vector<std::string> ls(Utils::split(line,",\t","\\","\"'"));
|
||||
if ( ((ipStartColumn >= 0)&&(ipStartColumn < (int)ls.size()))&&
|
||||
((ipEndColumn >= 0)&&(ipEndColumn < (int)ls.size()))&&
|
||||
((latitudeColumn >= 0)&&(latitudeColumn < (int)ls.size()))&&
|
||||
((longitudeColumn >= 0)&&(longitudeColumn < (int)ls.size())) ) {
|
||||
InetAddress ipStart(ls[ipStartColumn].c_str(),0);
|
||||
InetAddress ipEnd(ls[ipEndColumn].c_str(),0);
|
||||
const double lat = strtod(ls[latitudeColumn].c_str(),(char **)0);
|
||||
const double lon = strtod(ls[longitudeColumn].c_str(),(char **)0);
|
||||
|
||||
if ((ipStart.ss_family == ipEnd.ss_family)&&(ipStart)&&(ipEnd)&&(std::isfinite(lat))&&(std::isfinite(lon))) {
|
||||
const double latRadians = lat * 0.01745329251994; // PI / 180
|
||||
const double lonRadians = lon * 0.01745329251994; // PI / 180
|
||||
const double cosLat = cos(latRadians);
|
||||
const int x = (int)round((-6371.0) * cosLat * cos(lonRadians)); // 6371 == Earth's approximate radius in kilometers
|
||||
const int y = (int)round(6371.0 * sin(latRadians));
|
||||
const int z = (int)round(6371.0 * cosLat * sin(lonRadians));
|
||||
|
||||
if (ipStart.ss_family == AF_INET) {
|
||||
v4db.push_back(_V4E());
|
||||
v4db.back().start = Utils::ntoh((uint32_t)(reinterpret_cast<const struct sockaddr_in *>(&ipStart)->sin_addr.s_addr));
|
||||
v4db.back().end = Utils::ntoh((uint32_t)(reinterpret_cast<const struct sockaddr_in *>(&ipEnd)->sin_addr.s_addr));
|
||||
v4db.back().lat = (float)lat;
|
||||
v4db.back().lon = (float)lon;
|
||||
v4db.back().x = x;
|
||||
v4db.back().y = y;
|
||||
v4db.back().z = z;
|
||||
//printf("%s - %s : %d,%d,%d\n",ipStart.toIpString().c_str(),ipEnd.toIpString().c_str(),x,y,z);
|
||||
} else if (ipStart.ss_family == AF_INET6) {
|
||||
v6db.push_back(_V6E());
|
||||
memcpy(v6db.back().start,reinterpret_cast<const struct sockaddr_in6 *>(&ipStart)->sin6_addr.s6_addr,16);
|
||||
memcpy(v6db.back().end,reinterpret_cast<const struct sockaddr_in6 *>(&ipEnd)->sin6_addr.s6_addr,16);
|
||||
v6db.back().lat = (float)lat;
|
||||
v6db.back().lon = (float)lon;
|
||||
v6db.back().x = x;
|
||||
v6db.back().y = y;
|
||||
v6db.back().z = z;
|
||||
//printf("%s - %s : %d,%d,%d\n",ipStart.toIpString().c_str(),ipEnd.toIpString().c_str(),x,y,z);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
long ClusterGeoIpService::_load(const char *pathToCsv,int ipStartColumn,int ipEndColumn,int latitudeColumn,int longitudeColumn)
|
||||
{
|
||||
// assumes _lock is locked
|
||||
|
||||
FILE *f = fopen(pathToCsv,"rb");
|
||||
if (!f)
|
||||
return -1;
|
||||
|
||||
std::vector<_V4E> v4db;
|
||||
std::vector<_V6E> v6db;
|
||||
v4db.reserve(16777216);
|
||||
v6db.reserve(16777216);
|
||||
|
||||
char buf[4096];
|
||||
char linebuf[1024];
|
||||
unsigned int lineptr = 0;
|
||||
for(;;) {
|
||||
int n = (int)fread(buf,1,sizeof(buf),f);
|
||||
if (n <= 0)
|
||||
break;
|
||||
for(int i=0;i<n;++i) {
|
||||
if ((buf[i] == '\r')||(buf[i] == '\n')||(buf[i] == (char)0)) {
|
||||
if (lineptr) {
|
||||
linebuf[lineptr] = (char)0;
|
||||
_parseLine(linebuf,v4db,v6db,ipStartColumn,ipEndColumn,latitudeColumn,longitudeColumn);
|
||||
}
|
||||
lineptr = 0;
|
||||
} else if (lineptr < (unsigned int)sizeof(linebuf))
|
||||
linebuf[lineptr++] = buf[i];
|
||||
}
|
||||
}
|
||||
if (lineptr) {
|
||||
linebuf[lineptr] = (char)0;
|
||||
_parseLine(linebuf,v4db,v6db,ipStartColumn,ipEndColumn,latitudeColumn,longitudeColumn);
|
||||
}
|
||||
|
||||
fclose(f);
|
||||
|
||||
if ((v4db.size() > 0)||(v6db.size() > 0)) {
|
||||
std::sort(v4db.begin(),v4db.end());
|
||||
std::sort(v6db.begin(),v6db.end());
|
||||
|
||||
_pathToCsv = pathToCsv;
|
||||
_ipStartColumn = ipStartColumn;
|
||||
_ipEndColumn = ipEndColumn;
|
||||
_latitudeColumn = latitudeColumn;
|
||||
_longitudeColumn = longitudeColumn;
|
||||
|
||||
_lastFileCheckTime = OSUtils::now();
|
||||
_csvModificationTime = OSUtils::getLastModified(pathToCsv);
|
||||
_csvFileSize = OSUtils::getFileSize(pathToCsv);
|
||||
|
||||
_v4db.swap(v4db);
|
||||
_v6db.swap(v6db);
|
||||
|
||||
return (long)(_v4db.size() + _v6db.size());
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace ZeroTier
|
||||
|
||||
#endif // ZT_ENABLE_CLUSTER
|
||||
|
||||
/*
|
||||
int main(int argc,char **argv)
|
||||
{
|
||||
char buf[1024];
|
||||
|
||||
ZeroTier::ClusterGeoIpService gip;
|
||||
printf("loading...\n");
|
||||
gip.load("/Users/api/Code/ZeroTier/Infrastructure/root-servers/zerotier-one/cluster-geoip.csv",0,1,5,6);
|
||||
printf("... done!\n"); fflush(stdout);
|
||||
|
||||
while (gets(buf)) { // unsafe, testing only
|
||||
ZeroTier::InetAddress addr(buf,0);
|
||||
printf("looking up: %s\n",addr.toString().c_str()); fflush(stdout);
|
||||
int x = 0,y = 0,z = 0;
|
||||
if (gip.locate(addr,x,y,z)) {
|
||||
//printf("%s: %d,%d,%d\n",addr.toString().c_str(),x,y,z); fflush(stdout);
|
||||
} else {
|
||||
printf("%s: not found!\n",addr.toString().c_str()); fflush(stdout);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
*/
|
||||
|
|
@ -1,143 +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_CLUSTERGEOIPSERVICE_HPP
|
||||
#define ZT_CLUSTERGEOIPSERVICE_HPP
|
||||
|
||||
#ifdef ZT_ENABLE_CLUSTER
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
|
||||
#include "../node/Constants.hpp"
|
||||
#include "../node/Mutex.hpp"
|
||||
#include "../node/NonCopyable.hpp"
|
||||
#include "../node/InetAddress.hpp"
|
||||
|
||||
namespace ZeroTier {
|
||||
|
||||
/**
|
||||
* Loads a GeoIP CSV into memory for fast lookup, reloading as needed
|
||||
*
|
||||
* This was designed around the CSV from https://db-ip.com but can be used
|
||||
* with any similar GeoIP CSV database that is presented in the form of an
|
||||
* IP range and lat/long coordinates.
|
||||
*
|
||||
* It loads the whole database into memory, which can be kind of large. If
|
||||
* the CSV file changes, the changes are loaded automatically.
|
||||
*/
|
||||
class ClusterGeoIpService : NonCopyable
|
||||
{
|
||||
public:
|
||||
ClusterGeoIpService();
|
||||
~ClusterGeoIpService();
|
||||
|
||||
/**
|
||||
* Load or reload CSV file
|
||||
*
|
||||
* CSV column indexes start at zero. CSVs can be quoted with single or
|
||||
* double quotes. Whitespace before or after commas is ignored. Backslash
|
||||
* may be used for escaping whitespace as well.
|
||||
*
|
||||
* @param pathToCsv Path to (uncompressed) CSV file
|
||||
* @param ipStartColumn Column with IP range start
|
||||
* @param ipEndColumn Column with IP range end (inclusive)
|
||||
* @param latitudeColumn Column with latitude
|
||||
* @param longitudeColumn Column with longitude
|
||||
* @return Number of valid records loaded or -1 on error (invalid file, not found, etc.)
|
||||
*/
|
||||
inline long load(const char *pathToCsv,int ipStartColumn,int ipEndColumn,int latitudeColumn,int longitudeColumn)
|
||||
{
|
||||
Mutex::Lock _l(_lock);
|
||||
return _load(pathToCsv,ipStartColumn,ipEndColumn,latitudeColumn,longitudeColumn);
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempt to locate an IP
|
||||
*
|
||||
* This returns true if x, y, and z are set. If the return value is false
|
||||
* the values of x, y, and z are undefined.
|
||||
*
|
||||
* @param ip IPv4 or IPv6 address
|
||||
* @param x Reference to variable to receive X
|
||||
* @param y Reference to variable to receive Y
|
||||
* @param z Reference to variable to receive Z
|
||||
* @return True if coordinates were set
|
||||
*/
|
||||
bool locate(const InetAddress &ip,int &x,int &y,int &z);
|
||||
|
||||
/**
|
||||
* @return True if IP database/service is available for queries (otherwise locate() will always be false)
|
||||
*/
|
||||
inline bool available() const
|
||||
{
|
||||
Mutex::Lock _l(_lock);
|
||||
return ((_v4db.size() + _v6db.size()) > 0);
|
||||
}
|
||||
|
||||
private:
|
||||
struct _V4E
|
||||
{
|
||||
uint32_t start;
|
||||
uint32_t end;
|
||||
float lat,lon;
|
||||
int16_t x,y,z;
|
||||
|
||||
inline bool operator<(const _V4E &e) const { return (start < e.start); }
|
||||
};
|
||||
|
||||
struct _V6E
|
||||
{
|
||||
uint8_t start[16];
|
||||
uint8_t end[16];
|
||||
float lat,lon;
|
||||
int16_t x,y,z;
|
||||
|
||||
inline bool operator<(const _V6E &e) const { return (memcmp(start,e.start,16) < 0); }
|
||||
};
|
||||
|
||||
static void _parseLine(const char *line,std::vector<_V4E> &v4db,std::vector<_V6E> &v6db,int ipStartColumn,int ipEndColumn,int latitudeColumn,int longitudeColumn);
|
||||
long _load(const char *pathToCsv,int ipStartColumn,int ipEndColumn,int latitudeColumn,int longitudeColumn);
|
||||
|
||||
std::string _pathToCsv;
|
||||
int _ipStartColumn;
|
||||
int _ipEndColumn;
|
||||
int _latitudeColumn;
|
||||
int _longitudeColumn;
|
||||
|
||||
uint64_t _lastFileCheckTime;
|
||||
uint64_t _csvModificationTime;
|
||||
int64_t _csvFileSize;
|
||||
|
||||
std::vector<_V4E> _v4db;
|
||||
std::vector<_V6E> _v6db;
|
||||
|
||||
Mutex _lock;
|
||||
};
|
||||
|
||||
} // namespace ZeroTier
|
||||
|
||||
#endif // ZT_ENABLE_CLUSTER
|
||||
|
||||
#endif
|
||||
|
|
@ -1,628 +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 "ControlPlane.hpp"
|
||||
#include "OneService.hpp"
|
||||
|
||||
#include "../version.h"
|
||||
#include "../include/ZeroTierOne.h"
|
||||
|
||||
#ifdef ZT_USE_SYSTEM_HTTP_PARSER
|
||||
#include <http_parser.h>
|
||||
#else
|
||||
#include "../ext/http-parser/http_parser.h"
|
||||
#endif
|
||||
|
||||
#ifdef ZT_USE_SYSTEM_JSON_PARSER
|
||||
#include <json-parser/json.h>
|
||||
#else
|
||||
#include "../ext/json-parser/json.h"
|
||||
#endif
|
||||
|
||||
#ifdef ZT_ENABLE_NETWORK_CONTROLLER
|
||||
#include "../controller/SqliteNetworkController.hpp"
|
||||
#endif
|
||||
|
||||
#include "../node/InetAddress.hpp"
|
||||
#include "../node/Node.hpp"
|
||||
#include "../node/Utils.hpp"
|
||||
#include "../osdep/OSUtils.hpp"
|
||||
|
||||
namespace ZeroTier {
|
||||
|
||||
static std::string _jsonEscape(const char *s)
|
||||
{
|
||||
std::string buf;
|
||||
for(const char *p=s;(*p);++p) {
|
||||
switch(*p) {
|
||||
case '\t': buf.append("\\t"); break;
|
||||
case '\b': buf.append("\\b"); break;
|
||||
case '\r': buf.append("\\r"); break;
|
||||
case '\n': buf.append("\\n"); break;
|
||||
case '\f': buf.append("\\f"); break;
|
||||
case '"': buf.append("\\\""); break;
|
||||
case '\\': buf.append("\\\\"); break;
|
||||
case '/': buf.append("\\/"); break;
|
||||
default: buf.push_back(*p); break;
|
||||
}
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
static std::string _jsonEscape(const std::string &s) { return _jsonEscape(s.c_str()); }
|
||||
|
||||
static std::string _jsonEnumerate(const struct sockaddr_storage *ss,unsigned int count)
|
||||
{
|
||||
std::string buf;
|
||||
buf.push_back('[');
|
||||
for(unsigned int i=0;i<count;++i) {
|
||||
if (i > 0)
|
||||
buf.push_back(',');
|
||||
buf.push_back('"');
|
||||
buf.append(_jsonEscape(reinterpret_cast<const InetAddress *>(&(ss[i]))->toString()));
|
||||
buf.push_back('"');
|
||||
}
|
||||
buf.push_back(']');
|
||||
return buf;
|
||||
}
|
||||
static std::string _jsonEnumerate(const ZT_VirtualNetworkRoute *routes,unsigned int count)
|
||||
{
|
||||
std::string buf;
|
||||
buf.push_back('[');
|
||||
for(unsigned int i=0;i<count;++i) {
|
||||
if (i > 0)
|
||||
buf.push_back(',');
|
||||
buf.append("{\"target\":\"");
|
||||
buf.append(_jsonEscape(reinterpret_cast<const InetAddress *>(&(routes[i].target))->toString()));
|
||||
buf.append("\",\"via\":");
|
||||
if (routes[i].via.ss_family == routes[i].target.ss_family) {
|
||||
buf.push_back('"');
|
||||
buf.append(_jsonEscape(reinterpret_cast<const InetAddress *>(&(routes[i].via))->toIpString()));
|
||||
buf.append("\",");
|
||||
} else buf.append("null,");
|
||||
char tmp[1024];
|
||||
Utils::snprintf(tmp,sizeof(tmp),"\"flags\":%u,\"metric\":%u}",(unsigned int)routes[i].flags,(unsigned int)routes[i].metric);
|
||||
buf.append(tmp);
|
||||
}
|
||||
buf.push_back(']');
|
||||
return buf;
|
||||
}
|
||||
|
||||
static void _jsonAppend(unsigned int depth,std::string &buf,const ZT_VirtualNetworkConfig *nc,const std::string &portDeviceName,const OneService::NetworkSettings &localSettings)
|
||||
{
|
||||
char json[4096];
|
||||
char prefix[32];
|
||||
|
||||
if (depth >= sizeof(prefix)) // sanity check -- shouldn't be possible
|
||||
return;
|
||||
for(unsigned int i=0;i<depth;++i)
|
||||
prefix[i] = '\t';
|
||||
prefix[depth] = '\0';
|
||||
|
||||
const char *nstatus = "",*ntype = "";
|
||||
switch(nc->status) {
|
||||
case ZT_NETWORK_STATUS_REQUESTING_CONFIGURATION: nstatus = "REQUESTING_CONFIGURATION"; break;
|
||||
case ZT_NETWORK_STATUS_OK: nstatus = "OK"; break;
|
||||
case ZT_NETWORK_STATUS_ACCESS_DENIED: nstatus = "ACCESS_DENIED"; break;
|
||||
case ZT_NETWORK_STATUS_NOT_FOUND: nstatus = "NOT_FOUND"; break;
|
||||
case ZT_NETWORK_STATUS_PORT_ERROR: nstatus = "PORT_ERROR"; break;
|
||||
case ZT_NETWORK_STATUS_CLIENT_TOO_OLD: nstatus = "CLIENT_TOO_OLD"; break;
|
||||
}
|
||||
switch(nc->type) {
|
||||
case ZT_NETWORK_TYPE_PRIVATE: ntype = "PRIVATE"; break;
|
||||
case ZT_NETWORK_TYPE_PUBLIC: ntype = "PUBLIC"; break;
|
||||
}
|
||||
|
||||
Utils::snprintf(json,sizeof(json),
|
||||
"%s{\n"
|
||||
"%s\t\"nwid\": \"%.16llx\",\n"
|
||||
"%s\t\"mac\": \"%.2x:%.2x:%.2x:%.2x:%.2x:%.2x\",\n"
|
||||
"%s\t\"name\": \"%s\",\n"
|
||||
"%s\t\"status\": \"%s\",\n"
|
||||
"%s\t\"type\": \"%s\",\n"
|
||||
"%s\t\"mtu\": %u,\n"
|
||||
"%s\t\"dhcp\": %s,\n"
|
||||
"%s\t\"bridge\": %s,\n"
|
||||
"%s\t\"broadcastEnabled\": %s,\n"
|
||||
"%s\t\"portError\": %d,\n"
|
||||
"%s\t\"netconfRevision\": %lu,\n"
|
||||
"%s\t\"assignedAddresses\": %s,\n"
|
||||
"%s\t\"routes\": %s,\n"
|
||||
"%s\t\"portDeviceName\": \"%s\",\n"
|
||||
"%s\t\"allowManaged\": %s,\n"
|
||||
"%s\t\"allowGlobal\": %s,\n"
|
||||
"%s\t\"allowDefault\": %s\n"
|
||||
"%s}",
|
||||
prefix,
|
||||
prefix,nc->nwid,
|
||||
prefix,(unsigned int)((nc->mac >> 40) & 0xff),(unsigned int)((nc->mac >> 32) & 0xff),(unsigned int)((nc->mac >> 24) & 0xff),(unsigned int)((nc->mac >> 16) & 0xff),(unsigned int)((nc->mac >> 8) & 0xff),(unsigned int)(nc->mac & 0xff),
|
||||
prefix,_jsonEscape(nc->name).c_str(),
|
||||
prefix,nstatus,
|
||||
prefix,ntype,
|
||||
prefix,nc->mtu,
|
||||
prefix,(nc->dhcp == 0) ? "false" : "true",
|
||||
prefix,(nc->bridge == 0) ? "false" : "true",
|
||||
prefix,(nc->broadcastEnabled == 0) ? "false" : "true",
|
||||
prefix,nc->portError,
|
||||
prefix,nc->netconfRevision,
|
||||
prefix,_jsonEnumerate(nc->assignedAddresses,nc->assignedAddressCount).c_str(),
|
||||
prefix,_jsonEnumerate(nc->routes,nc->routeCount).c_str(),
|
||||
prefix,_jsonEscape(portDeviceName).c_str(),
|
||||
prefix,(localSettings.allowManaged) ? "true" : "false",
|
||||
prefix,(localSettings.allowGlobal) ? "true" : "false",
|
||||
prefix,(localSettings.allowDefault) ? "true" : "false",
|
||||
prefix);
|
||||
buf.append(json);
|
||||
}
|
||||
|
||||
static std::string _jsonEnumerate(unsigned int depth,const ZT_PeerPhysicalPath *pp,unsigned int count)
|
||||
{
|
||||
char json[1024];
|
||||
char prefix[32];
|
||||
|
||||
if (depth >= sizeof(prefix)) // sanity check -- shouldn't be possible
|
||||
return std::string();
|
||||
for(unsigned int i=0;i<depth;++i)
|
||||
prefix[i] = '\t';
|
||||
prefix[depth] = '\0';
|
||||
|
||||
std::string buf;
|
||||
for(unsigned int i=0;i<count;++i) {
|
||||
if (i > 0)
|
||||
buf.push_back(',');
|
||||
Utils::snprintf(json,sizeof(json),
|
||||
"{\n"
|
||||
"%s\t\"address\": \"%s\",\n"
|
||||
"%s\t\"lastSend\": %llu,\n"
|
||||
"%s\t\"lastReceive\": %llu,\n"
|
||||
"%s\t\"active\": %s,\n"
|
||||
"%s\t\"preferred\": %s,\n"
|
||||
"%s\t\"trustedPathId\": %llu\n"
|
||||
"%s}",
|
||||
prefix,_jsonEscape(reinterpret_cast<const InetAddress *>(&(pp[i].address))->toString()).c_str(),
|
||||
prefix,pp[i].lastSend,
|
||||
prefix,pp[i].lastReceive,
|
||||
prefix,(pp[i].active == 0) ? "false" : "true",
|
||||
prefix,(pp[i].preferred == 0) ? "false" : "true",
|
||||
prefix,pp[i].trustedPathId,
|
||||
prefix);
|
||||
buf.append(json);
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
static void _jsonAppend(unsigned int depth,std::string &buf,const ZT_Peer *peer)
|
||||
{
|
||||
char json[1024];
|
||||
char prefix[32];
|
||||
|
||||
if (depth >= sizeof(prefix)) // sanity check -- shouldn't be possible
|
||||
return;
|
||||
for(unsigned int i=0;i<depth;++i)
|
||||
prefix[i] = '\t';
|
||||
prefix[depth] = '\0';
|
||||
|
||||
const char *prole = "";
|
||||
switch(peer->role) {
|
||||
case ZT_PEER_ROLE_LEAF: prole = "LEAF"; break;
|
||||
case ZT_PEER_ROLE_RELAY: prole = "RELAY"; break;
|
||||
case ZT_PEER_ROLE_ROOT: prole = "ROOT"; break;
|
||||
}
|
||||
|
||||
Utils::snprintf(json,sizeof(json),
|
||||
"%s{\n"
|
||||
"%s\t\"address\": \"%.10llx\",\n"
|
||||
"%s\t\"lastUnicastFrame\": %llu,\n"
|
||||
"%s\t\"lastMulticastFrame\": %llu,\n"
|
||||
"%s\t\"versionMajor\": %d,\n"
|
||||
"%s\t\"versionMinor\": %d,\n"
|
||||
"%s\t\"versionRev\": %d,\n"
|
||||
"%s\t\"version\": \"%d.%d.%d\",\n"
|
||||
"%s\t\"latency\": %u,\n"
|
||||
"%s\t\"role\": \"%s\",\n"
|
||||
"%s\t\"paths\": [%s]\n"
|
||||
"%s}",
|
||||
prefix,
|
||||
prefix,peer->address,
|
||||
prefix,peer->lastUnicastFrame,
|
||||
prefix,peer->lastMulticastFrame,
|
||||
prefix,peer->versionMajor,
|
||||
prefix,peer->versionMinor,
|
||||
prefix,peer->versionRev,
|
||||
prefix,peer->versionMajor,peer->versionMinor,peer->versionRev,
|
||||
prefix,peer->latency,
|
||||
prefix,prole,
|
||||
prefix,_jsonEnumerate(depth+1,peer->paths,peer->pathCount).c_str(),
|
||||
prefix);
|
||||
buf.append(json);
|
||||
}
|
||||
|
||||
ControlPlane::ControlPlane(OneService *svc,Node *n,const char *uiStaticPath) :
|
||||
_svc(svc),
|
||||
_node(n),
|
||||
#ifdef ZT_ENABLE_NETWORK_CONTROLLER
|
||||
_controller((SqliteNetworkController *)0),
|
||||
#endif
|
||||
_uiStaticPath((uiStaticPath) ? uiStaticPath : "")
|
||||
{
|
||||
}
|
||||
|
||||
ControlPlane::~ControlPlane()
|
||||
{
|
||||
}
|
||||
|
||||
unsigned int ControlPlane::handleRequest(
|
||||
const InetAddress &fromAddress,
|
||||
unsigned int httpMethod,
|
||||
const std::string &path,
|
||||
const std::map<std::string,std::string> &headers,
|
||||
const std::string &body,
|
||||
std::string &responseBody,
|
||||
std::string &responseContentType)
|
||||
{
|
||||
char json[8194];
|
||||
unsigned int scode = 404;
|
||||
std::vector<std::string> ps(Utils::split(path.c_str(),"/","",""));
|
||||
std::map<std::string,std::string> urlArgs;
|
||||
Mutex::Lock _l(_lock);
|
||||
|
||||
if (!((fromAddress.ipsEqual(InetAddress::LO4))||(fromAddress.ipsEqual(InetAddress::LO6))))
|
||||
return 403; // Forbidden: we only allow access from localhost right now
|
||||
|
||||
/* Note: this is kind of restricted in what it'll take. It does not support
|
||||
* URL encoding, and /'s in URL args will screw it up. But the only URL args
|
||||
* it really uses in ?jsonp=funcionName, and otherwise it just takes simple
|
||||
* paths to simply-named resources. */
|
||||
if (ps.size() > 0) {
|
||||
std::size_t qpos = ps[ps.size() - 1].find('?');
|
||||
if (qpos != std::string::npos) {
|
||||
std::string args(ps[ps.size() - 1].substr(qpos + 1));
|
||||
ps[ps.size() - 1] = ps[ps.size() - 1].substr(0,qpos);
|
||||
std::vector<std::string> asplit(Utils::split(args.c_str(),"&","",""));
|
||||
for(std::vector<std::string>::iterator a(asplit.begin());a!=asplit.end();++a) {
|
||||
std::size_t eqpos = a->find('=');
|
||||
if (eqpos == std::string::npos)
|
||||
urlArgs[*a] = "";
|
||||
else urlArgs[a->substr(0,eqpos)] = a->substr(eqpos + 1);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
ps.push_back(std::string("index.html"));
|
||||
}
|
||||
|
||||
bool isAuth = false;
|
||||
{
|
||||
std::map<std::string,std::string>::const_iterator ah(headers.find("x-zt1-auth"));
|
||||
if ((ah != headers.end())&&(_authTokens.count(ah->second) > 0)) {
|
||||
isAuth = true;
|
||||
} else {
|
||||
ah = urlArgs.find("auth");
|
||||
if ((ah != urlArgs.end())&&(_authTokens.count(ah->second) > 0))
|
||||
isAuth = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (httpMethod == HTTP_GET) {
|
||||
|
||||
std::string ext;
|
||||
std::size_t dotIdx = ps[0].find_last_of('.');
|
||||
if (dotIdx != std::string::npos)
|
||||
ext = ps[0].substr(dotIdx);
|
||||
|
||||
if ((ps.size() == 1)&&(ext.length() >= 2)&&(ext[0] == '.')) {
|
||||
/* Static web pages can be served without authentication to enable a simple web
|
||||
* UI. This is still only allowed from approved IP addresses. Anything with a
|
||||
* dot in the first path element (e.g. foo.html) is considered a static page,
|
||||
* as nothing in the API is so named. */
|
||||
|
||||
if (_uiStaticPath.length() > 0) {
|
||||
if (ext == ".html")
|
||||
responseContentType = "text/html";
|
||||
else if (ext == ".js")
|
||||
responseContentType = "application/javascript";
|
||||
else if (ext == ".jsx")
|
||||
responseContentType = "text/jsx";
|
||||
else if (ext == ".json")
|
||||
responseContentType = "application/json";
|
||||
else if (ext == ".css")
|
||||
responseContentType = "text/css";
|
||||
else if (ext == ".png")
|
||||
responseContentType = "image/png";
|
||||
else if (ext == ".jpg")
|
||||
responseContentType = "image/jpeg";
|
||||
else if (ext == ".gif")
|
||||
responseContentType = "image/gif";
|
||||
else if (ext == ".txt")
|
||||
responseContentType = "text/plain";
|
||||
else if (ext == ".xml")
|
||||
responseContentType = "text/xml";
|
||||
else if (ext == ".svg")
|
||||
responseContentType = "image/svg+xml";
|
||||
else responseContentType = "application/octet-stream";
|
||||
scode = OSUtils::readFile((_uiStaticPath + ZT_PATH_SEPARATOR_S + ps[0]).c_str(),responseBody) ? 200 : 404;
|
||||
} else {
|
||||
scode = 404;
|
||||
}
|
||||
|
||||
} else if (isAuth) {
|
||||
/* Things that require authentication -- a.k.a. everything but static web app pages. */
|
||||
|
||||
if (ps[0] == "status") {
|
||||
responseContentType = "application/json";
|
||||
|
||||
ZT_NodeStatus status;
|
||||
_node->status(&status);
|
||||
|
||||
std::string clusterJson;
|
||||
#ifdef ZT_ENABLE_CLUSTER
|
||||
{
|
||||
ZT_ClusterStatus cs;
|
||||
_node->clusterStatus(&cs);
|
||||
|
||||
if (cs.clusterSize >= 1) {
|
||||
char t[1024];
|
||||
Utils::snprintf(t,sizeof(t),"{\n\t\t\"myId\": %u,\n\t\t\"clusterSize\": %u,\n\t\t\"members\": [",cs.myId,cs.clusterSize);
|
||||
clusterJson.append(t);
|
||||
for(unsigned int i=0;i<cs.clusterSize;++i) {
|
||||
Utils::snprintf(t,sizeof(t),"%s\t\t\t{\n\t\t\t\t\"id\": %u,\n\t\t\t\t\"msSinceLastHeartbeat\": %u,\n\t\t\t\t\"alive\": %s,\n\t\t\t\t\"x\": %d,\n\t\t\t\t\"y\": %d,\n\t\t\t\t\"z\": %d,\n\t\t\t\t\"load\": %llu,\n\t\t\t\t\"peers\": %llu\n\t\t\t}",
|
||||
((i == 0) ? "\n" : ",\n"),
|
||||
cs.members[i].id,
|
||||
cs.members[i].msSinceLastHeartbeat,
|
||||
(cs.members[i].alive != 0) ? "true" : "false",
|
||||
cs.members[i].x,
|
||||
cs.members[i].y,
|
||||
cs.members[i].z,
|
||||
cs.members[i].load,
|
||||
cs.members[i].peers);
|
||||
clusterJson.append(t);
|
||||
}
|
||||
clusterJson.append(" ]\n\t\t}");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
Utils::snprintf(json,sizeof(json),
|
||||
"{\n"
|
||||
"\t\"address\": \"%.10llx\",\n"
|
||||
"\t\"publicIdentity\": \"%s\",\n"
|
||||
"\t\"worldId\": %llu,\n"
|
||||
"\t\"worldTimestamp\": %llu,\n"
|
||||
"\t\"online\": %s,\n"
|
||||
"\t\"tcpFallbackActive\": %s,\n"
|
||||
"\t\"versionMajor\": %d,\n"
|
||||
"\t\"versionMinor\": %d,\n"
|
||||
"\t\"versionRev\": %d,\n"
|
||||
"\t\"version\": \"%d.%d.%d\",\n"
|
||||
"\t\"clock\": %llu,\n"
|
||||
"\t\"cluster\": %s\n"
|
||||
"}\n",
|
||||
status.address,
|
||||
status.publicIdentity,
|
||||
status.worldId,
|
||||
status.worldTimestamp,
|
||||
(status.online) ? "true" : "false",
|
||||
(_svc->tcpFallbackActive()) ? "true" : "false",
|
||||
ZEROTIER_ONE_VERSION_MAJOR,
|
||||
ZEROTIER_ONE_VERSION_MINOR,
|
||||
ZEROTIER_ONE_VERSION_REVISION,
|
||||
ZEROTIER_ONE_VERSION_MAJOR,ZEROTIER_ONE_VERSION_MINOR,ZEROTIER_ONE_VERSION_REVISION,
|
||||
(unsigned long long)OSUtils::now(),
|
||||
((clusterJson.length() > 0) ? clusterJson.c_str() : "null"));
|
||||
responseBody = json;
|
||||
scode = 200;
|
||||
} else if (ps[0] == "config") {
|
||||
responseContentType = "application/json";
|
||||
responseBody = "{}"; // TODO
|
||||
scode = 200;
|
||||
} else if (ps[0] == "network") {
|
||||
ZT_VirtualNetworkList *nws = _node->networks();
|
||||
if (nws) {
|
||||
if (ps.size() == 1) {
|
||||
// Return [array] of all networks
|
||||
responseContentType = "application/json";
|
||||
responseBody = "[\n";
|
||||
for(unsigned long i=0;i<nws->networkCount;++i) {
|
||||
if (i > 0)
|
||||
responseBody.append(",");
|
||||
OneService::NetworkSettings localSettings;
|
||||
_svc->getNetworkSettings(nws->networks[i].nwid,localSettings);
|
||||
_jsonAppend(1,responseBody,&(nws->networks[i]),_svc->portDeviceName(nws->networks[i].nwid),localSettings);
|
||||
}
|
||||
responseBody.append("\n]\n");
|
||||
scode = 200;
|
||||
} else if (ps.size() == 2) {
|
||||
// Return a single network by ID or 404 if not found
|
||||
uint64_t wantnw = Utils::hexStrToU64(ps[1].c_str());
|
||||
for(unsigned long i=0;i<nws->networkCount;++i) {
|
||||
if (nws->networks[i].nwid == wantnw) {
|
||||
responseContentType = "application/json";
|
||||
OneService::NetworkSettings localSettings;
|
||||
_svc->getNetworkSettings(nws->networks[i].nwid,localSettings);
|
||||
_jsonAppend(0,responseBody,&(nws->networks[i]),_svc->portDeviceName(nws->networks[i].nwid),localSettings);
|
||||
responseBody.push_back('\n');
|
||||
scode = 200;
|
||||
break;
|
||||
}
|
||||
}
|
||||
} // else 404
|
||||
_node->freeQueryResult((void *)nws);
|
||||
} else scode = 500;
|
||||
} else if (ps[0] == "peer") {
|
||||
ZT_PeerList *pl = _node->peers();
|
||||
if (pl) {
|
||||
if (ps.size() == 1) {
|
||||
// Return [array] of all peers
|
||||
responseContentType = "application/json";
|
||||
responseBody = "[\n";
|
||||
for(unsigned long i=0;i<pl->peerCount;++i) {
|
||||
if (i > 0)
|
||||
responseBody.append(",\n");
|
||||
_jsonAppend(1,responseBody,&(pl->peers[i]));
|
||||
}
|
||||
responseBody.append("\n]\n");
|
||||
scode = 200;
|
||||
} else if (ps.size() == 2) {
|
||||
// Return a single peer by ID or 404 if not found
|
||||
uint64_t wantp = Utils::hexStrToU64(ps[1].c_str());
|
||||
for(unsigned long i=0;i<pl->peerCount;++i) {
|
||||
if (pl->peers[i].address == wantp) {
|
||||
responseContentType = "application/json";
|
||||
_jsonAppend(0,responseBody,&(pl->peers[i]));
|
||||
responseBody.push_back('\n');
|
||||
scode = 200;
|
||||
break;
|
||||
}
|
||||
}
|
||||
} // else 404
|
||||
_node->freeQueryResult((void *)pl);
|
||||
} else scode = 500;
|
||||
} else if (ps[0] == "newIdentity") {
|
||||
// Return a newly generated ZeroTier identity -- this is primarily for debugging
|
||||
// and testing to make it easy for automated test scripts to generate test IDs.
|
||||
Identity newid;
|
||||
newid.generate();
|
||||
responseBody = newid.toString(true);
|
||||
responseContentType = "text/plain";
|
||||
scode = 200;
|
||||
} else {
|
||||
#ifdef ZT_ENABLE_NETWORK_CONTROLLER
|
||||
if (_controller)
|
||||
scode = _controller->handleControlPlaneHttpGET(std::vector<std::string>(ps.begin()+1,ps.end()),urlArgs,headers,body,responseBody,responseContentType);
|
||||
else scode = 404;
|
||||
#else
|
||||
scode = 404;
|
||||
#endif
|
||||
}
|
||||
|
||||
} else scode = 401; // isAuth == false
|
||||
|
||||
} else if ((httpMethod == HTTP_POST)||(httpMethod == HTTP_PUT)) {
|
||||
|
||||
if (isAuth) {
|
||||
|
||||
if (ps[0] == "config") {
|
||||
// TODO
|
||||
} else if (ps[0] == "network") {
|
||||
if (ps.size() == 2) {
|
||||
uint64_t wantnw = Utils::hexStrToU64(ps[1].c_str());
|
||||
_node->join(wantnw,(void *)0); // does nothing if we are a member
|
||||
ZT_VirtualNetworkList *nws = _node->networks();
|
||||
if (nws) {
|
||||
for(unsigned long i=0;i<nws->networkCount;++i) {
|
||||
if (nws->networks[i].nwid == wantnw) {
|
||||
OneService::NetworkSettings localSettings;
|
||||
_svc->getNetworkSettings(nws->networks[i].nwid,localSettings);
|
||||
|
||||
json_value *j = json_parse(body.c_str(),body.length());
|
||||
if (j) {
|
||||
if (j->type == json_object) {
|
||||
for(unsigned int k=0;k<j->u.object.length;++k) {
|
||||
if (!strcmp(j->u.object.values[k].name,"allowManaged")) {
|
||||
if (j->u.object.values[k].value->type == json_boolean)
|
||||
localSettings.allowManaged = (j->u.object.values[k].value->u.boolean != 0);
|
||||
} else if (!strcmp(j->u.object.values[k].name,"allowGlobal")) {
|
||||
if (j->u.object.values[k].value->type == json_boolean)
|
||||
localSettings.allowGlobal = (j->u.object.values[k].value->u.boolean != 0);
|
||||
} else if (!strcmp(j->u.object.values[k].name,"allowDefault")) {
|
||||
if (j->u.object.values[k].value->type == json_boolean)
|
||||
localSettings.allowDefault = (j->u.object.values[k].value->u.boolean != 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
json_value_free(j);
|
||||
}
|
||||
|
||||
_svc->setNetworkSettings(nws->networks[i].nwid,localSettings);
|
||||
|
||||
responseContentType = "application/json";
|
||||
_jsonAppend(0,responseBody,&(nws->networks[i]),_svc->portDeviceName(nws->networks[i].nwid),localSettings);
|
||||
responseBody.push_back('\n');
|
||||
scode = 200;
|
||||
break;
|
||||
}
|
||||
}
|
||||
_node->freeQueryResult((void *)nws);
|
||||
} else scode = 500;
|
||||
}
|
||||
} else {
|
||||
#ifdef ZT_ENABLE_NETWORK_CONTROLLER
|
||||
if (_controller)
|
||||
scode = _controller->handleControlPlaneHttpPOST(std::vector<std::string>(ps.begin()+1,ps.end()),urlArgs,headers,body,responseBody,responseContentType);
|
||||
else scode = 404;
|
||||
#else
|
||||
scode = 404;
|
||||
#endif
|
||||
}
|
||||
|
||||
} else scode = 401; // isAuth == false
|
||||
|
||||
} else if (httpMethod == HTTP_DELETE) {
|
||||
|
||||
if (isAuth) {
|
||||
|
||||
if (ps[0] == "config") {
|
||||
// TODO
|
||||
} else if (ps[0] == "network") {
|
||||
ZT_VirtualNetworkList *nws = _node->networks();
|
||||
if (nws) {
|
||||
if (ps.size() == 2) {
|
||||
uint64_t wantnw = Utils::hexStrToU64(ps[1].c_str());
|
||||
for(unsigned long i=0;i<nws->networkCount;++i) {
|
||||
if (nws->networks[i].nwid == wantnw) {
|
||||
_node->leave(wantnw,(void **)0);
|
||||
responseBody = "true";
|
||||
responseContentType = "application/json";
|
||||
scode = 200;
|
||||
break;
|
||||
}
|
||||
}
|
||||
} // else 404
|
||||
_node->freeQueryResult((void *)nws);
|
||||
} else scode = 500;
|
||||
} else {
|
||||
#ifdef ZT_ENABLE_NETWORK_CONTROLLER
|
||||
if (_controller)
|
||||
scode = _controller->handleControlPlaneHttpDELETE(std::vector<std::string>(ps.begin()+1,ps.end()),urlArgs,headers,body,responseBody,responseContentType);
|
||||
else scode = 404;
|
||||
#else
|
||||
scode = 404;
|
||||
#endif
|
||||
}
|
||||
|
||||
} else {
|
||||
scode = 401; // isAuth = false
|
||||
}
|
||||
|
||||
} else {
|
||||
scode = 400;
|
||||
responseBody = "Method not supported.";
|
||||
}
|
||||
|
||||
// Wrap result in jsonp function call if the user included a jsonp= url argument.
|
||||
// Also double-check isAuth since forbidding this without auth feels safer.
|
||||
std::map<std::string,std::string>::const_iterator jsonp(urlArgs.find("jsonp"));
|
||||
if ((isAuth)&&(jsonp != urlArgs.end())&&(responseContentType == "application/json")) {
|
||||
if (responseBody.length() > 0)
|
||||
responseBody = jsonp->second + "(" + responseBody + ");";
|
||||
else responseBody = jsonp->second + "(null);";
|
||||
responseContentType = "application/javascript";
|
||||
}
|
||||
|
||||
return scode;
|
||||
}
|
||||
|
||||
} // namespace ZeroTier
|
||||
|
|
@ -1,102 +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_ONE_CONTROLPLANE_HPP
|
||||
#define ZT_ONE_CONTROLPLANE_HPP
|
||||
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <set>
|
||||
|
||||
#include "../include/ZeroTierOne.h"
|
||||
|
||||
#include "../node/Mutex.hpp"
|
||||
|
||||
namespace ZeroTier {
|
||||
|
||||
class OneService;
|
||||
class Node;
|
||||
class SqliteNetworkController;
|
||||
struct InetAddress;
|
||||
|
||||
/**
|
||||
* HTTP control plane and static web server
|
||||
*/
|
||||
class ControlPlane
|
||||
{
|
||||
public:
|
||||
ControlPlane(OneService *svc,Node *n,const char *uiStaticPath);
|
||||
~ControlPlane();
|
||||
|
||||
#ifdef ZT_ENABLE_NETWORK_CONTROLLER
|
||||
/**
|
||||
* Set controller, which will be available under /controller
|
||||
*
|
||||
* @param c Network controller instance
|
||||
*/
|
||||
inline void setController(SqliteNetworkController *c)
|
||||
{
|
||||
Mutex::Lock _l(_lock);
|
||||
_controller = c;
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Add an authentication token for API access
|
||||
*/
|
||||
inline void addAuthToken(const char *tok)
|
||||
{
|
||||
Mutex::Lock _l(_lock);
|
||||
_authTokens.insert(std::string(tok));
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle HTTP request
|
||||
*
|
||||
* @param fromAddress Originating IP address of request
|
||||
* @param httpMethod HTTP method (as defined in ext/http-parser/http_parser.h)
|
||||
* @param path Request path
|
||||
* @param headers Request headers
|
||||
* @param body Request body
|
||||
* @param responseBody Result parameter: fill with response data
|
||||
* @param responseContentType Result parameter: fill with content type
|
||||
* @return HTTP response code
|
||||
*/
|
||||
unsigned int handleRequest(
|
||||
const InetAddress &fromAddress,
|
||||
unsigned int httpMethod,
|
||||
const std::string &path,
|
||||
const std::map<std::string,std::string> &headers,
|
||||
const std::string &body,
|
||||
std::string &responseBody,
|
||||
std::string &responseContentType);
|
||||
|
||||
private:
|
||||
OneService *const _svc;
|
||||
Node *const _node;
|
||||
#ifdef ZT_ENABLE_NETWORK_CONTROLLER
|
||||
SqliteNetworkController *_controller;
|
||||
#endif
|
||||
std::string _uiStaticPath;
|
||||
std::set<std::string> _authTokens;
|
||||
Mutex _lock;
|
||||
};
|
||||
|
||||
} // namespace ZeroTier
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* ZeroTier One - Network Virtualization Everywhere
|
||||
* Copyright (C) 2011-2016 ZeroTier, Inc. https://www.zerotier.com/
|
||||
* Copyright (C) 2011-2018 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
|
||||
|
|
@ -14,29 +14,35 @@
|
|||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
* --
|
||||
*
|
||||
* You can be released from the requirements of the license by purchasing
|
||||
* a commercial license. Buying such a license is mandatory as soon as you
|
||||
* develop commercial closed-source software that incorporates or links
|
||||
* directly against ZeroTier software without disclosing the source code
|
||||
* of your own application.
|
||||
*/
|
||||
|
||||
#ifndef ZT_ONESERVICE_HPP
|
||||
#define ZT_ONESERVICE_HPP
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "../node/InetAddress.hpp"
|
||||
|
||||
#ifdef ZT_SDK
|
||||
#include "../node/Node.hpp"
|
||||
// Use the virtual netcon endpoint instead of a tun/tap port driver
|
||||
#include "../include/VirtualTap.h"
|
||||
namespace ZeroTier { typedef VirtualTap EthernetTap; }
|
||||
#endif
|
||||
|
||||
namespace ZeroTier {
|
||||
|
||||
/**
|
||||
* Local service for ZeroTier One as system VPN/NFV provider
|
||||
*
|
||||
* If built with ZT_ENABLE_NETWORK_CONTROLLER defined, this includes and
|
||||
* runs controller/SqliteNetworkController with a database called
|
||||
* controller.db in the specified home directory.
|
||||
*
|
||||
* If built with ZT_AUTO_UPDATE, an official ZeroTier update URL is
|
||||
* periodically checked and updates are automatically downloaded, verified
|
||||
* against a built-in list of update signing keys, and installed. This is
|
||||
* only supported for certain platforms.
|
||||
*
|
||||
* If built with ZT_ENABLE_CLUSTER, a 'cluster' file is checked and if
|
||||
* present is read to determine the identity of other cluster members.
|
||||
*/
|
||||
class OneService
|
||||
{
|
||||
|
|
@ -77,6 +83,12 @@ public:
|
|||
*/
|
||||
bool allowManaged;
|
||||
|
||||
/**
|
||||
* Whitelist of addresses that can be configured by this network.
|
||||
* If empty and allowManaged is true, allow all private/pseudoprivate addresses.
|
||||
*/
|
||||
std::vector<InetAddress> allowManagedWhitelist;
|
||||
|
||||
/**
|
||||
* Allow configuration of IPs and routes within global (Internet) IP space?
|
||||
*/
|
||||
|
|
@ -93,11 +105,6 @@ public:
|
|||
*/
|
||||
static std::string platformDefaultHomePath();
|
||||
|
||||
/**
|
||||
* @return Auto-update URL or empty string if auto-updates unsupported or not enabled
|
||||
*/
|
||||
static std::string autoUpdateUrl();
|
||||
|
||||
/**
|
||||
* Create a new instance of the service
|
||||
*
|
||||
|
|
@ -111,9 +118,7 @@ public:
|
|||
* @param hp Home path
|
||||
* @param port TCP and UDP port for packets and HTTP control (if 0, pick random port)
|
||||
*/
|
||||
static OneService *newInstance(
|
||||
const char *hp,
|
||||
unsigned int port);
|
||||
static OneService *newInstance(const char *hp,unsigned int port);
|
||||
|
||||
virtual ~OneService();
|
||||
|
||||
|
|
@ -141,10 +146,14 @@ public:
|
|||
*/
|
||||
virtual std::string portDeviceName(uint64_t nwid) const = 0;
|
||||
|
||||
/**
|
||||
* @return True if TCP fallback is currently active
|
||||
*/
|
||||
virtual bool tcpFallbackActive() const = 0;
|
||||
#ifdef ZT_SDK
|
||||
virtual void leave(const uint64_t hp) = 0;
|
||||
virtual void join(const uint64_t hp) = 0;
|
||||
virtual std::string givenHomePath() = 0;
|
||||
virtual Node * getNode() = 0;
|
||||
virtual void removeNets() = 0;
|
||||
virtual std::vector<ZT_VirtualNetworkRoute> *getRoutes(uint64_t nwid) = 0;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Terminate background service (can be called from other threads)
|
||||
|
|
|
|||
|
|
@ -1,9 +1,69 @@
|
|||
ZeroTier One Network Virtualization Service
|
||||
======
|
||||
|
||||
This is the common background service implementation for ZeroTier One, the VPN-like OS-level network virtualization service.
|
||||
This is the actual implementation of ZeroTier One, a service providing connectivity to ZeroTier virtual networks for desktops, laptops, servers, VMs, etc. (Mobile versions for iOS and Android have their own implementations in native Java and Objective C that leverage only the ZeroTier core engine.)
|
||||
|
||||
It provides a ready-made core I/O loop and a local HTTP-based JSON control bus for controlling the service. This control bus HTTP server can also serve the files in ui/ if this folder's contents are installed in the ZeroTier home folder. The ui/ implements a React-based HTML5 user interface which is then wrappered for various platforms via MacGap, Windows .NET WebControl, etc. It can also be used locally from scripts or via *curl*.
|
||||
### Local Configuration File
|
||||
|
||||
A file called `local.conf` in the ZeroTier home folder contains configuration options that apply to the local node. It can be used to set up trusted paths, blacklist physical paths, set up physical path hints for certain nodes, and define trusted upstream devices (federated roots). In a large deployment it can be deployed using a tool like Puppet, Chef, SaltStack, etc. to set a uniform configuration across systems. It's a JSON format file that can also be edited and rewritten by ZeroTier One itself, so ensure that proper JSON formatting is used.
|
||||
|
||||
Settings available in `local.conf` (this is not valid JSON, and JSON does not allow comments):
|
||||
|
||||
```javascript
|
||||
{
|
||||
"physical": { /* Settings that apply to physical L2/L3 network paths. */
|
||||
"NETWORK/bits": { /* Network e.g. 10.0.0.0/24 or fd00::/32 */
|
||||
"blacklist": true|false, /* If true, blacklist this path for all ZeroTier traffic */
|
||||
"trustedPathId": 0|!0, /* If present and nonzero, define this as a trusted path (see below) */
|
||||
"mtu": 0|!0 /* if present and non-zero, set UDP maximum payload MTU for this path */
|
||||
} /* ,... additional networks */
|
||||
},
|
||||
"virtual": { /* Settings applied to ZeroTier virtual network devices (VL1) */
|
||||
"##########": { /* 10-digit ZeroTier address */
|
||||
"try": [ "IP/port"/*,...*/ ], /* Hints on where to reach this peer if no upstreams/roots are online */
|
||||
"blacklist": [ "NETWORK/bits"/*,...*/ ] /* Blacklist a physical path for only this peer. */
|
||||
}
|
||||
},
|
||||
"settings": { /* Other global settings */
|
||||
"primaryPort": 0-65535, /* If set, override default port of 9993 and any command line port */
|
||||
"portMappingEnabled": true|false, /* If true (the default), try to use uPnP or NAT-PMP to map ports */
|
||||
"softwareUpdate": "apply"|"download"|"disable", /* Automatically apply updates, just download, or disable built-in software updates */
|
||||
"softwareUpdateChannel": "release"|"beta", /* Software update channel */
|
||||
"softwareUpdateDist": true|false, /* If true, distribute software updates (only really useful to ZeroTier, Inc. itself, default is false) */
|
||||
"interfacePrefixBlacklist": [ "XXX",... ], /* Array of interface name prefixes (e.g. eth for eth#) to blacklist for ZT traffic */
|
||||
"allowManagementFrom": "NETWORK/bits"|null, /* If non-NULL, allow JSON/HTTP management from this IP network. Default is 127.0.0.1 only. */
|
||||
"bind": [ "ip",... ] /* If present and non-null, bind to these IPs instead of to each interface (wildcard IP allowed) */
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
* **trustedPathId**: A trusted path is a physical network over which encryption and authentication are not required. This provides a performance boost but sacrifices all ZeroTier's security features when communicating over this path. Only use this if you know what you are doing and really need the performance! To set up a trusted path, all devices using it *MUST* have the *same trusted path ID* for the same network. Trusted path IDs are arbitrary positive non-zero integers. For example a group of devices on a LAN with IPs in 10.0.0.0/24 could use it as a fast trusted path if they all had the same trusted path ID of "25" defined for that network.
|
||||
|
||||
An example `local.conf`:
|
||||
|
||||
```javascript
|
||||
{
|
||||
"physical": {
|
||||
"10.0.0.0/24": {
|
||||
"blacklist": true
|
||||
},
|
||||
"10.10.10.0/24": {
|
||||
"trustedPathId": 101010024
|
||||
},
|
||||
},
|
||||
"virtual": {
|
||||
"feedbeef12": {
|
||||
"role": "UPSTREAM",
|
||||
"try": [ "10.10.20.1/9993" ],
|
||||
"blacklist": [ "192.168.0.0/24" ]
|
||||
}
|
||||
},
|
||||
"settings": {
|
||||
"softwareUpdate": "apply",
|
||||
"softwareUpdateChannel": "release"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Network Virtualization Service API
|
||||
|
||||
|
|
@ -21,30 +81,20 @@ A *jsonp* URL argument may be supplied to request JSONP encapsulation. A JSONP r
|
|||
* Methods: GET
|
||||
* Returns: { object }
|
||||
|
||||
<table>
|
||||
<tr><td><b>Field</b></td><td><b>Type</b></td><td><b>Description</b></td><td><b>Writable</b></td></tr>
|
||||
<tr><td>address</td><td>string</td><td>10-digit hexadecimal ZeroTier address of this node</td><td>no</td></tr>
|
||||
<tr><td>publicIdentity</td><td>string</td><td>Full public ZeroTier identity of this node</td><td>no</td></tr>
|
||||
<tr><td>online</td><td>boolean</td><td>Does this node appear to have upstream network access?</td><td>no</td></tr>
|
||||
<tr><td>tcpFallbackActive</td><td>boolean</td><td>Is TCP fallback mode active?</td><td>no</td></tr>
|
||||
<tr><td>versionMajor</td><td>integer</td><td>ZeroTier major version</td><td>no</td></tr>
|
||||
<tr><td>versionMinor</td><td>integer</td><td>ZeroTier minor version</td><td>no</td></tr>
|
||||
<tr><td>versionRev</td><td>integer</td><td>ZeroTier revision</td><td>no</td></tr>
|
||||
<tr><td>version</td><td>string</td><td>Version in major.minor.rev format</td><td>no</td></tr>
|
||||
<tr><td>clock</td><td>integer</td><td>Node system clock in ms since epoch</td><td>no</td></tr>
|
||||
</table>
|
||||
|
||||
#### /config
|
||||
|
||||
* Purpose: Get or set local configuration
|
||||
* Methods: GET, POST
|
||||
* Returns: { object }
|
||||
|
||||
No local configuration options are exposed yet.
|
||||
|
||||
<table>
|
||||
<tr><td><b>Field</b></td><td><b>Type</b></td><td><b>Description</b></td><td><b>Writable</b></td></tr>
|
||||
</table>
|
||||
| Field | Type | Description | Writable |
|
||||
| --------------------- | ------------- | ------------------------------------------------- | -------- |
|
||||
| address | string | 10-digit hex ZeroTier address of this node | no |
|
||||
| publicIdentity | string | This node's ZeroTier identity.public | no |
|
||||
| worldId | integer | ZeroTier world ID (never changes except for test) | no |
|
||||
| worldTimestamp | integer | Timestamp of most recent world definition | no |
|
||||
| online | boolean | If true at least one upstream peer is reachable | no |
|
||||
| tcpFallbackActive | boolean | If true we are using slow TCP fallback | no |
|
||||
| relayPolicy | string | Relay policy: ALWAYS, TRUSTED, or NEVER | no |
|
||||
| versionMajor | integer | Software major version | no |
|
||||
| versionMinor | integer | Software minor version | no |
|
||||
| versionRev | integer | Software revision | no |
|
||||
| version | string | major.minor.revision | no |
|
||||
| clock | integer | Current system clock at node (ms since epoch) | no |
|
||||
|
||||
#### /network
|
||||
|
||||
|
|
@ -64,23 +114,35 @@ To join a network, POST to it. Since networks have no mandatory writable paramet
|
|||
|
||||
Most network settings are not writable, as they are defined by the network controller.
|
||||
|
||||
<table>
|
||||
<tr><td><b>Field</b></td><td><b>Type</b></td><td><b>Description</b></td><td><b>Writable</b></td></tr>
|
||||
<tr><td>nwid</td><td>string</td><td>16-digit hex network ID</td><td>no</td></tr>
|
||||
<tr><td>mac</td><td>string</td><td>Ethernet MAC address of virtual network port</td><td>no</td></tr>
|
||||
<tr><td>name</td><td>string</td><td>Network short name as configured on network controller</td><td>no</td></tr>
|
||||
<tr><td>status</td><td>string</td><td>Network status: OK, ACCESS_DENIED, PORT_ERROR, etc.</td><td>no</td></tr>
|
||||
<tr><td>type</td><td>string</td><td>Network type, currently PUBLIC or PRIVATE</td><td>no</td></tr>
|
||||
<tr><td>mtu</td><td>integer</td><td>Ethernet MTU</td><td>no</td></tr>
|
||||
<tr><td>dhcp</td><td>boolean</td><td>If true, DHCP may be used to obtain an IP address</td><td>no</td></tr>
|
||||
<tr><td>bridge</td><td>boolean</td><td>If true, this node may bridge in other Ethernet devices</td><td>no</td></tr>
|
||||
<tr><td>broadcastEnabled</td><td>boolean</td><td>Is Ethernet broadcast (ff:ff:ff:ff:ff:ff) allowed?</td><td>no</td></tr>
|
||||
<tr><td>portError</td><td>integer</td><td>Error code (if any) returned by underlying OS "tap" driver</td><td>no</td></tr>
|
||||
<tr><td>netconfRevision</td><td>integer</td><td>Network configuration revision ID</td><td>no</td></tr>
|
||||
<tr><td>multicastSubscriptions</td><td>[string]</td><td>Multicast memberships as array of MAC/ADI tuples</td><td>no</td></tr>
|
||||
<tr><td>assignedAddresses</td><td>[string]</td><td>ZeroTier-managed IP address assignments as array of IP/netmask bits tuples</td><td>no</td></tr>
|
||||
<tr><td>portDeviceName</td><td>string</td><td>OS-specific network device name (if available)</td><td>no</td></tr>
|
||||
</table>
|
||||
| Field | Type | Description | Writable |
|
||||
| --------------------- | ------------- | ------------------------------------------------- | -------- |
|
||||
| id | string | 16-digit hex network ID | no |
|
||||
| nwid | string | 16-digit hex network ID (legacy field) | no |
|
||||
| mac | string | MAC address of network device for this network | no |
|
||||
| name | string | Short name of this network (from controller) | no |
|
||||
| status | string | Network status (OK, ACCESS_DENIED, etc.) | no |
|
||||
| type | string | Network type (PUBLIC or PRIVATE) | no |
|
||||
| mtu | integer | Ethernet MTU | no |
|
||||
| dhcp | boolean | If true, DHCP should be used to get IP info | no |
|
||||
| bridge | boolean | If true, this device can bridge others | no |
|
||||
| broadcastEnabled | boolean | If true ff:ff:ff:ff:ff:ff broadcasts work | no |
|
||||
| portError | integer | Error code returned by underlying tap driver | no |
|
||||
| netconfRevision | integer | Network configuration revision ID | no |
|
||||
| assignedAddresses | [string] | Array of ZeroTier-assigned IP addresses (/bits) | no |
|
||||
| routes | [object] | Array of ZeroTier-assigned routes (see below) | no |
|
||||
| portDeviceName | string | Name of virtual network device (if any) | no |
|
||||
| allowManaged | boolean | Allow IP and route management | yes |
|
||||
| allowGlobal | boolean | Allow IPs and routes that overlap with global IPs | yes |
|
||||
| allowDefault | boolean | Allow overriding of system default route | yes |
|
||||
|
||||
Route objects:
|
||||
|
||||
| Field | Type | Description | Writable |
|
||||
| --------------------- | ------------- | ------------------------------------------------- | -------- |
|
||||
| target | string | Target network / netmask bits | no |
|
||||
| via | string | Gateway IP address (next hop) or null for LAN | no |
|
||||
| flags | integer | Flags, currently always 0 | no |
|
||||
| metric | integer | Route metric (not currently used) | no |
|
||||
|
||||
#### /peer
|
||||
|
||||
|
|
@ -92,31 +154,29 @@ Getting /peer returns an array of peer objects for all current peers. See below
|
|||
|
||||
#### /peer/\<address\>
|
||||
|
||||
* Purpose: Get information about a peer
|
||||
* Methods: GET
|
||||
* Purpose: Get or set information about a peer
|
||||
* Methods: GET, POST
|
||||
* Returns: { object }
|
||||
|
||||
<table>
|
||||
<tr><td><b>Field</b></td><td><b>Type</b></td><td><b>Description</b></td><td><b>Writable</b></td></tr>
|
||||
<tr><td>address</td><td>string</td><td>10-digit hex ZeroTier address</td><td>no</td></tr>
|
||||
<tr><td>lastUnicastFrame</td><td>integer</td><td>Time of last unicast frame in ms since epoch</td><td>no</td></tr>
|
||||
<tr><td>lastMulticastFrame</td><td>integer</td><td>Time of last multicast frame in ms since epoch</td><td>no</td></tr>
|
||||
<tr><td>versionMajor</td><td>integer</td><td>Major version of remote if known</td><td>no</td></tr>
|
||||
<tr><td>versionMinor</td><td>integer</td><td>Minor version of remote if known</td><td>no</td></tr>
|
||||
<tr><td>versionRev</td><td>integer</td><td>Revision of remote if known</td><td>no</td></tr>
|
||||
<tr><td>version</td><td>string</td><td>Version in major.minor.rev format</td><td>no</td></tr>
|
||||
<tr><td>latency</td><td>integer</td><td>Latency in milliseconds if known</td><td>no</td></tr>
|
||||
<tr><td>role</td><td>string</td><td>LEAF, HUB, or ROOTSERVER</td><td>no</td></tr>
|
||||
<tr><td>paths</td><td>[object]</td><td>Array of path objects (see below)</td><td>no</td></tr>
|
||||
</table>
|
||||
| Field | Type | Description | Writable |
|
||||
| --------------------- | ------------- | ------------------------------------------------- | -------- |
|
||||
| address | string | 10-digit hex ZeroTier address of peer | no |
|
||||
| versionMajor | integer | Major version of remote (if known) | no |
|
||||
| versionMinor | integer | Minor version of remote (if known) | no |
|
||||
| versionRev | integer | Software revision of remote (if known) | no |
|
||||
| version | string | major.minor.revision | no |
|
||||
| latency | integer | Latency in milliseconds if known | no |
|
||||
| role | string | LEAF, UPSTREAM, ROOT or PLANET | no |
|
||||
| paths | [object] | Currently active physical paths (see below) | no |
|
||||
|
||||
Path objects describe direct physical paths to peer. If no path objects are listed, peer is only reachable via indirect relay fallback. Path object format is:
|
||||
Path objects:
|
||||
|
||||
<table>
|
||||
<tr><td><b>Field</b></td><td><b>Type</b></td><td><b>Description</b></td><td><b>Writable</b></td></tr>
|
||||
<tr><td>address</td><td>string</td><td>Physical socket address e.g. IP/port for UDP</td><td>no</td></tr>
|
||||
<tr><td>lastSend</td><td>integer</td><td>Last send via this path in ms since epoch</td><td>no</td></tr>
|
||||
<tr><td>lastReceive</td><td>integer</td><td>Last receive via this path in ms since epoch</td><td>no</td></tr>
|
||||
<tr><td>fixed</td><td>boolean</td><td>If true, this is a statically-defined "fixed" path</td><td>no</td></tr>
|
||||
<tr><td>preferred</td><td>boolean</td><td>If true, this is the current preferred path</td><td>no</td></tr>
|
||||
</table>
|
||||
| Field | Type | Description | Writable |
|
||||
| --------------------- | ------------- | ------------------------------------------------- | -------- |
|
||||
| address | string | Physical socket address e.g. IP/port | no |
|
||||
| lastSend | integer | Time of last send through this path | no |
|
||||
| lastReceive | integer | Time of last receive through this path | no |
|
||||
| active | boolean | Is this path in use? | no |
|
||||
| expired | boolean | Is this path expired? | no |
|
||||
| preferred | boolean | Is this a current preferred path? | no |
|
||||
| trustedPathId | integer | If nonzero this is a trusted path (unencrypted) | no |
|
||||
|
|
|
|||
439
service/SoftwareUpdater.cpp
Normal file
439
service/SoftwareUpdater.cpp
Normal file
|
|
@ -0,0 +1,439 @@
|
|||
/*
|
||||
* ZeroTier One - Network Virtualization Everywhere
|
||||
* Copyright (C) 2011-2018 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/>.
|
||||
*
|
||||
* --
|
||||
*
|
||||
* You can be released from the requirements of the license by purchasing
|
||||
* a commercial license. Buying such a license is mandatory as soon as you
|
||||
* develop commercial closed-source software that incorporates or links
|
||||
* directly against ZeroTier software without disclosing the source code
|
||||
* of your own application.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "../node/Constants.hpp"
|
||||
#include "../version.h"
|
||||
|
||||
#ifdef __WINDOWS__
|
||||
#include <WinSock2.h>
|
||||
#include <Windows.h>
|
||||
#include <ShlObj.h>
|
||||
#include <netioapi.h>
|
||||
#include <iphlpapi.h>
|
||||
#else
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/wait.h>
|
||||
#include <unistd.h>
|
||||
#include <ifaddrs.h>
|
||||
#endif
|
||||
|
||||
#include "SoftwareUpdater.hpp"
|
||||
|
||||
#include "../node/Utils.hpp"
|
||||
#include "../node/SHA512.hpp"
|
||||
#include "../node/Buffer.hpp"
|
||||
#include "../node/Node.hpp"
|
||||
|
||||
#include "../osdep/OSUtils.hpp"
|
||||
|
||||
namespace ZeroTier {
|
||||
|
||||
static int _compareVersion(unsigned int maj1,unsigned int min1,unsigned int rev1,unsigned int b1,unsigned int maj2,unsigned int min2,unsigned int rev2,unsigned int b2)
|
||||
{
|
||||
if (maj1 > maj2) {
|
||||
return 1;
|
||||
} else if (maj1 < maj2) {
|
||||
return -1;
|
||||
} else {
|
||||
if (min1 > min2) {
|
||||
return 1;
|
||||
} else if (min1 < min2) {
|
||||
return -1;
|
||||
} else {
|
||||
if (rev1 > rev2) {
|
||||
return 1;
|
||||
} else if (rev1 < rev2) {
|
||||
return -1;
|
||||
} else {
|
||||
if (b1 > b2) {
|
||||
return 1;
|
||||
} else if (b1 < b2) {
|
||||
return -1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SoftwareUpdater::SoftwareUpdater(Node &node,const std::string &homePath) :
|
||||
_node(node),
|
||||
_lastCheckTime(0),
|
||||
_homePath(homePath),
|
||||
_channel(ZT_SOFTWARE_UPDATE_DEFAULT_CHANNEL),
|
||||
_distLog((FILE *)0),
|
||||
_latestValid(false),
|
||||
_downloadLength(0)
|
||||
{
|
||||
OSUtils::rm((_homePath + ZT_PATH_SEPARATOR_S ZT_SOFTWARE_UPDATE_BIN_FILENAME).c_str());
|
||||
}
|
||||
|
||||
SoftwareUpdater::~SoftwareUpdater()
|
||||
{
|
||||
if (_distLog)
|
||||
fclose(_distLog);
|
||||
}
|
||||
|
||||
void SoftwareUpdater::setUpdateDistribution(bool distribute)
|
||||
{
|
||||
_dist.clear();
|
||||
if (distribute) {
|
||||
_distLog = fopen((_homePath + ZT_PATH_SEPARATOR_S "update-dist.log").c_str(),"a");
|
||||
|
||||
const std::string udd(_homePath + ZT_PATH_SEPARATOR_S "update-dist.d");
|
||||
const std::vector<std::string> ud(OSUtils::listDirectory(udd.c_str()));
|
||||
for(std::vector<std::string>::const_iterator u(ud.begin());u!=ud.end();++u) {
|
||||
// Each update has a companion .json file describing it. Other files are ignored.
|
||||
if ((u->length() > 5)&&(u->substr(u->length() - 5,5) == ".json")) {
|
||||
|
||||
std::string buf;
|
||||
if (OSUtils::readFile((udd + ZT_PATH_SEPARATOR_S + *u).c_str(),buf)) {
|
||||
try {
|
||||
_D d;
|
||||
d.meta = OSUtils::jsonParse(buf); // throws on invalid JSON
|
||||
|
||||
// If update meta is called e.g. foo.exe.json, then foo.exe is the update itself
|
||||
const std::string binPath(udd + ZT_PATH_SEPARATOR_S + u->substr(0,u->length() - 5));
|
||||
const std::string metaHash(OSUtils::jsonBinFromHex(d.meta[ZT_SOFTWARE_UPDATE_JSON_UPDATE_HASH]));
|
||||
if ((metaHash.length() == ZT_SHA512_DIGEST_LEN)&&(OSUtils::readFile(binPath.c_str(),d.bin))) {
|
||||
std::array<uint8_t,ZT_SHA512_DIGEST_LEN> sha512;
|
||||
SHA512::hash(sha512.data(),d.bin.data(),(unsigned int)d.bin.length());
|
||||
if (!memcmp(sha512.data(),metaHash.data(),ZT_SHA512_DIGEST_LEN)) { // double check that hash in JSON is correct
|
||||
d.meta[ZT_SOFTWARE_UPDATE_JSON_UPDATE_SIZE] = d.bin.length(); // override with correct value -- setting this in meta json is optional
|
||||
std::array<uint8_t,16> shakey;
|
||||
memcpy(shakey.data(),sha512.data(),16);
|
||||
_dist[shakey] = d;
|
||||
if (_distLog) {
|
||||
fprintf(_distLog,".......... INIT: DISTRIBUTING %s (%u bytes)" ZT_EOL_S,binPath.c_str(),(unsigned int)d.bin.length());
|
||||
fflush(_distLog);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch ( ... ) {} // ignore bad meta JSON, etc.
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (_distLog) {
|
||||
fclose(_distLog);
|
||||
_distLog = (FILE *)0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void SoftwareUpdater::handleSoftwareUpdateUserMessage(uint64_t origin,const void *data,unsigned int len)
|
||||
{
|
||||
if (!len) return;
|
||||
const MessageVerb v = (MessageVerb)reinterpret_cast<const uint8_t *>(data)[0];
|
||||
try {
|
||||
switch(v) {
|
||||
|
||||
case VERB_GET_LATEST:
|
||||
case VERB_LATEST: {
|
||||
nlohmann::json req = OSUtils::jsonParse(std::string(reinterpret_cast<const char *>(data) + 1,len - 1)); // throws on invalid JSON
|
||||
if (req.is_object()) {
|
||||
const unsigned int rvMaj = (unsigned int)OSUtils::jsonInt(req[ZT_SOFTWARE_UPDATE_JSON_VERSION_MAJOR],0);
|
||||
const unsigned int rvMin = (unsigned int)OSUtils::jsonInt(req[ZT_SOFTWARE_UPDATE_JSON_VERSION_MINOR],0);
|
||||
const unsigned int rvRev = (unsigned int)OSUtils::jsonInt(req[ZT_SOFTWARE_UPDATE_JSON_VERSION_REVISION],0);
|
||||
const unsigned int rvBld = (unsigned int)OSUtils::jsonInt(req[ZT_SOFTWARE_UPDATE_JSON_VERSION_BUILD],0);
|
||||
const unsigned int rvPlatform = (unsigned int)OSUtils::jsonInt(req[ZT_SOFTWARE_UPDATE_JSON_PLATFORM],0);
|
||||
const unsigned int rvArch = (unsigned int)OSUtils::jsonInt(req[ZT_SOFTWARE_UPDATE_JSON_ARCHITECTURE],0);
|
||||
const unsigned int rvVendor = (unsigned int)OSUtils::jsonInt(req[ZT_SOFTWARE_UPDATE_JSON_VENDOR],0);
|
||||
const std::string rvChannel(OSUtils::jsonString(req[ZT_SOFTWARE_UPDATE_JSON_CHANNEL],""));
|
||||
|
||||
if (v == VERB_GET_LATEST) {
|
||||
|
||||
if (_dist.size() > 0) {
|
||||
const nlohmann::json *latest = (const nlohmann::json *)0;
|
||||
const std::string expectedSigner = OSUtils::jsonString(req[ZT_SOFTWARE_UPDATE_JSON_EXPECT_SIGNED_BY],"");
|
||||
unsigned int bestVMaj = rvMaj;
|
||||
unsigned int bestVMin = rvMin;
|
||||
unsigned int bestVRev = rvRev;
|
||||
unsigned int bestVBld = rvBld;
|
||||
for(std::map< std::array<uint8_t,16>,_D >::const_iterator d(_dist.begin());d!=_dist.end();++d) {
|
||||
// The arch field in update description .json files can be an array for e.g. multi-arch update files
|
||||
const nlohmann::json &dvArch2 = d->second.meta[ZT_SOFTWARE_UPDATE_JSON_ARCHITECTURE];
|
||||
std::vector<unsigned int> dvArch;
|
||||
if (dvArch2.is_array()) {
|
||||
for(unsigned long i=0;i<dvArch2.size();++i)
|
||||
dvArch.push_back((unsigned int)OSUtils::jsonInt(dvArch2[i],0));
|
||||
} else {
|
||||
dvArch.push_back((unsigned int)OSUtils::jsonInt(dvArch2,0));
|
||||
}
|
||||
|
||||
if ((OSUtils::jsonInt(d->second.meta[ZT_SOFTWARE_UPDATE_JSON_PLATFORM],0) == rvPlatform)&&
|
||||
(std::find(dvArch.begin(),dvArch.end(),rvArch) != dvArch.end())&&
|
||||
(OSUtils::jsonInt(d->second.meta[ZT_SOFTWARE_UPDATE_JSON_VENDOR],0) == rvVendor)&&
|
||||
(OSUtils::jsonString(d->second.meta[ZT_SOFTWARE_UPDATE_JSON_CHANNEL],"") == rvChannel)&&
|
||||
(OSUtils::jsonString(d->second.meta[ZT_SOFTWARE_UPDATE_JSON_UPDATE_SIGNED_BY],"") == expectedSigner)) {
|
||||
const unsigned int dvMaj = (unsigned int)OSUtils::jsonInt(d->second.meta[ZT_SOFTWARE_UPDATE_JSON_VERSION_MAJOR],0);
|
||||
const unsigned int dvMin = (unsigned int)OSUtils::jsonInt(d->second.meta[ZT_SOFTWARE_UPDATE_JSON_VERSION_MINOR],0);
|
||||
const unsigned int dvRev = (unsigned int)OSUtils::jsonInt(d->second.meta[ZT_SOFTWARE_UPDATE_JSON_VERSION_REVISION],0);
|
||||
const unsigned int dvBld = (unsigned int)OSUtils::jsonInt(d->second.meta[ZT_SOFTWARE_UPDATE_JSON_VERSION_BUILD],0);
|
||||
if (_compareVersion(dvMaj,dvMin,dvRev,dvBld,bestVMaj,bestVMin,bestVRev,bestVBld) > 0) {
|
||||
latest = &(d->second.meta);
|
||||
bestVMaj = dvMaj;
|
||||
bestVMin = dvMin;
|
||||
bestVRev = dvRev;
|
||||
bestVBld = dvBld;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (latest) {
|
||||
std::string lj;
|
||||
lj.push_back((char)VERB_LATEST);
|
||||
lj.append(OSUtils::jsonDump(*latest));
|
||||
_node.sendUserMessage((void *)0,origin,ZT_SOFTWARE_UPDATE_USER_MESSAGE_TYPE,lj.data(),(unsigned int)lj.length());
|
||||
if (_distLog) {
|
||||
fprintf(_distLog,"%.10llx GET_LATEST %u.%u.%u_%u platform %u arch %u vendor %u channel %s -> LATEST %u.%u.%u_%u" ZT_EOL_S,(unsigned long long)origin,rvMaj,rvMin,rvRev,rvBld,rvPlatform,rvArch,rvVendor,rvChannel.c_str(),bestVMaj,bestVMin,bestVRev,bestVBld);
|
||||
fflush(_distLog);
|
||||
}
|
||||
}
|
||||
} // else no reply, since we have nothing to distribute
|
||||
|
||||
} else { // VERB_LATEST
|
||||
|
||||
if ((origin == ZT_SOFTWARE_UPDATE_SERVICE)&&
|
||||
(_compareVersion(rvMaj,rvMin,rvRev,rvBld,ZEROTIER_ONE_VERSION_MAJOR,ZEROTIER_ONE_VERSION_MINOR,ZEROTIER_ONE_VERSION_REVISION,ZEROTIER_ONE_VERSION_BUILD) > 0)&&
|
||||
(OSUtils::jsonString(req[ZT_SOFTWARE_UPDATE_JSON_UPDATE_SIGNED_BY],"") == ZT_SOFTWARE_UPDATE_SIGNING_AUTHORITY)) {
|
||||
const unsigned long len = (unsigned long)OSUtils::jsonInt(req[ZT_SOFTWARE_UPDATE_JSON_UPDATE_SIZE],0);
|
||||
const std::string hash = OSUtils::jsonBinFromHex(req[ZT_SOFTWARE_UPDATE_JSON_UPDATE_HASH]);
|
||||
if ((len <= ZT_SOFTWARE_UPDATE_MAX_SIZE)&&(hash.length() >= 16)) {
|
||||
if (_latestMeta != req) {
|
||||
_latestMeta = req;
|
||||
_latestValid = false;
|
||||
OSUtils::rm((_homePath + ZT_PATH_SEPARATOR_S ZT_SOFTWARE_UPDATE_BIN_FILENAME).c_str());
|
||||
_download = std::string();
|
||||
memcpy(_downloadHashPrefix.data(),hash.data(),16);
|
||||
_downloadLength = len;
|
||||
}
|
||||
|
||||
if ((_downloadLength > 0)&&(_download.length() < _downloadLength)) {
|
||||
Buffer<128> gd;
|
||||
gd.append((uint8_t)VERB_GET_DATA);
|
||||
gd.append(_downloadHashPrefix.data(),16);
|
||||
gd.append((uint32_t)_download.length());
|
||||
_node.sendUserMessage((void *)0,ZT_SOFTWARE_UPDATE_SERVICE,ZT_SOFTWARE_UPDATE_USER_MESSAGE_TYPE,gd.data(),gd.size());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
} break;
|
||||
|
||||
case VERB_GET_DATA:
|
||||
if ((len >= 21)&&(_dist.size() > 0)) {
|
||||
unsigned long idx = (unsigned long)*(reinterpret_cast<const uint8_t *>(data) + 17) << 24;
|
||||
idx |= (unsigned long)*(reinterpret_cast<const uint8_t *>(data) + 18) << 16;
|
||||
idx |= (unsigned long)*(reinterpret_cast<const uint8_t *>(data) + 19) << 8;
|
||||
idx |= (unsigned long)*(reinterpret_cast<const uint8_t *>(data) + 20);
|
||||
std::array<uint8_t,16> shakey;
|
||||
memcpy(shakey.data(),reinterpret_cast<const uint8_t *>(data) + 1,16);
|
||||
std::map< std::array<uint8_t,16>,_D >::iterator d(_dist.find(shakey));
|
||||
if ((d != _dist.end())&&(idx < (unsigned long)d->second.bin.length())) {
|
||||
Buffer<ZT_SOFTWARE_UPDATE_CHUNK_SIZE + 128> buf;
|
||||
buf.append((uint8_t)VERB_DATA);
|
||||
buf.append(reinterpret_cast<const uint8_t *>(data) + 1,16);
|
||||
buf.append((uint32_t)idx);
|
||||
buf.append(d->second.bin.data() + idx,std::min((unsigned long)ZT_SOFTWARE_UPDATE_CHUNK_SIZE,(unsigned long)(d->second.bin.length() - idx)));
|
||||
_node.sendUserMessage((void *)0,origin,ZT_SOFTWARE_UPDATE_USER_MESSAGE_TYPE,buf.data(),buf.size());
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case VERB_DATA:
|
||||
if ((len >= 21)&&(_downloadLength > 0)&&(!memcmp(_downloadHashPrefix.data(),reinterpret_cast<const uint8_t *>(data) + 1,16))) {
|
||||
unsigned long idx = (unsigned long)*(reinterpret_cast<const uint8_t *>(data) + 17) << 24;
|
||||
idx |= (unsigned long)*(reinterpret_cast<const uint8_t *>(data) + 18) << 16;
|
||||
idx |= (unsigned long)*(reinterpret_cast<const uint8_t *>(data) + 19) << 8;
|
||||
idx |= (unsigned long)*(reinterpret_cast<const uint8_t *>(data) + 20);
|
||||
if (idx == (unsigned long)_download.length()) {
|
||||
_download.append(reinterpret_cast<const char *>(data) + 21,len - 21);
|
||||
if (_download.length() < _downloadLength) {
|
||||
Buffer<128> gd;
|
||||
gd.append((uint8_t)VERB_GET_DATA);
|
||||
gd.append(_downloadHashPrefix.data(),16);
|
||||
gd.append((uint32_t)_download.length());
|
||||
_node.sendUserMessage((void *)0,ZT_SOFTWARE_UPDATE_SERVICE,ZT_SOFTWARE_UPDATE_USER_MESSAGE_TYPE,gd.data(),gd.size());
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
if (_distLog) {
|
||||
fprintf(_distLog,"%.10llx WARNING: bad update message verb==%u length==%u (unrecognized verb)" ZT_EOL_S,(unsigned long long)origin,(unsigned int)v,len);
|
||||
fflush(_distLog);
|
||||
}
|
||||
break;
|
||||
}
|
||||
} catch ( ... ) {
|
||||
if (_distLog) {
|
||||
fprintf(_distLog,"%.10llx WARNING: bad update message verb==%u length==%u (unexpected exception, likely invalid JSON)" ZT_EOL_S,(unsigned long long)origin,(unsigned int)v,len);
|
||||
fflush(_distLog);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool SoftwareUpdater::check(const int64_t now)
|
||||
{
|
||||
if ((now - _lastCheckTime) >= ZT_SOFTWARE_UPDATE_CHECK_PERIOD) {
|
||||
_lastCheckTime = now;
|
||||
char tmp[512];
|
||||
const unsigned int len = OSUtils::ztsnprintf(tmp,sizeof(tmp),
|
||||
"%c{\"" ZT_SOFTWARE_UPDATE_JSON_VERSION_MAJOR "\":%d,"
|
||||
"\"" ZT_SOFTWARE_UPDATE_JSON_VERSION_MINOR "\":%d,"
|
||||
"\"" ZT_SOFTWARE_UPDATE_JSON_VERSION_REVISION "\":%d,"
|
||||
"\"" ZT_SOFTWARE_UPDATE_JSON_VERSION_BUILD "\":%d,"
|
||||
"\"" ZT_SOFTWARE_UPDATE_JSON_EXPECT_SIGNED_BY "\":\"%s\","
|
||||
"\"" ZT_SOFTWARE_UPDATE_JSON_PLATFORM "\":%d,"
|
||||
"\"" ZT_SOFTWARE_UPDATE_JSON_ARCHITECTURE "\":%d,"
|
||||
"\"" ZT_SOFTWARE_UPDATE_JSON_VENDOR "\":%d,"
|
||||
"\"" ZT_SOFTWARE_UPDATE_JSON_CHANNEL "\":\"%s\"}",
|
||||
(char)VERB_GET_LATEST,
|
||||
ZEROTIER_ONE_VERSION_MAJOR,
|
||||
ZEROTIER_ONE_VERSION_MINOR,
|
||||
ZEROTIER_ONE_VERSION_REVISION,
|
||||
ZEROTIER_ONE_VERSION_BUILD,
|
||||
ZT_SOFTWARE_UPDATE_SIGNING_AUTHORITY,
|
||||
ZT_BUILD_PLATFORM,
|
||||
ZT_BUILD_ARCHITECTURE,
|
||||
(int)ZT_VENDOR_ZEROTIER,
|
||||
_channel.c_str());
|
||||
_node.sendUserMessage((void *)0,ZT_SOFTWARE_UPDATE_SERVICE,ZT_SOFTWARE_UPDATE_USER_MESSAGE_TYPE,tmp,len);
|
||||
}
|
||||
|
||||
if (_latestValid)
|
||||
return true;
|
||||
|
||||
if (_downloadLength > 0) {
|
||||
if (_download.length() >= _downloadLength) {
|
||||
// This is the very important security validation part that makes sure
|
||||
// this software update doesn't have cooties.
|
||||
|
||||
const std::string binPath(_homePath + ZT_PATH_SEPARATOR_S ZT_SOFTWARE_UPDATE_BIN_FILENAME);
|
||||
try {
|
||||
// (1) Check the hash itself to make sure the image is basically okay
|
||||
uint8_t sha512[ZT_SHA512_DIGEST_LEN];
|
||||
SHA512::hash(sha512,_download.data(),(unsigned int)_download.length());
|
||||
char hexbuf[(ZT_SHA512_DIGEST_LEN * 2) + 2];
|
||||
if (OSUtils::jsonString(_latestMeta[ZT_SOFTWARE_UPDATE_JSON_UPDATE_HASH],"") == Utils::hex(sha512,ZT_SHA512_DIGEST_LEN,hexbuf)) {
|
||||
// (2) Check signature by signing authority
|
||||
const std::string sig(OSUtils::jsonBinFromHex(_latestMeta[ZT_SOFTWARE_UPDATE_JSON_UPDATE_SIGNATURE]));
|
||||
if (Identity(ZT_SOFTWARE_UPDATE_SIGNING_AUTHORITY).verify(_download.data(),(unsigned int)_download.length(),sig.data(),(unsigned int)sig.length())) {
|
||||
// (3) Try to save file, and if so we are good.
|
||||
OSUtils::rm(binPath.c_str());
|
||||
if (OSUtils::writeFile(binPath.c_str(),_download)) {
|
||||
OSUtils::lockDownFile(binPath.c_str(),false);
|
||||
_latestValid = true;
|
||||
_download = std::string();
|
||||
_downloadLength = 0;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch ( ... ) {} // any exception equals verification failure
|
||||
|
||||
// If we get here, checks failed.
|
||||
OSUtils::rm(binPath.c_str());
|
||||
_latestMeta = nlohmann::json();
|
||||
_latestValid = false;
|
||||
_download = std::string();
|
||||
_downloadLength = 0;
|
||||
} else {
|
||||
Buffer<128> gd;
|
||||
gd.append((uint8_t)VERB_GET_DATA);
|
||||
gd.append(_downloadHashPrefix.data(),16);
|
||||
gd.append((uint32_t)_download.length());
|
||||
_node.sendUserMessage((void *)0,ZT_SOFTWARE_UPDATE_SERVICE,ZT_SOFTWARE_UPDATE_USER_MESSAGE_TYPE,gd.data(),gd.size());
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void SoftwareUpdater::apply()
|
||||
{
|
||||
std::string updatePath(_homePath + ZT_PATH_SEPARATOR_S ZT_SOFTWARE_UPDATE_BIN_FILENAME);
|
||||
if ((_latestMeta.is_object())&&(_latestValid)&&(OSUtils::fileExists(updatePath.c_str(),false))) {
|
||||
#ifdef __WINDOWS__
|
||||
std::string cmdArgs(OSUtils::jsonString(_latestMeta[ZT_SOFTWARE_UPDATE_JSON_UPDATE_EXEC_ARGS],""));
|
||||
if (cmdArgs.length() > 0) {
|
||||
updatePath.push_back(' ');
|
||||
updatePath.append(cmdArgs);
|
||||
}
|
||||
STARTUPINFOA si;
|
||||
PROCESS_INFORMATION pi;
|
||||
memset(&si,0,sizeof(si));
|
||||
memset(&pi,0,sizeof(pi));
|
||||
CreateProcessA(NULL,const_cast<LPSTR>(updatePath.c_str()),NULL,NULL,FALSE,CREATE_NO_WINDOW|CREATE_NEW_PROCESS_GROUP,NULL,NULL,&si,&pi);
|
||||
// Windows doesn't exit here -- updater will stop the service during update, etc. -- but we do want to stop multiple runs from happening
|
||||
_latestMeta = nlohmann::json();
|
||||
_latestValid = false;
|
||||
#else
|
||||
char *argv[256];
|
||||
unsigned long ac = 0;
|
||||
argv[ac++] = const_cast<char *>(updatePath.c_str());
|
||||
const std::vector<std::string> argsSplit(OSUtils::split(OSUtils::jsonString(_latestMeta[ZT_SOFTWARE_UPDATE_JSON_UPDATE_EXEC_ARGS],"").c_str()," ","\\","\""));
|
||||
for(std::vector<std::string>::const_iterator a(argsSplit.begin());a!=argsSplit.end();++a) {
|
||||
argv[ac] = const_cast<char *>(a->c_str());
|
||||
if (++ac == 255) break;
|
||||
}
|
||||
argv[ac] = (char *)0;
|
||||
chmod(updatePath.c_str(),0700);
|
||||
|
||||
// Close all open file descriptors except stdout/stderr/etc.
|
||||
int minMyFd = STDIN_FILENO;
|
||||
if (STDOUT_FILENO > minMyFd) minMyFd = STDOUT_FILENO;
|
||||
if (STDERR_FILENO > minMyFd) minMyFd = STDERR_FILENO;
|
||||
++minMyFd;
|
||||
#ifdef _SC_OPEN_MAX
|
||||
int maxMyFd = (int)sysconf(_SC_OPEN_MAX);
|
||||
if (maxMyFd <= minMyFd)
|
||||
maxMyFd = 65536;
|
||||
#else
|
||||
int maxMyFd = 65536;
|
||||
#endif
|
||||
while (minMyFd < maxMyFd)
|
||||
close(minMyFd++);
|
||||
|
||||
execv(updatePath.c_str(),argv);
|
||||
fprintf(stderr,"FATAL: unable to execute software update binary at %s\n",updatePath.c_str());
|
||||
exit(1);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace ZeroTier
|
||||
217
service/SoftwareUpdater.hpp
Normal file
217
service/SoftwareUpdater.hpp
Normal file
|
|
@ -0,0 +1,217 @@
|
|||
/*
|
||||
* ZeroTier One - Network Virtualization Everywhere
|
||||
* Copyright (C) 2011-2018 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/>.
|
||||
*
|
||||
* --
|
||||
*
|
||||
* You can be released from the requirements of the license by purchasing
|
||||
* a commercial license. Buying such a license is mandatory as soon as you
|
||||
* develop commercial closed-source software that incorporates or links
|
||||
* directly against ZeroTier software without disclosing the source code
|
||||
* of your own application.
|
||||
*/
|
||||
|
||||
#ifndef ZT_SOFTWAREUPDATER_HPP
|
||||
#define ZT_SOFTWAREUPDATER_HPP
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <array>
|
||||
|
||||
#include "../include/ZeroTierOne.h"
|
||||
|
||||
#include "../node/Identity.hpp"
|
||||
#include "../node/Packet.hpp"
|
||||
|
||||
#include "../ext/json/json.hpp"
|
||||
|
||||
/**
|
||||
* VERB_USER_MESSAGE type ID for software update messages
|
||||
*/
|
||||
#define ZT_SOFTWARE_UPDATE_USER_MESSAGE_TYPE 100
|
||||
|
||||
/**
|
||||
* ZeroTier address of node that provides software updates
|
||||
*/
|
||||
#define ZT_SOFTWARE_UPDATE_SERVICE 0xb1d366e81fULL
|
||||
|
||||
/**
|
||||
* ZeroTier identity that must be used to sign software updates
|
||||
*
|
||||
* df24360f3e - update-signing-key-0010 generated Fri Jan 13th, 2017 at 4:05pm PST
|
||||
*/
|
||||
#define ZT_SOFTWARE_UPDATE_SIGNING_AUTHORITY "df24360f3e:0:06072642959c8dfb68312904d74d90197c8a7692697caa1b3fd769eca714f4370fab462fcee6ebcb5fffb63bc5af81f28a2514b2cd68daabb42f7352c06f21db"
|
||||
|
||||
/**
|
||||
* Chunk size for in-band downloads (can be changed, designed to always fit in one UDP packet easily)
|
||||
*/
|
||||
#define ZT_SOFTWARE_UPDATE_CHUNK_SIZE (ZT_PROTO_MAX_PACKET_LENGTH - 128)
|
||||
|
||||
/**
|
||||
* Sanity limit for the size of an update binary image
|
||||
*/
|
||||
#define ZT_SOFTWARE_UPDATE_MAX_SIZE (1024 * 1024 * 256)
|
||||
|
||||
/**
|
||||
* How often (ms) do we check?
|
||||
*/
|
||||
#define ZT_SOFTWARE_UPDATE_CHECK_PERIOD (60 * 10 * 1000)
|
||||
|
||||
/**
|
||||
* Default update channel
|
||||
*/
|
||||
#define ZT_SOFTWARE_UPDATE_DEFAULT_CHANNEL "release"
|
||||
|
||||
/**
|
||||
* Filename for latest update's binary image
|
||||
*/
|
||||
#define ZT_SOFTWARE_UPDATE_BIN_FILENAME "latest-update.exe"
|
||||
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_VERSION_MAJOR "vMajor"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_VERSION_MINOR "vMinor"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_VERSION_REVISION "vRev"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_VERSION_BUILD "vBuild"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_PLATFORM "platform"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_ARCHITECTURE "arch"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_VENDOR "vendor"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_CHANNEL "channel"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_EXPECT_SIGNED_BY "expectedSigner"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_UPDATE_SIGNED_BY "signer"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_UPDATE_SIGNATURE "signature"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_UPDATE_HASH "hash"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_UPDATE_SIZE "size"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_UPDATE_EXEC_ARGS "execArgs"
|
||||
#define ZT_SOFTWARE_UPDATE_JSON_UPDATE_URL "url"
|
||||
|
||||
namespace ZeroTier {
|
||||
|
||||
class Node;
|
||||
|
||||
/**
|
||||
* This class handles retrieving and executing updates, or serving them
|
||||
*/
|
||||
class SoftwareUpdater
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Each message begins with an 8-bit message verb
|
||||
*/
|
||||
enum MessageVerb
|
||||
{
|
||||
/**
|
||||
* Payload: JSON containing current system platform, version, etc.
|
||||
*/
|
||||
VERB_GET_LATEST = 1,
|
||||
|
||||
/**
|
||||
* Payload: JSON describing latest update for this target. (No response is sent if there is none.)
|
||||
*/
|
||||
VERB_LATEST = 2,
|
||||
|
||||
/**
|
||||
* Payload:
|
||||
* <[16] first 128 bits of hash of data object>
|
||||
* <[4] 32-bit index of chunk to get>
|
||||
*/
|
||||
VERB_GET_DATA = 3,
|
||||
|
||||
/**
|
||||
* Payload:
|
||||
* <[16] first 128 bits of hash of data object>
|
||||
* <[4] 32-bit index of chunk>
|
||||
* <[...] chunk data>
|
||||
*/
|
||||
VERB_DATA = 4
|
||||
};
|
||||
|
||||
SoftwareUpdater(Node &node,const std::string &homePath);
|
||||
~SoftwareUpdater();
|
||||
|
||||
/**
|
||||
* Set whether or not we will distribute updates
|
||||
*
|
||||
* @param distribute If true, scan update-dist.d now and distribute updates found there -- if false, clear and stop distributing
|
||||
*/
|
||||
void setUpdateDistribution(bool distribute);
|
||||
|
||||
/**
|
||||
* Handle a software update user message
|
||||
*
|
||||
* @param origin ZeroTier address of message origin
|
||||
* @param data Message payload
|
||||
* @param len Length of message
|
||||
*/
|
||||
void handleSoftwareUpdateUserMessage(uint64_t origin,const void *data,unsigned int len);
|
||||
|
||||
/**
|
||||
* Check for updates and do other update-related housekeeping
|
||||
*
|
||||
* It should be called about every 10 seconds.
|
||||
*
|
||||
* @return True if we've downloaded and verified an update
|
||||
*/
|
||||
bool check(const int64_t now);
|
||||
|
||||
/**
|
||||
* @return Meta-data for downloaded update or NULL if none
|
||||
*/
|
||||
inline const nlohmann::json &pending() const { return _latestMeta; }
|
||||
|
||||
/**
|
||||
* Apply any ready update now
|
||||
*
|
||||
* Depending on the platform this function may never return and may forcibly
|
||||
* exit the process. It does nothing if no update is ready.
|
||||
*/
|
||||
void apply();
|
||||
|
||||
/**
|
||||
* Set software update channel
|
||||
*
|
||||
* @param channel 'release', 'beta', etc.
|
||||
*/
|
||||
inline void setChannel(const std::string &channel) { _channel = channel; }
|
||||
|
||||
private:
|
||||
Node &_node;
|
||||
uint64_t _lastCheckTime;
|
||||
std::string _homePath;
|
||||
std::string _channel;
|
||||
FILE *_distLog;
|
||||
|
||||
// Offered software updates if we are an update host (we have update-dist.d and update hosting is enabled)
|
||||
struct _D
|
||||
{
|
||||
nlohmann::json meta;
|
||||
std::string bin;
|
||||
};
|
||||
std::map< std::array<uint8_t,16>,_D > _dist; // key is first 16 bytes of hash
|
||||
|
||||
nlohmann::json _latestMeta;
|
||||
bool _latestValid;
|
||||
|
||||
std::string _download;
|
||||
std::array<uint8_t,16> _downloadHashPrefix;
|
||||
unsigned long _downloadLength;
|
||||
};
|
||||
|
||||
} // namespace ZeroTier
|
||||
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue