mirror of
https://github.com/zerotier/ZeroTierOne.git
synced 2024-12-23 23:02:23 +00:00
275 lines
8.7 KiB
C++
275 lines
8.7 KiB
C++
/*
|
|
* ZeroTier One - Network Virtualization Everywhere
|
|
* Copyright (C) 2011-2015 ZeroTier, Inc.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* --
|
|
*
|
|
* ZeroTier may be used and distributed under the terms of the GPLv3, which
|
|
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
|
|
*
|
|
* If you would like to embed ZeroTier into a commercial application or
|
|
* redistribute it in a modified binary form, please contact ZeroTier Networks
|
|
* LLC. Start here: http://www.zerotier.com/
|
|
*/
|
|
|
|
#include "ControlPlane.hpp"
|
|
|
|
#include "../version.h"
|
|
#include "../include/ZeroTierOne.h"
|
|
|
|
#include "../ext/http-parser/http_parser.h"
|
|
|
|
#include "../node/InetAddress.hpp"
|
|
#include "../node/Node.hpp"
|
|
#include "../node/Utils.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(*s); break;
|
|
}
|
|
}
|
|
return buf;
|
|
}
|
|
static std::string _jsonEscape(const std::string &s) { return _jsonEscape(s.c_str()); }
|
|
static std::string _jsonEnumerate(const ZT1_MulticastGroup *mg,unsigned int count)
|
|
{
|
|
std::string buf;
|
|
char tmp[128];
|
|
buf.push_back('[');
|
|
for(unsigned int i=0;i<count;++i) {
|
|
if (i > 0)
|
|
buf.push_back(',');
|
|
Utils::snprintf(tmp,sizeof(tmp),"\"%.2x:%.2x:%.2x:%.2x:%.2x:%.2x\\/%.8lx\"",
|
|
(unsigned int)((mg->mac >> 40) & 0xff),
|
|
(unsigned int)((mg->mac >> 32) & 0xff),
|
|
(unsigned int)((mg->mac >> 24) & 0xff),
|
|
(unsigned int)((mg->mac >> 16) & 0xff),
|
|
(unsigned int)((mg->mac >> 8) & 0xff),
|
|
(unsigned int)(mg->mac & 0xff),
|
|
mg->adi);
|
|
buf.append(tmp);
|
|
}
|
|
buf.push_back(']');
|
|
return buf;
|
|
}
|
|
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)->toString()));
|
|
buf.push_back('"');
|
|
}
|
|
buf.push_back(']');
|
|
return buf;
|
|
}
|
|
static void _jsonAppend(std::string &buf,const ZT1_VirtualNetworkConfig *nc)
|
|
{
|
|
char json[65536];
|
|
const char *nstatus = "",*ntype = "";
|
|
switch(nc->status) {
|
|
case ZT1_NETWORK_STATUS_REQUESTING_CONFIGURATION: nstatus = "REQUESTING_CONFIGURATION"; break;
|
|
case ZT1_NETWORK_STATUS_OK: nstatus = "OK"; break;
|
|
case ZT1_NETWORK_STATUS_ACCESS_DENIED: nstatus = "ACCESS_DENIED"; break;
|
|
case ZT1_NETWORK_STATUS_NOT_FOUND: nstatus = "NOT_FOUND"; break;
|
|
case ZT1_NETWORK_STATUS_PORT_ERROR: nstatus = "PORT_ERROR"; break;
|
|
case ZT1_NETWORK_STATUS_CLIENT_TOO_OLD: nstatus = "CLIENT_TOO_OLD"; break;
|
|
}
|
|
switch(nc->type) {
|
|
case ZT1_NETWORK_TYPE_PRIVATE: ntype = "PRIVATE"; break;
|
|
case ZT1_NETWORK_TYPE_PUBLIC: ntype = "PUBLIC"; break;
|
|
}
|
|
Utils::snprintf(json,sizeof(json),
|
|
"{"
|
|
"\"nwid\": \"%.16llx\","
|
|
"\"mac\": \"%.2x:%.2x:%.2x:%.2x:%.2x:%.2x\","
|
|
"\"name\": %s,"
|
|
"\"status\": \"%s\","
|
|
"\"type\": \"%s\","
|
|
"\"mtu\": %u,"
|
|
"\"dhcp\": %s,"
|
|
"\"bridge\": %s,"
|
|
"\"broadcastEnabled\": %s,"
|
|
"\"portError\": %d,"
|
|
"\"netconfRevision\": %lu,"
|
|
"\"multicastSubscriptions\": %s,"
|
|
"\"assignedAddresses\": %s"
|
|
"}",
|
|
nc->nwid,
|
|
(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),
|
|
_jsonEscape(nc->name).c_str(),
|
|
nstatus,
|
|
ntype,
|
|
nc->mtu,
|
|
(nc->dhcp == 0) ? "false" : "true",
|
|
(nc->bridge == 0) ? "false" : "true",
|
|
(nc->broadcastEnabled == 0) ? "false" : "true",
|
|
nc->portError,
|
|
nc->netconfRevision,
|
|
_jsonEnumerate(nc->multicastSubscriptions,nc->multicastSubscriptionCount).c_str(),
|
|
_jsonEnumerate(nc->assignedAddresses,nc->assignedAddressCount).c_str());
|
|
buf.append(json);
|
|
}
|
|
static void _jsonAppend(std::string &buf,const ZT1_Peer *peer)
|
|
{
|
|
}
|
|
|
|
ControlPlane::ControlPlane(Node *n,const std::set<std::string> atoks) :
|
|
_node(n),
|
|
_authTokens(atoks)
|
|
{
|
|
}
|
|
|
|
ControlPlane::~ControlPlane()
|
|
{
|
|
}
|
|
|
|
unsigned int ControlPlane::handleRequest(
|
|
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[65536];
|
|
unsigned int scode = 404;
|
|
std::vector<std::string> ps(Utils::split(path.c_str(),"/","",""));
|
|
std::map<std::string,std::string> urlArgs;
|
|
|
|
/* 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"));
|
|
}
|
|
|
|
if (httpMethod == HTTP_GET) {
|
|
if (ps[0] == "index") {
|
|
responseContentType = "text/html";
|
|
responseBody = "<html><body>Hello World!</body></html>";
|
|
} else if (ps[0] == "status") {
|
|
responseContentType = "application/json";
|
|
ZT1_NodeStatus status;
|
|
_node->status(&status);
|
|
Utils::snprintf(json,sizeof(json),
|
|
"{"
|
|
"\"address\":\"%.10llx\","
|
|
"\"publicIdentity\":\"%s\","
|
|
"\"online\":%s,"
|
|
"\"versionMajor\":%d,"
|
|
"\"versionMinor\":%d,"
|
|
"\"versionRevision\":%d,"
|
|
"\"version\":\"%d.%d.%d\""
|
|
"}",
|
|
status.address,
|
|
status.publicIdentity,
|
|
(status.online) ? "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);
|
|
responseBody = json;
|
|
} else if (ps[0] == "config") {
|
|
responseContentType = "application/json";
|
|
responseBody = "{}"; // TODO
|
|
} else if (ps[0] == "network") {
|
|
ZT1_VirtualNetworkList *nws = _node->networks();
|
|
if (nws) {
|
|
if (ps.size() == 1) {
|
|
// Return [array] of all networks
|
|
responseContentType = "application/json";
|
|
responseBody = "[";
|
|
for(unsigned long i=0;i<nws->networkCount;++i) {
|
|
if (i > 0)
|
|
responseBody.push_back(',');
|
|
_jsonAppend(responseBody,&(nws->networks[i]));
|
|
}
|
|
responseBody.push_back(']');
|
|
} 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());
|
|
bool got = false;
|
|
for(unsigned long i=0;i<nws->networkCount;++i) {
|
|
if (nws->networks[i].nwid == wantnw) {
|
|
got = true;
|
|
responseContentType = "application/json";
|
|
_jsonAppend(responseBody,&(nws->networks[i]));
|
|
break;
|
|
}
|
|
}
|
|
if (!got)
|
|
scode = 404;
|
|
} else {
|
|
// Not sure what they want here, 404
|
|
scode = 404;
|
|
}
|
|
_node->freeQueryResult((void *)nws);
|
|
} else scode = 500;
|
|
} else if (ps[0] == "peer") {
|
|
}
|
|
} else if ((httpMethod == HTTP_POST)||(httpMethod == HTTP_PUT)) { // PUT is weird in REST but we'll take it anyway
|
|
} else if (httpMethod == HTTP_DELETE) {
|
|
} else {
|
|
scode = 400;
|
|
responseBody = "Method not supported for resource ";
|
|
responseBody.append(path);
|
|
}
|
|
|
|
std::map<std::string,std::string>::const_iterator jsonp(urlArgs.find("jsonp"));
|
|
if (jsonp != urlArgs.end()) {
|
|
if (responseBody.length() > 0)
|
|
responseBody = jsonp->second + "(" + responseBody + ");";
|
|
else responseBody = jsonp->second + "(null);";
|
|
responseContentType = "application/javascript";
|
|
}
|
|
|
|
return scode;
|
|
}
|
|
|
|
} // namespace ZeroTier
|