struct DHTModuleRegistry* DHTModuleRegistry_new(struct Allocator* allocator) { struct DHTModuleRegistry* reg = Allocator_calloc(allocator, sizeof(struct DHTModuleRegistry), 1); reg->allocator = allocator; reg->members = Allocator_calloc(allocator, sizeof(char*), 1); return reg; }
struct NetCore* NetCore_new(uint8_t* privateKey, struct Allocator* allocator, struct EventBase* base, struct Random* rand, struct Log* log) { struct Allocator* alloc = Allocator_child(allocator); struct NetCore* nc = Allocator_calloc(alloc, sizeof(struct NetCore), 1); nc->alloc = alloc; nc->base = base; nc->rand = rand; nc->log = log; struct CryptoAuth* ca = nc->ca = CryptoAuth_new(alloc, privateKey, base, log, rand); struct EventEmitter* ee = nc->ee = EventEmitter_new(alloc, log, ca->publicKey); struct Address* myAddress = nc->myAddress = Allocator_calloc(alloc, sizeof(struct Address), 1); Bits_memcpy(myAddress->key, ca->publicKey, 32); Address_getPrefix(myAddress); myAddress->protocolVersion = Version_CURRENT_PROTOCOL; myAddress->path = 1; // lower half struct SwitchCore* switchCore = nc->switchCore = SwitchCore_new(log, alloc, base); struct SwitchAdapter* switchAdapter = nc->switchAdapter = SwitchAdapter_new(alloc, log); Iface_plumb(&switchAdapter->switchIf, switchCore->routerIf); struct ControlHandler* controlHandler = nc->controlHandler = ControlHandler_new(alloc, log, ee, ca->publicKey); Iface_plumb(&controlHandler->coreIf, &switchAdapter->controlIf); struct SwitchPinger* sp = nc->sp = SwitchPinger_new(base, rand, log, myAddress, alloc); Iface_plumb(&controlHandler->switchPingerIf, &sp->controlHandlerIf); nc->ifController = InterfaceController_new(ca, switchCore, log, base, sp, rand, alloc, ee); // session manager struct SessionManager* sm = nc->sm = SessionManager_new(alloc, base, ca, rand, log, ee); Iface_plumb(&switchAdapter->sessionManagerIf, &sm->switchIf); // upper half struct UpperDistributor* upper = nc->upper = UpperDistributor_new(alloc, log, ee, myAddress); Iface_plumb(&sm->insideIf, &upper->sessionManagerIf); struct TUNAdapter* tunAdapt = nc->tunAdapt = TUNAdapter_new(alloc, log, myAddress->ip6.bytes); Iface_plumb(&tunAdapt->upperDistributorIf, &upper->tunAdapterIf); return nc; }
struct SupernodeHunter* SupernodeHunter_new(struct Allocator* allocator, struct Log* log, struct EventBase* base, struct AddrSet* peers, struct MsgCore* msgCore, struct Address* myAddress) { struct Allocator* alloc = Allocator_child(allocator); struct SupernodeHunter_pvt* out = Allocator_calloc(alloc, sizeof(struct SupernodeHunter_pvt), 1); out->authorizedSnodes = AddrSet_new(alloc); out->peers = peers; out->base = base; out->nodes = AddrSet_new(alloc); //out->timeSnodeCalled = Time_currentTimeMilliseconds(base); out->snodeCandidates = AddrSet_new(alloc); out->log = log; out->alloc = alloc; out->msgCore = msgCore; out->myAddress = myAddress; out->selfAddrStr = String_newBinary(myAddress->ip6.bytes, 16, alloc); Identity_set(out); Timeout_setInterval(pingCycle, out, CYCLE_MS, base, alloc); return &out->pub; }
struct GlobalConfig* GlobalConfig_new(struct Allocator* alloc) { struct GlobalConfig_pvt* gcp = Allocator_calloc(alloc, sizeof(struct GlobalConfig_pvt), 1); Identity_set(gcp); gcp->alloc = alloc; return &gcp->pub; }
struct CryptoAuth_Session* CryptoAuth_newSession(struct CryptoAuth* ca, struct Allocator* alloc, const uint8_t herPublicKey[32], const uint8_t herIp6[16], const bool requireAuth, char* displayName) { struct CryptoAuth_pvt* context = Identity_check((struct CryptoAuth_pvt*) ca); struct CryptoAuth_Session_pvt* session = Allocator_calloc(alloc, sizeof(struct CryptoAuth_Session_pvt), 1); Identity_set(session); session->context = context; session->requireAuth = requireAuth; session->pub.displayName = String_new(displayName, alloc); session->timeOfLastPacket = Time_currentTimeSeconds(context->eventBase); session->alloc = alloc; if (herPublicKey != NULL) { Bits_memcpyConst(session->pub.herPublicKey, herPublicKey, 32); uint8_t calculatedIp6[16]; AddressCalc_addressForPublicKey(calculatedIp6, herPublicKey); Bits_memcpyConst(session->pub.herIp6, calculatedIp6, 16); if (herIp6 != NULL) { Assert_true(!Bits_memcmp(calculatedIp6, herIp6, 16)); } } else if (herIp6) { Bits_memcpyConst(session->pub.herIp6, herIp6, 16); } return &session->pub; }
struct RandomSeed* RandomSeed_new(RandomSeed_Provider* providers, int providerCount, struct Log* logger, struct Allocator* alloc) { struct RandomSeed** rsList = Allocator_calloc(alloc, sizeof(struct RandomSeed), providerCount); int i = 0; for (int j = 0; j < providerCount; j++) { struct RandomSeed* rs = providers[j](alloc); if (rs) { rsList[i++] = rs; } } Assert_true(i > 0); struct RandomSeed_pvt* out = Allocator_malloc(alloc, sizeof(struct RandomSeed_pvt)); out->rsList = rsList; out->rsCount = i; out->logger = logger; out->pub.get = get; out->pub.name = "RandomSeed conglomeration of random seed providers"; Identity_set(out); return &out->pub; }
void Core_init(struct Allocator* alloc, struct Log* logger, struct EventBase* eventBase, uint8_t privateKey[32], struct Admin* admin, struct Random* rand, struct Except* eh, struct FakeNetwork* fakeNet, bool noSec) { struct Security* sec = NULL; if (!noSec) { sec = Security_new(alloc, logger, eventBase); } struct NetCore* nc = NetCore_new(privateKey, alloc, eventBase, rand, logger); struct IpTunnel* ipTunnel = IpTunnel_new(logger, eventBase, alloc, rand); Iface_plumb(&nc->tunAdapt->ipTunnelIf, &ipTunnel->tunInterface); Iface_plumb(&nc->upper->ipTunnelIf, &ipTunnel->nodeInterface); // The link between the Pathfinder and the core needs to be asynchronous. struct Pathfinder* pf = Pathfinder_register(alloc, logger, eventBase, rand, admin); struct ASynchronizer* pfAsync = ASynchronizer_new(alloc, eventBase, logger); Iface_plumb(&pfAsync->ifA, &pf->eventIf); EventEmitter_regPathfinderIface(nc->ee, &pfAsync->ifB); // ------------------- Register RPC functions ----------------------- // InterfaceController_admin_register(nc->ifController, admin, alloc); SwitchPinger_admin_register(nc->sp, admin, alloc); UDPInterface_admin_register(eventBase, alloc, logger, admin, nc->ifController, fakeNet); #ifdef HAS_ETH_INTERFACE ETHInterface_admin_register(eventBase, alloc, logger, admin, nc->ifController); #endif AuthorizedPasswords_init(admin, nc->ca, alloc); Admin_registerFunction("ping", adminPing, admin, false, NULL, admin); if (!noSec) { Security_admin_register(alloc, logger, sec, admin); } IpTunnel_admin_register(ipTunnel, admin, alloc); SessionManager_admin_register(nc->sm, admin, alloc); Allocator_admin_register(alloc, admin); struct Context* ctx = Allocator_calloc(alloc, sizeof(struct Context), 1); Identity_set(ctx); ctx->alloc = alloc; ctx->admin = admin; ctx->logger = logger; ctx->base = eventBase; ctx->ipTunnel = ipTunnel; ctx->nc = nc; Admin_registerFunction("Core_exit", adminExit, ctx, true, NULL, admin); Admin_registerFunction("Core_pid", adminPid, admin, false, NULL, admin); Admin_registerFunction("Core_initTunnel", initTunnel, ctx, true, ((struct Admin_FunctionArg[]) { { .name = "desiredTunName", .required = 0, .type = "String" } }), admin);
static void search(Dict* args, void* vctx, String* txid, struct Allocator* reqAlloc) { struct Context* ctx = Identity_check((struct Context*) vctx); String* addrStr = Dict_getStringC(args, "ipv6"); int maxRequests = -1; uint64_t* maxRequestsPtr = Dict_getIntC(args, "maxRequests"); if (maxRequestsPtr) { maxRequests = *maxRequestsPtr; } uint8_t addr[16]; if (AddrTools_parseIp(addr, (uint8_t*) addrStr->bytes)) { Dict* resp = Dict_new(reqAlloc); Dict_putStringCC(resp, "error", "ipv6 invalid", reqAlloc); Admin_sendMessage(resp, txid, ctx->admin); } else { struct Allocator* alloc = Allocator_child(ctx->allocator); struct Search* s = Allocator_calloc(alloc, sizeof(struct Search), 1); s->promise = SearchRunner_search(addr, maxRequests, maxRequests, ctx->runner, alloc); s->ctx = ctx; s->txid = String_clone(txid, alloc); s->alloc = alloc; Identity_set(s); if (!s->promise) { Dict* resp = Dict_new(reqAlloc); Dict_putStringCC(resp, "error", "creating search", reqAlloc); Admin_sendMessage(resp, txid, ctx->admin); Allocator_free(alloc); return; } s->promise->userData = s; s->promise->callback = searchResponse; } }
struct CryptoAuth* CryptoAuth_new(struct Allocator* allocator, const uint8_t* privateKey, struct EventBase* eventBase, struct Log* logger, struct Random* rand) { struct CryptoAuth_pvt* ca = Allocator_calloc(allocator, sizeof(struct CryptoAuth_pvt), 1); Identity_set(ca); ca->allocator = allocator; ca->eventBase = eventBase; ca->logger = logger; ca->pub.resetAfterInactivitySeconds = CryptoAuth_DEFAULT_RESET_AFTER_INACTIVITY_SECONDS; ca->rand = rand; if (privateKey != NULL) { Bits_memcpyConst(ca->privateKey, privateKey, 32); } else { Random_bytes(rand, ca->privateKey, 32); } crypto_scalarmult_curve25519_base(ca->pub.publicKey, ca->privateKey); if (Defined(Log_KEYS)) { uint8_t publicKeyHex[65]; printHexKey(publicKeyHex, ca->pub.publicKey); uint8_t privateKeyHex[65]; printHexKey(privateKeyHex, ca->privateKey); Log_keys(logger, "Initialized CryptoAuth:\n myPrivateKey=%s\n myPublicKey=%s\n", privateKeyHex, publicKeyHex); } return &ca->pub; }
/** * Incoming message from someone we don't know, maybe someone responding to a beacon? * expects: [ struct LLAddress ][ content ] */ static Iface_DEFUN handleUnexpectedIncoming(struct Message* msg, struct InterfaceController_Iface_pvt* ici) { struct InterfaceController_pvt* ic = ici->ic; struct Sockaddr* lladdr = (struct Sockaddr*) msg->bytes; Message_shift(msg, -lladdr->addrLen, NULL); if (msg->length < CryptoHeader_SIZE) { return NULL; } struct Allocator* epAlloc = Allocator_child(ici->alloc); lladdr = Sockaddr_clone(lladdr, epAlloc); Assert_true(!((uintptr_t)msg->bytes % 4) && "alignment fault"); struct Peer* ep = Allocator_calloc(epAlloc, sizeof(struct Peer), 1); Identity_set(ep); ep->alloc = epAlloc; ep->ici = ici; ep->lladdr = lladdr; ep->alloc = epAlloc; ep->peerLink = PeerLink_new(ic->eventBase, epAlloc); struct CryptoHeader* ch = (struct CryptoHeader*) msg->bytes; ep->caSession = CryptoAuth_newSession(ic->ca, epAlloc, ch->publicKey, true, "outer"); if (CryptoAuth_decrypt(ep->caSession, msg)) { // If the first message is a dud, drop all state for this peer. // probably some random crap that wandered in the socket. Allocator_free(epAlloc); return NULL; } Assert_true(!Bits_isZero(ep->caSession->herPublicKey, 32)); Assert_true(Map_EndpointsBySockaddr_indexForKey(&lladdr, &ici->peerMap) == -1); int index = Map_EndpointsBySockaddr_put(&lladdr, &ep, &ici->peerMap); Assert_true(index >= 0); ep->handle = ici->peerMap.handles[index]; Allocator_onFree(epAlloc, closeInterface, ep); ep->state = InterfaceController_PeerState_UNAUTHENTICATED; ep->isIncomingConnection = true; ep->switchIf.send = sendFromSwitch; if (SwitchCore_addInterface(ic->switchCore, &ep->switchIf, epAlloc, &ep->addr.path)) { Log_debug(ic->logger, "handleUnexpectedIncoming() SwitchCore out of space"); Allocator_free(epAlloc); return NULL; } // We want the node to immedietly be pinged but we don't want it to appear unresponsive because // the pinger will only ping every (PING_INTERVAL * 8) so we set timeOfLastMessage to // (now - pingAfterMilliseconds - 1) so it will be considered a "lazy node". ep->timeOfLastMessage = Time_currentTimeMilliseconds(ic->eventBase) - ic->pingAfterMilliseconds - 1; Bits_memcpy(ep->addr.key, ep->caSession->herPublicKey, 32); Bits_memcpy(ep->addr.ip6.bytes, ep->caSession->herIp6, 16); Log_info(ic->logger, "Added peer [%s] from incoming message", Address_toString(&ep->addr, msg->alloc)->bytes); return receivedPostCryptoAuth(msg, ep, ic); }
static struct Message* newMessage(struct Allocator* alloc, int messageSize) { uint8_t* buff = Allocator_calloc(alloc, messageSize + 64, 1); return Allocator_clone(alloc, (&(struct Message) { .bytes = buff + 64, .length = messageSize, .padding = 64 }));
struct Security* Security_new(struct Allocator* alloc, struct Log* log, struct EventBase* base) { struct Security_pvt* sec = Allocator_calloc(alloc, sizeof(struct Security_pvt), 1); Identity_set(sec); sec->setupAlloc = Allocator_child(alloc); Timeout_setInterval(fail, sec, 20000, base, sec->setupAlloc); sec->log = log; return &sec->pub; }
struct AddrSet* AddrSet_new(struct Allocator* allocator) { struct Allocator* alloc = Allocator_child(allocator); struct AddrSet_pvt* out = Allocator_calloc(alloc, sizeof(struct AddrSet_pvt), 1); out->alloc = alloc; out->addrList = ArrayList_OfAddrs_new(alloc); Identity_set(out); return &out->pub; }
struct RumorMill* RumorMill_new(struct Allocator* allocator, struct Address* selfAddr, int capacity, struct Log* log, const char* name) { struct Allocator* alloc = Allocator_child(allocator); Address_getPrefix(selfAddr); struct RumorMill_pvt* rm = Allocator_calloc(alloc, sizeof(struct RumorMill_pvt), 1); rm->pub.addresses = Allocator_calloc(alloc, sizeof(struct Address), capacity); rm->capacity = capacity; rm->selfAddr = Allocator_clone(alloc, selfAddr); rm->log = log; rm->pub.name = name; Identity_set(rm); return &rm->pub; }
struct PeerLink* PeerLink_new(struct EventBase* base, struct Allocator* allocator) { struct Allocator* alloc = Allocator_child(allocator); struct PeerLink_pvt* pl = Allocator_calloc(alloc, sizeof(struct PeerLink_pvt), 1); Identity_set(pl); pl->base = base; pl->alloc = alloc; pl->queue = ArrayList_Messages_new(alloc); return &pl->pub; }
int main() { struct Allocator* alloc = MallocAllocator_new(1<<20); struct Random* rand = Random_new(alloc, NULL, NULL); // mock interface controller. struct Context ctx = { .ic = { .registerPeer = registerPeer, .getPeerState = getPeerState } }; struct Interface externalIf = { .sendMessage = sendMessage, .allocator = alloc, .senderContext = &ctx }; /*struct MultiInterface* mif = */MultiInterface_new(KEY_SIZE, &externalIf, &ctx.ic); struct Entry* entries = Allocator_malloc(alloc, sizeof(struct Entry) * ENTRY_COUNT); Random_bytes(rand, (uint8_t*)entries, ENTRY_COUNT * sizeof(struct Entry)); struct Interface** ifaces = Allocator_calloc(alloc, sizeof(char*), ENTRY_COUNT); // seed the list with some near collisions. for (int i = 0; i < 10; i++) { int rnd = (((uint32_t*)entries)[i] >> 1) % ENTRY_COUNT; ((uint32_t*) (&entries[rnd]))[0] = ((uint32_t*) (&entries[i]))[0]; } for (int i = 0; i < CYCLES; i++) { int rnd = ((uint32_t*)entries)[i] % ENTRY_COUNT; struct Entry* entry = &entries[rnd]; struct Interface* iface = ifaces[rnd]; struct Message* msg; Message_STACK(msg, 0, 128); Message_push(msg, "hello world", 12); Message_push(msg, entry, 16); externalIf.receiveMessage(msg, &externalIf); //printf("Received message for iface [%u] from [%p]\n", rnd, (void*)ctx.receivedOn); if (iface) { Assert_always(ctx.receivedOn == iface); } else { ifaces[rnd] = ctx.receivedOn; } } Allocator_free(alloc); }
struct TUNAdapter* TUNAdapter_new(struct Allocator* allocator, struct Log* log, uint8_t myIp6[16]) { struct Allocator* alloc = Allocator_child(allocator); struct TUNAdapter_pvt* out = Allocator_calloc(alloc, sizeof(struct TUNAdapter_pvt), 1); out->pub.tunIf.send = incomingFromTunIf; out->pub.ipTunnelIf.send = incomingFromIpTunnelIf; out->pub.upperDistributorIf.send = incomingFromUpperDistributorIf; out->log = log; Identity_set(out); Bits_memcpy(out->myIp6, myIp6, 16); return &out->pub; }
int SupernodeHunter_listSnodes(struct SupernodeHunter* snh, struct Address*** outP, struct Allocator* alloc) { struct SupernodeHunter_pvt* snp = Identity_check((struct SupernodeHunter_pvt*) snh); struct Address** out = Allocator_calloc(alloc, sizeof(char*), snp->authorizedSnodes->length); for (int i = 0; i < snp->authorizedSnodes->length; i++) { out[i] = AddrSet_get(snp->authorizedSnodes, i); } *outP = out; return snp->authorizedSnodes->length; }
struct TAPWrapper* TAPWrapper_new(struct Iface* external, struct Log* log, struct Allocator* alloc) { struct TAPWrapper_pvt* out = Allocator_calloc(alloc, sizeof(struct TAPWrapper_pvt), 1); Identity_set(out); out->log = log; out->external.send = receiveMessage; out->pub.internal.send = sendMessage; Iface_plumb(external, &out->external); return &out->pub; }
struct EventBase* EventBase_new(struct Allocator* allocator) { struct Allocator* alloc = Allocator_child(allocator); struct EventBase_pvt* base = Allocator_calloc(alloc, sizeof(struct EventBase_pvt), 1); base->loop = uv_loop_new(); base->alloc = alloc; Identity_set(base); Allocator_onFree(alloc, onFree, base); calibrateTime(base); return &base->pub; }
char* Process_getPath(struct Allocator* alloc) { char buff[MAXPATHLEN]; if (NULL == realpath(__progname,buff)) { return NULL; } uint32_t length = strlen(buff); char* output = Allocator_calloc(alloc, length + 1, 1); Bits_memcpy(output, buff, length); return output; }
/** Check if nodes A and C can communicate via B without A knowing that C exists. */ void Benchmark_runAll() { struct Allocator* alloc = MallocAllocator_new(1<<22); struct Context* ctx = Allocator_calloc(alloc, sizeof(struct Context), 1); Identity_set(ctx); ctx->alloc = alloc; ctx->base = EventBase_new(alloc); struct Log* log = ctx->log = FileWriterLog_new(stdout, alloc); ctx->rand = Random_new(alloc, log, NULL); cryptoAuth(ctx); switching(ctx); }
struct EventEmitter* EventEmitter_new(struct Allocator* allocator, struct Log* log, uint8_t* publicKey) { struct Allocator* alloc = Allocator_child(allocator); struct EventEmitter_pvt* ee = Allocator_calloc(alloc, sizeof(struct EventEmitter_pvt), 1); ee->log = log; ee->alloc = alloc; ee->trickIf.send = incomingFromCore; ee->pathfinders = ArrayList_Pathfinders_new(ee->alloc); Bits_memcpy(ee->publicKey, publicKey, 32); Identity_set(ee); return &ee->pub; }
int CryptoAuth_addUser_ipv6(String* password, String* login, uint8_t ipv6[16], struct CryptoAuth* cryptoAuth) { struct CryptoAuth_pvt* ca = Identity_check((struct CryptoAuth_pvt*) cryptoAuth); struct Allocator* alloc = Allocator_child(ca->allocator); struct CryptoAuth_User* user = Allocator_calloc(alloc, sizeof(struct CryptoAuth_User), 1); user->alloc = alloc; Identity_set(user); if (!login) { int i = 0; for (struct CryptoAuth_User* u = ca->users; u; u = u->next) { i++; } user->login = login = String_printf(alloc, "Anon #%d", i); } else { user->login = String_clone(login, alloc); } union CryptoHeader_Challenge ac; // Users specified with a login field might want to use authType 1 still. hashPassword(user->secret, &ac, login, password, 2); Bits_memcpyConst(user->userNameHash, ac.bytes, CryptoHeader_Challenge_KEYSIZE); hashPassword(user->secret, &ac, NULL, password, 1); Bits_memcpyConst(user->passwordHash, ac.bytes, CryptoHeader_Challenge_KEYSIZE); for (struct CryptoAuth_User* u = ca->users; u; u = u->next) { if (Bits_memcmp(user->secret, u->secret, 32)) { } else if (!login) { } else if (String_equals(login, u->login)) { Allocator_free(alloc); return CryptoAuth_addUser_DUPLICATE; } } if (ipv6) { Bits_memcpyConst(user->restrictedToip6, ipv6, 16); } // Add the user to the *end* of the list for (struct CryptoAuth_User** up = &ca->users; ; up = &(*up)->next) { if (!*up) { *up = user; break; } } return 0; }
void AddrSet_add(struct AddrSet* as, struct Address* addr) { struct AddrSet_pvt* ap = Identity_check((struct AddrSet_pvt*) as); int idx = indexOf(ap, addr); if (idx != -1) { return; } struct Allocator* alloc = Allocator_child(ap->alloc); struct Elem* el = Allocator_calloc(alloc, sizeof(struct Elem), 1); el->alloc = alloc; Bits_memcpy(&el->addr, addr, sizeof(struct Address)); Identity_set(el); ArrayList_OfAddrs_add(ap->addrList, el); ArrayList_OfAddrs_sort(ap->addrList); ap->pub.length = ap->addrList->length; }
int InterfaceController_getPeerStats(struct InterfaceController* ifController, struct Allocator* alloc, struct InterfaceController_PeerStats** statsOut) { struct InterfaceController_pvt* ic = Identity_check((struct InterfaceController_pvt*) ifController); int count = 0; for (int i = 0; i < ic->icis->length; i++) { struct InterfaceController_Iface_pvt* ici = ArrayList_OfIfaces_get(ic->icis, i); count += ici->peerMap.count; } struct InterfaceController_PeerStats* stats = Allocator_calloc(alloc, sizeof(struct InterfaceController_PeerStats), count); int xcount = 0; for (int j = 0; j < ic->icis->length; j++) { struct InterfaceController_Iface_pvt* ici = ArrayList_OfIfaces_get(ic->icis, j); for (int i = 0; i < (int)ici->peerMap.count; i++) { struct Peer* peer = Identity_check((struct Peer*) ici->peerMap.values[i]); struct InterfaceController_PeerStats* s = &stats[xcount]; xcount++; Bits_memcpy(&s->addr, &peer->addr, sizeof(struct Address)); s->bytesOut = peer->bytesOut; s->bytesIn = peer->bytesIn; s->timeOfLastMessage = peer->timeOfLastMessage; s->state = peer->state; s->isIncomingConnection = peer->isIncomingConnection; if (peer->caSession->displayName) { s->user = String_clone(peer->caSession->displayName, alloc); } struct ReplayProtector* rp = &peer->caSession->replayProtector; s->duplicates = rp->duplicates; s->lostPackets = rp->lostPackets; s->receivedOutOfRange = rp->receivedOutOfRange; struct PeerLink_Kbps kbps; PeerLink_kbps(peer->peerLink, &kbps); s->sendKbps = kbps.sendKbps; s->recvKbps = kbps.recvKbps; } } Assert_true(xcount == count); *statsOut = stats; return count; }
/** * Register a new RouterModule. * * @param registry the DHT module registry for signal handling. * @param allocator a means to allocate memory. * @param myAddress the address for this DHT node. * @return the RouterModule. */ struct RouterModule* RouterModule_register(struct DHTModuleRegistry* registry, struct Allocator* allocator, const uint8_t myAddress[Address_KEY_SIZE], struct EventBase* eventBase, struct Log* logger, struct Random* rand) { struct RouterModule* const out = Allocator_calloc(allocator, sizeof(struct RouterModule), 1); struct DHTModule* dm = Allocator_clone(allocator, (&(struct DHTModule) { .name = "RouterModule", .context = out, .handleIncoming = handleIncoming, .handleOutgoing = handleOutgoing }));
struct MsgCore_Handler* MsgCore_onQuery(struct MsgCore* core, char* queryType, struct Allocator* allocator) { struct MsgCore_pvt* mcp = Identity_check((struct MsgCore_pvt*) core); struct Allocator* alloc = Allocator_child(allocator); struct QueryHandler* qh = Allocator_calloc(alloc, sizeof(struct QueryHandler), 1); qh->queryType = String_new(queryType, alloc); qh->alloc = alloc; qh->mcp = mcp; Identity_set(qh); ArrayList_OfQueryHandlers_add(mcp->qh, qh); Allocator_onFree(alloc, qhOnFree, qh); return &qh->pub; }
static void onConnectionParent(struct Pipe* p, int status) { Assert_true(!status); struct Context* c = Identity_check((struct Context*) p->userData); struct Allocator* alloc = Allocator_child(c->alloc); uint8_t* bytes = Allocator_calloc(alloc, CString_strlen(MESSAGE) + 1, 1); Bits_memcpy(bytes, MESSAGE, CString_strlen(MESSAGE)); struct Message* m = Allocator_clone(alloc, (&(struct Message) { .length = CString_strlen(MESSAGE), .padding = 0, .capacity = CString_strlen(MESSAGE), .alloc = alloc, .bytes = bytes }));
void TestFramework_linkNodes(struct TestFramework* client, struct TestFramework* server, bool beacon) { // ifaceA is the client, ifaceB is the server struct TestFramework_Link* link = Allocator_calloc(client->alloc, sizeof(struct TestFramework_Link), 1); Identity_set(link); link->clientIf.send = sendClient; link->serverIf.send = sendServer; link->client = client; link->server = server; struct InterfaceController_Iface* clientIci = InterfaceController_newIface( client->nc->ifController, String_CONST("client"), client->alloc); link->clientIfNum = clientIci->ifNum; Iface_plumb(&link->clientIf, &clientIci->addrIf); struct InterfaceController_Iface* serverIci = InterfaceController_newIface( server->nc->ifController, String_CONST("server"), server->alloc); link->serverIfNum = serverIci->ifNum; Iface_plumb(&link->serverIf, &serverIci->addrIf); if (beacon) { int ret = InterfaceController_beaconState(client->nc->ifController, link->clientIfNum, InterfaceController_beaconState_newState_ACCEPT); Assert_true(!ret); ret = InterfaceController_beaconState(server->nc->ifController, link->serverIfNum, InterfaceController_beaconState_newState_SEND); Assert_true(!ret); } else { // Except that it has an authorizedPassword added. CryptoAuth_addUser(String_CONST("abcdefg123"), String_CONST("TEST"), server->nc->ca); // Client has pubKey and passwd for the server. InterfaceController_bootstrapPeer(client->nc->ifController, link->clientIfNum, server->publicKey, Sockaddr_LOOPBACK, String_CONST("abcdefg123"), NULL, NULL, client->alloc); } }