ExternalVendorCode/ZeroTierOne
1
0
Fork 0
mirror of https://github.com/zerotier/ZeroTierOne.git synced 2024-12-23 23:02:23 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
e1fbf7b34c
ZeroTierOne/cli/zerotier.cpp
Adam Ierymenko 7762cd680b fix json include path in cli
2016-08-12 11:30:50 -07:00

958 lines
34 KiB
C++
Raw Blame History

/*
* 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/>.
*/
// Note: unlike the rest of ZT's code base, this requires C++11 due to
// the JSON library it uses and other things.
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include "../node/Constants.hpp"
#include "../node/Identity.hpp"
#include "../version.h"
#include "../osdep/OSUtils.hpp"
#include "../ext/offbase/json/json.hpp"
#ifdef __WINDOWS__
#include <WinSock2.h>
#include <windows.h>
#include <tchar.h>
#include <wchar.h>
#else
#include <ctype.h>
#include <unistd.h>
#endif
#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <tuple>
#include <regex>
#include <curl/curl.h>
using json = nlohmann::json;
using namespace ZeroTier;
#define ZT_CLI_FLAG_VERBOSE 'v'
#define ZT_CLI_FLAG_UNSAFE_SSL 'X'
#define REQ_GET 0
#define REQ_POST 1
#define REQ_DEL 2
#define OK_STR "[OK ]: "
#define FAIL_STR "[FAIL]: "
#define WARN_STR "[WARN]: "
#define INVALID_ARGS_STR "Invalid args. Usage: "
struct CLIState
{
std::string atname;
std::string command;
std::string url;
std::map<std::string,std::string> reqHeaders;
std::vector<std::string> args;
std::map<char,std::string> opts;
json settings;
};
namespace {
static Identity getIdFromArg(char *arg)
{
Identity id;
if ((strlen(arg) > 32)&&(arg[10] == ':')) { // identity is a literal on the command line
if (id.fromString(arg))
return id;
} else { // identity is to be read from a file
std::string idser;
if (OSUtils::readFile(arg,idser)) {
if (id.fromString(idser))
return id;
}
}
return Identity();
}
static std::string trimString(const std::string &s)
{
unsigned long end = (unsigned long)s.length();
while (end) {
char c = s[end - 1];
if ((c == ' ')||(c == '\r')||(c == '\n')||(!c)||(c == '\t'))
--end;
else break;
}
unsigned long start = 0;
while (start < end) {
char c = s[start];
if ((c == ' ')||(c == '\r')||(c == '\n')||(!c)||(c == '\t'))
++start;
else break;
}
return s.substr(start,end - start);
}
static inline std::string getSettingsFilePath()
{
#ifdef __WINDOWS__
#else
const char *home = getenv("HOME");
if (!home)
home = "/";
return (std::string(home) + "/.zerotierCliSettings");
#endif
}
static bool saveSettingsBackup(CLIState &state)
{
std::string sfp(getSettingsFilePath().c_str());
if(state.settings.find("generateBackupConfig") != state.settings.end()
&& state.settings["generateBackupConfig"].get<std::string>() == "true") {
std::string backup_file = getSettingsFilePath() + ".bak";
if(!OSUtils::writeFile(sfp.c_str(), state.settings.dump(2))) {
OSUtils::lockDownFile(sfp.c_str(),false);
std::cout << WARN_STR << "unable to write backup config file" << std::endl;
return false;
}
return true;
}
return false;
}
static bool saveSettings(CLIState &state)
{
std::string sfp(getSettingsFilePath().c_str());
if(OSUtils::writeFile(sfp.c_str(), state.settings.dump(2))) {
OSUtils::lockDownFile(sfp.c_str(),false);
std::cout << OK_STR << "changes saved." << std::endl;
return true;
}
std::cout << FAIL_STR << "unable to write to " << sfp << std::endl;
return false;
}
static void dumpHelp()
{
std::cout << "ZeroTier Newer-Spiffier CLI " << ZEROTIER_ONE_VERSION_MAJOR << "." << ZEROTIER_ONE_VERSION_MINOR << "." << ZEROTIER_ONE_VERSION_REVISION << std::endl;
std::cout << "(c)2016 ZeroTier, Inc. / Licensed under the GNU GPL v3" << std::endl;
std::cout << std::endl;
std::cout << "Configuration path: " << getSettingsFilePath() << std::endl;
std::cout << std::endl;
std::cout << "Usage: zerotier [-option] [@name] <command> [<command options>]" << std::endl;
std::cout << std::endl;
std::cout << "Options:" << std::endl;
std::cout << " -verbose - Verbose JSON output" << std::endl;
std::cout << " -X - Do not check SSL certs (CAUTION!)" << std::endl;
std::cout << std::endl;
std::cout << "CLI Configuration Commands:" << std::endl;
std::cout << " cli-set <setting> <value> - Set a CLI option ('cli-set help')" << std::endl;
std::cout << " cli-unset <setting> <value> - Un-sets a CLI option ('cli-unset help')" << std::endl;
std::cout << " cli-ls - List configured @things" << std::endl;
std::cout << " cli-rm @name - Remove a configured @thing" << std::endl;
std::cout << " cli-add-zt @name <url> <auth> - Add a ZeroTier service" << std::endl;
std::cout << " cli-add-central @name <url> <auth> - Add ZeroTier Central instance" << std::endl;
std::cout << std::endl;
std::cout << "ZeroTier One Service Commands:" << std::endl;
std::cout << " -v / -version - Displays default local instance's version'" << std::endl;
std::cout << " ls - List currently joined networks" << std::endl;
std::cout << " join <network> [opt=value ...] - Join a network" << std::endl;
std::cout << " leave <network> - Leave a network" << std::endl;
std::cout << " peers - List ZeroTier VL1 peers" << std::endl;
std::cout << " show [<network/peer address>] - Get info about self or object" << std::endl;
std::cout << std::endl;
std::cout << "Network Controller Commands:" << std::endl;
std::cout << " net-create - Create a new network" << std::endl;
std::cout << " net-rm <network> - Delete a network (CAUTION!)" << std::endl;
std::cout << " net-ls - List administered networks" << std::endl;
std::cout << " net-members <network> - List members of a network" << std::endl;
std::cout << " net-show <network> [<address>] - Get network or member info" << std::endl;
std::cout << " net-auth <network> <address> - Authorize a member" << std::endl;
std::cout << " net-unauth <network> <address> - De-authorize a member" << std::endl;
std::cout << " net-set <path> <value> - See 'net-set help'" << std::endl;
std::cout << std::endl;
std::cout << "Identity Commands:" << std::endl;
std::cout << " id-generate [<vanity prefix>] - Generate a ZeroTier identity" << std::endl;
std::cout << " id-validate <identity> - Locally validate an identity" << std::endl;
std::cout << " id-sign <identity> <file> - Sign a file" << std::endl;
std::cout << " id-verify <secret> <file> <sig> - Verify a file's signature" << std::endl;
std::cout << " id-getpublic <secret> - Get full identity's public portion" << std::endl;
std::cout << std::endl;
}
static size_t _curlStringAppendCallback(void *contents,size_t size,size_t nmemb,void *stdstring)
{
size_t totalSize = size * nmemb;
reinterpret_cast<std::string *>(stdstring)->append((const char *)contents,totalSize);
return totalSize;
}
static std::tuple<int,std::string> REQUEST(int requestType, CLIState &state, const std::map<std::string,std::string> &headers, const std::string &postfield, const std::string &url)
{
std::string body;
char errbuf[CURL_ERROR_SIZE];
char urlbuf[4096];
CURL *curl;
curl = curl_easy_init();
if (!curl) {
std::cerr << "FATAL: curl_easy_init() failed" << std::endl;
exit(-1);
}
Utils::scopy(urlbuf,sizeof(urlbuf),url.c_str());
curl_easy_setopt(curl,CURLOPT_URL,urlbuf);
struct curl_slist *hdrs = (struct curl_slist *)0;
for(std::map<std::string,std::string>::const_iterator i(headers.begin());i!=headers.end();++i) {
std::string htmp(i->first);
htmp.append(": ");
htmp.append(i->second);
hdrs = curl_slist_append(hdrs,htmp.c_str());
}
if (hdrs)
curl_easy_setopt(curl,CURLOPT_HTTPHEADER,hdrs);
//curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
curl_easy_setopt(curl,CURLOPT_WRITEDATA,(void *)&body);
curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,_curlStringAppendCallback);
if(std::find(state.args.begin(), state.args.end(), "-X") == state.args.end())
curl_easy_setopt(curl,CURLOPT_SSL_VERIFYPEER,(state.opts.count(ZT_CLI_FLAG_UNSAFE_SSL) > 0) ? 0L : 1L);
if(requestType == REQ_POST) {
curl_easy_setopt(curl, CURLOPT_POST, 1);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postfield.c_str());
}
if(requestType == REQ_DEL)
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
if(requestType == REQ_GET) {
curl_easy_setopt(curl,CURLOPT_ERRORBUFFER,errbuf);
curl_easy_setopt(curl,CURLOPT_FOLLOWLOCATION,0L);
}
curl_easy_setopt(curl,CURLOPT_USERAGENT,"ZeroTier-CLI");
CURLcode res = curl_easy_perform(curl);
errbuf[CURL_ERROR_SIZE-1] = (char)0; // sanity check
if (res != CURLE_OK)
return std::make_tuple(-1,std::string(errbuf));
long response_code;
int rc = (int)curl_easy_getinfo(curl,CURLINFO_RESPONSE_CODE, &response_code);
if(response_code == 401) { std::cout << FAIL_STR << response_code << "Unauthorized." << std::endl; exit(0); }
else if(response_code == 403) { std::cout << FAIL_STR << response_code << "Forbidden." << std::endl; exit(0); }
else if(response_code == 404) { std::cout << FAIL_STR << response_code << "Not found." << std::endl; exit(0); }
else if(response_code == 408) { std::cout << FAIL_STR << response_code << "Request timed out." << std::endl; exit(0); }
else if(response_code != 200) { std::cout << FAIL_STR << response_code << "Unable to process request." << std::endl; exit(0); }
curl_easy_cleanup(curl);
if (hdrs)
curl_slist_free_all(hdrs);
return std::make_tuple(response_code,body);
}
} // anonymous namespace
//////////////////////////////////////////////////////////////////////////////
// Check for user-specified @thing config
// Make sure it @thing makes sense
// Apply appropriate request headers
static void checkForThing(CLIState &state, std::string thingType, bool warnNoThingProvided)
{
std::string configName;
if(state.atname.length()) {
configName = state.atname.erase(0,1);
// make sure specified @thing makes sense in the context of the command
if(thingType == "one" && state.settings["things"][configName]["type"].get<std::string>() != "one") {
std::cout << FAIL_STR << "A ZeroTier Central config was specified for a ZeroTier One command." << std::endl;
exit(0);
}
if(thingType == "central" && state.settings["things"][configName]["type"].get<std::string>() != "central") {
std::cout << FAIL_STR << "A ZeroTier One config was specified for a ZeroTier Central command." << std::endl;
exit(0);
}
}
else { // no @thing specified, check for defaults depending on type
if(thingType == "one") {
if(state.settings.find("defaultOne") != state.settings.end()) {
if(warnNoThingProvided)
std::cout << WARN_STR << "No @thing specified, assuming default for ZeroTier One command: " << state.settings["defaultOne"].get<std::string>().c_str() << std::endl;
configName = state.settings["defaultOne"].get<std::string>().erase(0,1); // get default
}
else {
std::cout << WARN_STR << "No @thing specified, and no default is known." << std::endl;
std::cout << "HELP: To set a default: zerotier cli-set defaultOne @my_default_thing" << std::endl;
exit(0);
}
}
if(thingType == "central") {
if(state.settings.find("defaultCentral") != state.settings.end()) {
if(warnNoThingProvided)
std::cout << WARN_STR << "No @thing specified, assuming default for ZeroTier Central command: " << state.settings["defaultCentral"].get<std::string>().c_str() << std::endl;
configName = state.settings["defaultCentral"].get<std::string>().erase(0,1); // get default
}
else {
std::cout << WARN_STR << "No @thing specified, and no default is known." << std::endl;
std::cout << "HELP: To set a default: zerotier cli-set defaultCentral @my_default_thing" << std::endl;
exit(0);
}
}
}
// Apply headers
if(thingType == "one") {
state.reqHeaders["X-ZT1-Auth"] = state.settings["things"][configName]["auth"];
}
if(thingType == "central"){
state.reqHeaders["Content-Type"] = "application/json";
state.reqHeaders["Authorization"] = "Bearer " + state.settings["things"][configName]["auth"].get<std::string>();
state.reqHeaders["Accept"] = "application/json";
}
state.url = state.settings["things"][configName]["url"];
}
static bool checkURL(std::string url)
{
// TODO
return true;
}
static std::string getLocalVersion(CLIState &state)
{
json result;
std::tuple<int,std::string> res;
checkForThing(state,"one",false);
res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "/status");
if(std::get<0>(res) == 200) {
result = json::parse(std::get<1>(res));
return result["version"].get<std::string>();
}
return "---";
}
#ifdef __WINDOWS__
int _tmain(int argc, _TCHAR* argv[])
#else
int main(int argc,char **argv)
#endif
{
#ifdef __WINDOWS__
{
WSADATA wsaData;
WSAStartup(MAKEWORD(2,2),&wsaData);
}
#endif
curl_global_init(CURL_GLOBAL_DEFAULT);
CLIState state;
std::string arg1, arg2, authToken;
for(int i=1;i<argc;++i) {
if (argv[i][0] == '@') {
state.atname = argv[i];
}
else if (state.command.length() == 0) {
if (argv[i][0] == '-') {
if (!argv[i][1]) {
dumpHelp();
return -1;
} else if (argv[i][2]) {
state.opts[argv[i][1]] = argv[i] + 2;
} else {
state.opts[argv[i][1]] = "";
}
} else {
state.command = argv[i];
}
}
else {
state.args.push_back(std::string(argv[i]));
}
}
{
std::string buf;
if (OSUtils::readFile(getSettingsFilePath().c_str(),buf))
state.settings = json::parse(buf);
if (state.settings.empty()) {
// Default settings
state.settings = {
{ "configVersion", 1 },
{ "things", {
{ "my.zerotier.com", {
{ "type", "central" },
{ "url", "https://my.zerotier.com/" },
{ "auth", "" }
}},
{ "local", {
{ "type", "one" },
{ "url", "" },
{ "auth", "" }
}}
}},
{ "defaultController", "@my.zerotier.com" },
{ "defaultOne", "@local" }
};
std::string oneHome(OSUtils::platformDefaultHomePath());
std::string portStr;
bool initSuccess = false;
std::string path = oneHome + ZT_PATH_SEPARATOR_S ;
if (OSUtils::readFile((oneHome + ZT_PATH_SEPARATOR_S + "authtoken.secret").c_str(),authToken)&&OSUtils::readFile((oneHome + ZT_PATH_SEPARATOR_S + "zerotier-one.port").c_str(),portStr)) {
portStr = trimString(portStr);
authToken = trimString(authToken);
int port = Utils::strToInt(portStr.c_str());
if (((port > 0)&&(port < 65536))&&(authToken.length() > 0)) {
state.settings["things"]["local"]["url"] = (std::string("http://127.0.0.1:") + portStr + "/");
state.settings["things"]["local"]["auth"] = authToken;
initSuccess = true;
}
}
if (!saveSettings(state)) {
std::cerr << "FATAL: unable to write " << getSettingsFilePath() << std::endl;
exit(-1);
}
if (initSuccess) {
std::cerr << "INFO: initialized new config at " << getSettingsFilePath() << std::endl;
} else {
std::cerr << "INFO: initialized new config at " << getSettingsFilePath() << " but could not auto-init local ZeroTier One service config from " << oneHome << " -- you will need to set local service URL and port manually if you want to control a local instance of ZeroTier One. (This happens if you are not root/administrator.)" << std::endl;
}
}
}
// PRE-REQUEST SETUP
json result;
std::tuple<int,std::string> res;
std::string url = "";
// META
if ((state.command.length() == 0)||(state.command == "help")) {
dumpHelp();
return -1;
}
// zerotier version
else if (state.command == "v" || state.command == "version") {
std::cout << getLocalVersion(state) << std::endl;
return 1;
}
// zerotier cli-set <setting> <value>
else if (state.command == "cli-set") {
if(argc != 4) {
std::cerr << INVALID_ARGS_STR << "zerotier cli-set <setting> <value>" << std::endl;
return 1;
}
std::string settingName, settingValue;
if(state.atname.length()) { // User provided @thing erroneously, we will ignore it and adjust argument indices
settingName = argv[3];
settingValue = argv[4];
}
else {
settingName = argv[2];
settingValue = argv[3];
}
saveSettingsBackup(state);
state.settings[settingName] = settingValue; // changes
saveSettings(state);
}
// zerotier cli-unset <setting>
else if (state.command == "cli-unset") {
if(argc != 3) {
std::cerr << INVALID_ARGS_STR << "zerotier cli-unset <setting>" << std::endl;
return 1;
}
std::string settingName;
if(state.atname.length()) // User provided @thing erroneously, we will ignore it and adjust argument indices
settingName = argv[3];
else
settingName = argv[2];
saveSettingsBackup(state);
state.settings.erase(settingName); // changes
saveSettings(state);
}
// zerotier @thing_to_remove cli-rm --- removes the configuration
else if (state.command == "cli-rm") {
if(argc != 3) {
std::cerr << INVALID_ARGS_STR << "zerotier cli-rm <@thing>" << std::endl;
return 1;
}
if(state.settings["things"].find(state.atname) != state.settings["things"].end()) {
if(state.settings["defaultOne"] == state.atname) {
std::cout << "WARNING: The config you're trying to remove is currently set as your default. Set a new default first!" << std::endl;
std::cout << " | Usage: zerotier set defaultOne @your_other_thing" << std::endl;
}
else {
state.settings["things"].erase(state.atname.c_str());
saveSettings(state);
}
}
}
// zerotier cli-add-zt <shortname> <url> <auth>
// TODO: Check for malformed urls/auth
else if (state.command == "cli-add-zt") {
if(argc != 5) {
std::cerr << INVALID_ARGS_STR << "zerotier cli-add-zt <shortname> <url> <authToken>" << std::endl;
return 1;
}
std::string thing_name = argv[2], url = argv[3], auth = argv[4];
if(!checkURL(url)) {
std::cout << FAIL_STR << "Malformed URL" << std::endl;
return 1;
}
if(state.settings.find(thing_name) != state.settings.end()) {
std::cout << "WARNING: A @thing with the shortname " << thing_name.c_str()
<< " already exists. Choose another name or rename the old @thing" << std::endl;
std::cout << " | Usage: To rename a @thing: zerotier cli-rename @old_thing_name @new_thing_name" << std::endl;
}
else {
result = json::parse("{ \"auth\": \"" + auth + "\", \"type\": \"" + "one" + "\", \"url\": \"" + url + "\" }");
saveSettingsBackup(state);
// TODO: Handle cases where user may or may not prepend an @
state.settings["things"][thing_name] = result; // changes
saveSettings(state);
}
}
// zerotier cli-add-central <shortname> <url> <auth>
// TODO: Check for malformed urls/auth
else if (state.command == "cli-add-central") {
if(argc != 5) {
std::cerr << INVALID_ARGS_STR << "zerotier cli-add-central <shortname> <url> <authToken>" << std::endl;
return 1;
}
std::string thing_name = argv[2], url = argv[3], auth = argv[4];
if(!checkURL(url)) {
std::cout << FAIL_STR << "Malformed URL" << std::endl;
return 1;
}
if(state.settings.find(thing_name) != state.settings.end()) {
std::cout << "WARNING: A @thing with the shortname " << thing_name.c_str()
<< " already exists. Choose another name or rename the old @thing" << std::endl;
std::cout << " | Usage: To rename a @thing: zerotier cli-rename @old_thing_name @new_thing_name" << std::endl;
}
else {
result = json::parse("{ \"auth\": \"" + auth + "\", \"type\": \"" + "central" + "\", \"url\": \"" + url + "\" }");
saveSettingsBackup(state);
// TODO: Handle cases where user may or may not prepend an @
state.settings["things"]["@" + thing_name] = result; // changes
saveSettings(state);
}
}
// ONE SERVICE
// zerotier ls --- display all networks currently joined
else if (state.command == "ls" || state.command == "listnetworks") {
if(argc != 2) {
std::cerr << INVALID_ARGS_STR << "zerotier ls" << std::endl;
return 1;
}
checkForThing(state,"one",true);
url = state.url + "network";
res = REQUEST(REQ_GET,state,state.reqHeaders,"",(const std::string)url);
if(std::get<0>(res) == 200) {
std::cout << "listnetworks <nwid> <name> <mac> <status> <type> <dev> <ZT assigned ips>" << std::endl;
auto j = json::parse(std::get<1>(res).c_str());
if (j.type() == json::value_t::array) {
for(int i=0;i<j.size();i++){
std::string nwid = j[i]["nwid"].get<std::string>();
std::string name = j[i]["name"].get<std::string>();
std::string mac = j[i]["mac"].get<std::string>();
std::string status = j[i]["status"].get<std::string>();
std::string type = j[i]["type"].get<std::string>();
std::string addrs;
for(int m=0; m<j[i]["assignedAddresses"].size(); m++) {
addrs += j[i]["assignedAddresses"][m].get<std::string>() + " ";
}
std::string dev = j[i]["portDeviceName"].get<std::string>();
std::cout << "listnetworks " << nwid << " " << name << " " << mac << " " << status << " " << type << " " << dev << " " << addrs << std::endl;
}
}
}
}
// zerotier join <nwid> --- joins a network
else if (state.command == "join") {
if(argc != 3) {
std::cerr << INVALID_ARGS_STR << "zerotier join <nwid>" << std::endl;
return 1;
}
checkForThing(state,"one",true);
res = REQUEST(REQ_POST,state,state.reqHeaders,"{}",state.url + "/network/" + state.args[0]);
if(std::get<0>(res) == 200) {
std::cout << OK_STR << "connected to " << state.args[0] << std::endl;
}
}
// zerotier leave <nwid> --- leaves a network
else if (state.command == "leave") {
if(argc != 3) {
std::cerr << INVALID_ARGS_STR << "zerotier leave <nwid>" << std::endl;
return 1;
}
checkForThing(state,"one",true);
res = REQUEST(REQ_DEL,state,state.reqHeaders,"{}",state.url + "/network/" + state.args[0]);
if(std::get<0>(res) == 200) {
std::cout << OK_STR << "disconnected from " << state.args[0] << std::endl;
}
}
// zerotier peers --- display address and role of all peers
else if (state.command == "peers") {
if(argc != 2) {
std::cerr << INVALID_ARGS_STR << "zerotier peers" << std::endl;
return 1;
}
checkForThing(state,"one",true);
res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "/peer");
if(std::get<0>(res) == 200) {
json result = json::parse(std::get<1>(res));
for(int i=0; i<result.size(); i++) {
std::cout << result[i]["address"] << " " << result[i]["role"] << std::endl;
}
}
}
// zerotier show --- display status of local instance
else if (state.command == "show" || state.command == "status") {
if(argc != 2) {
std::cerr << INVALID_ARGS_STR << "zerotier show" << std::endl;
return 1;
}
checkForThing(state,"one",true);
res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "/status");
if(std::get<0>(res) == 200) {
result = json::parse(std::get<1>(res));
std::string status_str = result["online"].get<bool>() ? "ONLINE" : "OFFLINE";
std::cout << "info " << result["address"].get<std::string>()
<< " " << status_str << " " << result["version"].get<std::string>() << std::endl;
}
}
// REMOTE
// zerotier @thing net-create --- creates a new network
else if (state.command == "net-create") {
if(argc > 3 || (argc == 3 && !state.atname.length())) {
std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-create" << std::endl;
return 1;
}
checkForThing(state,"central",true);
res = REQUEST(REQ_POST,state,state.reqHeaders,"",state.url + "api/network");
if(std::get<0>(res) == 200) {
json result = json::parse(std::get<1>(res));
std::cout << OK_STR << "created network " << result["config"]["nwid"].get<std::string>() << std::endl;
}
}
// zerotier @thing net-rm <nwid> --- deletes a network
else if (state.command == "net-rm") {
if(argc > 4 || (argc == 4 && !state.atname.length())) {
std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-rm <nwid>" << std::endl;
return 1;
}
checkForThing(state,"central",true);
if(!state.args.size()) {
std::cout << "Argument error: No network specified." << std::endl;
std::cout << " | Usage: zerotier net-rm <nwid>" << std::endl;
}
else {
std::string nwid = state.args[0];
res = REQUEST(REQ_DEL,state,state.reqHeaders,"",state.url + "api/network/" + nwid);
if(std::get<0>(res) == 200) {
std::cout << "deleted network " << nwid << std::endl;
}
}
}
// zerotier @thing net-ls --- lists all networks
else if (state.command == "net-ls") {
if(argc > 3 || (argc == 3 && !state.atname.length())) {
std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-ls" << std::endl;
return 1;
}
checkForThing(state,"central",true);
res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "api/network");
if(std::get<0>(res) == 200) {
json result = json::parse(std::get<1>(res));
for(int m=0;m<result.size(); m++) {
std::cout << "network " << result[m]["id"].get<std::string>() << std::endl;
}
}
}
// zerotier @thing net-members <nwid> --- show all members of a network
else if (state.command == "net-members") {
if(argc > 4 || (argc == 4 && !state.atname.length())) {
std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-members <nwid>" << std::endl;
return 1;
}
checkForThing(state,"central",true);
if(!state.args.size()) {
std::cout << FAIL_STR << "Argument error: No network specified." << std::endl;
std::cout << " | Usage: zerotier net-members <nwid>" << std::endl;
}
else {
std::string nwid = state.args[0];
res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "api/network/" + nwid + "/member");
json result = json::parse(std::get<1>(res));
std::cout << "Members of " << nwid << ":" << std::endl;
for (json::iterator it = result.begin(); it != result.end(); ++it) {
std::cout << it.key() << std::endl;
}
}
}
// zerotier @thing net-show <nwid> <devID> --- show info about a device on a specific network
else if (state.command == "net-show") {
if(argc > 5 || (argc == 5 && !state.atname.length())) {
std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-show <nwid> <devID>" << std::endl;
return 1;
}
checkForThing(state,"central",true);
if(state.args.size() < 2) {
std::cout << FAIL_STR << "Argument error: Too few arguments." << std::endl;
std::cout << " | Usage: zerotier net-show <nwid> <devID>" << std::endl;
}
else {
std::string nwid = state.args[0];
std::string devid = state.args[1];
res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "api/network/" + nwid + "/member/" + devid);
// TODO: More info, what would we like to show exactly?
if(std::get<0>(res) == 200) {
json result = json::parse(std::get<1>(res));
std::cout << "Assigned IP: " << std::endl;
for(int m=0; m<result["config"]["ipAssignments"].size();m++) {
std::cout << "\t" << result["config"]["ipAssignments"][m].get<std::string>() << std::endl;
}
}
}
}
// zerotier @thing net-auth <nwid> <devID> --- authorize a device on a network
else if (state.command == "net-auth") {
if(argc > 5 || (argc == 5 && !state.atname.length())) {
std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-auth <nwid> <devID>" << std::endl;
return 1;
}
checkForThing(state,"central",true);
if(state.args.size() != 2) {
std::cout << FAIL_STR << "Argument error: Network and/or device ID not specified." << std::endl;
std::cout << " | Usage: zerotier net-auth <nwid> <devID>" << std::endl;
}
std::string nwid = state.args[0];
std::string devid = state.args[1];
url = state.url + "api/network/" + nwid + "/member/" + devid;
// Add device to network
res = REQUEST(REQ_POST,state,state.reqHeaders,"",(const std::string)url);
if(std::get<0>(res) == 200) {
result = json::parse(std::get<1>(res));
res = REQUEST(REQ_GET,state,state.reqHeaders,"",(const std::string)url);
result = json::parse(std::get<1>(res));
result["config"]["authorized"] = "true";
std::string newconfig = result.dump();
res = REQUEST(REQ_POST,state,state.reqHeaders,newconfig,(const std::string)url);
if(std::get<0>(res) == 200)
std::cout << OK_STR << devid << " authorized on " << nwid << std::endl;
else
std::cout << FAIL_STR << "There was a problem authorizing that device." << std::endl;
}
}
// zerotier @thing net-unauth <nwid> <devID>
else if (state.command == "net-unauth") {
if(argc > 5 || (argc == 5 && !state.atname.length())) {
std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-unauth <nwid> <devID>" << std::endl;
return 1;
}
checkForThing(state,"central",true);
if(state.args.size() != 2) {
std::cout << FAIL_STR << "Bad argument. No network and/or device ID specified." << std::endl;
std::cout << " | Usage: zerotier net-unauth <nwid> <devID>" << std::endl;
}
std::string nwid = state.args[0];
std::string devid = state.args[1];
// If successful, get member config
res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "api/network/" + nwid + "/member/" + devid);
result = json::parse(std::get<1>(res));
// modify auth field and re-POST
result["config"]["authorized"] = "false";
std::string newconfig = result.dump();
res = REQUEST(REQ_POST,state,state.reqHeaders,newconfig,state.url + "api/network/" + nwid + "/member/" + devid);
if(std::get<0>(res) == 200)
std::cout << OK_STR << devid << " de-authorized from " << nwid << std::endl;
else
std::cout << FAIL_STR << "There was a problem de-authorizing that device." << std::endl;
}
// zerotier @thing net-set
else if (state.command == "net-set") {
}
// ID
// zerotier id-generate [<vanity prefix>]
else if (state.command == "id-generate") {
if(argc != 3) {
std::cerr << INVALID_ARGS_STR << "zerotier id-generate [<vanity prefix>]" << std::endl;
return 1;
}
uint64_t vanity = 0;
int vanityBits = 0;
if (argc >= 5) {
vanity = Utils::hexStrToU64(argv[4]) & 0xffffffffffULL;
vanityBits = 4 * strlen(argv[4]);
if (vanityBits > 40)
vanityBits = 40;
}
ZeroTier::Identity id;
for(;;) {
id.generate();
if ((id.address().toInt() >> (40 - vanityBits)) == vanity) {
if (vanityBits > 0) {
fprintf(stderr,"vanity address: found %.10llx !\n",(unsigned long long)id.address().toInt());
}
break;
} else {
fprintf(stderr,"vanity address: tried %.10llx looking for first %d bits of %.10llx\n",(unsigned long long)id.address().toInt(),vanityBits,(unsigned long long)(vanity << (40 - vanityBits)));
}
}
std::string idser = id.toString(true);
if (argc >= 3) {
if (!OSUtils::writeFile(argv[2],idser)) {
std::cerr << "Error writing to " << argv[2] << std::endl;
return 1;
} else std::cout << argv[2] << " written" << std::endl;
if (argc >= 4) {
idser = id.toString(false);
if (!OSUtils::writeFile(argv[3],idser)) {
std::cerr << "Error writing to " << argv[3] << std::endl;
return 1;
} else std::cout << argv[3] << " written" << std::endl;
}
} else std::cout << idser << std::endl;
}
// zerotier id-validate <identity>
else if (state.command == "id-validate") {
if(argc != 3) {
std::cerr << INVALID_ARGS_STR << "zerotier id-validate <identity>" << std::endl;
return 1;
}
Identity id = getIdFromArg(argv[2]);
if (!id) {
std::cerr << "Identity argument invalid or file unreadable: " << argv[2] << std::endl;
return 1;
}
if (!id.locallyValidate()) {
std::cerr << argv[2] << " FAILED validation." << std::endl;
return 1;
} else std::cout << argv[2] << "is a valid identity" << std::endl;
}
// zerotier id-sign <identity> <file>
else if (state.command == "id-sign") {
if(argc != 4) {
std::cerr << INVALID_ARGS_STR << "zerotier id-sign <identity> <file>" << std::endl;
return 1;
}
Identity id = getIdFromArg(argv[2]);
if (!id) {
std::cerr << "Identity argument invalid or file unreadable: " << argv[2] << std::endl;
return 1;
}
if (!id.hasPrivate()) {
std::cerr << argv[2] << " does not contain a private key (must use private to sign)" << std::endl;
return 1;
}
std::string inf;
if (!OSUtils::readFile(argv[3],inf)) {
std::cerr << argv[3] << " is not readable" << std::endl;
return 1;
}
C25519::Signature signature = id.sign(inf.data(),(unsigned int)inf.length());
std::cout << Utils::hex(signature.data,(unsigned int)signature.size()) << std::endl;
}
// zerotier id-verify <secret> <file> <sig>
else if (state.command == "id-verify") {
if(argc != 4) {
std::cerr << INVALID_ARGS_STR << "zerotier id-verify <secret> <file> <sig>" << std::endl;
return 1;
}
Identity id = getIdFromArg(argv[2]);
if (!id) {
std::cerr << "Identity argument invalid or file unreadable: " << argv[2] << std::endl;
return 1;
}
std::string inf;
if (!OSUtils::readFile(argv[3],inf)) {
std::cerr << argv[3] << " is not readable" << std::endl;
return 1;
}
std::string signature(Utils::unhex(argv[4]));
if ((signature.length() > ZT_ADDRESS_LENGTH)&&(id.verify(inf.data(),(unsigned int)inf.length(),signature.data(),(unsigned int)signature.length()))) {
std::cout << argv[3] << " signature valid" << std::endl;
} else {
std::cerr << argv[3] << " signature check FAILED" << std::endl;
return 1;
}
}
// zerotier id-getpublic <secret>
else if (state.command == "id-getpublic") {
if(argc != 3) {
std::cerr << INVALID_ARGS_STR << "zerotier id-getpublic <secret>" << std::endl;
return 1;
}
Identity id = getIdFromArg(argv[2]);
if (!id) {
std::cerr << "Identity argument invalid or file unreadable: " << argv[2] << std::endl;
return 1;
}
std::cerr << id.toString(false) << std::endl;
}
//
else {
dumpHelp();
return -1;
}
if(std::find(state.args.begin(), state.args.end(), "-verbose") != state.args.end())
std::cout << "\n\nAPI response = " << std::get<1>(res) << std::endl;
curl_global_cleanup();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink