1
0

cjdroute2.c 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659
  1. /* vim: set expandtab ts=4 sw=4: */
  2. /*
  3. * You may redistribute this program and/or modify it under the terms of
  4. * the GNU General Public License as published by the Free Software Foundation,
  5. * either version 3 of the License, or (at your option) any later version.
  6. *
  7. * This program is distributed in the hope that it will be useful,
  8. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  9. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  10. * GNU General Public License for more details.
  11. *
  12. * You should have received a copy of the GNU General Public License
  13. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  14. */
  15. #include "client/AdminClient.h"
  16. #include "admin/angel/Core.h"
  17. #include "admin/angel/InterfaceWaiter.h"
  18. #include "client/Configurator.h"
  19. #include "benc/Dict.h"
  20. #include "benc/Int.h"
  21. #include "benc/List.h"
  22. #include "benc/serialization/BencSerializer.h"
  23. #include "benc/serialization/json/JsonBencSerializer.h"
  24. #include "benc/serialization/standard/BencMessageReader.h"
  25. #include "benc/serialization/standard/BencMessageWriter.h"
  26. #include "crypto/AddressCalc.h"
  27. #include "crypto/CryptoAuth.h"
  28. #include "dht/Address.h"
  29. #include "exception/Except.h"
  30. #include "interface/Iface.h"
  31. #include "io/FileReader.h"
  32. #include "io/FileWriter.h"
  33. #include "io/Reader.h"
  34. #include "io/Writer.h"
  35. #include "memory/Allocator.h"
  36. #include "memory/MallocAllocator.h"
  37. #include "util/ArchInfo.h"
  38. #include "util/Assert.h"
  39. #include "util/Base32.h"
  40. #include "util/CString.h"
  41. #include "util/events/UDPAddrIface.h"
  42. #include "util/events/Time.h"
  43. #include "util/events/EventBase.h"
  44. #include "util/events/Pipe.h"
  45. #include "util/events/Process.h"
  46. #include "util/Hex.h"
  47. #include "util/log/Log.h"
  48. #include "util/log/FileWriterLog.h"
  49. #include "util/SysInfo.h"
  50. #include "util/version/Version.h"
  51. #include "net/Benchmark.h"
  52. #include "crypto_scalarmult_curve25519.h"
  53. #include <stdint.h>
  54. #include <stdio.h>
  55. #include <unistd.h>
  56. #define DEFAULT_TUN_DEV "tun0"
  57. static int genAddress(uint8_t addressOut[40],
  58. uint8_t privateKeyHexOut[65],
  59. uint8_t publicKeyBase32Out[53],
  60. struct Random* rand)
  61. {
  62. struct Address address;
  63. uint8_t privateKey[32];
  64. for (;;) {
  65. Random_bytes(rand, privateKey, 32);
  66. crypto_scalarmult_curve25519_base(address.key, privateKey);
  67. // Brute force for keys until one matches FC00:/8
  68. if (AddressCalc_addressForPublicKey(address.ip6.bytes, address.key)) {
  69. Hex_encode(privateKeyHexOut, 65, privateKey, 32);
  70. Base32_encode(publicKeyBase32Out, 53, address.key, 32);
  71. Address_printShortIp(addressOut, &address);
  72. return 0;
  73. }
  74. }
  75. }
  76. static int genconf(struct Random* rand, bool eth)
  77. {
  78. uint8_t password[32];
  79. uint8_t password2[32];
  80. uint8_t password3[32];
  81. uint8_t password4[32];
  82. Random_base32(rand, password, 32);
  83. Random_base32(rand, password2, 32);
  84. Random_base32(rand, password3, 32);
  85. Random_base32(rand, password4, 32);
  86. uint8_t adminPassword[32];
  87. Random_base32(rand, adminPassword, 32);
  88. uint16_t port = 0;
  89. while (port <= 1024) {
  90. port = Random_uint16(rand);
  91. }
  92. uint8_t publicKeyBase32[53];
  93. uint8_t address[40];
  94. uint8_t privateKeyHex[65];
  95. genAddress(address, privateKeyHex, publicKeyBase32, rand);
  96. printf("{\n");
  97. printf(" // Private key:\n"
  98. " // Your confidentiality and data integrity depend on this key, keep it secret!\n"
  99. " \"privateKey\": \"%s\",\n\n", privateKeyHex);
  100. printf(" // This key corresponds to the public key and ipv6 address:\n"
  101. " \"publicKey\": \"%s.k\",\n", publicKeyBase32);
  102. printf(" \"ipv6\": \"%s\",\n", address);
  103. printf("\n"
  104. " // Anyone connecting and offering these passwords on connection will be allowed.\n"
  105. " //\n"
  106. " // WARNING: Currently there is no key derivation done on the password field,\n"
  107. " // DO NOT USE A PASSWORD HERE use something which is truly random and\n"
  108. " // cannot be guessed.\n"
  109. " // Including a username in the beginning of the password string is encouraged\n"
  110. " // to aid in remembering which users are who.\n"
  111. " //\n"
  112. " \"authorizedPasswords\":\n"
  113. " [\n"
  114. " // A unique string which is known to the client and server.\n"
  115. " {\"password\": \"%s\"}\n", password);
  116. printf("\n"
  117. " // More passwords should look like this.\n"
  118. " // {\"password\": \"%s\"},\n", password2);
  119. printf(" // {\"password\": \"%s\"},\n", password3);
  120. printf(" // {\"password\": \"%s\"},\n", password4);
  121. printf("\n"
  122. " // Below is an example of your connection credentials\n"
  123. " // that you can give to other people so they can connect\n"
  124. " // to you using your default password (from above)\n"
  125. " // Adding a unique password for each user is advisable\n"
  126. " // so that leaks can be isolated.\n"
  127. " //\n"
  128. " // \"your.external.ip.goes.here:%u\":{", port);
  129. printf("\"password\":\"%s\",", password);
  130. printf("\"publicKey\":\"%s.k\"}\n", publicKeyBase32);
  131. printf(" ],\n"
  132. "\n"
  133. " // Settings for administering and extracting information from your router.\n"
  134. " // This interface provides functions which can be called through a UDP socket.\n"
  135. " // See admin/Readme.md for more information about the API and try:\n"
  136. " // ./contrib/python/cexec 'functions'\n"
  137. " // For a list of functions which can be called.\n"
  138. " // For example: ./contrib/python/cexec 'memory()'\n"
  139. " // will call a function which gets the core's current memory consumption.\n"
  140. " // ./contrib/python/cjdnslog\n"
  141. " // is a tool which uses this admin interface to get logs from cjdns.\n"
  142. " \"admin\":\n"
  143. " {\n"
  144. " // Port to bind the admin RPC server to.\n"
  145. " \"bind\": \"127.0.0.1:11234\",\n"
  146. "\n"
  147. " // Password for admin RPC server.\n"
  148. " \"password\": \"%s\"\n", adminPassword);
  149. printf(" },\n"
  150. "\n"
  151. " // Interfaces to connect to the switch core.\n"
  152. " \"interfaces\":\n"
  153. " {\n"
  154. " // The interface which connects over UDP/IP based VPN tunnel.\n"
  155. " \"UDPInterface\":\n"
  156. " [\n"
  157. " {\n"
  158. " // Bind to this port.\n"
  159. " \"bind\": \"0.0.0.0:%u\",\n", port);
  160. printf("\n"
  161. " // Nodes to connect to (IPv4 only).\n"
  162. " \"connectTo\":\n"
  163. " {\n"
  164. " // Add connection credentials here to join the network\n"
  165. " // Ask somebody who is already connected.\n"
  166. " }\n"
  167. " },\n"
  168. " {\n"
  169. " // Bind to this port.\n"
  170. " \"bind\": \"[::]:%u\",\n", port);
  171. printf("\n"
  172. " // Nodes to connect to (IPv6 only).\n"
  173. " \"connectTo\":\n"
  174. " {\n"
  175. " // Add connection credentials here to join the network\n"
  176. " // Ask somebody who is already connected.\n"
  177. " }\n"
  178. " }\n"
  179. " ]\n");
  180. #ifdef HAS_ETH_INTERFACE
  181. printf("\n");
  182. if (!eth) {
  183. printf(" /*\n");
  184. }
  185. printf(" \"ETHInterface\":\n"
  186. " [\n"
  187. " // Alternatively bind to just one device and either beacon and/or\n"
  188. " // connect to a specified MAC address\n"
  189. " {\n"
  190. " // Bind to this device (interface name, not MAC)\n"
  191. " // \"all\" is a pseudo-name which will try to connect to all devices.\n"
  192. " \"bind\": \"all\",\n"
  193. "\n"
  194. " // Auto-connect to other cjdns nodes on the same network.\n"
  195. " // Options:\n"
  196. " //\n"
  197. " // 0 -- Disabled.\n"
  198. " //\n"
  199. " // 1 -- Accept beacons, this will cause cjdns to accept incoming\n"
  200. " // beacon messages and try connecting to the sender.\n"
  201. " //\n"
  202. " // 2 -- Accept and send beacons, this will cause cjdns to broadcast\n"
  203. " // messages on the local network which contain a randomly\n"
  204. " // generated per-session password, other nodes which have this\n"
  205. " // set to 1 or 2 will hear the beacon messages and connect\n"
  206. " // automatically.\n"
  207. " //\n"
  208. " \"beacon\": 2,\n"
  209. "\n"
  210. " // Node(s) to connect to manually\n"
  211. " // Note: does not work with \"all\" pseudo-device-name\n"
  212. " \"connectTo\":\n"
  213. " {\n"
  214. " // Credentials for connecting look similar to UDP credientials\n"
  215. " // except they begin with the mac address, for example:\n"
  216. " // \"01:02:03:04:05:06\":{\"password\":\"a\",\"publicKey\":\"b\"}\n"
  217. " }\n"
  218. " }\n"
  219. " ]\n");
  220. if (!eth) {
  221. printf(" */\n");
  222. }
  223. printf("\n");
  224. #endif
  225. printf(" },\n"
  226. "\n"
  227. " // Configuration for the router.\n"
  228. " \"router\":\n"
  229. " {\n"
  230. " // The interface which is used for connecting to the cjdns network.\n"
  231. " \"interface\":\n"
  232. " {\n"
  233. " // The type of interface (only TUNInterface is supported for now)\n"
  234. " \"type\": \"TUNInterface\"\n"
  235. #ifndef __APPLE__
  236. "\n"
  237. " // The name of a persistent TUN device to use.\n"
  238. " // This for starting cjdroute as its own user.\n"
  239. " // *MOST USERS DON'T NEED THIS*\n"
  240. " //\"tunDevice\": \"" DEFAULT_TUN_DEV "\"\n"
  241. #endif
  242. " },\n"
  243. "\n"
  244. " // System for tunneling IPv4 and ICANN IPv6 through cjdns.\n"
  245. " // This is using the cjdns switch layer as a VPN carrier.\n"
  246. " \"ipTunnel\":\n"
  247. " {\n"
  248. " // Nodes allowed to connect to us.\n"
  249. " // When a node with the given public key connects, give them the\n"
  250. " // ip4 and/or ip6 addresses listed.\n"
  251. " \"allowedConnections\":\n"
  252. " [\n"
  253. " // Give the client an address on 192.168.1.0/24, and an address\n"
  254. " // it thinks has all of IPv6 behind it.\n"
  255. " // {\n"
  256. " // \"publicKey\": "
  257. "\"f64hfl7c4uxt6krmhPutTheRealAddressOfANodeHere7kfm5m0.k\",\n"
  258. " // \"ip4Address\": \"192.168.1.24\",\n"
  259. " // \"ip4Prefix\": 24,\n"
  260. " // \"ip6Address\": \"2001:123:ab::10\",\n"
  261. " // \"ip6Prefix\": 0\n"
  262. " // },\n"
  263. "\n"
  264. " // It's ok to only specify one address.\n"
  265. " // {\n"
  266. " // \"publicKey\": "
  267. "\"ydq8csdk8p8ThisIsJustAnExampleAddresstxuyqdf27hvn2z0.k\",\n"
  268. " // \"ip4Address\": \"192.168.1.25\",\n"
  269. " // \"ip4Prefix\": 24\n"
  270. " // }\n"
  271. " ],\n"
  272. "\n"
  273. " \"outgoingConnections\":\n"
  274. " [\n"
  275. " // Connect to one or more machines and ask them for IP addresses.\n"
  276. " // \"6743gf5tw80ExampleExampleExampleExamplevlyb23zfnuzv0.k\",\n"
  277. " // \"pw9tfmr8pcrExampleExampleExampleExample8rhg1pgwpwf80.k\",\n"
  278. " // \"g91lxyxhq0kExampleExampleExampleExample6t0mknuhw75l0.k\"\n"
  279. " ]\n"
  280. " }\n"
  281. " },\n"
  282. "\n");
  283. printf(" // Dropping permissions.\n"
  284. " // In the event of a serious security exploit in cjdns, leak of confidential\n"
  285. " // network traffic and/or keys is highly likely but the following rules are\n"
  286. " // designed to prevent the attack from spreading to the system on which cjdns\n"
  287. " // is running.\n"
  288. " // Counter-intuitively, cjdns is *more* secure if it is started as root because\n"
  289. " // non-root users do not have permission to use chroot or change usernames,\n"
  290. " // limiting the effectiveness of the mitigations herein.\n"
  291. " \"security\":\n"
  292. " [\n"
  293. " // Change the user id to sandbox the cjdns process after it starts.\n"
  294. " // If keepNetAdmin is set to 0, IPTunnel will be unable to set IP addresses\n"
  295. " // and ETHInterface will be unable to hot-add new interfaces\n"
  296. " // Use { \"setuser\": 0 } to disable.\n"
  297. " // Default: enabled with keepNetAdmin\n"
  298. " { \"setuser\": \"nobody\", \"keepNetAdmin\": 1 },\n"
  299. "\n"
  300. " // Chroot changes the filesystem root directory which cjdns sees, blocking it\n"
  301. " // from accessing files outside of the chroot sandbox, if the user does not\n"
  302. " // have permission to use chroot(), this will fail quietly.\n"
  303. " // Use { \"chroot\": 0 } to disable.\n"
  304. " // Default: enabled (using \"/var/run\")\n"
  305. " { \"chroot\": \"/var/run/\" },\n"
  306. "\n"
  307. " // Nofiles is a deprecated security feature which prevents cjdns from opening\n"
  308. " // any files at all, using this will block setting of IP addresses and\n"
  309. " // hot-adding ETHInterface devices but for users who do not need this, it\n"
  310. " // provides a formidable sandbox.\n"
  311. " // Default: disabled\n"
  312. " { \"nofiles\": 0 },\n"
  313. "\n"
  314. " // Noforks will prevent cjdns from spawning any new processes or threads,\n"
  315. " // this prevents many types of exploits from attacking the wider system.\n"
  316. " // Default: enabled\n"
  317. " { \"noforks\": 1 },\n"
  318. "\n"
  319. " // Seccomp is the most advanced sandboxing feature in cjdns, it uses\n"
  320. " // SECCOMP_BPF to filter the system calls which cjdns is able to make on a\n"
  321. " // linux system, strictly limiting it's access to the outside world\n"
  322. " // This will fail quietly on any non-linux system\n"
  323. " // Default: enabled\n"
  324. " { \"seccomp\": 1 },\n"
  325. "\n"
  326. " // The client sets up the core using a sequence of RPC calls, the responses\n"
  327. " // to these calls are verified but in the event that the client crashes\n"
  328. " // setup of the core completes, it could leave the core in an insecure state\n"
  329. " // This call constitutes the client telling the core that the security rules\n"
  330. " // have been fully applied and the core may run. Without it, the core will\n"
  331. " // exit within a few seconds with return code 232.\n"
  332. " // Default: enabled\n"
  333. " { \"setupComplete\": 1 }\n"
  334. " ],\n"
  335. "\n"
  336. " // Logging\n"
  337. " \"logging\":\n"
  338. " {\n"
  339. " // Uncomment to have cjdns log to stdout rather than making logs available\n"
  340. " // via the admin socket.\n"
  341. " // \"logTo\":\"stdout\"\n"
  342. " },\n"
  343. "\n"
  344. " // If set to non-zero, cjdns will not fork to the background.\n"
  345. " // Recommended for use in conjunction with \"logTo\":\"stdout\".\n"
  346. " \"noBackground\":0,\n"
  347. "}\n");
  348. return 0;
  349. }
  350. static int usage(struct Allocator* alloc, char* appName)
  351. {
  352. char* sysInfo = SysInfo_describe(SysInfo_detect(), alloc);
  353. printf("Cjdns %s %s\n"
  354. "Usage: %s [--help] [--genconf] [--bench] [--version] [--cleanconf] [--nobg]\n"
  355. "\n"
  356. "To get the router up and running.\n"
  357. "Step 1:\n"
  358. " Generate a new configuration file.\n"
  359. " %s --genconf > cjdroute.conf\n"
  360. "\n"
  361. "Step 2:\n"
  362. " Find somebody to connect to.\n"
  363. " Check out the IRC channel or http://hyperboria.net/\n"
  364. " for information about how to meet new people and make connect to them.\n"
  365. "\n"
  366. "Step 3:\n"
  367. " Fire it up!\n"
  368. " sudo %s < cjdroute.conf\n"
  369. "\n"
  370. "For more information about other functions and non-standard setups, see README.md\n",
  371. ArchInfo_getArchStr(), sysInfo, appName, appName, appName);
  372. return 0;
  373. }
  374. struct CheckRunningInstanceContext
  375. {
  376. struct EventBase* base;
  377. struct Allocator* alloc;
  378. struct AdminClient_Result* res;
  379. };
  380. static void checkRunningInstanceCallback(struct AdminClient_Promise* p,
  381. struct AdminClient_Result* res)
  382. {
  383. struct CheckRunningInstanceContext* ctx = p->userData;
  384. // Prevent this from freeing until after we drop out of the loop.
  385. Allocator_adopt(ctx->alloc, p->alloc);
  386. ctx->res = res;
  387. EventBase_endLoop(ctx->base);
  388. }
  389. static void checkRunningInstance(struct Allocator* allocator,
  390. struct EventBase* base,
  391. String* addr,
  392. String* password,
  393. struct Log* logger,
  394. struct Except* eh)
  395. {
  396. struct Allocator* alloc = Allocator_child(allocator);
  397. struct Sockaddr_storage pingAddrStorage;
  398. if (Sockaddr_parse(addr->bytes, &pingAddrStorage)) {
  399. Except_throw(eh, "Unable to parse [%s] as an ip address port, eg: 127.0.0.1:11234",
  400. addr->bytes);
  401. }
  402. struct UDPAddrIface* udp = UDPAddrIface_new(base, NULL, alloc, NULL, logger);
  403. struct AdminClient* adminClient =
  404. AdminClient_new(&udp->generic, &pingAddrStorage.addr, password, base, logger, alloc);
  405. // 100 milliseconds is plenty to wait for a process to respond on the same machine.
  406. adminClient->millisecondsToWait = 100;
  407. Dict* pingArgs = Dict_new(alloc);
  408. struct AdminClient_Promise* pingPromise =
  409. AdminClient_rpcCall(String_new("ping", alloc), pingArgs, adminClient, alloc);
  410. struct CheckRunningInstanceContext* ctx =
  411. Allocator_malloc(alloc, sizeof(struct CheckRunningInstanceContext));
  412. ctx->base = base;
  413. ctx->alloc = alloc;
  414. ctx->res = NULL;
  415. pingPromise->callback = checkRunningInstanceCallback;
  416. pingPromise->userData = ctx;
  417. EventBase_beginLoop(base);
  418. Assert_true(ctx->res);
  419. if (ctx->res->err != AdminClient_Error_TIMEOUT) {
  420. Except_throw(eh, "Startup failed: cjdroute is already running. [%d]", ctx->res->err);
  421. }
  422. Allocator_free(alloc);
  423. }
  424. int main(int argc, char** argv)
  425. {
  426. #ifdef Log_KEYS
  427. fprintf(stderr, "Log_LEVEL = KEYS, EXPECT TO SEE PRIVATE KEYS IN YOUR LOGS!\n");
  428. #endif
  429. if (argc > 1 && (!CString_strcmp("angel", argv[1]) || !CString_strcmp("core", argv[1]))) {
  430. return Core_main(argc, argv);
  431. }
  432. Assert_ifParanoid(argc > 0);
  433. struct Except* eh = NULL;
  434. // Allow it to allocate 8MB
  435. struct Allocator* allocator = MallocAllocator_new(1<<23);
  436. struct Random* rand = Random_new(allocator, NULL, eh);
  437. struct EventBase* eventBase = EventBase_new(allocator);
  438. if (argc >= 2) {
  439. // one argument
  440. if ((CString_strcmp(argv[1], "--help") == 0) || (CString_strcmp(argv[1], "-h") == 0)) {
  441. return usage(allocator, argv[0]);
  442. } else if (CString_strcmp(argv[1], "--genconf") == 0) {
  443. bool eth = 0;
  444. for (int i = 1; i < argc; i++) {
  445. if (!CString_strcmp(argv[i], "--eth")) {
  446. eth = 1;
  447. }
  448. }
  449. return genconf(rand, eth);
  450. } else if (CString_strcmp(argv[1], "--pidfile") == 0) {
  451. // deprecated
  452. fprintf(stderr, "'--pidfile' option is deprecated.\n");
  453. return 0;
  454. } else if (CString_strcmp(argv[1], "--reconf") == 0) {
  455. // Performed after reading the configuration
  456. } else if (CString_strcmp(argv[1], "--bench") == 0) {
  457. Benchmark_runAll();
  458. return 0;
  459. } else if ((CString_strcmp(argv[1], "--version") == 0)
  460. || (CString_strcmp(argv[1], "-v") == 0))
  461. {
  462. printf("Cjdns protocol version: %d\n", Version_CURRENT_PROTOCOL);
  463. return 0;
  464. } else if (CString_strcmp(argv[1], "--cleanconf") == 0) {
  465. // Performed after reading configuration
  466. } else if (CString_strcmp(argv[1], "--nobg") == 0) {
  467. // Performed while reading configuration
  468. } else {
  469. fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], argv[1]);
  470. fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]);
  471. return -1;
  472. }
  473. } else if (argc > 2) {
  474. // more than one argument?
  475. fprintf(stderr, "%s: too many arguments [%s]\n", argv[0], argv[1]);
  476. fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]);
  477. // because of '--pidfile $filename'?
  478. if (CString_strcmp(argv[1], "--pidfile") == 0)
  479. {
  480. fprintf(stderr, "\n'--pidfile' option is deprecated.\n");
  481. }
  482. return -1;
  483. }
  484. if (isatty(STDIN_FILENO)) {
  485. // We were started from a terminal
  486. // The chances an user wants to type in a configuration
  487. // bij hand are pretty slim so we show him the usage
  488. return usage(allocator, argv[0]);
  489. } else {
  490. // We assume stdin is a configuration file and that we should
  491. // start routing
  492. }
  493. struct Reader* stdinReader = FileReader_new(stdin, allocator);
  494. Dict config;
  495. if (JsonBencSerializer_get()->parseDictionary(stdinReader, allocator, &config)) {
  496. fprintf(stderr, "Failed to parse configuration.\n");
  497. return -1;
  498. }
  499. if (argc == 2 && CString_strcmp(argv[1], "--cleanconf") == 0) {
  500. struct Writer* stdoutWriter = FileWriter_new(stdout, allocator);
  501. JsonBencSerializer_get()->serializeDictionary(stdoutWriter, &config);
  502. printf("\n");
  503. return 0;
  504. }
  505. int forceNoBackground = 0;
  506. if (argc == 2 && CString_strcmp(argv[1], "--nobg") == 0) {
  507. forceNoBackground = 1;
  508. }
  509. struct Log* logger = FileWriterLog_new(stdout, allocator);
  510. // --------------------- Get Admin --------------------- //
  511. Dict* configAdmin = Dict_getDict(&config, String_CONST("admin"));
  512. String* adminPass = Dict_getString(configAdmin, String_CONST("password"));
  513. String* adminBind = Dict_getString(configAdmin, String_CONST("bind"));
  514. if (!adminPass) {
  515. adminPass = String_newBinary(NULL, 32, allocator);
  516. Random_base32(rand, (uint8_t*) adminPass->bytes, 32);
  517. adminPass->len = CString_strlen(adminPass->bytes);
  518. }
  519. if (!adminBind) {
  520. Except_throw(eh, "You must specify admin.bind in the cjdroute.conf file.");
  521. }
  522. // --------------------- Welcome to cjdns ---------------------- //
  523. char* sysInfo = SysInfo_describe(SysInfo_detect(), allocator);
  524. Log_info(logger, "Cjdns %s %s", ArchInfo_getArchStr(), sysInfo);
  525. // --------------------- Check for running instance --------------------- //
  526. Log_info(logger, "Checking for running instance...");
  527. checkRunningInstance(allocator, eventBase, adminBind, adminPass, logger, eh);
  528. // --------------------- Setup Pipes to Angel --------------------- //
  529. struct Allocator* corePipeAlloc = Allocator_child(allocator);
  530. char corePipeName[64] = "client-core-";
  531. Random_base32(rand, (uint8_t*)corePipeName+CString_strlen(corePipeName), 31);
  532. Assert_ifParanoid(EventBase_eventCount(eventBase) == 0);
  533. struct Pipe* corePipe = Pipe_named(corePipeName, eventBase, eh, corePipeAlloc);
  534. Assert_ifParanoid(EventBase_eventCount(eventBase) == 2);
  535. corePipe->logger = logger;
  536. char* args[] = { "core", corePipeName, NULL };
  537. // --------------------- Spawn Angel --------------------- //
  538. String* privateKey = Dict_getString(&config, String_CONST("privateKey"));
  539. char* corePath = Process_getPath(allocator);
  540. if (!corePath) {
  541. Except_throw(eh, "Can't find a usable cjdns core executable, "
  542. "make sure it is in the same directory as cjdroute");
  543. }
  544. if (!privateKey) {
  545. Except_throw(eh, "Need to specify privateKey.");
  546. }
  547. Process_spawn(corePath, args, eventBase, allocator);
  548. // --------------------- Pre-Configure Core ------------------------- //
  549. Dict* preConf = Dict_new(allocator);
  550. Dict* adminPreConf = Dict_new(allocator);
  551. Dict_putDict(preConf, String_CONST("admin"), adminPreConf, allocator);
  552. Dict_putString(preConf, String_CONST("privateKey"), privateKey, allocator);
  553. Dict_putString(adminPreConf, String_CONST("bind"), adminBind, allocator);
  554. Dict_putString(adminPreConf, String_CONST("pass"), adminPass, allocator);
  555. Dict* logging = Dict_getDict(&config, String_CONST("logging"));
  556. if (logging) {
  557. Dict_putDict(preConf, String_CONST("logging"), logging, allocator);
  558. }
  559. struct Message* toCoreMsg = Message_new(0, 1024, allocator);
  560. BencMessageWriter_write(preConf, toCoreMsg, eh);
  561. Iface_CALL(corePipe->iface.send, toCoreMsg, &corePipe->iface);
  562. Log_debug(logger, "Sent [%d] bytes to core", toCoreMsg->length);
  563. // --------------------- Get Response from Core --------------------- //
  564. struct Message* fromCoreMsg =
  565. InterfaceWaiter_waitForData(&corePipe->iface, eventBase, allocator, eh);
  566. Dict* responseFromCore = BencMessageReader_read(fromCoreMsg, allocator, eh);
  567. // --------------------- Close the Core Pipe --------------------- //
  568. Allocator_free(corePipeAlloc);
  569. corePipe = NULL;
  570. // --------------------- Get Admin Addr/Port/Passwd --------------------- //
  571. Dict* responseFromCoreAdmin = Dict_getDict(responseFromCore, String_CONST("admin"));
  572. adminBind = Dict_getString(responseFromCoreAdmin, String_CONST("bind"));
  573. if (!adminBind) {
  574. Except_throw(eh, "didn't get address and port back from core");
  575. }
  576. struct Sockaddr_storage adminAddr;
  577. if (Sockaddr_parse(adminBind->bytes, &adminAddr)) {
  578. Except_throw(eh, "Unable to parse [%s] as an ip address port, eg: 127.0.0.1:11234",
  579. adminBind->bytes);
  580. }
  581. Assert_ifParanoid(EventBase_eventCount(eventBase) == 1);
  582. // --------------------- Configuration ------------------------- //
  583. Configurator_config(&config,
  584. &adminAddr.addr,
  585. adminPass,
  586. eventBase,
  587. logger,
  588. allocator);
  589. // --------------------- noBackground ------------------------ //
  590. int64_t* noBackground = Dict_getInt(&config, String_CONST("noBackground"));
  591. if (forceNoBackground || (noBackground && *noBackground)) {
  592. Log_debug(logger, "Keeping cjdns client alive because %s",
  593. (forceNoBackground) ? "--nobg was specified on the command line"
  594. : "noBackground was set in the configuration");
  595. EventBase_beginLoop(eventBase);
  596. }
  597. // Freeing this allocator here causes the core to be terminated in the epoll syscall.
  598. //Allocator_free(allocator);
  599. return 0;
  600. }