static void dns(Dict* dns, struct Context* ctx, struct Except* eh) { List* servers = Dict_getList(dns, String_CONST("servers")); int count = List_size(servers); for (int i = 0; i < count; i++) { String* server = List_getString(servers, i); if (!server) { Except_throw(eh, "dns.servers[%d] is not a string", i); } Dict* d = Dict_new(ctx->alloc); Dict_putString(d, String_CONST("addr"), server, ctx->alloc); rpcCall(String_CONST("RainflyClient_addServer"), d, ctx, ctx->alloc); } List* keys = Dict_getList(dns, String_CONST("keys")); count = List_size(keys); for (int i = 0; i < count; i++) { String* key = List_getString(keys, i); if (!key) { Except_throw(eh, "dns.keys[%d] is not a string", i); } Dict* d = Dict_new(ctx->alloc); Dict_putString(d, String_CONST("ident"), key, ctx->alloc); rpcCall(String_CONST("RainflyClient_addKey"), d, ctx, ctx->alloc); } int64_t* minSigs = Dict_getInt(dns, String_CONST("minSignatures")); if (minSigs) { Dict* d = Dict_new(ctx->alloc); Dict_putInt(d, String_CONST("count"), *minSigs, ctx->alloc); rpcCall(String_CONST("RainflyClient_minSignatures"), d, ctx, ctx->alloc); } }
static void getSomething(Dict* args, struct RouteGen_admin_Ctx* ctx, String* txid, struct Allocator* requestAlloc, Dict* genRoutes) { int page = getIntVal(args, String_CONST("page")); List* routes; if (getIntVal(args, String_CONST("ip6"))) { routes = Dict_getList(genRoutes, String_CONST("ipv6")); } else { routes = Dict_getList(genRoutes, String_CONST("ipv4")); } Assert_true(routes); List* outList = List_new(requestAlloc); bool more = false; for (int i = page * ROUTES_PER_PAGE, j = 0; i < List_size(routes) && j < ROUTES_PER_PAGE; j++) { String* route = List_getString(routes, i); Assert_true(route); List_addString(outList, route, requestAlloc); if (++i >= List_size(routes)) { more = false; break; } more = true; } Dict* out = Dict_new(requestAlloc); if (more) { Dict_putInt(out, String_new("more", requestAlloc), 1, requestAlloc); } Dict_putList(out, String_new("routes", requestAlloc), outList, requestAlloc); Admin_sendMessage(out, txid, ctx->admin); }
static void ipTunnel(Dict* ifaceConf, struct Allocator* tempAlloc, struct Context* ctx) { List* incoming = Dict_getList(ifaceConf, String_CONST("allowedConnections")); Dict* d; for (int i = 0; (d = List_getDict(incoming, i)) != NULL; i++) { String* key = Dict_getString(d, String_CONST("publicKey")); String* ip4 = Dict_getString(d, String_CONST("ip4Address")); String* ip6 = Dict_getString(d, String_CONST("ip6Address")); if (!key) { Log_critical(ctx->logger, "In router.ipTunnel.allowedConnections[%d]" "'publicKey' required.", i); exit(1); } if (!ip4 && !ip6) { Log_critical(ctx->logger, "In router.ipTunnel.allowedConnections[%d]" "either ip4Address or ip6Address required.", i); exit(1); } Log_debug(ctx->logger, "Allowing IpTunnel connections from [%s]", key->bytes); Dict_putString(d, String_CONST("publicKeyOfAuthorizedNode"), key, tempAlloc); rpcCall0(String_CONST("IpTunnel_allowConnection"), d, ctx, tempAlloc, true); } List* outgoing = Dict_getList(ifaceConf, String_CONST("outgoingConnections")); String* s; for (int i = 0; (s = List_getString(outgoing, i)) != NULL; i++) { Log_debug(ctx->logger, "Initiating IpTunnel connection to [%s]", s->bytes); Dict requestDict = Dict_CONST(String_CONST("publicKeyOfNodeToConnectTo"), String_OBJ(s), NULL); rpcCall0(String_CONST("IpTunnel_connectTo"), &requestDict, ctx, tempAlloc, true); } }
static void testGetUsers() { struct Allocator* allocator = MallocAllocator_new(1<<20); struct EventBase* base = EventBase_new(allocator); struct CryptoAuth* ca = CryptoAuth_new(allocator, NULL, base, NULL, evilRandom(allocator, NULL)); List* users = NULL; users = CryptoAuth_getUsers(ca, allocator); Assert_true(List_size(users) == 0); CryptoAuth_addUser(String_CONST("pass1"), String_CONST("user1"), ca); users = CryptoAuth_getUsers(ca, allocator); Assert_true(List_size(users) == 1); Assert_true(String_equals(String_CONST("user1"), List_getString(users,0))); CryptoAuth_addUser(String_CONST("pass2"), String_CONST("user2"), ca); users = CryptoAuth_getUsers(ca, allocator); Assert_true(List_size(users) == 2); Assert_true(String_equals(String_CONST("user2"),List_getString(users,0))); Assert_true(String_equals(String_CONST("user1"),List_getString(users,1))); Allocator_free(allocator); }
static void supernodes(List* supernodes, struct Allocator* tempAlloc, struct Context* ctx) { if (!supernodes) { return; } String* s; for (int i = 0; (s = List_getString(supernodes, i)) != NULL; i++) { Log_debug(ctx->logger, "Loading supernode connection to [%s]", s->bytes); Dict reqDict = Dict_CONST(String_CONST("key"), String_OBJ(s), NULL); if (!Defined(SUBNODE)) { Log_debug(ctx->logger, "Skipping because SUBNODE is not enabled"); continue; } rpcCall0(String_CONST("SupernodeHunter_addSnode"), &reqDict, ctx, tempAlloc, NULL, true); } }
static void security(List* securityConf, struct Allocator* tempAlloc, struct Context* ctx) { bool noFiles = false; for (int i = 0; i < List_size(securityConf); i++) { if (String_equals(String_CONST("nofiles"), List_getString(securityConf, i))) { noFiles = true; } else { Dict* userDict = List_getDict(securityConf, i); String* userName = Dict_getString(userDict, String_CONST("setuser")); if (userName) { Dict d = Dict_CONST(String_CONST("user"), String_OBJ(userName), NULL); // If this call returns an error, it is ok. rpcCall0(String_CONST("Security_setUser"), &d, ctx, tempAlloc, false); } } } if (noFiles) { Dict d = NULL; rpcCall(String_CONST("Security_noFiles"), &d, ctx, tempAlloc); } }
static void security(List* config, struct Log* logger, struct ExceptionHandler* eh) { if (!config) { return; } bool nofiles = false; for (int i = 0; i < List_size(config); i++) { String* s = List_getString(config, i); if (s && String_equals(s, BSTR("nofiles"))) { nofiles = true; } } char* user = setUser(config); if (user) { Log_info1(logger, "Changing user to [%s]\n", user); Security_setUser(user, logger, eh); } if (nofiles) { Log_info(logger, "Setting max open files to zero.\n"); Security_noFiles(eh); } }
static void ethInterface(Dict* config, struct Context* ctx) { List* ifaces = Dict_getList(config, String_CONST("ETHInterface")); if (!ifaces) { ifaces = List_new(ctx->alloc); List_addDict(ifaces, Dict_getDict(config, String_CONST("ETHInterface")), ctx->alloc); } uint32_t count = List_size(ifaces); for (uint32_t i = 0; i < count; i++) { Dict *eth = List_getDict(ifaces, i); if (!eth) { continue; } String* deviceStr = Dict_getString(eth, String_CONST("bind")); if (!deviceStr || !String_equals(String_CONST("all"), deviceStr)) { continue; } Log_info(ctx->logger, "Setting up all ETHInterfaces..."); Dict* res = NULL; Dict* d = Dict_new(ctx->alloc); if (rpcCall0(String_CONST("ETHInterface_listDevices"), d, ctx, ctx->alloc, &res, false)) { Log_info(ctx->logger, "Getting device list failed"); break; } List* devs = Dict_getList(res, String_CONST("devices")); uint32_t devCount = List_size(devs); for (uint32_t j = 0; j < devCount; j++) { Dict* d = Dict_new(ctx->alloc); String* deviceName = List_getString(devs, j); // skip loopback... if (String_equals(String_CONST("lo"), deviceName)) { continue; } Dict_putString(d, String_CONST("bindDevice"), deviceName, ctx->alloc); Dict* resp; Log_info(ctx->logger, "Creating new ETHInterface [%s]", deviceName->bytes); if (rpcCall0(String_CONST("ETHInterface_new"), d, ctx, ctx->alloc, &resp, false)) { Log_warn(ctx->logger, "Failed to create ETHInterface."); continue; } int ifNum = *(Dict_getInt(resp, String_CONST("interfaceNumber"))); ethInterfaceSetBeacon(ifNum, eth, ctx); } return; } for (uint32_t i = 0; i < count; i++) { Dict *eth = List_getDict(ifaces, i); if (!eth) { continue; } // Setup the interface. String* deviceStr = Dict_getString(eth, String_CONST("bind")); Log_info(ctx->logger, "Setting up ETHInterface [%d].", i); Dict* d = Dict_new(ctx->alloc); if (deviceStr) { Log_info(ctx->logger, "Binding to device [%s].", deviceStr->bytes); Dict_putString(d, String_CONST("bindDevice"), deviceStr, ctx->alloc); } Dict* resp = NULL; if (rpcCall0(String_CONST("ETHInterface_new"), d, ctx, ctx->alloc, &resp, false)) { Log_warn(ctx->logger, "Failed to create ETHInterface."); continue; } int ifNum = *(Dict_getInt(resp, String_CONST("interfaceNumber"))); ethInterfaceSetBeacon(ifNum, eth, ctx); // Make the connections. Dict* connectTo = Dict_getDict(eth, String_CONST("connectTo")); if (connectTo) { Log_info(ctx->logger, "ETHInterface should connect to a specific node."); struct Dict_Entry* entry = *connectTo; while (entry != NULL) { String* key = (String*) entry->key; if (entry->val->type != Object_DICT) { Log_critical(ctx->logger, "interfaces.ETHInterface.connectTo: entry [%s] " "is not a dictionary type.", key->bytes); exit(-1); } Dict* value = entry->val->as.dictionary; Log_keys(ctx->logger, "Attempting to connect to node [%s].", key->bytes); struct Allocator* perCallAlloc = Allocator_child(ctx->alloc); // Turn the dict from the config into our RPC args dict by filling in all // the arguments, Dict_putString(value, String_CONST("macAddress"), key, perCallAlloc); Dict_putInt(value, String_CONST("interfaceNumber"), ifNum, perCallAlloc); rpcCall(String_CONST("ETHInterface_beginConnection"), value, ctx, perCallAlloc); Allocator_free(perCallAlloc); entry = entry->next; } } } }
static void ipTunnel(Dict* ifaceConf, struct Allocator* tempAlloc, struct Context* ctx) { List* incoming = Dict_getList(ifaceConf, String_CONST("allowedConnections")); if (incoming) { Dict* d; for (int i = 0; (d = List_getDict(incoming, i)) != NULL; i++) { String* key = Dict_getString(d, String_CONST("publicKey")); String* ip4 = Dict_getString(d, String_CONST("ip4Address")); // Note that the prefix length has to be a proper int in the config // (not quoted!) int64_t* ip4Prefix = Dict_getInt(d, String_CONST("ip4Prefix")); String* ip6 = Dict_getString(d, String_CONST("ip6Address")); int64_t* ip6Prefix = Dict_getInt(d, String_CONST("ip6Prefix")); if (!key) { Log_critical(ctx->logger, "In router.ipTunnel.allowedConnections[%d]" "'publicKey' required.", i); exit(1); } if (!ip4 && !ip6) { Log_critical(ctx->logger, "In router.ipTunnel.allowedConnections[%d]" "either 'ip4Address' or 'ip6Address' required.", i); exit(1); } else if (ip4Prefix && !ip4) { Log_critical(ctx->logger, "In router.ipTunnel.allowedConnections[%d]" "'ip4Address' required with 'ip4Prefix'.", i); exit(1); } else if (ip6Prefix && !ip6) { Log_critical(ctx->logger, "In router.ipTunnel.allowedConnections[%d]" "'ip6Address' required with 'ip6Prefix'.", i); exit(1); } Log_debug(ctx->logger, "Allowing IpTunnel connections from [%s]", key->bytes); if (ip4) { Log_debug(ctx->logger, "Issue IPv4 address %s", ip4->bytes); if (ip4Prefix) { Log_debug(ctx->logger, "Issue IPv4 netmask/prefix length /%d", (int) *ip4Prefix); } else { Log_debug(ctx->logger, "Use default netmask/prefix length /0"); } } if (ip6) { Log_debug(ctx->logger, "Issue IPv6 address [%s]", ip6->bytes); if (ip6Prefix) { Log_debug(ctx->logger, "Issue IPv6 netmask/prefix length /%d", (int) *ip6Prefix); } else { Log_debug(ctx->logger, "Use default netmask/prefix length /0"); } } Dict_putString(d, String_CONST("publicKeyOfAuthorizedNode"), key, tempAlloc); rpcCall0(String_CONST("IpTunnel_allowConnection"), d, ctx, tempAlloc, NULL, true); } } List* outgoing = Dict_getList(ifaceConf, String_CONST("outgoingConnections")); if (outgoing) { String* s; for (int i = 0; (s = List_getString(outgoing, i)) != NULL; i++) { Log_debug(ctx->logger, "Initiating IpTunnel connection to [%s]", s->bytes); Dict requestDict = Dict_CONST(String_CONST("publicKeyOfNodeToConnectTo"), String_OBJ(s), NULL); rpcCall0(String_CONST("IpTunnel_connectTo"), &requestDict, ctx, tempAlloc, NULL, true); } } }
int main(int argc, char** argv) { if (argc > 1 && !strcmp("--genconf", argv[argc-1])) { genconf(); return 0; } struct Allocator* alloc = MallocAllocator_new(1<<22); struct EventBase* base = EventBase_new(alloc); struct Writer* logWriter = FileWriter_new(stdout, alloc); struct Log* logger = WriterLog_new(logWriter, alloc); struct Random* rand = Random_new(alloc, logger, NULL); struct Reader* stdinReader = FileReader_new(stdin, alloc); Dict config; if (JsonBencSerializer_get()->parseDictionary(stdinReader, alloc, &config)) { Log_critical(logger, "Failed to parse configuration"); return -1; } Dict* dns = Dict_getDict(&config, String_CONST("dns")); if (!dns) { Log_critical(logger, "No DNS in configuration"); return -1; } struct Sockaddr_storage addr; Assert_true(!Sockaddr_parse("::", &addr)); struct AddrInterface* ifaceB = UDPAddrInterface_new(base, &addr.addr, alloc, NULL, logger); struct RainflyClient* client = RainflyClient_new(ifaceB, base, rand, logger); String* bind = Dict_getString(dns, String_CONST("bind")); Assert_true(!Sockaddr_parse(bind ? bind->bytes : "[::]:5353", &addr)); struct AddrInterface* iface = UDPAddrInterface_new(base, &addr.addr, alloc, NULL, logger); struct DNSServer* dnsServer = DNSServer_new(iface, logger, client); List* auth = Dict_getList(dns, String_CONST("authorities")); for (int i = 0; i < (int)List_size(auth); i++) { String* str = List_getString(auth, i); if (!str) { Log_warn(logger, "Element [%d] in [dns.authorities] list of wrong type", i); continue; } uint8_t key[32] = {0}; if (str->len < 52 || Base32_decode(key, 32, str->bytes, 52) != 32) { Log_warn(logger, "Failed to parse key [%s]", str->bytes); continue; } if (RainflyClient_addKey(client, key)) { Log_warn(logger, "Failed to add key to RainflyClient [%s]", str->bytes); } } List* servers = Dict_getList(dns, String_CONST("servers")); for (int i = 0; i < (int)List_size(servers); i++) { String* str = List_getString(servers, i); if (!str) { Log_warn(logger, "Element [%d] in [dns.servers] list of wrong type", i); continue; } struct Sockaddr_storage node; if (Sockaddr_parse(str->bytes, &node)) { Log_warn(logger, "Failed to parse server name [%s]", str->bytes); continue; } if (RainflyClient_addServer(client, &node.addr)) { Log_warn(logger, "Failed to add server to RainflyClient [%s]", str->bytes); } } List* legacy = Dict_getList(dns, String_CONST("legacy")); for (int i = 0; i < (int)List_size(legacy); i++) { String* str = List_getString(legacy, i); if (!str) { Log_warn(logger, "Element [%d] in [dns.legacy] list of wrong type", i); continue; } struct Sockaddr_storage node; if (Sockaddr_parse(str->bytes, &node)) { Log_warn(logger, "Failed to parse legacy server name [%s]", str->bytes); continue; } if (DNSServer_addServer(dnsServer, &node.addr)) { Log_warn(logger, "Failed to add server to DNSServer [%s]", str->bytes); } } EventBase_beginLoop(base); }
static void runTest0(char** prefixes, char** exceptions4, char** exceptions6, char** expectedOut4, char** expectedOut6, struct Allocator* alloc, struct Log* log) { struct RouteGen* rg = RouteGen_new(alloc, log); for (int i = 0; prefixes[i]; i++) { RouteGen_addPrefix(rg, mkSockaddr(prefixes[i], alloc)); } for (int i = 0; exceptions4 && exceptions4[i]; i++) { RouteGen_addException(rg, mkSockaddr(exceptions4[i], alloc)); } for (int i = 0; exceptions6 && exceptions6[i]; i++) { RouteGen_addException(rg, mkSockaddr(exceptions6[i], alloc)); } Dict* routes = RouteGen_getGeneratedRoutes(rg, alloc); List* routes4 = Dict_getList(routes, String_CONST("ipv4")); List* routes6 = Dict_getList(routes, String_CONST("ipv6")); if (expectedOut4) { for (int i = 0; expectedOut4[i]; i++) { Log_debug(log, "%s\n", expectedOut4[i]); } for (int i = 0; i < List_size(routes4); i++) { Log_debug(log, "%s\n", List_getString(routes4, i)->bytes); } Assert_true(!expectedOut4[List_size(routes4)]); for (int i = 0; i < List_size(routes4); i++) { String* str = List_getString(routes4, i); Assert_true(str); Assert_true(expectedOut4[i]); if (CString_strncmp(expectedOut4[i], str->bytes, str->len)) { Log_error(log, "Fail\nexpected: %s\nGot: %s\n", expectedOut4[i], str->bytes); Assert_failure("fail"); } } } else { Assert_true(!List_size(routes4)); } if (expectedOut6) { for (int i = 0; expectedOut6[i]; i++) { Log_debug(log, "%s\n", expectedOut6[i]); } for (int i = 0; i < List_size(routes6); i++) { Log_debug(log, "%s\n", List_getString(routes6, i)->bytes); } Assert_true(!expectedOut6[List_size(routes6)]); for (int i = 0; i < List_size(routes6); i++) { String* str = List_getString(routes6, i); Assert_true(str); Assert_true(expectedOut6[i]); if (CString_strncmp(expectedOut6[i], str->bytes, str->len)) { Log_error(log, "Fail\nexpected: %s\nGot: %s\n", expectedOut6[i], str->bytes); Assert_failure("fail"); } } } else { Assert_true(!List_size(routes6)); } }