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

static void adminInterfaces(Dict* args,                            void* vcontext,                            String* txid,                            struct Allocator* alloc){    struct Context* context = Identity_check((struct Context*)vcontext);    int64_t* page = Dict_getIntC(args, "page");    int i = (page) ? *page * ENTRIES_PER_PAGE : 0;    int count = InterfaceController_ifaceCount(context->ic);    //int count = InterfaceController_getIface(context->ic, alloc, &stats);    List* list = List_new(alloc);    for (int counter = 0; i < count && counter++ < ENTRIES_PER_PAGE; i++) {        struct InterfaceController_Iface* iface = InterfaceController_getIface(context->ic, i);        Dict* d = Dict_new(alloc);        Dict_putIntC(d, "ifNum", iface->ifNum, alloc);        Dict_putStringC(d, "name", iface->name, alloc);        char* bs = InterfaceController_beaconStateString(iface->beaconState);        Dict_putStringCC(d, "beaconState", bs, alloc);        List_addDict(list, d, alloc);    }    Dict* resp = Dict_new(alloc);    Dict_putListC(resp, "ifaces", list, alloc);    Dict_putIntC(resp, "total", count, alloc);    if (i < count) { Dict_putIntC(resp, "more", 1, alloc); }    Admin_sendMessage(resp, txid, context->admin);}

static void sendFirstMessageToCore(void* vcontext){    struct NodeContext* ctx = Identity_check((struct NodeContext*) vcontext);    struct Allocator* alloc = Allocator_child(ctx->alloc);    struct Message* msg = Message_new(0, 512, alloc);    Dict* d = Dict_new(alloc);    Dict_putString(d, String_CONST("privateKey"), String_new(ctx->privateKeyHex, alloc), alloc);    Dict* logging = Dict_new(alloc);    {        Dict_putString(logging, String_CONST("logTo"), String_CONST("stdout"), alloc);    }    Dict_putDict(d, String_CONST("logging"), logging, alloc);    Dict* admin = Dict_new(alloc);    {        Dict_putString(admin, String_CONST("bind"), ctx->bind, alloc);        Dict_putString(admin, String_CONST("pass"), ctx->pass, alloc);    }    Dict_putDict(d, String_CONST("admin"), admin, alloc);    BencMessageWriter_write(d, msg, NULL);    Iface_send(&ctx->angelIface, msg);    Allocator_free(alloc);}

static void handleRequestFromChild(struct Admin* admin,                                   uint8_t buffer[MAX_API_REQUEST_SIZE],                                   size_t amount,                                   struct Allocator* allocator){    String* txid = NULL;    int skip = 0;    if (!memcmp(buffer, "0123", 4)) {        // out of band txid        txid = &(String) { .len = 4, .bytes = (char*) buffer + 4 };        skip = 8;    }    struct Reader* reader = ArrayReader_new(buffer + skip, amount - skip, allocator);    Dict message;    if (List_getStandardBencSerializer()->parseDictionary(reader, allocator, &message)) {        return;    }    String* query = Dict_getString(&message, CJDHTConstants_QUERY);    if (!query) {        return;    }    // If they're asking for a cookie then lets give them one.    String* cookie = BSTR("cookie");    if (String_equals(query, cookie)) {        Dict* d = Dict_new(allocator);        char bytes[32];        snprintf(bytes, 32, "%u", (uint32_t) Time_currentTimeSeconds(admin->eventBase));        String* theCookie = &(String) { .len = strlen(bytes), .bytes = bytes };        Dict_putString(d, cookie, theCookie, allocator);        Admin_sendMessage(d, txid, admin);        return;    }    // If this is a permitted query, make sure the cookie is right.    String* auth = BSTR("auth");    bool authed = false;    if (String_equals(query, auth)) {        if (!authValid(&message, buffer + skip, reader->bytesRead(reader), admin)) {            Dict* d = Dict_new(allocator);            Dict_putString(d, BSTR("error"), BSTR("Auth failed."), allocator);            Admin_sendMessage(d, txid, admin);            return;        }        query = Dict_getString(&message, BSTR("aq"));        authed = true;    }    for (int i = 0; i < admin->functionCount; i++) {        if (String_equals(query, admin->functions[i].name)            && (authed || !admin->functions[i].needsAuth))        {            admin->functions[i].call(&message, admin->functions[i].context, txid);        }    }    return;}

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 String* getExpectedResponse(struct Sockaddr* sa4, int prefix4, int alloc4,                                   struct Sockaddr* sa6, int prefix6, int alloc6,                                   struct Allocator* allocator){    Assert_true(alloc6 >= prefix6);    Assert_true(alloc4 >= prefix4);    struct Allocator* alloc = Allocator_child(allocator);    Dict* addresses = Dict_new(alloc);    if (sa4) {        uint8_t* addr = NULL;        Assert_true(Sockaddr_getAddress(sa4, &addr) == 4);        String* addrStr = String_newBinary(addr, 4, alloc);        Dict_putString(addresses, String_new("ip4", alloc), addrStr, alloc);        Dict_putInt(addresses, String_new("ip4Prefix", alloc), prefix4, alloc);        Dict_putInt(addresses, String_new("ip4Alloc", alloc), alloc4, alloc);    }    if (sa6) {        uint8_t* addr = NULL;        Assert_true(Sockaddr_getAddress(sa6, &addr) == 16);        String* addrStr = String_newBinary(addr, 16, alloc);        Dict_putString(addresses, String_new("ip6", alloc), addrStr, alloc);        Dict_putInt(addresses, String_new("ip6Prefix", alloc), prefix6, alloc);        Dict_putInt(addresses, String_new("ip6Alloc", alloc), alloc6, alloc);    }    Dict* output = Dict_new(alloc);    Dict_putDict(output, String_new("addresses", alloc), addresses, alloc);    Dict_putString(output, String_new("txid", alloc), String_new("abcd", alloc), alloc);    struct Message* msg = Message_new(0, 512, alloc);    BencMessageWriter_write(output, msg, NULL);    String* outStr = String_newBinary(msg->bytes, msg->length, allocator);    Allocator_free(alloc);    return outStr;}

static void tunInterface(Dict* ifaceConf, struct Allocator* tempAlloc, struct Context* ctx){    String* ifaceType = Dict_getString(ifaceConf, String_CONST("type"));    if (!String_equals(ifaceType, String_CONST("TUNInterface"))) {        return;    }    // Setup the interface.    String* tunfd = Dict_getString(ifaceConf, String_CONST("tunfd"));    String* device = Dict_getString(ifaceConf, String_CONST("tunDevice"));    Dict* args = Dict_new(tempAlloc);    if (tunfd && device) {        Dict_putString(args, String_CONST("path"), device, tempAlloc);        Dict_putString(args, String_CONST("type"),                       String_new(tunfd->bytes, tempAlloc), tempAlloc);        Dict* res = NULL;        rpcCall0(String_CONST("FileNo_import"), args, ctx, tempAlloc, &res, false);        if (res) {            Dict* args = Dict_new(tempAlloc);            int64_t* tunfd = Dict_getInt(res, String_CONST("tunfd"));            int64_t* type = Dict_getInt(res, String_CONST("type"));            Dict_putInt(args, String_CONST("tunfd"), *tunfd, tempAlloc);            Dict_putInt(args, String_CONST("type"), *type, tempAlloc);            rpcCall0(String_CONST("Core_initTunfd"), args, ctx, tempAlloc, NULL, false);        }    } else {        if (device) {            Dict_putString(args, String_CONST("desiredTunName"), device, tempAlloc);        }        rpcCall0(String_CONST("Core_initTunnel"), args, ctx, tempAlloc, NULL, false);    }}

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

static void dumpTable(Dict* args, void* vcontext, String* txid, struct Allocator* requestAlloc){    struct Context* ctx = Identity_check((struct Context*) vcontext);    int64_t* page = Dict_getInt(args, String_CONST("page"));    int ctr = (page) ? *page * ENTRIES_PER_PAGE : 0;    Dict* out = Dict_new(requestAlloc);    List* table = List_new(requestAlloc);    struct Node_Two* nn = NULL;    for (int i = 0; i < ctr+ENTRIES_PER_PAGE; i++) {        nn = NodeStore_getNextNode(ctx->store, nn);        if (!nn) { break; }        if (i < ctr) { continue; }        Dict* nodeDict = Dict_new(requestAlloc);        String* ip = String_newBinary(NULL, 39, requestAlloc);        Address_printIp(ip->bytes, &nn->address);        Dict_putString(nodeDict, String_CONST("ip"), ip, requestAlloc);        String* addr = Address_toString(&nn->address, requestAlloc);        Dict_putString(nodeDict, String_CONST("addr"), addr, requestAlloc);        String* path = String_newBinary(NULL, 19, requestAlloc);        AddrTools_printPath(path->bytes, nn->address.path);        Dict_putString(nodeDict, String_CONST("path"), path, requestAlloc);        Dict_putInt(nodeDict, String_CONST("link"), Node_getCost(nn), requestAlloc);        Dict_putInt(nodeDict, String_CONST("version"), nn->address.protocolVersion, requestAlloc);        Dict_putInt(nodeDict,                    String_CONST("time"),                    NodeStore_timeSinceLastPing(ctx->store, nn),                    requestAlloc);        Dict_putInt(nodeDict,                    String_CONST("bucket"),                    NodeStore_bucketForAddr(ctx->store->selfAddress, &nn->address),                    requestAlloc);        List_addDict(table, nodeDict, requestAlloc);    }    Dict_putList(out, String_CONST("routingTable"), table, requestAlloc);    if (nn) {        Dict_putInt(out, String_CONST("more"), 1, requestAlloc);    }    Dict_putInt(out, String_CONST("count"), ctx->store->nodeCount, requestAlloc);    Dict_putInt(out, String_CONST("peers"), ctx->store->peerCount, requestAlloc);    Dict_putString(out, String_CONST("deprecation"),        String_CONST("ip,path,version will soon be removed"), requestAlloc);    Admin_sendMessage(out, txid, ctx->admin);}

int main(int argc, char** argv){    struct AdminTestFramework* fw = AdminTestFramework_setUp(argc, argv, "UDPInterface_test");    // mock interface controller.    struct InterfaceController ifController = {        .registerPeer = registerPeer    };    UDPInterface_admin_register(fw->eventBase,                                fw->alloc,                                fw->logger,                                fw->admin,                                &ifController);    Dict* dict = Dict_new(fw->alloc);    struct AdminClient_Promise* promise =        AdminClient_rpcCall(String_CONST("UDPInterface_new"), dict, fw->client, fw->alloc);    promise->callback = ifNewCallback;    promise->userData = fw;    EventBase_beginLoop(fw->eventBase);    // bad key    dict = Dict_new(fw->alloc);    Dict_putString(dict, String_CONST("publicKey"), String_CONST("notAValidKey"), fw->alloc);    Dict_putString(dict, String_CONST("address"), String_CONST("127.0.0.1:12345"), fw->alloc);    promise = AdminClient_rpcCall(        String_CONST("UDPInterface_beginConnection"), dict, fw->client, fw->alloc);    promise->callback = badKeyCallback;    promise->userData = fw;    EventBase_beginLoop(fw->eventBase);    dict = Dict_new(fw->alloc);    Dict_putString(dict,                   String_CONST("publicKey"),                   String_CONST("c86pf0ngj3wlb569juqm10yzv29n9t4w5tmsyhx6xd3fbqjlcu50.k"),                   fw->alloc);    Dict_putString(dict, String_CONST("address"), String_CONST("127.0.0.1:12345"), fw->alloc);    promise = AdminClient_rpcCall(        String_CONST("UDPInterface_beginConnection"), dict, fw->client, fw->alloc);    promise->callback = goodCallback;    promise->userData = fw;    EventBase_beginLoop(fw->eventBase);    AdminTestFramework_tearDown(fw);    return 0;}

void Admin_registerFunctionWithArgCount(char* name,                                        Admin_FUNCTION(callback),                                        void* callbackContext,                                        bool needsAuth,                                        struct Admin_FunctionArg* arguments,                                        int argCount,                                        struct Admin* admin){    if (!admin) {        return;    }    String* str = String_new(name, admin->allocator);    if (!admin->functionCount) {        admin->functions = admin->allocator->malloc(sizeof(struct Function), admin->allocator);    } else {        admin->functions =            admin->allocator->realloc(admin->functions,                                      sizeof(struct Function) * (admin->functionCount + 1),                                      admin->allocator);    }    struct Function* fu = &admin->functions[admin->functionCount];    admin->functionCount++;    fu->name = str;    fu->call = callback;    fu->context = callbackContext;    fu->needsAuth = needsAuth;    fu->args = Dict_new(admin->allocator);    for (int i = 0; arguments && i < argCount; i++) {        // "type" must be one of: [ "String", "Int", "Dict", "List" ]        String* type = NULL;        if (!strcmp(arguments[i].type, STRING->bytes)) {            type = STRING;        } else if (!strcmp(arguments[i].type, INT->bytes)) {            type = INT;        } else if (!strcmp(arguments[i].type, DICT->bytes)) {            type = DICT;        } else if (!strcmp(arguments[i].type, LIST->bytes)) {            type = LIST;        } else {            abort();        }        Dict* arg = Dict_new(admin->allocator);        Dict_putString(arg, TYPE, type, admin->allocator);        Dict_putInt(arg, REQUIRED, arguments[i].required, admin->allocator);        String* name = String_new(arguments[i].name, admin->allocator);        Dict_putDict(fu->args, name, arg, admin->allocator);    }}

static void adminPeerStats(Dict* args, void* vcontext, String* txid, struct Allocator* alloc){    struct Context* context = Identity_check((struct Context*)vcontext);    struct InterfaceController_PeerStats* stats = NULL;    int64_t* page = Dict_getIntC(args, "page");    int i = (page) ? *page * ENTRIES_PER_PAGE : 0;    int count = InterfaceController_getPeerStats(context->ic, alloc, &stats);    List* list = List_new(alloc);    for (int counter=0; i < count && counter++ < ENTRIES_PER_PAGE; i++) {        Dict* d = Dict_new(alloc);        Dict_putIntC(d, "bytesIn", stats[i].bytesIn, alloc);        Dict_putIntC(d, "bytesOut", stats[i].bytesOut, alloc);        Dict_putIntC(d, "recvKbps", stats[i].recvKbps, alloc);        Dict_putIntC(d, "sendKbps", stats[i].sendKbps, alloc);        Dict_putStringC(d, "addr", Address_toString(&stats[i].addr, alloc), alloc);        String* stateString = String_new(InterfaceController_stateString(stats[i].state), alloc);        Dict_putStringC(d, "state", stateString, alloc);        Dict_putIntC(d, "last", stats[i].timeOfLastMessage, alloc);        Dict_putIntC(d, "isIncoming", stats[i].isIncomingConnection, alloc);        Dict_putIntC(d, "duplicates", stats[i].duplicates, alloc);        Dict_putIntC(d, "lostPackets", stats[i].lostPackets, alloc);        Dict_putIntC(d, "receivedOutOfRange", stats[i].receivedOutOfRange, alloc);        if (stats[i].user) {            Dict_putStringC(d, "user", stats[i].user, alloc);        }        List_addDict(list, d, alloc);    }    Dict* resp = Dict_new(alloc);    Dict_putListC(resp, "peers", list, alloc);    Dict_putIntC(resp, "total", count, alloc);    if (i < count) {        Dict_putIntC(resp, "more", 1, alloc);    }    Admin_sendMessage(resp, txid, context->admin);}

static void searchResponse(struct RouterModule_Promise* promise,                           uint32_t lag,                           struct Address* from,                           Dict* responseDict){    struct Search* search = Identity_check((struct Search*) promise->userData);    struct Allocator* alloc = Allocator_child(search->alloc);    Dict* resp = Dict_new(alloc);    if (!from) {        Dict_putStringCC(resp, "error", "none", alloc);        Dict_putIntC(resp, "complete", 1, alloc);        Admin_sendMessage(resp, search->txid, search->ctx->admin);        Allocator_free(alloc);        return;    }    String* fromStr = Address_toString(from, alloc);    Dict_putStringC(resp, "from", fromStr, alloc);    Dict_putIntC(resp, "ms", lag, alloc);    struct Address_List* addrs = ReplySerializer_parse(from, responseDict, NULL, true, alloc);    List* nodes = List_new(alloc);    for (int i = 0; addrs && i < addrs->length; i++) {        String* addr = Address_toString(&addrs->elems[i], alloc);        List_addString(nodes, addr, alloc);    }    Dict_putListC(resp, "nodes", nodes, alloc);    Admin_sendMessage(resp, search->txid, search->ctx->admin);}

static void checkRunningInstance(struct Allocator* allocator,                                 struct EventBase* base,                                 String* addr,                                 String* password,                                 struct Log* logger,                                 struct Except* eh){    struct Allocator* alloc = Allocator_child(allocator);    struct Sockaddr_storage pingAddrStorage;    if (Sockaddr_parse(addr->bytes, &pingAddrStorage)) {        Except_raise(eh, -1, "Unable to parse [%s] as an ip address port, eg: 127.0.0.1:11234",                     addr->bytes);    }    struct AdminClient* adminClient =        AdminClient_new(&pingAddrStorage.addr, password, base, logger, alloc);    // 100 milliseconds is plenty to wait for a process to respond on the same machine.    adminClient->millisecondsToWait = 100;    Dict* pingArgs = Dict_new(alloc);    struct AdminClient_Result* pingResult =        AdminClient_rpcCall(String_new("ping", alloc), pingArgs, adminClient, alloc);    if (pingResult->err == AdminClient_Error_NONE) {        Except_raise(eh, -1, "Startup failed: cjdroute is already running.");    }    Allocator_free(alloc);}

static void bytesAllocated(Dict* in, void* vcontext, String* txid, struct Allocator* requestAlloc){    struct Allocator_admin_pvt* ctx = Identity_check((struct Allocator_admin_pvt*)vcontext);    Dict* d = Dict_new(requestAlloc);    Dict_putIntC(d, "bytes", Allocator_bytesAllocated(ctx->alloc), requestAlloc);    Admin_sendMessage(d, txid, ctx->admin);}

static Dict* makeLogMessage(struct Subscription* subscription,                            struct AdminLog* logger,                            enum Log_Level logLevel,                            const char* fullFilePath,                            uint32_t line,                            const char* format,                            va_list vaArgs,                            struct Allocator* alloc){    time_t now;    time(&now);    Dict* out = Dict_new(alloc);    char* buff = Allocator_malloc(alloc, 20);    Hex_encode((uint8_t*)buff, 20, subscription->streamId, 8);    Dict_putString(out, String_new("streamId", alloc), String_new(buff, alloc), alloc);    Dict_putInt(out, String_new("time", alloc), now, alloc);    Dict_putString(out,                   String_new("level", alloc),                   String_new(Log_nameForLevel(logLevel), alloc),                   alloc);    const char* shortName = getShortName(fullFilePath);    Dict_putString(out, String_new("file", alloc), String_new((char*)shortName, alloc), alloc);    Dict_putInt(out, String_new("line", alloc), line, alloc);    String* message = String_vprintf(alloc, format, vaArgs);    // Strip all of the annoying /n marks in the log entries.    if (message->len > 0 && message->bytes[message->len - 1] == '/n') {        message->len--;    }    Dict_putString(out, String_new("message", alloc), message, alloc);    return out;}

static void showActiveSearch(Dict* args, void* vctx, String* txid, struct Allocator* alloc){    struct Context* ctx = Identity_check((struct Context*) vctx);    int number = *(Dict_getIntC(args, "number"));    struct SearchRunner_SearchData* search =        SearchRunner_showActiveSearch(ctx->runner, number, alloc);    Dict* dict = Dict_new(alloc);    // Nothing is an error    Dict_putString(dict, String_new("error", alloc), String_new("none", alloc), alloc);    if (number < search->activeSearches) {        uint8_t target[40];        AddrTools_printIp(target, search->target);        Dict_putString(dict, String_new("target", alloc), String_new((char*)target, alloc), alloc);        uint8_t lastNodeAsked[60];        Address_print(lastNodeAsked, &search->lastNodeAsked);        Dict_putString(dict,                       String_new("lastNodeAsked", alloc),                       String_new((char*)lastNodeAsked, alloc),                       alloc);        Dict_putInt(dict, String_new("totalRequests", alloc), search->totalRequests, alloc);    }    Dict_putInt(dict, String_new("activeSearches", alloc), search->activeSearches, alloc);    Admin_sendMessage(dict, txid, ctx->admin);}

static void getHandles(Dict* args, void* vcontext, String* txid, struct Allocator* requestAlloc){    struct Context* context = Identity_check((struct Context*) vcontext);    struct Allocator* alloc = Allocator_child(context->alloc);    int64_t* page = Dict_getInt(args, String_CONST("page"));    int i = (page) ? *page * ENTRIES_PER_PAGE : 0;    struct SessionManager_HandleList* hList = SessionManager_getHandleList(context->sm, alloc);    List* list = List_new(alloc);    for (int counter = 0; i < hList->length && counter++ < ENTRIES_PER_PAGE; i++) {        List_addInt(list, hList->handles[i], alloc);    }    Dict* r = Dict_new(alloc);    Dict_putList(r, String_CONST("handles"), list, alloc);    Dict_putInt(r, String_CONST("total"), hList->length, alloc);    String* more = String_CONST("more");    if (i < hList->length) {        Dict_putInt(r, more, 1, alloc);    }    Admin_sendMessage(r, txid, context->admin);    Allocator_free(alloc);}

static void addServer(Dict* args, void* vcontext, String* txid, struct Allocator* requestAlloc){    struct Context* context = vcontext;    struct Allocator* alloc = Allocator_child(context->alloc);    String* addrStr = Dict_getString(args, String_CONST("addr"));    int ret;    struct Sockaddr_storage ss;    char* err = "none";    if (Sockaddr_parse(addrStr->bytes, &ss)) {        err = "could not parse address";    } else if ((ret = RainflyClient_addServer(context->rainfly, &ss.addr))) {        if (ret == RainflyClient_addServer_WRONG_ADDRESS_TYPE) {            err = "RainflyClient_addServer_WRONG_ADDRESS_TYPE";        } else {            err = "unknown error";        }    }    Dict* response = Dict_new(alloc);    Dict_putString(response, String_CONST("error"), String_CONST(err), alloc);    Admin_sendMessage(response, txid, context->admin);    Allocator_free(alloc);}

static void adminPingOnResponse(struct SwitchPinger_Response* resp, void* vping){    struct Allocator* pingAlloc = resp->ping->pingAlloc;    struct Ping* ping = vping;    Dict* rd = Dict_new(pingAlloc);    if (resp->res == SwitchPinger_Result_LABEL_MISMATCH) {        uint8_t path[20] = {0};        AddrTools_printPath(path, resp->label);        String* pathStr = String_new(path, pingAlloc);        Dict_putString(rd, String_CONST("rpath"), pathStr, pingAlloc);    }    Dict_putInt(rd, String_CONST("version"), resp->version, pingAlloc);    Dict_putInt(rd, String_CONST("ms"), resp->milliseconds, pingAlloc);    Dict_putString(rd, String_CONST("result"), SwitchPinger_resultString(resp->res), pingAlloc);    Dict_putString(rd, String_CONST("path"), ping->path, pingAlloc);    if (resp->data) {        Dict_putString(rd, String_CONST("data"), resp->data, pingAlloc);    }    if (!Bits_isZero(resp->key, 32)) {        Dict_putString(rd, String_CONST("key"), Key_stringify(resp->key, pingAlloc), pingAlloc);    }    Admin_sendMessage(rd, ping->txid, ping->context->admin);}

static void dumpRumorMill(Dict* args, void* vcontext, String* txid, struct Allocator* requestAlloc){    struct Context* ctx = Identity_check((struct Context*) vcontext);    Dict* out = Dict_new(requestAlloc);    struct RumorMill* rm = getRumorMill(ctx, Dict_getString(args, String_CONST("mill")));    if (!rm) {        Dict_putString(out,                       String_CONST("error"),                       String_CONST("mill must be one of "                                    "[externalMill,linkMill,nodeMill,dhtMill,splitMill]"),                       requestAlloc);        Admin_sendMessage(out, txid, ctx->admin);        return;    }    int64_t* page = Dict_getInt(args, String_CONST("page"));    int ctr = (page) ? *page * ENTRIES_PER_PAGE : 0;    List* table = List_new(requestAlloc);    for (int i = 0; i < ENTRIES_PER_PAGE && ctr < rm->count; i++) {        String* addr = Address_toString(&rm->addresses[ctr++], requestAlloc);        List_addString(table, addr, requestAlloc);    }    Dict_putList(out, String_CONST("addresses"), table, requestAlloc);    Dict_putInt(out, String_CONST("total"), rm->count, requestAlloc);    Admin_sendMessage(out, txid, ctx->admin);}

static void adminResetPeering(Dict* args,                              void* vcontext,                              String* txid,                              struct Allocator* requestAlloc){    struct Context* context = Identity_check((struct Context*)vcontext);    String* pubkeyString = Dict_getStringC(args, "pubkey");    int error = 0;    char* errorMsg = NULL;    if (pubkeyString) {        // parse the key        uint8_t pubkey[32];        uint8_t addr[16];        error = Key_parse(pubkeyString, pubkey, addr);        if (error) {            errorMsg = "bad key";        } else {            InterfaceController_resetPeering(context->ic, pubkey);        }    } else {        // reset all        InterfaceController_resetPeering(context->ic, NULL);    }    Dict* response = Dict_new(requestAlloc);    Dict_putIntC(response, "success", error ? 0 : 1, requestAlloc);    if (error) {        Dict_putStringCC(response, "error", errorMsg, requestAlloc);    }    Admin_sendMessage(response, txid, context->admin);}

static void adminDisconnectPeer(Dict* args,                                void* vcontext,                                String* txid,                                struct Allocator* requestAlloc){    struct Context* context = Identity_check((struct Context*)vcontext);    String* pubkeyString = Dict_getString(args, String_CONST("pubkey"));    // parse the key    uint8_t pubkey[32];    uint8_t addr[16];    int error = Key_parse(pubkeyString, pubkey, addr);    char* errorMsg = NULL;    if (error) {        errorMsg = "bad key";    } else {        //  try to remove the peer if the key is valid        error = InterfaceController_disconnectPeer(context->ic,pubkey);        if (error) {            errorMsg = "no peer found for that key";        }    }    Dict* response = Dict_new(requestAlloc);    Dict_putInt(response, String_CONST("success"), error ? 0 : 1, requestAlloc);    if (error) {        Dict_putString(response, String_CONST("error"), String_CONST(errorMsg), requestAlloc);    }    Admin_sendMessage(response, txid, context->admin);}

static void addKey(Dict* args, void* vcontext, String* txid, struct Allocator* requestAlloc){    struct Context* context = vcontext;    struct Allocator* alloc = Allocator_child(context->alloc);    String* identStr = Dict_getString(args, String_CONST("ident"));    int ret;    uint8_t key[32];    char* err = "none";    if (identStr->len < 52) {        err = "too short";    } else if (Base32_decode(key, 32, identStr->bytes, 52) != 32) {        err = "failed to parse";    } else if ((ret = RainflyClient_addKey(context->rainfly, key))) {        if (ret == RainflyClient_addKey_TOO_MANY_KEYS) {            err = "RainflyClient_addKey_TOO_MANY_KEYS";        } else {            err = "unknown error";        }    }    Dict* response = Dict_new(alloc);    Dict_putString(response, String_CONST("error"), String_CONST(err), alloc);    Admin_sendMessage(response, txid, context->admin);    Allocator_free(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 newInterface2(struct Context* ctx,                          struct Sockaddr* addr,                          String* txid,                          struct Allocator* requestAlloc){    struct Allocator* const alloc = Allocator_child(ctx->alloc);    struct UDPAddrIface* udpIf = NULL;    struct Jmp jmp;    Jmp_try(jmp) {        udpIf = UDPAddrIface_new(ctx->eventBase, addr, alloc, &jmp.handler, ctx->logger);    } Jmp_catch {        String* errStr = String_CONST(jmp.message);        Dict out = Dict_CONST(String_CONST("error"), String_OBJ(errStr), NULL);        Admin_sendMessage(&out, txid, ctx->admin);        Allocator_free(alloc);        return;    }    struct AddrIface* ai = ctx->udpIf = &udpIf->generic;    struct InterfaceController_Iface* ici =        InterfaceController_newIface(ctx->ic, String_CONST("UDP"), alloc);    Iface_plumb(&ici->addrIf, &ai->iface);    Dict* out = Dict_new(requestAlloc);    Dict_putString(out, String_CONST("error"), String_CONST("none"), requestAlloc);    Dict_putInt(out, String_CONST("interfaceNumber"), ici->ifNum, requestAlloc);    char* printedAddr = Sockaddr_print(ai->addr, requestAlloc);    Dict_putString(out,                   String_CONST("bindAddress"),                   String_CONST(printedAddr),                   requestAlloc);    Admin_sendMessage(out, txid, ctx->admin);}

static void genericResponse(struct RouterModule_Promise* promise,                            uint32_t lag,                            struct Address* from,                            Dict* responseDict,                            String* name){    struct Ping* ping = Identity_check((struct Ping*)promise->userData);    Dict* out = Dict_new(promise->alloc);    String* result = (responseDict) ? name : String_CONST("timeout");    Dict_putString(out, String_CONST("result"), result, promise->alloc);    if (responseDict) {        struct Address_List* addrs =            ReplySerializer_parse(from, responseDict, NULL, promise->alloc);        List* nodes = List_new(promise->alloc);        for (int i = 0; i < addrs->length; i++) {            String* addr = Address_toString(&addrs->elems[i], promise->alloc);            List_addString(nodes, addr, promise->alloc);        }        Dict_putList(out, name, nodes, promise->alloc);    }    Dict_putInt(out, String_CONST("ms"), lag, promise->alloc);    Dict_putString(out, String_CONST("error"), String_CONST("none"), promise->alloc);    Admin_sendMessage(out, ping->txid, ping->ctx->admin);}

static void showConn(struct IpTunnel_Connection* conn,                     String* txid,                     struct Admin* admin,                     struct Allocator* alloc){    Dict* d = Dict_new(alloc);    if (!Bits_isZero(conn->connectionIp6, 16)) {        struct Sockaddr* addr = Sockaddr_clone(Sockaddr_LOOPBACK6, alloc);        uint8_t* address;        Assert_true(16 == Sockaddr_getAddress(addr, &address));        Bits_memcpy(address, conn->connectionIp6, 16);        char* printedAddr = Sockaddr_print(addr, alloc);        Dict_putString(d, String_CONST("ip6Address"), String_CONST(printedAddr), alloc);        Dict_putInt(d, String_CONST("ip6Prefix"), conn->connectionIp6Prefix, alloc);    }    if (!Bits_isZero(conn->connectionIp4, 4)) {        struct Sockaddr* addr = Sockaddr_clone(Sockaddr_LOOPBACK, alloc);        uint8_t* address;        Assert_true(4 == Sockaddr_getAddress(addr, &address));        Bits_memcpy(address, conn->connectionIp4, 4);        char* printedAddr = Sockaddr_print(addr, alloc);        Dict_putString(d, String_CONST("ip4Address"), String_CONST(printedAddr), alloc);        Dict_putInt(d, String_CONST("ip4Prefix"), conn->connectionIp4Prefix, alloc);    }    Dict_putString(d, String_CONST("key"),                      Key_stringify(conn->routeHeader.publicKey, alloc), alloc);    Dict_putInt(d, String_CONST("outgoing"), (conn->isOutgoing) ? 1 : 0, alloc);    Dict_putString(d, String_CONST("error"), String_CONST("none"), alloc);    Admin_sendMessage(d, txid, admin);}

static Dict* serialize(void* vcontext){    char* buffer = calloc(2048, 1);    struct Allocator* allocator = BufferAllocator_new(buffer, 2048);    Dict* out = Dict_new(allocator);    Dict_putString(out, &hi, String_new((char*) vcontext, allocator), allocator);    return out;}

Dict* Security_getUser(char* userName, struct Allocator* retAlloc){    Dict* ret = Dict_new(retAlloc);    Dict_putString(ret, String_new("error", retAlloc),                        String_new("Not supported on windows", retAlloc),                        retAlloc);    return ret;}

static void sendResponse(String* error,                         struct Admin* admin,                         String* txid,                         struct Allocator* tempAlloc){    Dict* output = Dict_new(tempAlloc);    Dict_putString(output, String_CONST("error"), error, tempAlloc);    Admin_sendMessage(output, txid, admin);}