自学教程：C++ Allocator_calloc函数代码示例

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);    }}