SqliteNetworkController.cpp 62 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323
  1. /*
  2. * ZeroTier One - Network Virtualization Everywhere
  3. * Copyright (C) 2011-2015 ZeroTier, Inc.
  4. *
  5. * This program is free software: you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation, either version 3 of the License, or
  8. * (at your option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17. *
  18. * --
  19. *
  20. * ZeroTier may be used and distributed under the terms of the GPLv3, which
  21. * are available at: http://www.gnu.org/licenses/gpl-3.0.html
  22. *
  23. * If you would like to embed ZeroTier into a commercial application or
  24. * redistribute it in a modified binary form, please contact ZeroTier Networks
  25. * LLC. Start here: http://www.zerotier.com/
  26. */
  27. #include <stdint.h>
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30. #include <string.h>
  31. #include <time.h>
  32. #include <sys/time.h>
  33. #include <sys/types.h>
  34. #include <algorithm>
  35. #include <utility>
  36. #include <stdexcept>
  37. #include <set>
  38. #include "../include/ZeroTierOne.h"
  39. #include "../node/Constants.hpp"
  40. #include "../ext/json-parser/json.h"
  41. #include "SqliteNetworkController.hpp"
  42. #include "../node/Utils.hpp"
  43. #include "../node/CertificateOfMembership.hpp"
  44. #include "../node/NetworkConfig.hpp"
  45. #include "../node/InetAddress.hpp"
  46. #include "../node/MAC.hpp"
  47. #include "../node/Address.hpp"
  48. #include "../osdep/OSUtils.hpp"
  49. // Include ZT_NETCONF_SCHEMA_SQL constant to init database
  50. #include "schema.sql.c"
  51. // Stored in database as schemaVersion key in Config.
  52. // If not present, database is assumed to be empty and at the current schema version
  53. // and this key/value is added automatically.
  54. #define ZT_NETCONF_SQLITE_SCHEMA_VERSION 1
  55. #define ZT_NETCONF_SQLITE_SCHEMA_VERSION_STR "1"
  56. // API version reported via JSON control plane
  57. #define ZT_NETCONF_CONTROLLER_API_VERSION 1
  58. namespace ZeroTier {
  59. namespace {
  60. static std::string _jsonEscape(const char *s)
  61. {
  62. if (!s)
  63. return std::string();
  64. std::string buf;
  65. for(const char *p=s;(*p);++p) {
  66. switch(*p) {
  67. case '\t': buf.append("\\t"); break;
  68. case '\b': buf.append("\\b"); break;
  69. case '\r': buf.append("\\r"); break;
  70. case '\n': buf.append("\\n"); break;
  71. case '\f': buf.append("\\f"); break;
  72. case '"': buf.append("\\\""); break;
  73. case '\\': buf.append("\\\\"); break;
  74. case '/': buf.append("\\/"); break;
  75. default: buf.push_back(*p); break;
  76. }
  77. }
  78. return buf;
  79. }
  80. static std::string _jsonEscape(const std::string &s) { return _jsonEscape(s.c_str()); }
  81. struct MemberRecord {
  82. int64_t rowid;
  83. char nodeId[16];
  84. bool authorized;
  85. bool activeBridge;
  86. };
  87. struct NetworkRecord {
  88. char id[24];
  89. const char *name;
  90. const char *v4AssignMode;
  91. const char *v6AssignMode;
  92. bool isPrivate;
  93. bool enableBroadcast;
  94. bool allowPassiveBridging;
  95. int multicastLimit;
  96. uint64_t creationTime;
  97. uint64_t revision;
  98. };
  99. } // anonymous namespace
  100. SqliteNetworkController::SqliteNetworkController(const char *dbPath) :
  101. _dbPath(dbPath),
  102. _db((sqlite3 *)0)
  103. {
  104. if (sqlite3_open_v2(dbPath,&_db,SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE,(const char *)0) != SQLITE_OK)
  105. throw std::runtime_error("SqliteNetworkController cannot open database file");
  106. sqlite3_busy_timeout(_db,10000);
  107. sqlite3_stmt *s = (sqlite3_stmt *)0;
  108. if ((sqlite3_prepare_v2(_db,"SELECT v FROM Config WHERE k = 'schemaVersion';",-1,&s,(const char **)0) == SQLITE_OK)&&(s)) {
  109. int schemaVersion = -1234;
  110. if (sqlite3_step(s) == SQLITE_ROW) {
  111. schemaVersion = sqlite3_column_int(s,0);
  112. }
  113. sqlite3_finalize(s);
  114. if (schemaVersion == -1234) {
  115. sqlite3_close(_db);
  116. throw std::runtime_error("SqliteNetworkController schemaVersion not found in Config table (init failure?)");
  117. } else if (schemaVersion != ZT_NETCONF_SQLITE_SCHEMA_VERSION) {
  118. // Note -- this will eventually run auto-upgrades so this isn't how it'll work going forward
  119. sqlite3_close(_db);
  120. throw std::runtime_error("SqliteNetworkController database schema version mismatch");
  121. }
  122. } else {
  123. // Prepare statement will fail if Config table doesn't exist, which means our DB
  124. // needs to be initialized.
  125. if (sqlite3_exec(_db,ZT_NETCONF_SCHEMA_SQL"INSERT INTO Config (k,v) VALUES ('schemaVersion',"ZT_NETCONF_SQLITE_SCHEMA_VERSION_STR");",0,0,0) != SQLITE_OK) {
  126. sqlite3_close(_db);
  127. throw std::runtime_error("SqliteNetworkController cannot initialize database and/or insert schemaVersion into Config table");
  128. }
  129. }
  130. if (
  131. (sqlite3_prepare_v2(_db,"SELECT name,private,enableBroadcast,allowPassiveBridging,v4AssignMode,v6AssignMode,multicastLimit,creationTime,revision FROM Network WHERE id = ?",-1,&_sGetNetworkById,(const char **)0) != SQLITE_OK)
  132. ||(sqlite3_prepare_v2(_db,"SELECT rowid,authorized,activeBridge FROM Member WHERE networkId = ? AND nodeId = ?",-1,&_sGetMember,(const char **)0) != SQLITE_OK)
  133. ||(sqlite3_prepare_v2(_db,"INSERT INTO Member (networkId,nodeId,authorized,activeBridge) VALUES (?,?,?,0)",-1,&_sCreateMember,(const char **)0) != SQLITE_OK)
  134. ||(sqlite3_prepare_v2(_db,"SELECT identity FROM Node WHERE id = ?",-1,&_sGetNodeIdentity,(const char **)0) != SQLITE_OK)
  135. ||(sqlite3_prepare_v2(_db,"INSERT INTO Node (id,identity,lastAt,lastSeen,firstSeen) VALUES (?,?,?,?,?)",-1,&_sCreateNode,(const char **)0) != SQLITE_OK)
  136. ||(sqlite3_prepare_v2(_db,"UPDATE Node SET lastAt = ?,lastSeen = ? WHERE id = ?",-1,&_sUpdateNode,(const char **)0) != SQLITE_OK)
  137. ||(sqlite3_prepare_v2(_db,"UPDATE Node SET lastSeen = ? WHERE id = ?",-1,&_sUpdateNode2,(const char **)0) != SQLITE_OK)
  138. ||(sqlite3_prepare_v2(_db,"SELECT etherType FROM Rule WHERE networkId = ? AND \"action\" = 'accept'",-1,&_sGetEtherTypesFromRuleTable,(const char **)0) != SQLITE_OK)
  139. ||(sqlite3_prepare_v2(_db,"SELECT mgMac,mgAdi,preload,maxBalance,accrual FROM MulticastRate WHERE networkId = ?",-1,&_sGetMulticastRates,(const char **)0) != SQLITE_OK)
  140. ||(sqlite3_prepare_v2(_db,"SELECT nodeId FROM Member WHERE networkId = ? AND activeBridge > 0 AND authorized > 0",-1,&_sGetActiveBridges,(const char **)0) != SQLITE_OK)
  141. ||(sqlite3_prepare_v2(_db,"SELECT ip,ipNetmaskBits FROM IpAssignment WHERE networkId = ? AND nodeId = ? AND ipVersion = ?",-1,&_sGetIpAssignmentsForNode,(const char **)0) != SQLITE_OK)
  142. ||(sqlite3_prepare_v2(_db,"SELECT ipNetwork,ipNetmaskBits FROM IpAssignmentPool WHERE networkId = ? AND ipVersion = ?",-1,&_sGetIpAssignmentPools,(const char **)0) != SQLITE_OK)
  143. ||(sqlite3_prepare_v2(_db,"SELECT 1 FROM IpAssignment WHERE networkId = ? AND ip = ? AND ipVersion = ?",-1,&_sCheckIfIpIsAllocated,(const char **)0) != SQLITE_OK)
  144. ||(sqlite3_prepare_v2(_db,"INSERT INTO IpAssignment (networkId,nodeId,ip,ipNetmaskBits,ipVersion) VALUES (?,?,?,?,?)",-1,&_sAllocateIp,(const char **)0) != SQLITE_OK)
  145. ||(sqlite3_prepare_v2(_db,"DELETE FROM IpAssignment WHERE networkId = ? AND nodeId = ?",-1,&_sDeleteIpAllocations,(const char **)0) != SQLITE_OK)
  146. ||(sqlite3_prepare_v2(_db,"SELECT nodeId,phyAddress FROM Relay WHERE networkId = ? ORDER BY nodeId ASC",-1,&_sGetRelays,(const char **)0) != SQLITE_OK)
  147. ||(sqlite3_prepare_v2(_db,"SELECT id FROM Network ORDER BY id ASC",-1,&_sListNetworks,(const char **)0) != SQLITE_OK)
  148. ||(sqlite3_prepare_v2(_db,"SELECT n.id FROM Member AS m,Node AS n WHERE m.networkId = ? AND n.id = m.nodeId ORDER BY n.id ASC",-1,&_sListNetworkMembers,(const char **)0) != SQLITE_OK)
  149. ||(sqlite3_prepare_v2(_db,"SELECT m.authorized,m.activeBridge,n.identity,n.lastAt,n.lastSeen,n.firstSeen FROM Member AS m,Node AS n WHERE m.networkId = ? AND m.nodeId = ?",-1,&_sGetMember2,(const char **)0) != SQLITE_OK)
  150. ||(sqlite3_prepare_v2(_db,"SELECT ipNetwork,ipNetmaskBits,ipVersion FROM IpAssignmentPool WHERE networkId = ? ORDER BY ipNetwork ASC",-1,&_sGetIpAssignmentPools2,(const char **)0) != SQLITE_OK)
  151. ||(sqlite3_prepare_v2(_db,"SELECT ruleId,nodeId,vlanId,vlanPcp,etherType,macSource,macDest,ipSource,ipDest,ipTos,ipProtocol,ipSourcePort,ipDestPort,\"flags\",invFlags,\"action\" FROM Rule WHERE networkId = ? ORDER BY ruleId ASC",-1,&_sListRules,(const char **)0) != SQLITE_OK)
  152. ||(sqlite3_prepare_v2(_db,"INSERT INTO Rule (networkId,ruleId,nodeId,vlanId,vlanPcP,etherType,macSource,macDest,ipSource,ipDest,ipTos,ipProtocol,ipSourcePort,ipDestPort,\"action\") VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",-1,&_sCreateRule,(const char **)0) != SQLITE_OK)
  153. ||(sqlite3_prepare_v2(_db,"INSERT INTO Network (id,name,creationTime,revision) VALUES (?,?,?,1)",-1,&_sCreateNetwork,(const char **)0) != SQLITE_OK)
  154. ||(sqlite3_prepare_v2(_db,"SELECT revision FROM Network WHERE id = ?",-1,&_sGetNetworkRevision,(const char **)0) != SQLITE_OK)
  155. ||(sqlite3_prepare_v2(_db,"UPDATE Network SET revision = ? WHERE id = ?",-1,&_sSetNetworkRevision,(const char **)0) != SQLITE_OK)
  156. ||(sqlite3_prepare_v2(_db,"SELECT ip,ipNetmaskBits,ipVersion FROM IpAssignment WHERE networkId = ? AND nodeId = ? ORDER BY ip ASC",-1,&_sGetIpAssignmentsForNode2,(const char **)0) != SQLITE_OK)
  157. ||(sqlite3_prepare_v2(_db,"DELETE FROM Relay WHERE networkId = ?",-1,&_sDeleteRelaysForNetwork,(const char **)0) != SQLITE_OK)
  158. ||(sqlite3_prepare_v2(_db,"INSERT INTO Relay (networkId,nodeId,phyAddress) VALUES (?,?,?)",-1,&_sCreateRelay,(const char **)0) != SQLITE_OK)
  159. ||(sqlite3_prepare_v2(_db,"DELETE FROM IpAssignmentPool WHERE networkId = ?",-1,&_sDeleteIpAssignmentPoolsForNetwork,(const char **)0) != SQLITE_OK)
  160. ||(sqlite3_prepare_v2(_db,"DELETE FROM Rule WHERE networkId = ?",-1,&_sDeleteRulesForNetwork,(const char **)0) != SQLITE_OK)
  161. ||(sqlite3_prepare_v2(_db,"INSERT INTO IpAssignmentPool (networkId,ipNetwork,ipNetmaskBits,ipVersion) VALUES (?,?,?,?)",-1,&_sCreateIpAssignmentPool,(const char **)0) != SQLITE_OK)
  162. ||(sqlite3_prepare_v2(_db,"DELETE FROM Member WHERE networkId = ? AND nodeId = ?",-1,&_sDeleteMember,(const char **)0) != SQLITE_OK)
  163. ||(sqlite3_prepare_v2(_db,"DELETE FROM IpAssignment WHERE networkId = ?; DELETE FROM IpAssignmentPool WHERE networkId = ?; DELETE FROM Member WHERE networkId = ?; DELETE FROM MulticastRate WHERE networkId = ?; DELETE FROM Relay WHERE networkId = ?; DELETE FROM Rule WHERE networkId = ?; DELETE FROM Network WHERE id = ?;",-1,&_sDeleteNetworkAndRelated,(const char **)0) != SQLITE_OK)
  164. ) {
  165. //printf("!!! %s\n",sqlite3_errmsg(_db));
  166. sqlite3_close(_db);
  167. throw std::runtime_error("SqliteNetworkController unable to initialize one or more prepared statements");
  168. }
  169. }
  170. SqliteNetworkController::~SqliteNetworkController()
  171. {
  172. Mutex::Lock _l(_lock);
  173. if (_db) {
  174. sqlite3_finalize(_sGetNetworkById);
  175. sqlite3_finalize(_sGetMember);
  176. sqlite3_finalize(_sCreateMember);
  177. sqlite3_finalize(_sGetNodeIdentity);
  178. sqlite3_finalize(_sCreateNode);
  179. sqlite3_finalize(_sUpdateNode);
  180. sqlite3_finalize(_sUpdateNode2);
  181. sqlite3_finalize(_sGetEtherTypesFromRuleTable);
  182. sqlite3_finalize(_sGetMulticastRates);
  183. sqlite3_finalize(_sGetActiveBridges);
  184. sqlite3_finalize(_sGetIpAssignmentsForNode);
  185. sqlite3_finalize(_sGetIpAssignmentPools);
  186. sqlite3_finalize(_sCheckIfIpIsAllocated);
  187. sqlite3_finalize(_sAllocateIp);
  188. sqlite3_finalize(_sDeleteIpAllocations);
  189. sqlite3_finalize(_sGetRelays);
  190. sqlite3_finalize(_sListNetworks);
  191. sqlite3_finalize(_sListNetworkMembers);
  192. sqlite3_finalize(_sGetMember2);
  193. sqlite3_finalize(_sGetIpAssignmentPools2);
  194. sqlite3_finalize(_sListRules);
  195. sqlite3_finalize(_sCreateRule);
  196. sqlite3_finalize(_sCreateNetwork);
  197. sqlite3_finalize(_sGetNetworkRevision);
  198. sqlite3_finalize(_sSetNetworkRevision);
  199. sqlite3_finalize(_sGetIpAssignmentsForNode2);
  200. sqlite3_finalize(_sDeleteRelaysForNetwork);
  201. sqlite3_finalize(_sCreateRelay);
  202. sqlite3_finalize(_sDeleteIpAssignmentPoolsForNetwork);
  203. sqlite3_finalize(_sDeleteRulesForNetwork);
  204. sqlite3_finalize(_sCreateIpAssignmentPool);
  205. sqlite3_finalize(_sDeleteNetworkAndRelated);
  206. sqlite3_close(_db);
  207. }
  208. }
  209. NetworkController::ResultCode SqliteNetworkController::doNetworkConfigRequest(const InetAddress &fromAddr,const Identity &signingId,const Identity &identity,uint64_t nwid,const Dictionary &metaData,uint64_t haveRevision,Dictionary &netconf)
  210. {
  211. Mutex::Lock _l(_lock);
  212. // Note: we can't reuse prepared statements that return const char * pointers without
  213. // making our own copy in e.g. a std::string first.
  214. if ((!signingId)||(!signingId.hasPrivate())) {
  215. netconf["error"] = "signing identity invalid or lacks private key";
  216. return NetworkController::NETCONF_QUERY_INTERNAL_SERVER_ERROR;
  217. }
  218. if (signingId.address().toInt() != (nwid >> 24)) {
  219. netconf["error"] = "signing identity address does not match most significant 40 bits of network ID";
  220. return NetworkController::NETCONF_QUERY_INTERNAL_SERVER_ERROR;
  221. }
  222. NetworkRecord network;
  223. memset(&network,0,sizeof(network));
  224. Utils::snprintf(network.id,sizeof(network.id),"%.16llx",(unsigned long long)nwid);
  225. MemberRecord member;
  226. memset(&member,0,sizeof(member));
  227. Utils::snprintf(member.nodeId,sizeof(member.nodeId),"%.10llx",(unsigned long long)identity.address().toInt());
  228. // Create/update Node record and check identity fully -- identities are first-come-first-claim
  229. sqlite3_reset(_sGetNodeIdentity);
  230. sqlite3_bind_text(_sGetNodeIdentity,1,member.nodeId,10,SQLITE_STATIC);
  231. if (sqlite3_step(_sGetNodeIdentity) == SQLITE_ROW) {
  232. try {
  233. Identity alreadyKnownIdentity((const char *)sqlite3_column_text(_sGetNodeIdentity,0));
  234. if (alreadyKnownIdentity == identity) {
  235. char lastSeen[64];
  236. Utils::snprintf(lastSeen,sizeof(lastSeen),"%llu",(unsigned long long)OSUtils::now());
  237. if (fromAddr) {
  238. std::string lastAt(fromAddr.toString());
  239. sqlite3_reset(_sUpdateNode);
  240. sqlite3_bind_text(_sUpdateNode,1,lastAt.c_str(),-1,SQLITE_STATIC);
  241. sqlite3_bind_text(_sUpdateNode,2,lastSeen,-1,SQLITE_STATIC);
  242. sqlite3_bind_text(_sUpdateNode,3,member.nodeId,10,SQLITE_STATIC);
  243. sqlite3_step(_sUpdateNode);
  244. } else { // fromAddr is empty, which means this was a relayed packet -- so don't update lastAt
  245. sqlite3_reset(_sUpdateNode2);
  246. sqlite3_bind_text(_sUpdateNode2,1,lastSeen,-1,SQLITE_STATIC);
  247. sqlite3_bind_text(_sUpdateNode2,2,member.nodeId,10,SQLITE_STATIC);
  248. sqlite3_step(_sUpdateNode2);
  249. }
  250. } else {
  251. return NetworkController::NETCONF_QUERY_ACCESS_DENIED;
  252. }
  253. } catch ( ... ) { // identity stored in database is not valid or is NULL
  254. return NetworkController::NETCONF_QUERY_ACCESS_DENIED;
  255. }
  256. } else {
  257. std::string idstr(identity.toString(false));
  258. std::string lastAt;
  259. if (fromAddr)
  260. lastAt = fromAddr.toString();
  261. char lastSeen[64];
  262. Utils::snprintf(lastSeen,sizeof(lastSeen),"%llu",(unsigned long long)OSUtils::now());
  263. sqlite3_reset(_sCreateNode);
  264. sqlite3_bind_text(_sCreateNode,1,member.nodeId,10,SQLITE_STATIC);
  265. sqlite3_bind_text(_sCreateNode,2,idstr.c_str(),-1,SQLITE_STATIC);
  266. sqlite3_bind_text(_sCreateNode,3,lastAt.c_str(),-1,SQLITE_STATIC);
  267. sqlite3_bind_text(_sCreateNode,4,lastSeen,-1,SQLITE_STATIC);
  268. sqlite3_bind_text(_sCreateNode,5,lastSeen,-1,SQLITE_STATIC);
  269. if (sqlite3_step(_sCreateNode) != SQLITE_DONE) {
  270. netconf["error"] = "unable to create new node record";
  271. return NetworkController::NETCONF_QUERY_INTERNAL_SERVER_ERROR;
  272. }
  273. }
  274. // Fetch Network record
  275. sqlite3_reset(_sGetNetworkById);
  276. sqlite3_bind_text(_sGetNetworkById,1,network.id,16,SQLITE_STATIC);
  277. if (sqlite3_step(_sGetNetworkById) == SQLITE_ROW) {
  278. network.name = (const char *)sqlite3_column_text(_sGetNetworkById,0);
  279. network.isPrivate = (sqlite3_column_int(_sGetNetworkById,1) > 0);
  280. network.enableBroadcast = (sqlite3_column_int(_sGetNetworkById,2) > 0);
  281. network.allowPassiveBridging = (sqlite3_column_int(_sGetNetworkById,3) > 0);
  282. network.v4AssignMode = (const char *)sqlite3_column_text(_sGetNetworkById,4);
  283. network.v6AssignMode = (const char *)sqlite3_column_text(_sGetNetworkById,5);
  284. network.multicastLimit = sqlite3_column_int(_sGetNetworkById,6);
  285. network.creationTime = (uint64_t)sqlite3_column_int64(_sGetNetworkById,7);
  286. network.revision = (uint64_t)sqlite3_column_int64(_sGetNetworkById,8);
  287. } else return NetworkController::NETCONF_QUERY_OBJECT_NOT_FOUND;
  288. // Fetch Member record
  289. bool foundMember = false;
  290. sqlite3_reset(_sGetMember);
  291. sqlite3_bind_text(_sGetMember,1,network.id,16,SQLITE_STATIC);
  292. sqlite3_bind_text(_sGetMember,2,member.nodeId,10,SQLITE_STATIC);
  293. if (sqlite3_step(_sGetMember) == SQLITE_ROW) {
  294. foundMember = true;
  295. member.rowid = (int64_t)sqlite3_column_int64(_sGetMember,0);
  296. member.authorized = (sqlite3_column_int(_sGetMember,1) > 0);
  297. member.activeBridge = (sqlite3_column_int(_sGetMember,2) > 0);
  298. }
  299. // Create Member record for unknown nodes, auto-authorizing if network is public
  300. if (!foundMember) {
  301. member.authorized = (network.isPrivate ? false : true);
  302. member.activeBridge = false;
  303. sqlite3_reset(_sCreateMember);
  304. sqlite3_bind_text(_sCreateMember,1,network.id,16,SQLITE_STATIC);
  305. sqlite3_bind_text(_sCreateMember,2,member.nodeId,10,SQLITE_STATIC);
  306. sqlite3_bind_int(_sCreateMember,3,(member.authorized ? 0 : 1));
  307. if (sqlite3_step(_sCreateMember) != SQLITE_DONE) {
  308. netconf["error"] = "unable to create new member record";
  309. return NetworkController::NETCONF_QUERY_INTERNAL_SERVER_ERROR;
  310. }
  311. member.rowid = (int64_t)sqlite3_last_insert_rowid(_db);
  312. }
  313. // Check member authorization
  314. if (!member.authorized)
  315. return NetworkController::NETCONF_QUERY_ACCESS_DENIED;
  316. // If netconf is unchanged from client reported revision, just tell client they're up to date
  317. if ((haveRevision > 0)&&(haveRevision == network.revision))
  318. return NetworkController::NETCONF_QUERY_OK_BUT_NOT_NEWER;
  319. // Create and sign netconf
  320. netconf.clear();
  321. {
  322. char tss[24],rs[24];
  323. Utils::snprintf(tss,sizeof(tss),"%.16llx",(unsigned long long)OSUtils::now());
  324. Utils::snprintf(rs,sizeof(rs),"%.16llx",(unsigned long long)network.revision);
  325. netconf[ZT_NETWORKCONFIG_DICT_KEY_TIMESTAMP] = tss;
  326. netconf[ZT_NETWORKCONFIG_DICT_KEY_REVISION] = rs;
  327. netconf[ZT_NETWORKCONFIG_DICT_KEY_NETWORK_ID] = network.id;
  328. netconf[ZT_NETWORKCONFIG_DICT_KEY_ISSUED_TO] = member.nodeId;
  329. netconf[ZT_NETWORKCONFIG_DICT_KEY_PRIVATE] = network.isPrivate ? "1" : "0";
  330. netconf[ZT_NETWORKCONFIG_DICT_KEY_NAME] = (network.name) ? network.name : "";
  331. netconf[ZT_NETWORKCONFIG_DICT_KEY_ENABLE_BROADCAST] = network.enableBroadcast ? "1" : "0";
  332. netconf[ZT_NETWORKCONFIG_DICT_KEY_ALLOW_PASSIVE_BRIDGING] = network.allowPassiveBridging ? "1" : "0";
  333. {
  334. std::vector<int> allowedEtherTypes;
  335. sqlite3_reset(_sGetEtherTypesFromRuleTable);
  336. sqlite3_bind_text(_sGetEtherTypesFromRuleTable,1,network.id,16,SQLITE_STATIC);
  337. while (sqlite3_step(_sGetEtherTypesFromRuleTable) == SQLITE_ROW) {
  338. int et = sqlite3_column_int(_sGetEtherTypesFromRuleTable,0);
  339. if ((et >= 0)&&(et <= 0xffff))
  340. allowedEtherTypes.push_back(et);
  341. }
  342. std::sort(allowedEtherTypes.begin(),allowedEtherTypes.end());
  343. std::unique(allowedEtherTypes.begin(),allowedEtherTypes.end());
  344. std::string allowedEtherTypesCsv;
  345. for(std::vector<int>::const_iterator i(allowedEtherTypes.begin());i!=allowedEtherTypes.end();++i) {
  346. if (allowedEtherTypesCsv.length())
  347. allowedEtherTypesCsv.push_back(',');
  348. char tmp[16];
  349. Utils::snprintf(tmp,sizeof(tmp),"%.4x",(unsigned int)*i);
  350. allowedEtherTypesCsv.append(tmp);
  351. }
  352. netconf[ZT_NETWORKCONFIG_DICT_KEY_ALLOWED_ETHERNET_TYPES] = allowedEtherTypesCsv;
  353. }
  354. {
  355. std::string multicastRates;
  356. sqlite3_reset(_sGetMulticastRates);
  357. sqlite3_bind_text(_sGetMulticastRates,1,network.id,16,SQLITE_STATIC);
  358. while (sqlite3_step(_sGetMulticastRates) == SQLITE_ROW) {
  359. const char *mac = (const char *)sqlite3_column_text(_sGetMulticastRates,0);
  360. if ((mac)&&(strlen(mac) == 12)) {
  361. unsigned long adi = ((unsigned long)sqlite3_column_int64(_sGetMulticastRates,1)) & 0xffffffff;
  362. char tmp[256];
  363. Utils::snprintf(tmp,sizeof(tmp),"%s/%.4lx=%x,%x,%x\n",mac,adi,sqlite3_column_int(_sGetMulticastRates,2),sqlite3_column_int(_sGetMulticastRates,3),sqlite3_column_int(_sGetMulticastRates,4));
  364. multicastRates.append(tmp);
  365. }
  366. }
  367. if (multicastRates.length() > 0)
  368. netconf[ZT_NETWORKCONFIG_DICT_KEY_MULTICAST_RATES] = multicastRates;
  369. if (network.multicastLimit > 0) {
  370. char ml[16];
  371. Utils::snprintf(ml,sizeof(ml),"%lx",(unsigned long)network.multicastLimit);
  372. netconf[ZT_NETWORKCONFIG_DICT_KEY_MULTICAST_LIMIT] = ml;
  373. }
  374. }
  375. {
  376. std::string activeBridges;
  377. sqlite3_reset(_sGetActiveBridges);
  378. sqlite3_bind_text(_sGetActiveBridges,1,network.id,16,SQLITE_STATIC);
  379. while (sqlite3_step(_sGetActiveBridges) == SQLITE_ROW) {
  380. const char *ab = (const char *)sqlite3_column_text(_sGetActiveBridges,0);
  381. if ((ab)&&(strlen(ab) == 10)) {
  382. if (activeBridges.length())
  383. activeBridges.push_back(',');
  384. activeBridges.append(ab);
  385. }
  386. if (activeBridges.length() > 1024) // sanity check -- you can't have too many active bridges at the moment
  387. break;
  388. }
  389. if (activeBridges.length())
  390. netconf[ZT_NETWORKCONFIG_DICT_KEY_ACTIVE_BRIDGES] = activeBridges;
  391. }
  392. {
  393. std::string relays;
  394. sqlite3_reset(_sGetRelays);
  395. sqlite3_bind_text(_sGetRelays,1,network.id,16,SQLITE_STATIC);
  396. while (sqlite3_step(_sGetRelays) == SQLITE_ROW) {
  397. const char *n = (const char *)sqlite3_column_text(_sGetRelays,0);
  398. const char *a = (const char *)sqlite3_column_text(_sGetRelays,1);
  399. if ((n)&&(a)) {
  400. Address node(n);
  401. InetAddress addr(a);
  402. if ((node)&&(addr)) {
  403. if (relays.length())
  404. relays.push_back(',');
  405. relays.append(node.toString());
  406. relays.push_back(';');
  407. relays.append(addr.toString());
  408. }
  409. }
  410. }
  411. if (relays.length())
  412. netconf[ZT_NETWORKCONFIG_DICT_KEY_RELAYS] = relays;
  413. }
  414. if ((network.v4AssignMode)&&(!strcmp(network.v4AssignMode,"zt"))) {
  415. std::string v4s;
  416. sqlite3_reset(_sGetIpAssignmentsForNode);
  417. sqlite3_bind_text(_sGetIpAssignmentsForNode,1,network.id,16,SQLITE_STATIC);
  418. sqlite3_bind_text(_sGetIpAssignmentsForNode,2,member.nodeId,10,SQLITE_STATIC);
  419. sqlite3_bind_int(_sGetIpAssignmentsForNode,3,4); // 4 == IPv4
  420. while (sqlite3_step(_sGetIpAssignmentsForNode) == SQLITE_ROW) {
  421. const unsigned char *ip = (const unsigned char *)sqlite3_column_blob(_sGetIpAssignmentsForNode,0);
  422. int ipNetmaskBits = sqlite3_column_int(_sGetIpAssignmentsForNode,1);
  423. if ((ip)&&(sqlite3_column_bytes(_sGetIpAssignmentsForNode,0) >= 4)&&(ipNetmaskBits > 0)&&(ipNetmaskBits <= 32)) {
  424. char tmp[32];
  425. Utils::snprintf(tmp,sizeof(tmp),"%d.%d.%d.%d/%d",(int)ip[0],(int)ip[1],(int)ip[2],(int)ip[3],ipNetmaskBits);
  426. if (v4s.length())
  427. v4s.push_back(',');
  428. v4s.append(tmp);
  429. }
  430. }
  431. if (!v4s.length()) {
  432. // Attempt to auto-assign an IPv4 address from an available pool if one isn't assigned already
  433. sqlite3_reset(_sGetIpAssignmentPools);
  434. sqlite3_bind_text(_sGetIpAssignmentPools,1,network.id,16,SQLITE_STATIC);
  435. sqlite3_bind_int(_sGetIpAssignmentPools,2,4); // 4 == IPv4
  436. while ((!v4s.length())&&(sqlite3_step(_sGetIpAssignmentPools) == SQLITE_ROW)) {
  437. const void *ipNetwork = sqlite3_column_blob(_sGetIpAssignmentPools,0);
  438. int ipNetmaskBits = sqlite3_column_int(_sGetIpAssignmentPools,1);
  439. if ((ipNetwork)&&(sqlite3_column_bytes(_sGetIpAssignmentPools,0) >= 4)&&(ipNetmaskBits > 0)&&(ipNetmaskBits < 32)) {
  440. uint32_t n = Utils::ntoh(*((const uint32_t *)ipNetwork)); // network in host byte order e.g. 192.168.0.0
  441. uint32_t m = 0xffffffff << (32 - ipNetmaskBits); // netmask e.g. 0xffffff00 for '24' since 32 - 24 == 8
  442. n &= m; // sanity check -- ipNetwork bits right of netmask bit count should be zero
  443. uint32_t im = ~m; // inverse mask, e.g. 0x000000ff for a netmask of 0xffffff00
  444. uint32_t abits = (uint32_t)(identity.address().toInt() & 0xffffffff); // least significant bits of member ZT address
  445. for(uint32_t k=0;k<=im;++k) { // try up to the number of IPs possible in this network
  446. uint32_t ip = ( ((abits + k) & im) | n ); // build IP using bits from ZT address of member + k
  447. if ((ip & 0xffffff00) == 0) continue; // no IPs ending in .0
  448. if (ip == n) continue; // no IPs equal to the network e.g. 10.0.0.0 for 10.0.0.0/255.255.255.0
  449. if (ip == (n | im)) continue; // broadcast address e.g. 10.0.0.255 for 10.0.0.0/255.255.255.0
  450. uint32_t nip = Utils::hton(ip); // IP in big-endian "network" byte order
  451. char ipBlob[16];
  452. memset(ipBlob,0,12);
  453. memcpy(ipBlob + 12,&nip,4);
  454. sqlite3_reset(_sCheckIfIpIsAllocated);
  455. sqlite3_bind_text(_sCheckIfIpIsAllocated,1,network.id,16,SQLITE_STATIC);
  456. sqlite3_bind_blob(_sCheckIfIpIsAllocated,2,(const void *)ipBlob,16,SQLITE_STATIC);
  457. sqlite3_bind_int(_sCheckIfIpIsAllocated,3,4); // 4 == IPv4
  458. if (sqlite3_step(_sCheckIfIpIsAllocated) != SQLITE_ROW) {
  459. // No rows returned, so the IP is available
  460. sqlite3_reset(_sAllocateIp);
  461. sqlite3_bind_text(_sAllocateIp,1,network.id,16,SQLITE_STATIC);
  462. sqlite3_bind_text(_sAllocateIp,2,member.nodeId,10,SQLITE_STATIC);
  463. sqlite3_bind_blob(_sAllocateIp,3,(const void *)ipBlob,16,SQLITE_STATIC);
  464. sqlite3_bind_int(_sAllocateIp,4,ipNetmaskBits);
  465. sqlite3_bind_int(_sAllocateIp,5,4); // 4 == IPv4
  466. if (sqlite3_step(_sAllocateIp) == SQLITE_DONE) {
  467. char tmp[32];
  468. Utils::snprintf(tmp,sizeof(tmp),"%d.%d.%d.%d/%d",(int)((ip >> 24) & 0xff),(int)((ip >> 16) & 0xff),(int)((ip >> 8) & 0xff),(int)(ip & 0xff),ipNetmaskBits);
  469. if (v4s.length())
  470. v4s.push_back(',');
  471. v4s.append(tmp);
  472. break; // IP found and reserved! v4s containing something will cause outer while() to break.
  473. }
  474. }
  475. }
  476. }
  477. }
  478. }
  479. if (v4s.length())
  480. netconf[ZT_NETWORKCONFIG_DICT_KEY_IPV4_STATIC] = v4s;
  481. }
  482. // TODO: IPv6 auto-assign once it's supported in UI
  483. if (network.isPrivate) {
  484. CertificateOfMembership com(network.revision,ZT1_CERTIFICATE_OF_MEMBERSHIP_REVISION_MAX_DELTA,nwid,identity.address());
  485. if (com.sign(signingId)) // basically can't fail unless our identity is invalid
  486. netconf[ZT_NETWORKCONFIG_DICT_KEY_CERTIFICATE_OF_MEMBERSHIP] = com.toString();
  487. else {
  488. netconf["error"] = "unable to sign COM";
  489. return NETCONF_QUERY_INTERNAL_SERVER_ERROR;
  490. }
  491. }
  492. if (!netconf.sign(signingId,OSUtils::now())) {
  493. netconf["error"] = "unable to sign netconf dictionary";
  494. return NETCONF_QUERY_INTERNAL_SERVER_ERROR;
  495. }
  496. }
  497. return NetworkController::NETCONF_QUERY_OK;
  498. }
  499. unsigned int SqliteNetworkController::handleControlPlaneHttpGET(
  500. const std::vector<std::string> &path,
  501. const std::map<std::string,std::string> &urlArgs,
  502. const std::map<std::string,std::string> &headers,
  503. const std::string &body,
  504. std::string &responseBody,
  505. std::string &responseContentType)
  506. {
  507. Mutex::Lock _l(_lock);
  508. return _doCPGet(path,urlArgs,headers,body,responseBody,responseContentType);
  509. }
  510. unsigned int SqliteNetworkController::handleControlPlaneHttpPOST(
  511. const std::vector<std::string> &path,
  512. const std::map<std::string,std::string> &urlArgs,
  513. const std::map<std::string,std::string> &headers,
  514. const std::string &body,
  515. std::string &responseBody,
  516. std::string &responseContentType)
  517. {
  518. if (path.empty())
  519. return 404;
  520. Mutex::Lock _l(_lock);
  521. if (path[0] == "network") {
  522. if ((path.size() >= 2)&&(path[1].length() == 16)) {
  523. uint64_t nwid = Utils::hexStrToU64(path[1].c_str());
  524. char nwids[24];
  525. Utils::snprintf(nwids,sizeof(nwids),"%.16llx",(unsigned long long)nwid);
  526. int64_t revision = 0;
  527. sqlite3_reset(_sGetNetworkRevision);
  528. sqlite3_bind_text(_sGetNetworkRevision,1,nwids,16,SQLITE_STATIC);
  529. bool networkExists = false;
  530. if (sqlite3_step(_sGetNetworkRevision) == SQLITE_ROW) {
  531. networkExists = true;
  532. revision = sqlite3_column_int64(_sGetNetworkRevision,0);
  533. }
  534. if (path.size() >= 3) {
  535. if (!networkExists)
  536. return 404;
  537. if ((path.size() == 4)&&(path[2] == "member")&&(path[3].length() == 10)) {
  538. uint64_t address = Utils::hexStrToU64(path[3].c_str());
  539. char addrs[24];
  540. Utils::snprintf(addrs,sizeof(addrs),"%.10llx",address);
  541. int64_t memberRowId = 0;
  542. sqlite3_reset(_sGetMember);
  543. sqlite3_bind_text(_sGetMember,1,nwids,16,SQLITE_STATIC);
  544. sqlite3_bind_text(_sGetMember,2,addrs,10,SQLITE_STATIC);
  545. bool memberExists = false;
  546. if (sqlite3_step(_sGetMember) == SQLITE_ROW) {
  547. memberExists = true;
  548. memberRowId = sqlite3_column_int64(_sGetMember,0);
  549. }
  550. if (!memberExists) {
  551. sqlite3_reset(_sCreateMember);
  552. sqlite3_bind_text(_sCreateMember,1,nwids,16,SQLITE_STATIC);
  553. sqlite3_bind_text(_sCreateMember,2,addrs,10,SQLITE_STATIC);
  554. sqlite3_bind_int(_sCreateMember,3,0);
  555. if (sqlite3_step(_sCreateMember) != SQLITE_DONE)
  556. return 500;
  557. memberRowId = (int64_t)sqlite3_last_insert_rowid(_db);
  558. }
  559. json_value *j = json_parse(body.c_str(),body.length());
  560. if (j) {
  561. if (j->type == json_object) {
  562. for(unsigned int k=0;k<j->u.object.length;++k) {
  563. if (!strcmp(j->u.object.values[k].name,"authorized")) {
  564. if (j->u.object.values[k].value->type == json_boolean) {
  565. sqlite3_stmt *stmt = (sqlite3_stmt *)0;
  566. if (sqlite3_prepare_v2(_db,"UPDATE Member SET authorized = ? WHERE rowid = ?",-1,&stmt,(const char **)0) == SQLITE_OK)
  567. sqlite3_bind_int(stmt,1,(j->u.object.values[k].value->u.boolean == 0) ? 0 : 1);
  568. sqlite3_bind_int64(stmt,2,memberRowId);
  569. sqlite3_step(stmt);
  570. sqlite3_finalize(stmt);
  571. }
  572. } else if (!strcmp(j->u.object.values[k].name,"activeBridge")) {
  573. if (j->u.object.values[k].value->type == json_boolean) {
  574. sqlite3_stmt *stmt = (sqlite3_stmt *)0;
  575. if (sqlite3_prepare_v2(_db,"UPDATE Member SET activeBridge = ? WHERE rowid = ?",-1,&stmt,(const char **)0) == SQLITE_OK) {
  576. sqlite3_bind_int(stmt,1,(j->u.object.values[k].value->u.boolean == 0) ? 0 : 1);
  577. sqlite3_bind_int64(stmt,2,memberRowId);
  578. sqlite3_step(stmt);
  579. sqlite3_finalize(stmt);
  580. }
  581. }
  582. } else if (!strcmp(j->u.object.values[k].name,"ipAssignments")) {
  583. if (j->u.object.values[k].value->type == json_array) {
  584. sqlite3_reset(_sDeleteIpAllocations);
  585. sqlite3_bind_text(_sDeleteIpAllocations,1,nwids,16,SQLITE_STATIC);
  586. sqlite3_bind_text(_sDeleteIpAllocations,2,addrs,10,SQLITE_STATIC);
  587. sqlite3_step(_sDeleteIpAllocations);
  588. for(unsigned int kk=0;kk<j->u.object.values[k].value->u.array.length;++kk) {
  589. json_value *ipalloc = j->u.object.values[k].value->u.array.values[kk];
  590. if (ipalloc->type == json_string) {
  591. InetAddress a(ipalloc->u.string.ptr);
  592. char ipBlob[16];
  593. int ipVersion = 0;
  594. switch(a.ss_family) {
  595. case AF_INET:
  596. if ((a.netmaskBits() > 0)&&(a.netmaskBits() <= 32)) {
  597. memset(ipBlob,0,12);
  598. memcpy(ipBlob + 12,a.rawIpData(),4);
  599. ipVersion = 4;
  600. }
  601. break;
  602. case AF_INET6:
  603. if ((a.netmaskBits() > 0)&&(a.netmaskBits() <= 128)) {
  604. memcpy(ipBlob,a.rawIpData(),16);
  605. ipVersion = 6;
  606. }
  607. break;
  608. }
  609. if (ipVersion > 0) {
  610. sqlite3_reset(_sAllocateIp);
  611. sqlite3_bind_text(_sAllocateIp,1,nwids,16,SQLITE_STATIC);
  612. sqlite3_bind_text(_sAllocateIp,2,addrs,10,SQLITE_STATIC);
  613. sqlite3_bind_blob(_sAllocateIp,3,(const void *)ipBlob,16,SQLITE_STATIC);
  614. sqlite3_bind_int(_sAllocateIp,4,(int)a.netmaskBits());
  615. sqlite3_bind_int(_sAllocateIp,5,ipVersion);
  616. sqlite3_step(_sAllocateIp);
  617. }
  618. }
  619. }
  620. }
  621. }
  622. }
  623. }
  624. json_value_free(j);
  625. }
  626. return _doCPGet(path,urlArgs,headers,body,responseBody,responseContentType);
  627. } // else 404
  628. } else {
  629. if (!networkExists) {
  630. if (path[1].substr(10) == "______") {
  631. // A special POST /network/##########______ feature lets users create a network
  632. // with an arbitrary unused network ID.
  633. nwid = 0;
  634. uint64_t nwidPrefix = (Utils::hexStrToU64(path[1].substr(0,10).c_str()) << 24) & 0xffffffffff000000ULL;
  635. uint64_t nwidPostfix = 0;
  636. Utils::getSecureRandom(&nwidPostfix,sizeof(nwidPostfix));
  637. nwidPostfix &= 0xffffffULL;
  638. uint64_t nwidOriginalPostfix = nwidPostfix;
  639. do {
  640. uint64_t tryNwid = nwidPrefix | nwidPostfix;
  641. Utils::snprintf(nwids,sizeof(nwids),"%.16llx",(unsigned long long)tryNwid);
  642. sqlite3_reset(_sGetNetworkRevision);
  643. sqlite3_bind_text(_sGetNetworkRevision,1,nwids,16,SQLITE_STATIC);
  644. if (sqlite3_step(_sGetNetworkRevision) != SQLITE_ROW) {
  645. nwid = tryNwid;
  646. break;
  647. }
  648. ++nwidPostfix;
  649. nwidPostfix &= 0xffffffULL;
  650. } while (nwidPostfix != nwidOriginalPostfix);
  651. // 503 means we have no more free IDs for this prefix. You shouldn't host anywhere
  652. // near 16 million networks on the same controller, so shouldn't happen.
  653. if (!nwid)
  654. return 503;
  655. }
  656. sqlite3_reset(_sCreateNetwork);
  657. sqlite3_bind_text(_sCreateNetwork,1,nwids,16,SQLITE_STATIC);
  658. sqlite3_bind_text(_sCreateNetwork,2,nwids,16,SQLITE_STATIC); // default name, will be changed below if a name is specified in JSON
  659. sqlite3_bind_int64(_sCreateNetwork,3,(long long)OSUtils::now());
  660. if (sqlite3_step(_sCreateNetwork) != SQLITE_DONE)
  661. return 500;
  662. }
  663. json_value *j = json_parse(body.c_str(),body.length());
  664. if (j) {
  665. if (j->type == json_object) {
  666. for(unsigned int k=0;k<j->u.object.length;++k) {
  667. sqlite3_stmt *stmt = (sqlite3_stmt *)0;
  668. if (!strcmp(j->u.object.values[k].name,"name")) {
  669. if ((j->u.object.values[k].value->type == json_string)&&(j->u.object.values[k].value->u.string.ptr[0])) {
  670. if (sqlite3_prepare_v2(_db,"UPDATE Network SET name = ? WHERE id = ?",-1,&stmt,(const char **)0) == SQLITE_OK)
  671. sqlite3_bind_text(stmt,1,j->u.object.values[k].value->u.string.ptr,-1,SQLITE_STATIC);
  672. }
  673. } else if (!strcmp(j->u.object.values[k].name,"private")) {
  674. if (j->u.object.values[k].value->type == json_boolean) {
  675. if (sqlite3_prepare_v2(_db,"UPDATE Network SET private = ? WHERE id = ?",-1,&stmt,(const char **)0) == SQLITE_OK)
  676. sqlite3_bind_int(stmt,1,(j->u.object.values[k].value->u.boolean == 0) ? 0 : 1);
  677. }
  678. } else if (!strcmp(j->u.object.values[k].name,"enableBroadcast")) {
  679. if (j->u.object.values[k].value->type == json_boolean) {
  680. if (sqlite3_prepare_v2(_db,"UPDATE Network SET enableBroadcast = ? WHERE id = ?",-1,&stmt,(const char **)0) == SQLITE_OK)
  681. sqlite3_bind_int(stmt,1,(j->u.object.values[k].value->u.boolean == 0) ? 0 : 1);
  682. }
  683. } else if (!strcmp(j->u.object.values[k].name,"allowPassiveBridging")) {
  684. if (j->u.object.values[k].value->type == json_boolean) {
  685. if (sqlite3_prepare_v2(_db,"UPDATE Network SET allowPassiveBridging = ? WHERE id = ?",-1,&stmt,(const char **)0) == SQLITE_OK)
  686. sqlite3_bind_int(stmt,1,(j->u.object.values[k].value->u.boolean == 0) ? 0 : 1);
  687. }
  688. } else if (!strcmp(j->u.object.values[k].name,"v4AssignMode")) {
  689. if (j->u.object.values[k].value->type == json_string) {
  690. if (sqlite3_prepare_v2(_db,"UPDATE Network SET v4AssignMode = ? WHERE id = ?",-1,&stmt,(const char **)0) == SQLITE_OK)
  691. sqlite3_bind_text(stmt,1,j->u.object.values[k].value->u.string.ptr,-1,SQLITE_STATIC);
  692. }
  693. } else if (!strcmp(j->u.object.values[k].name,"v6AssignMode")) {
  694. if (j->u.object.values[k].value->type == json_string) {
  695. if (sqlite3_prepare_v2(_db,"UPDATE Network SET v6AssignMode = ? WHERE id = ?",-1,&stmt,(const char **)0) == SQLITE_OK)
  696. sqlite3_bind_text(stmt,1,j->u.object.values[k].value->u.string.ptr,-1,SQLITE_STATIC);
  697. }
  698. } else if (!strcmp(j->u.object.values[k].name,"multicastLimit")) {
  699. if (j->u.object.values[k].value->type == json_integer) {
  700. if (sqlite3_prepare_v2(_db,"UPDATE Network SET multicastLimit = ? WHERE id = ?",-1,&stmt,(const char **)0) == SQLITE_OK)
  701. sqlite3_bind_int(stmt,1,(int)j->u.object.values[k].value->u.integer);
  702. }
  703. } else if (!strcmp(j->u.object.values[k].name,"relays")) {
  704. if (j->u.object.values[k].value->type == json_array) {
  705. std::map<Address,InetAddress> nodeIdToPhyAddress;
  706. for(unsigned int kk=0;kk<j->u.object.values[k].value->u.array.length;++kk) {
  707. json_value *relay = j->u.object.values[k].value->u.array.values[kk];
  708. const char *address = (const char *)0;
  709. const char *phyAddress = (const char *)0;
  710. if ((relay)&&(relay->type == json_object)) {
  711. for(unsigned int rk=0;rk<relay->u.object.length;++rk) {
  712. if ((!strcmp(relay->u.object.values[rk].name,"address"))&&(relay->u.object.values[rk].value->type == json_string))
  713. address = relay->u.object.values[rk].value->u.string.ptr;
  714. else if ((!strcmp(relay->u.object.values[rk].name,"phyAddress"))&&(relay->u.object.values[rk].value->type == json_string))
  715. phyAddress = relay->u.object.values[rk].value->u.string.ptr;
  716. }
  717. }
  718. if ((address)&&(phyAddress))
  719. nodeIdToPhyAddress[Address(address)] = InetAddress(phyAddress);
  720. }
  721. sqlite3_reset(_sDeleteRelaysForNetwork);
  722. sqlite3_bind_text(_sDeleteRelaysForNetwork,1,nwids,16,SQLITE_STATIC);
  723. sqlite3_step(_sDeleteRelaysForNetwork);
  724. for(std::map<Address,InetAddress>::iterator rl(nodeIdToPhyAddress.begin());rl!=nodeIdToPhyAddress.end();++rl) {
  725. sqlite3_reset(_sCreateRelay);
  726. sqlite3_bind_text(_sCreateRelay,1,nwids,16,SQLITE_STATIC);
  727. sqlite3_bind_text(_sCreateRelay,2,rl->first.toString().c_str(),-1,SQLITE_STATIC);
  728. sqlite3_bind_text(_sCreateRelay,3,rl->second.toString().c_str(),-1,SQLITE_STATIC);
  729. sqlite3_step(_sCreateRelay);
  730. }
  731. }
  732. } else if (!strcmp(j->u.object.values[k].name,"ipAssignmentPools")) {
  733. if (j->u.object.values[k].value->type == json_array) {
  734. std::set<InetAddress> pools;
  735. for(unsigned int kk=0;kk<j->u.object.values[k].value->u.array.length;++kk) {
  736. json_value *pool = j->u.object.values[k].value->u.array.values[kk];
  737. const char *net = (const char *)0;
  738. int bits = 0;
  739. if ((pool)&&(pool->type == json_object)) {
  740. for(unsigned int rk=0;rk<pool->u.object.length;++rk) {
  741. if ((!strcmp(pool->u.object.values[rk].name,"network"))&&(pool->u.object.values[rk].value->type == json_string))
  742. net = pool->u.object.values[rk].value->u.string.ptr;
  743. else if ((!strcmp(pool->u.object.values[rk].name,"netmaskBits"))&&(pool->u.object.values[rk].value->type == json_integer))
  744. bits = (int)pool->u.object.values[rk].value->u.integer;
  745. }
  746. }
  747. if ((net)&&(bits > 0)) {
  748. char tmp[128];
  749. Utils::snprintf(tmp,sizeof(tmp),"%s/%d",net,bits);
  750. InetAddress n(tmp);
  751. if (((n.ss_family == AF_INET)&&(n.netmaskBits() < 32))||((n.ss_family == AF_INET6)&&(n.netmaskBits() < 128)))
  752. pools.insert(n);
  753. }
  754. sqlite3_reset(_sDeleteIpAssignmentPoolsForNetwork);
  755. sqlite3_bind_text(_sDeleteIpAssignmentPoolsForNetwork,1,nwids,16,SQLITE_STATIC);
  756. sqlite3_step(_sDeleteIpAssignmentPoolsForNetwork);
  757. for(std::set<InetAddress>::const_iterator p(pools.begin());p!=pools.end();++p) {
  758. sqlite3_reset(_sCreateIpAssignmentPool);
  759. sqlite3_bind_text(_sCreateIpAssignmentPool,1,nwids,16,SQLITE_STATIC);
  760. sqlite3_bind_blob(_sCreateIpAssignmentPool,2,p->rawIpData(),(p->ss_family == AF_INET6) ? 16 : 4,SQLITE_STATIC);
  761. sqlite3_bind_int(_sCreateIpAssignmentPool,3,(int)p->netmaskBits());
  762. sqlite3_bind_int(_sCreateIpAssignmentPool,4,(p->ss_family == AF_INET6) ? 6 : 4);
  763. sqlite3_step(_sCreateIpAssignmentPool);
  764. }
  765. }
  766. }
  767. } else if (!strcmp(j->u.object.values[k].name,"rules")) {
  768. if (j->u.object.values[k].value->type == json_array) {
  769. sqlite3_reset(_sDeleteRulesForNetwork);
  770. sqlite3_bind_text(_sDeleteRulesForNetwork,1,nwids,16,SQLITE_STATIC);
  771. sqlite3_step(_sDeleteRulesForNetwork);
  772. for(unsigned int kk=0;kk<j->u.object.values[k].value->u.array.length;++kk) {
  773. json_value *rj = j->u.object.values[k].value->u.array.values[kk];
  774. if ((rj)&&(rj->type == json_object)) {
  775. struct { // NULL pointers indicate missing or NULL -- wildcards
  776. const json_int_t *ruleId;
  777. const char *nodeId;
  778. const json_int_t *vlanId;
  779. const json_int_t *vlanPcp;
  780. const json_int_t *etherType;
  781. const char *macSource;
  782. const char *macDest;
  783. const char *ipSource;
  784. const char *ipDest;
  785. const json_int_t *ipTos;
  786. const json_int_t *ipProtocol;
  787. const json_int_t *ipSourcePort;
  788. const json_int_t *ipDestPort;
  789. const json_int_t *flags;
  790. const json_int_t *invFlags;
  791. const char *action;
  792. } rule;
  793. memset(&rule,0,sizeof(rule));
  794. for(unsigned int rk=0;rk<rj->u.object.length;++rk) {
  795. if ((!strcmp(rj->u.object.values[rk].name,"ruleId"))&&(rj->u.object.values[rk].value->type == json_integer))
  796. rule.ruleId = &(rj->u.object.values[rk].value->u.integer);
  797. else if ((!strcmp(rj->u.object.values[rk].name,"nodeId"))&&(rj->u.object.values[rk].value->type == json_string))
  798. rule.nodeId = rj->u.object.values[rk].value->u.string.ptr;
  799. else if ((!strcmp(rj->u.object.values[rk].name,"vlanId"))&&(rj->u.object.values[rk].value->type == json_integer))
  800. rule.vlanId = &(rj->u.object.values[rk].value->u.integer);
  801. else if ((!strcmp(rj->u.object.values[rk].name,"vlanPcp"))&&(rj->u.object.values[rk].value->type == json_integer))
  802. rule.vlanPcp = &(rj->u.object.values[rk].value->u.integer);
  803. else if ((!strcmp(rj->u.object.values[rk].name,"etherType"))&&(rj->u.object.values[rk].value->type == json_integer))
  804. rule.etherType = &(rj->u.object.values[rk].value->u.integer);
  805. else if ((!strcmp(rj->u.object.values[rk].name,"macSource"))&&(rj->u.object.values[rk].value->type == json_string))
  806. rule.macSource = rj->u.object.values[rk].value->u.string.ptr;
  807. else if ((!strcmp(rj->u.object.values[rk].name,"macDest"))&&(rj->u.object.values[rk].value->type == json_string))
  808. rule.macDest = rj->u.object.values[rk].value->u.string.ptr;
  809. else if ((!strcmp(rj->u.object.values[rk].name,"ipSource"))&&(rj->u.object.values[rk].value->type == json_string))
  810. rule.ipSource = rj->u.object.values[rk].value->u.string.ptr;
  811. else if ((!strcmp(rj->u.object.values[rk].name,"ipDest"))&&(rj->u.object.values[rk].value->type == json_string))
  812. rule.ipDest = rj->u.object.values[rk].value->u.string.ptr;
  813. else if ((!strcmp(rj->u.object.values[rk].name,"ipTos"))&&(rj->u.object.values[rk].value->type == json_integer))
  814. rule.ipTos = &(rj->u.object.values[rk].value->u.integer);
  815. else if ((!strcmp(rj->u.object.values[rk].name,"ipProtocol"))&&(rj->u.object.values[rk].value->type == json_integer))
  816. rule.ipProtocol = &(rj->u.object.values[rk].value->u.integer);
  817. else if ((!strcmp(rj->u.object.values[rk].name,"ipSourcePort"))&&(rj->u.object.values[rk].value->type == json_integer))
  818. rule.ipSourcePort = &(rj->u.object.values[rk].value->u.integer);
  819. else if ((!strcmp(rj->u.object.values[rk].name,"ipDestPort"))&&(rj->u.object.values[rk].value->type == json_integer))
  820. rule.ipDestPort = &(rj->u.object.values[rk].value->u.integer);
  821. else if ((!strcmp(rj->u.object.values[rk].name,"flags"))&&(rj->u.object.values[rk].value->type == json_integer))
  822. rule.flags = &(rj->u.object.values[rk].value->u.integer);
  823. else if ((!strcmp(rj->u.object.values[rk].name,"invFlags"))&&(rj->u.object.values[rk].value->type == json_integer))
  824. rule.invFlags = &(rj->u.object.values[rk].value->u.integer);
  825. else if ((!strcmp(rj->u.object.values[rk].name,"action"))&&(rj->u.object.values[rk].value->type == json_string))
  826. rule.action = rj->u.object.values[rk].value->u.string.ptr;
  827. }
  828. if ((rule.ruleId)&&(rule.action)&&(rule.action[0])) {
  829. char mactmp1[16],mactmp2[16];
  830. sqlite3_reset(_sCreateRule);
  831. sqlite3_bind_text(_sCreateRule,1,nwids,16,SQLITE_STATIC);
  832. sqlite3_bind_int64(_sCreateRule,2,*rule.ruleId);
  833. // Optional values: null by default
  834. for(int i=3;i<=16;++i)
  835. sqlite3_bind_null(_sCreateRule,i);
  836. if ((rule.nodeId)&&(strlen(rule.nodeId) == 10)) sqlite3_bind_text(_sCreateRule,3,rule.nodeId,10,SQLITE_STATIC);
  837. if (rule.vlanId) sqlite3_bind_int(_sCreateRule,4,(int)*rule.vlanId);
  838. if (rule.vlanPcp) sqlite3_bind_int(_sCreateRule,5,(int)*rule.vlanPcp);
  839. if (rule.etherType) sqlite3_bind_int(_sCreateRule,6,(int)*rule.etherType & (int)0xffff);
  840. if (rule.macSource) {
  841. MAC m(rule.macSource);
  842. Utils::snprintf(mactmp1,sizeof(mactmp1),"%.12llx",(unsigned long long)m.toInt());
  843. sqlite3_bind_text(_sCreateRule,7,mactmp1,-1,SQLITE_STATIC);
  844. }
  845. if (rule.macDest) {
  846. MAC m(rule.macDest);
  847. Utils::snprintf(mactmp2,sizeof(mactmp2),"%.12llx",(unsigned long long)m.toInt());
  848. sqlite3_bind_text(_sCreateRule,8,mactmp2,-1,SQLITE_STATIC);
  849. }
  850. if (rule.ipSource) sqlite3_bind_text(_sCreateRule,9,rule.ipSource,-1,SQLITE_STATIC);
  851. if (rule.ipDest) sqlite3_bind_text(_sCreateRule,10,rule.ipDest,-1,SQLITE_STATIC);
  852. if (rule.ipTos) sqlite3_bind_int(_sCreateRule,11,(int)*rule.ipTos);
  853. if (rule.ipProtocol) sqlite3_bind_int(_sCreateRule,12,(int)*rule.ipProtocol);
  854. if (rule.ipSourcePort) sqlite3_bind_int(_sCreateRule,13,(int)*rule.ipSourcePort & (int)0xffff);
  855. if (rule.ipDestPort) sqlite3_bind_int(_sCreateRule,14,(int)*rule.ipDestPort & (int)0xffff);
  856. if (rule.flags) sqlite3_bind_int64(_sCreateRule,15,(int64_t)*rule.flags);
  857. if (rule.invFlags) sqlite3_bind_int64(_sCreateRule,16,(int64_t)*rule.invFlags);
  858. sqlite3_bind_text(_sCreateRule,17,rule.action,-1,SQLITE_STATIC);
  859. sqlite3_step(_sCreateRule);
  860. }
  861. }
  862. }
  863. }
  864. }
  865. if (stmt) {
  866. sqlite3_bind_text(stmt,2,nwids,16,SQLITE_STATIC);
  867. sqlite3_step(stmt);
  868. sqlite3_finalize(stmt);
  869. }
  870. }
  871. }
  872. json_value_free(j);
  873. }
  874. sqlite3_reset(_sSetNetworkRevision);
  875. sqlite3_bind_int64(_sSetNetworkRevision,1,revision += 1);
  876. sqlite3_bind_text(_sSetNetworkRevision,2,nwids,16,SQLITE_STATIC);
  877. sqlite3_step(_sSetNetworkRevision);
  878. return _doCPGet(path,urlArgs,headers,body,responseBody,responseContentType);
  879. }
  880. } // else 404
  881. } // else 404
  882. return 404;
  883. }
  884. unsigned int SqliteNetworkController::handleControlPlaneHttpDELETE(
  885. const std::vector<std::string> &path,
  886. const std::map<std::string,std::string> &urlArgs,
  887. const std::map<std::string,std::string> &headers,
  888. const std::string &body,
  889. std::string &responseBody,
  890. std::string &responseContentType)
  891. {
  892. if (path.empty())
  893. return 404;
  894. Mutex::Lock _l(_lock);
  895. if (path[0] == "network") {
  896. if ((path.size() >= 2)&&(path[1].length() == 16)) {
  897. uint64_t nwid = Utils::hexStrToU64(path[1].c_str());
  898. char nwids[24];
  899. Utils::snprintf(nwids,sizeof(nwids),"%.16llx",(unsigned long long)nwid);
  900. if (path.size() >= 3) {
  901. if ((path.size() == 4)&&(path[2] == "member")&&(path[3].length() == 10)) {
  902. uint64_t address = Utils::hexStrToU64(path[3].c_str());
  903. char addrs[24];
  904. Utils::snprintf(addrs,sizeof(addrs),"%.10llx",address);
  905. sqlite3_reset(_sDeleteIpAllocations);
  906. sqlite3_bind_text(_sDeleteIpAllocations,1,nwids,16,SQLITE_STATIC);
  907. sqlite3_bind_text(_sDeleteIpAllocations,2,addrs,10,SQLITE_STATIC);
  908. if (sqlite3_step(_sDeleteIpAllocations) == SQLITE_DONE) {
  909. sqlite3_reset(_sDeleteMember);
  910. sqlite3_bind_text(_sDeleteMember,1,nwids,16,SQLITE_STATIC);
  911. sqlite3_bind_text(_sDeleteMember,2,addrs,10,SQLITE_STATIC);
  912. if (sqlite3_step(_sDeleteMember) != SQLITE_DONE)
  913. return 500;
  914. } else return 500;
  915. return 200;
  916. }
  917. } else {
  918. sqlite3_reset(_sDeleteNetworkAndRelated);
  919. for(int i=1;i<=7;++i)
  920. sqlite3_bind_text(_sDeleteNetworkAndRelated,i,nwids,16,SQLITE_STATIC);
  921. return ((sqlite3_step(_sDeleteNetworkAndRelated) == SQLITE_DONE) ? 200 : 500);
  922. }
  923. } // else 404
  924. } // else 404
  925. return 404;
  926. }
  927. unsigned int SqliteNetworkController::_doCPGet(
  928. const std::vector<std::string> &path,
  929. const std::map<std::string,std::string> &urlArgs,
  930. const std::map<std::string,std::string> &headers,
  931. const std::string &body,
  932. std::string &responseBody,
  933. std::string &responseContentType)
  934. {
  935. // Assumes _lock is locked
  936. char json[16384];
  937. if ((path.size() > 0)&&(path[0] == "network")) {
  938. if ((path.size() >= 2)&&(path[1].length() == 16)) {
  939. uint64_t nwid = Utils::hexStrToU64(path[1].c_str());
  940. char nwids[24];
  941. Utils::snprintf(nwids,sizeof(nwids),"%.16llx",(unsigned long long)nwid);
  942. if (path.size() >= 3) {
  943. if ((path.size() == 4)&&(path[2] == "member")&&(path[3].length() == 10)) {
  944. uint64_t address = Utils::hexStrToU64(path[3].c_str());
  945. char addrs[24];
  946. Utils::snprintf(addrs,sizeof(addrs),"%.10llx",address);
  947. sqlite3_reset(_sGetMember2);
  948. sqlite3_bind_text(_sGetMember2,1,nwids,16,SQLITE_STATIC);
  949. sqlite3_bind_text(_sGetMember2,2,addrs,10,SQLITE_STATIC);
  950. if (sqlite3_step(_sGetMember2) == SQLITE_ROW) {
  951. Utils::snprintf(json,sizeof(json),
  952. "{\n"
  953. "\t\"nwid\": \"%s\",\n"
  954. "\t\"address\": \"%s\",\n"
  955. "\t\"authorized\": %s,\n"
  956. "\t\"activeBridge\": %s,\n"
  957. "\t\"lastAt\": \"%s\",\n"
  958. "\t\"lastSeen\": %llu,\n"
  959. "\t\"firstSeen\": %llu,\n"
  960. "\t\"identity\": \"%s\",\n"
  961. "\t\"ipAssignments\": [",
  962. nwids,
  963. addrs,
  964. (sqlite3_column_int(_sGetMember2,0) > 0) ? "true" : "false",
  965. (sqlite3_column_int(_sGetMember2,1) > 0) ? "true" : "false",
  966. _jsonEscape((const char *)sqlite3_column_text(_sGetMember2,3)).c_str(),
  967. (unsigned long long)sqlite3_column_int64(_sGetMember2,4),
  968. (unsigned long long)sqlite3_column_int64(_sGetMember2,5),
  969. _jsonEscape((const char *)sqlite3_column_text(_sGetMember2,2)).c_str());
  970. responseBody = json;
  971. sqlite3_reset(_sGetIpAssignmentsForNode2);
  972. sqlite3_bind_text(_sGetIpAssignmentsForNode2,1,nwids,16,SQLITE_STATIC);
  973. sqlite3_bind_text(_sGetIpAssignmentsForNode2,2,addrs,10,SQLITE_STATIC);
  974. bool firstIp = true;
  975. while (sqlite3_step(_sGetIpAssignmentPools2) == SQLITE_ROW) {
  976. InetAddress ip((const void *)sqlite3_column_blob(_sGetIpAssignmentsForNode2,0),(sqlite3_column_int(_sGetIpAssignmentsForNode2,2) == 6) ? 16 : 4,(unsigned int)sqlite3_column_int(_sGetIpAssignmentPools2,1));
  977. responseBody.append(firstIp ? "\"" : ",\"");
  978. firstIp = false;
  979. responseBody.append(_jsonEscape(ip.toString()));
  980. responseBody.push_back('"');
  981. }
  982. responseBody.append("]");
  983. /* It's possible to get the actual netconf dictionary by including these
  984. * three URL arguments. The member identity must be the string
  985. * serialized identity of this member, and the signing identity must be
  986. * the full secret identity of this network controller. The have revision
  987. * is optional but would designate the revision our hypothetical client
  988. * already has.
  989. *
  990. * This is primarily for testing and is not used in production. It makes
  991. * it easy to test the entire network controller via its JSON API.
  992. *
  993. * If these arguments are included, three more object fields are returned:
  994. * 'netconf', 'netconfResult', and 'netconfResultMessage'. These are all
  995. * string fields and contain the actual netconf dictionary, the query
  996. * result code, and any verbose message e.g. an error description. */
  997. std::map<std::string,std::string>::const_iterator memids(urlArgs.find("memberIdentity"));
  998. std::map<std::string,std::string>::const_iterator sigids(urlArgs.find("signingIdentity"));
  999. std::map<std::string,std::string>::const_iterator hrs(urlArgs.find("haveRevision"));
  1000. if ((memids != urlArgs.end())&&(sigids != urlArgs.end())) {
  1001. Dictionary netconf;
  1002. Identity memid,sigid;
  1003. try {
  1004. if (memid.fromString(memids->second)&&sigid.fromString(sigids->second)&&sigid.hasPrivate()) {
  1005. uint64_t hr = 0;
  1006. if (hrs != urlArgs.end())
  1007. hr = Utils::strToU64(hrs->second.c_str());
  1008. const char *result = "";
  1009. switch(this->doNetworkConfigRequest(InetAddress(),sigid,memid,nwid,Dictionary(),hr,netconf)) {
  1010. case NetworkController::NETCONF_QUERY_OK: result = "OK"; break;
  1011. case NetworkController::NETCONF_QUERY_OK_BUT_NOT_NEWER: result = "OK_BUT_NOT_NEWER"; break;
  1012. case NetworkController::NETCONF_QUERY_OBJECT_NOT_FOUND: result = "OBJECT_NOT_FOUND"; break;
  1013. case NetworkController::NETCONF_QUERY_ACCESS_DENIED: result = "ACCESS_DENIED"; break;
  1014. case NetworkController::NETCONF_QUERY_INTERNAL_SERVER_ERROR: result = "INTERNAL_SERVER_ERROR"; break;
  1015. default: result = "(unrecognized result code)"; break;
  1016. }
  1017. responseBody.append(",\n\t\"netconf\": \"");
  1018. responseBody.append(_jsonEscape(netconf.toString().c_str()));
  1019. responseBody.append("\",\n\t\"netconfResult\": \"");
  1020. responseBody.append(result);
  1021. responseBody.append("\",\n\t\"netconfResultMessage\": \"");
  1022. responseBody.append(_jsonEscape(netconf["error"].c_str()));
  1023. responseBody.append("\"");
  1024. } else {
  1025. responseBody.append(",\n\t\"netconf\": \"\",\n\t\"netconfResult\": \"INTERNAL_SERVER_ERROR\",\n\t\"netconfResultMessage\": \"invalid member or signing identity\"");
  1026. }
  1027. } catch ( ... ) {
  1028. responseBody.append(",\n\t\"netconf\": \"\",\n\t\"netconfResult\": \"INTERNAL_SERVER_ERROR\",\n\t\"netconfResultMessage\": \"unexpected exception\"");
  1029. }
  1030. }
  1031. responseBody.append("\n}\n");
  1032. responseContentType = "application/json";
  1033. return 200;
  1034. } // else 404
  1035. } // else 404
  1036. } else {
  1037. // get network info
  1038. sqlite3_reset(_sGetNetworkById);
  1039. sqlite3_bind_text(_sGetNetworkById,1,nwids,16,SQLITE_STATIC);
  1040. if (sqlite3_step(_sGetNetworkById) == SQLITE_ROW) {
  1041. Utils::snprintf(json,sizeof(json),
  1042. "{\n"
  1043. "\t\"nwid\": \"%s\",\n"
  1044. "\t\"name\": \"%s\",\n"
  1045. "\t\"private\": %s,\n"
  1046. "\t\"enableBroadcast\": %s,\n"
  1047. "\t\"allowPassiveBridging\": %s,\n"
  1048. "\t\"v4AssignMode\": \"%s\",\n"
  1049. "\t\"v6AssignMode\": \"%s\",\n"
  1050. "\t\"multicastLimit\": %d,\n"
  1051. "\t\"creationTime\": %llu,\n"
  1052. "\t\"revision\": %llu,\n"
  1053. "\t\"members\": [",
  1054. nwids,
  1055. _jsonEscape((const char *)sqlite3_column_text(_sGetNetworkById,0)).c_str(),
  1056. (sqlite3_column_int(_sGetNetworkById,1) > 0) ? "true" : "false",
  1057. (sqlite3_column_int(_sGetNetworkById,2) > 0) ? "true" : "false",
  1058. (sqlite3_column_int(_sGetNetworkById,3) > 0) ? "true" : "false",
  1059. _jsonEscape((const char *)sqlite3_column_text(_sGetNetworkById,4)).c_str(),
  1060. _jsonEscape((const char *)sqlite3_column_text(_sGetNetworkById,5)).c_str(),
  1061. sqlite3_column_int(_sGetNetworkById,6),
  1062. (unsigned long long)sqlite3_column_int64(_sGetNetworkById,7),
  1063. (unsigned long long)sqlite3_column_int64(_sGetNetworkById,8));
  1064. responseBody = json;
  1065. sqlite3_reset(_sListNetworkMembers);
  1066. sqlite3_bind_text(_sListNetworkMembers,1,nwids,16,SQLITE_STATIC);
  1067. bool firstMember = true;
  1068. while (sqlite3_step(_sListNetworkMembers) == SQLITE_ROW) {
  1069. if (!firstMember)
  1070. responseBody.push_back(',');
  1071. responseBody.push_back('"');
  1072. responseBody.append((const char *)sqlite3_column_text(_sListNetworkMembers,0));
  1073. responseBody.push_back('"');
  1074. firstMember = false;
  1075. }
  1076. responseBody.append("],\n\t\"relays\": [");
  1077. sqlite3_reset(_sGetRelays);
  1078. sqlite3_bind_text(_sGetRelays,1,nwids,16,SQLITE_STATIC);
  1079. bool firstRelay = true;
  1080. while (sqlite3_step(_sGetRelays) == SQLITE_ROW) {
  1081. responseBody.append(firstRelay ? "\n\t\t" : ",\n\t\t");
  1082. firstRelay = false;
  1083. responseBody.append("{\"address\":\"");
  1084. responseBody.append((const char *)sqlite3_column_text(_sGetRelays,0));
  1085. responseBody.append("\",\"phyAddress\":\"");
  1086. responseBody.append(_jsonEscape((const char *)sqlite3_column_text(_sGetRelays,1)));
  1087. responseBody.append("\"}");
  1088. }
  1089. responseBody.append("],\n\t\"ipAssignmentPools\": [");
  1090. sqlite3_reset(_sGetIpAssignmentPools2);
  1091. sqlite3_bind_text(_sGetIpAssignmentPools2,1,nwids,16,SQLITE_STATIC);
  1092. bool firstIpAssignmentPool = true;
  1093. while (sqlite3_step(_sGetIpAssignmentPools2) == SQLITE_ROW) {
  1094. responseBody.append(firstIpAssignmentPool ? "\n\t\t" : ",\n\t\t");
  1095. firstIpAssignmentPool = false;
  1096. InetAddress ipp((const void *)sqlite3_column_blob(_sGetIpAssignmentPools2,0),(sqlite3_column_int(_sGetIpAssignmentPools2,2) == 6) ? 16 : 4,(unsigned int)sqlite3_column_int(_sGetIpAssignmentPools2,1));
  1097. Utils::snprintf(json,sizeof(json),"{\"network\":\"%s\",\"netmaskBits\":%u}",
  1098. _jsonEscape(ipp.toIpString()).c_str(),
  1099. ipp.netmaskBits());
  1100. responseBody.append(json);
  1101. }
  1102. responseBody.append("],\n\t\"rules\": [");
  1103. sqlite3_reset(_sListRules);
  1104. sqlite3_bind_text(_sListRules,1,nwids,16,SQLITE_STATIC);
  1105. bool firstRule = true;
  1106. while (sqlite3_step(_sListRules) == SQLITE_ROW) {
  1107. responseBody.append(firstRule ? "\n\t{\n" : ",{\n");
  1108. Utils::snprintf(json,sizeof(json),"\t\t\"ruleId\": %lld,\n",sqlite3_column_int64(_sListRules,0));
  1109. responseBody.append(json);
  1110. if (sqlite3_column_type(_sListRules,1) != SQLITE_NULL) {
  1111. Utils::snprintf(json,sizeof(json),"\t\t\"nodeId\": \"%s\",\n",(const char *)sqlite3_column_text(_sListRules,1));
  1112. responseBody.append(json);
  1113. }
  1114. if (sqlite3_column_type(_sListRules,2) != SQLITE_NULL) {
  1115. Utils::snprintf(json,sizeof(json),"\t\t\"vlanId\": %d,\n",sqlite3_column_int(_sListRules,2));
  1116. responseBody.append(json);
  1117. }
  1118. if (sqlite3_column_type(_sListRules,3) != SQLITE_NULL) {
  1119. Utils::snprintf(json,sizeof(json),"\t\t\"vlanPcp\": %d,\n",sqlite3_column_int(_sListRules,3));
  1120. responseBody.append(json);
  1121. }
  1122. if (sqlite3_column_type(_sListRules,4) != SQLITE_NULL) {
  1123. Utils::snprintf(json,sizeof(json),"\t\t\"etherType\": %d,\n",sqlite3_column_int(_sListRules,4));
  1124. responseBody.append(json);
  1125. }
  1126. if (sqlite3_column_type(_sListRules,5) != SQLITE_NULL) {
  1127. Utils::snprintf(json,sizeof(json),"\t\t\"macSource\": \"%s\",\n",MAC((const char *)sqlite3_column_text(_sListRules,5)).toString().c_str());
  1128. responseBody.append(json);
  1129. }
  1130. if (sqlite3_column_type(_sListRules,6) != SQLITE_NULL) {
  1131. Utils::snprintf(json,sizeof(json),"\t\t\"macDest\": \"%s\",\n",MAC((const char *)sqlite3_column_text(_sListRules,6)).toString().c_str());
  1132. responseBody.append(json);
  1133. }
  1134. if (sqlite3_column_type(_sListRules,7) != SQLITE_NULL) {
  1135. Utils::snprintf(json,sizeof(json),"\t\t\"ipSource\": \"%s\",\n",_jsonEscape((const char *)sqlite3_column_text(_sListRules,7)).c_str());
  1136. responseBody.append(json);
  1137. }
  1138. if (sqlite3_column_type(_sListRules,8) != SQLITE_NULL) {
  1139. Utils::snprintf(json,sizeof(json),"\t\t\"ipDest\": \"%s\",\n",_jsonEscape((const char *)sqlite3_column_text(_sListRules,8)).c_str());
  1140. responseBody.append(json);
  1141. }
  1142. if (sqlite3_column_type(_sListRules,9) != SQLITE_NULL) {
  1143. Utils::snprintf(json,sizeof(json),"\t\t\"ipTos\": %d,\n",sqlite3_column_int(_sListRules,9));
  1144. responseBody.append(json);
  1145. }
  1146. if (sqlite3_column_type(_sListRules,10) != SQLITE_NULL) {
  1147. Utils::snprintf(json,sizeof(json),"\t\t\"ipProtocol\": %d,\n",sqlite3_column_int(_sListRules,10));
  1148. responseBody.append(json);
  1149. }
  1150. if (sqlite3_column_type(_sListRules,11) != SQLITE_NULL) {
  1151. Utils::snprintf(json,sizeof(json),"\t\t\"ipSourcePort\": %d,\n",sqlite3_column_int(_sListRules,11));
  1152. responseBody.append(json);
  1153. }
  1154. if (sqlite3_column_type(_sListRules,12) != SQLITE_NULL) {
  1155. Utils::snprintf(json,sizeof(json),"\t\t\"ipDestPort\": %d,\n",sqlite3_column_int(_sListRules,12));
  1156. responseBody.append(json);
  1157. }
  1158. if (sqlite3_column_type(_sListRules,13) != SQLITE_NULL) {
  1159. Utils::snprintf(json,sizeof(json),"\t\t\"flags\": %lu,\n",(unsigned long)sqlite3_column_int64(_sListRules,13));
  1160. responseBody.append(json);
  1161. }
  1162. if (sqlite3_column_type(_sListRules,14) != SQLITE_NULL) {
  1163. Utils::snprintf(json,sizeof(json),"\t\t\"invFlags\": %lu,\n",(unsigned long)sqlite3_column_int64(_sListRules,14));
  1164. responseBody.append(json);
  1165. }
  1166. responseBody.append("\t\t\"action\": \"");
  1167. responseBody.append(_jsonEscape( (sqlite3_column_type(_sListRules,15) == SQLITE_NULL) ? "drop" : (const char *)sqlite3_column_text(_sListRules,15) ));
  1168. responseBody.append("\"\n\t}");
  1169. }
  1170. responseBody.append("]\n}\n");
  1171. responseContentType = "application/json";
  1172. return 200;
  1173. } // else 404
  1174. }
  1175. } else if (path.size() == 1) {
  1176. // list networks
  1177. sqlite3_reset(_sListNetworks);
  1178. responseContentType = "application/json";
  1179. responseBody = "[";
  1180. bool first = true;
  1181. while (sqlite3_step(_sListNetworks) == SQLITE_ROW) {
  1182. if (first) {
  1183. first = false;
  1184. responseBody.push_back('"');
  1185. } else responseBody.append(",\"");
  1186. responseBody.append((const char *)sqlite3_column_text(_sListNetworks,0));
  1187. responseBody.push_back('"');
  1188. }
  1189. responseBody.push_back(']');
  1190. return 200;
  1191. } // else 404
  1192. } else {
  1193. // GET /controller returns status and API version if controller is supported
  1194. Utils::snprintf(json,sizeof(json),"{\n\t\"controller\": true,\n\t\"apiVersion\": %d,\n\t\"clock\": %llu\n}",ZT_NETCONF_CONTROLLER_API_VERSION,(unsigned long long)OSUtils::now());
  1195. responseBody = json;
  1196. responseContentType = "applicaiton/json";
  1197. return 200;
  1198. }
  1199. return 404;
  1200. }
  1201. } // namespace ZeroTier