static void adminPeerStats(Dict* args, void* vcontext, String* txid)
{
struct Context* context = vcontext;
struct Allocator* alloc = Allocator_child(context->alloc);
struct InterfaceController_peerStats* stats = NULL;
int64_t* page = Dict_getInt(args, String_CONST("page"));
int i = (page) ? *page * ENTRIES_PER_PAGE : 0;
int count = context->ic->getPeerStats(context->ic, alloc, &stats);
String* bytesIn = String_CONST("bytesIn");
String* bytesOut = String_CONST("bytesOut");
String* pubKey = String_CONST("publicKey");
String* state = String_CONST("state");
String* last = String_CONST("last");
String* switchLabel = String_CONST("switchLabel");
String* isIncoming = String_CONST("isIncoming");
List* list = NULL;
for (int counter=0; i < count && counter++ < ENTRIES_PER_PAGE; i++) {
Dict* d = Dict_new(alloc);
Dict_putInt(d, bytesIn, stats[i].bytesIn, alloc);
Dict_putInt(d, bytesOut, stats[i].bytesOut, alloc);
Dict_putString(d, pubKey, Key_stringify(stats[i].pubKey, alloc), alloc);
String* stateString = String_new(InterfaceController_stateString(stats[i].state), alloc);
Dict_putString(d, state, stateString, alloc);
Dict_putInt(d, last, stats[i].timeOfLastMessage, alloc);
uint8_t labelStack[20];
AddrTools_printPath(labelStack, stats[i].switchLabel);
Dict_putString(d, switchLabel, String_new((char*)labelStack, alloc), alloc);
Dict_putInt(d, isIncoming, stats[i].isIncomingConnection, alloc);
list = List_addDict(list, d, alloc);
}
Dict response = Dict_CONST(
String_CONST("peers"), List_OBJ(list), Dict_CONST(
String_CONST("total"), Int_OBJ(count), NULL
));
if (i < count) {
response = Dict_CONST(
String_CONST("more"), Int_OBJ(1), response
);
}
Admin_sendMessage(&response, txid, context->admin);
Allocator_free(alloc);
}
static void dumpTable_send(struct Context* ctx,
struct List_Item* last,
bool isMore,
String* txid)
{
Dict table = Dict_CONST(String_CONST("routingTable"), List_OBJ(&last), NULL);
if (isMore) {
table = Dict_CONST(String_CONST("more"), Int_OBJ(1), table);
} else {
// the self route is synthetic so add 1 to the count.
table = Dict_CONST(String_CONST("count"), Int_OBJ(ctx->store->size + 1), table);
}
Admin_sendMessage(&table, txid, ctx->admin);
}
static void ethInterfaceSetBeacon(int ifNum, Dict* eth, struct Context* ctx)
{
int64_t* beaconP = Dict_getInt(eth, String_CONST("beacon"));
if (beaconP) {
int64_t beacon = *beaconP;
if (beacon > 3 || beacon < 0) {
Log_error(ctx->logger, "interfaces.ETHInterface.beacon may only be 0, 1,or 2");
} else {
// We can cast beacon to an int here because we know it's small enough
Log_info(ctx->logger, "Setting beacon mode on ETHInterface to [%d].", (int) beacon);
Dict d = Dict_CONST(String_CONST("interfaceNumber"), Int_OBJ(ifNum),
Dict_CONST(String_CONST("state"), Int_OBJ(beacon), NULL));
rpcCall(String_CONST("ETHInterface_beacon"), &d, ctx, ctx->alloc);
}
}
}
static void authorizedPasswords(List* list, struct Context* ctx)
{
uint32_t count = List_size(list);
for (uint32_t i = 0; i < count; i++) {
Dict* d = List_getDict(list, i);
Log_info(ctx->logger, "Checking authorized password %d.", i);
if (!d) {
Log_critical(ctx->logger, "Not a dictionary type %d.", i);
exit(-1);
}
String* passwd = Dict_getString(d, String_CONST("password"));
if (!passwd) {
Log_critical(ctx->logger, "Must specify a password %d.", i);
exit(-1);
}
}
Log_info(ctx->logger, "Flushing existing authorized passwords");
rpcCall(String_CONST("AuthorizedPasswords_flush"), NULL, ctx, ctx->alloc);
for (uint32_t i = 0; i < count; i++) {
Dict* d = List_getDict(list, i);
String* passwd = Dict_getString(d, String_CONST("password"));
Log_info(ctx->logger, "Adding authorized password #[%d].", i);
Dict args = Dict_CONST(
String_CONST("authType"), Int_OBJ(1), Dict_CONST(
String_CONST("password"), String_OBJ(passwd), NULL
));
struct Allocator* child = ctx->alloc->child(ctx->alloc);
rpcCall(String_CONST("AuthorizedPasswords_add"), &args, ctx, child);
child->free(child);
}
}
static void adminFunc(Dict* input, void* vcontext, String* txid, struct Allocator* requestAlloc)
{
struct Context* ctx = vcontext;
ctx->called = true;
Dict d = Dict_CONST(String_CONST("called!"), Int_OBJ(1), NULL);
Admin_sendMessage(&d, txid, ctx->framework->admin);
}
static void newInterface2(struct Context* ctx,
struct Sockaddr* addr,
String* txid)
{
struct Allocator* const alloc = Allocator_child(ctx->allocator);
struct UDPInterface* udpIf = NULL;
struct Jmp jmp;
Jmp_try(jmp) {
udpIf = UDPInterface_new(ctx->eventBase, addr, alloc, &jmp.handler, ctx->logger, ctx->ic);
} 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);
}
// sizeof(struct UDPInterface*) the size of a pointer.
ctx->ifaces = Allocator_realloc(ctx->allocator,
ctx->ifaces,
sizeof(struct UDPInterface*) * (ctx->ifCount + 1));
ctx->ifaces[ctx->ifCount] = udpIf;
Dict out = Dict_CONST(
String_CONST("error"), String_OBJ(String_CONST("none")), Dict_CONST(
String_CONST("interfaceNumber"), Int_OBJ(ctx->ifCount), NULL
));
Admin_sendMessage(&out, txid, ctx->admin);
ctx->ifCount++;
}
static void adminMemory(Dict* input, void* vcontext, String* txid)
{
struct MemoryContext* context = vcontext;
Dict d = Dict_CONST(
String_CONST("bytes"), Int_OBJ(MallocAllocator_bytesAllocated(context->allocator)), NULL
);
Admin_sendMessage(&d, txid, context->admin);
}
static void sendResponse(int conn, String* txid, struct Admin* admin)
{
Dict resp = Dict_CONST(
String_CONST("error"), String_OBJ(String_CONST("none")), Dict_CONST(
String_CONST("connection"), Int_OBJ(conn), NULL
));
Admin_sendMessage(&resp, txid, admin);
}
static void pingResponse(struct RouterModule_Promise* promise,
uint32_t lag,
struct Node* node,
Dict* responseDict)
{
struct Ping* ping = Identity_cast((struct Ping*)promise->userData);
uint8_t versionStr[40] = "old";
String* version = String_CONST((char*)versionStr);
String* versionBin = Dict_getString(responseDict, CJDHTConstants_VERSION);
if (versionBin && versionBin->len == 20) {
Hex_encode(versionStr, 40, (uint8_t*) versionBin->bytes, 20);
version->len = 40;
}
int64_t* protocolVersion = Dict_getInt(responseDict, CJDHTConstants_PROTOCOL);
int64_t pv = (protocolVersion) ? *protocolVersion : -1;
Dict response = NULL;
Dict verResponse = Dict_CONST(String_CONST("version"), String_OBJ(version), response);
if (versionBin) {
response = verResponse;
}
String* result = (responseDict) ? String_CONST("pong") : String_CONST("timeout");
response = Dict_CONST(String_CONST("result"), String_OBJ(result), response);
Dict protoResponse = Dict_CONST(String_CONST("protocol"), Int_OBJ(pv), response);
if (protocolVersion) {
response = protoResponse;
}
response = Dict_CONST(String_CONST("ms"), Int_OBJ(lag), response);
char from[60] = "";
if (node) {
Address_print((uint8_t*)from, &node->address);
}
Dict fromResponse = Dict_CONST(String_CONST("from"), String_OBJ(String_CONST(from)), response);
if (node) {
response = fromResponse;
}
Admin_sendMessage(&response, ping->txid, ping->ctx->admin);
}
static void list(Dict* args, void* vcontext, String* txid, struct Allocator* requestAlloc)
{
struct Context* context = (struct Context*) vcontext;
struct Allocator* child = Allocator_child(context->allocator);
List* users = CryptoAuth_getUsers(context->ca, child);
uint32_t count = List_size(users);
Dict response = Dict_CONST(
String_CONST("total"), Int_OBJ(count), Dict_CONST(
String_CONST("users"), List_OBJ(users), NULL
));
Admin_sendMessage(&response, txid, context->admin);
Allocator_free(child);
}
static void newInterface(Dict* args, void* vcontext, String* txid)
{
struct Context* const ctx = vcontext;
String* const bindAddress = Dict_getString(args, String_CONST("bindAddress"));
struct Allocator* const alloc = ctx->allocator->child(ctx->allocator);
struct UDPInterface* udpIf = NULL;
struct Jmp jmp;
Jmp_try(jmp) {
char* const bindBytes = (bindAddress) ? bindAddress->bytes : NULL;
udpIf = UDPInterface_new(
ctx->eventBase, bindBytes, alloc, &jmp.handler, ctx->logger, ctx->ic);
} Jmp_catch {
String* errStr = String_CONST(jmp.message);
Dict out = Dict_CONST(String_CONST("error"), String_OBJ(errStr), NULL);
if (jmp.code == UDPInterface_new_SOCKET_FAILED
|| jmp.code == UDPInterface_new_BIND_FAILED)
{
char* err = strerror(EVUTIL_SOCKET_ERROR());
Dict out2 = Dict_CONST(String_CONST("cause"), String_OBJ(String_CONST(err)), out);
Admin_sendMessage(&out2, txid, ctx->admin);
} else {
Admin_sendMessage(&out, txid, ctx->admin);
}
alloc->free(alloc);
return;
}
// sizeof(struct UDPInterface*) the size of a pointer.
ctx->ifaces = ctx->allocator->realloc(ctx->ifaces,
sizeof(struct UDPInterface*) * (ctx->ifCount + 1),
ctx->allocator);
ctx->ifaces[ctx->ifCount] = udpIf;
Dict out = Dict_CONST(
String_CONST("error"), String_OBJ(String_CONST("none")), Dict_CONST(
String_CONST("interfaceNumber"), Int_OBJ(ctx->ifCount), NULL
));
Admin_sendMessage(&out, txid, ctx->admin);
ctx->ifCount++;
}
static void authorizedPasswords(List* list, struct Context* ctx)
{
uint32_t count = List_size(list);
for (uint32_t i = 0; i < count; i++) {
Dict* d = List_getDict(list, i);
Log_info(ctx->logger, "Checking authorized password %d.", i);
if (!d) {
Log_critical(ctx->logger, "Not a dictionary type %d.", i);
exit(-1);
}
String* passwd = Dict_getString(d, String_CONST("password"));
if (!passwd) {
Log_critical(ctx->logger, "Must specify a password %d.", i);
exit(-1);
}
}
for (uint32_t i = 0; i < count; i++) {
struct Allocator* child = Allocator_child(ctx->alloc);
Dict* d = List_getDict(list, i);
String* passwd = Dict_getString(d, String_CONST("password"));
String* user = Dict_getString(d, String_CONST("user"));
if (!user) {
user = String_printf(child, "password [%d]", i);
}
Log_info(ctx->logger, "Adding authorized password #[%d] for user [%s].", i, user->bytes);
Dict args = Dict_CONST(
String_CONST("authType"), Int_OBJ(1), Dict_CONST(
String_CONST("password"), String_OBJ(passwd), Dict_CONST(
String_CONST("user"), String_OBJ(user), NULL
)));
rpcCall(String_CONST("AuthorizedPasswords_add"), &args, ctx, child);
Allocator_free(child);
}
}
static void dumpTable_addEntries(struct Context* ctx,
int i,
int j,
struct List_Item* last,
String* txid)
{
uint8_t path[20];
uint8_t ip[40];
String* pathStr = &(String) { .len = 19, .bytes = (char*)path };
String* ipStr = &(String) { .len = 39, .bytes = (char*)ip };
Object* link = Int_OBJ(0xFFFFFFFF);
Object* version = Int_OBJ(Version_DEFAULT_ASSUMPTION);
Dict entry = Dict_CONST(
String_CONST("ip"), String_OBJ(ipStr), Dict_CONST(
String_CONST("link"), link, Dict_CONST(
String_CONST("path"), String_OBJ(pathStr), Dict_CONST(
String_CONST("version"), version, NULL
))));
struct List_Item next = { .next = last, .elem = Dict_OBJ(&entry) };
if (i >= ctx->store->size || j >= ENTRIES_PER_PAGE) {
if (i > j) {
dumpTable_send(ctx, last, (j >= ENTRIES_PER_PAGE), txid);
return;
}
Address_printIp(ip, ctx->store->selfAddress);
strcpy((char*)path, "0000.0000.0000.0001");
dumpTable_send(ctx, &next, (j >= ENTRIES_PER_PAGE), txid);
return;
}
struct Node* n = NodeStore_dumpTable(ctx->store, i);
link->as.number = n->reach;
version->as.number = n->version;
Address_printIp(ip, &n->address);
AddrTools_printPath(path, n->address.path);
dumpTable_addEntries(ctx, i + 1, j + 1, &next, txid);
}
static void dumpTable(Dict* args, void* vcontext, String* txid)
{
struct Context* ctx = Identity_cast((struct Context*) vcontext);
int64_t* page = Dict_getInt(args, String_CONST("page"));
int i = (page) ? *page * ENTRIES_PER_PAGE : 0;
dumpTable_addEntries(ctx, i, 0, NULL, txid);
}
void NodeStore_admin_register(struct NodeStore* nodeStore,
struct Admin* admin,
struct Allocator* alloc)
{
struct Context* ctx = Allocator_clone(alloc, (&(struct Context) {
.admin = admin,
.alloc = alloc,
.store = nodeStore
}));
Identity_set(ctx);
Admin_registerFunction("NodeStore_dumpTable", dumpTable, ctx, false,
((struct Admin_FunctionArg[]) {
{ .name = "page", .required = 1, .type = "Int" },
}), admin);
}
/** @return a string representing the address and port to connect to. */
static String* initAngel(int fromAngel,
int toAngel,
int corePipes[2][2],
struct PipeInterface** piOut,
struct EventBase* eventBase,
struct Log* logger,
struct Allocator* alloc,
struct Random* rand)
{
#define TO_CORE (corePipes[0][1])
#define FROM_CORE (corePipes[1][0])
#define TO_ANGEL_AS_CORE (corePipes[1][1])
#define FROM_ANGEL_AS_CORE (corePipes[0][0])
Dict core = Dict_CONST(
String_CONST("fromCore"), Int_OBJ(FROM_CORE), Dict_CONST(
String_CONST("toCore"), Int_OBJ(TO_CORE), NULL
));
Dict admin = Dict_CONST(
String_CONST("bind"), String_OBJ(String_CONST("127.0.0.1")), Dict_CONST(
String_CONST("core"), Dict_OBJ(&core), Dict_CONST(
String_CONST("pass"), String_OBJ(String_CONST("abcd")), NULL
)));
Dict message = Dict_CONST(
String_CONST("admin"), Dict_OBJ(&admin), NULL
);
struct Allocator* tempAlloc;
BufferAllocator_STACK(tempAlloc, 1024);
#define BUFFER_SZ 1023
uint8_t buff[BUFFER_SZ + 1] = {0};
struct Writer* w = ArrayWriter_new(buff, BUFFER_SZ, tempAlloc);
StandardBencSerializer_get()->serializeDictionary(w, &message);
Log_info(logger, "Writing intial configuration to angel on [%d] config: [%s]", toAngel, buff);
write(toAngel, buff, w->bytesWritten(w));
// This is angel->core data, we can throw this away.
//Waiter_getData(buff, BUFFER_SZ, fromAngel, eventBase, NULL);
//Log_info(logger, "Init message from angel to core: [%s]", buff);
Bits_memset(buff, 0, BUFFER_SZ);
struct PipeInterface* pi =
PipeInterface_new(FROM_ANGEL_AS_CORE, TO_ANGEL_AS_CORE, eventBase, logger, alloc, rand);
*piOut = pi;
Log_info(logger, "PipeInterface [%p] is now ready.", (void*)pi);
// Make sure the angel sends data to the core.
InterfaceWaiter_waitForData(&pi->generic, eventBase, alloc, NULL);
// Send response on behalf of core.
char coreToAngelResponse[128] = " PADDING "
"\xff\xff\xff\xff"
"d"
"5:error" "4:none"
"e";
char* start = strchr(coreToAngelResponse, '\xff');
struct Message m = {
.bytes = (uint8_t*) start,
.length = strlen(start),
.padding = start - coreToAngelResponse
};
pi->generic.sendMessage(&m, &pi->generic);
// This is angel->client data, it will tell us which port was bound.
Waiter_getData(buff, BUFFER_SZ, fromAngel, eventBase, NULL);
printf("Response from angel to client: [%s]\n", buff);
struct Reader* reader = ArrayReader_new(buff, BUFFER_SZ, tempAlloc);
Dict configStore;
Dict* config = &configStore;
Assert_true(!StandardBencSerializer_get()->parseDictionary(reader, tempAlloc, config));
Dict* responseAdmin = Dict_getDict(config, String_CONST("admin"));
String* bind = Dict_getString(responseAdmin, String_CONST("bind"));
Assert_true(bind);
return String_clone(bind, alloc);
}
/**
* This spawns itself as the Angel process which spawns itself again as the core process.
* The "core process" pipes all of its inputs back to the originating process
*/
struct AdminTestFramework* AdminTestFramework_setUp(int argc, char** argv)
{
if (argc > 1 && !strcmp("angel", argv[1])) {
exit(AngelInit_main(argc, argv));
}
struct Allocator* alloc = CanaryAllocator_new(MallocAllocator_new(1<<20), NULL);
struct Writer* logwriter = FileWriter_new(stdout, alloc);
Assert_always(logwriter);
struct Log* logger = WriterLog_new(logwriter, alloc);
struct EventBase* eventBase = EventBase_new(alloc);
struct Random* rand = Random_new(alloc, NULL);
int fromAngel;
int toAngel;
int corePipes[2][2];
if (Pipe_createUniPipe(corePipes[0]) || Pipe_createUniPipe(corePipes[1])) {
Except_raise(NULL, -1, "Failed to create pipes [%s]", Errno_getString());
}
spawnAngel(&fromAngel, &toAngel);
struct PipeInterface* pi;
String* addrStr =
initAngel(fromAngel, toAngel, corePipes, &pi, eventBase, logger, alloc, rand);
Log_info(logger, "Angel initialized.");
String* password = String_new("abcd", alloc);
struct Admin* admin =
Admin_new(&pi->generic, alloc, logger, eventBase, password);
// Now setup the client.
struct sockaddr_storage addr;
int addrLen = sizeof(struct sockaddr_storage);
Bits_memset(&addr, 0, sizeof(struct sockaddr_storage));
Assert_true(!evutil_parse_sockaddr_port(addrStr->bytes, (struct sockaddr*) &addr, &addrLen));
struct AdminClient* client =
AdminClient_new((uint8_t*) &addr, addrLen, password, eventBase, logger, alloc);
Assert_always(client);
return alloc->clone(sizeof(struct AdminTestFramework), alloc, &(struct AdminTestFramework) {
.admin = admin,
.client = client,
.alloc = alloc,
.eventBase = eventBase,
.logger = logger,
.addr = alloc->clone(addrLen, alloc, &addr),
.addrLen = addrLen,
.angelInterface = &pi->generic
});
}
static void adminPid(Dict* input, void* vadmin, String* txid, struct Allocator* requestAlloc)
{
int pid = getpid();
Dict d = Dict_CONST(String_CONST("pid"), Int_OBJ(pid), NULL);
Admin_sendMessage(&d, txid, (struct Admin*) vadmin);
}
static void ethInterface(Dict* config, struct Context* ctx)
{
List* ifaces = Dict_getList(config, String_CONST("ETHInterface"));
if (!ifaces) {
ifaces = 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;
}
// 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);
}
if (rpcCall0(String_CONST("ETHInterface_new"), d, ctx, ctx->alloc, false)) {
Log_warn(ctx->logger, "Failed to create ETHInterface.");
continue;
}
// 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"), i, perCallAlloc);
rpcCall(String_CONST("ETHInterface_beginConnection"), value, ctx, perCallAlloc);
Allocator_free(perCallAlloc);
entry = entry->next;
}
}
int64_t* beaconP = Dict_getInt(eth, String_CONST("beacon"));
if (beaconP) {
int64_t beacon = *beaconP;
if (beacon > 3 || beacon < 0) {
Log_error(ctx->logger, "interfaces.ETHInterface.beacon may only be 0, 1,or 2");
} else {
// We can cast beacon to an int here because we know it's small enough
Log_info(ctx->logger, "Setting beacon mode on ETHInterface to [%d].", (int) beacon);
Dict d = Dict_CONST(String_CONST("interfaceNumber"), Int_OBJ(i),
Dict_CONST(String_CONST("state"), Int_OBJ(beacon), NULL));
rpcCall(String_CONST("ETHInterface_beacon"), &d, ctx, ctx->alloc);
}
}
}
}
static void dumpTable_addEntries(struct Context* ctx,
int i,
int j,
struct List_Item* last,
String* txid)
{
uint8_t path[20];
uint8_t ip[40];
String* pathStr = &(String) { .len = 19, .bytes = (char*)path };
String* ipStr = &(String) { .len = 39, .bytes = (char*)ip };
Object* link = Int_OBJ(0xFFFFFFFF);
Object* version = Int_OBJ(Version_DEFAULT_ASSUMPTION);
Dict entry = Dict_CONST(
String_CONST("ip"), String_OBJ(ipStr), Dict_CONST(
String_CONST("link"), link, Dict_CONST(
String_CONST("path"), String_OBJ(pathStr), Dict_CONST(
String_CONST("version"), version, NULL
))));
struct List_Item next = { .next = last, .elem = Dict_OBJ(&entry) };
if (i >= ctx->store->size || j >= ENTRIES_PER_PAGE) {
if (i > j) {
dumpTable_send(ctx, last, (j >= ENTRIES_PER_PAGE), txid);
return;
}
Address_printIp(ip, ctx->store->selfAddress);
strcpy((char*)path, "0000.0000.0000.0001");
version->as.number = Version_CURRENT_PROTOCOL;
dumpTable_send(ctx, &next, (j >= ENTRIES_PER_PAGE), txid);
return;
}
struct Node* n = NodeStore_dumpTable(ctx->store, i);
link->as.number = n->reach;
version->as.number = n->version;
Address_printIp(ip, &n->address);
AddrTools_printPath(path, n->address.path);
dumpTable_addEntries(ctx, i + 1, j + 1, &next, txid);
}
static void dumpTable(Dict* args, void* vcontext, String* txid, struct Allocator* requestAlloc)
{
struct Context* ctx = Identity_cast((struct Context*) vcontext);
int64_t* page = Dict_getInt(args, String_CONST("page"));
int i = (page) ? *page * ENTRIES_PER_PAGE : 0;
dumpTable_addEntries(ctx, i, 0, NULL, txid);
}
static bool isOneHop(struct Node_Link* link)
{
struct EncodingScheme* ps = link->parent->encodingScheme;
int num = EncodingScheme_getFormNum(ps, link->cannonicalLabel);
Assert_always(num > -1 && num < ps->count);
return EncodingScheme_formSize(&ps->forms[num]) == Bits_log2x64(link->cannonicalLabel);
}
static void getLink(Dict* args, void* vcontext, String* txid, struct Allocator* alloc)
{
struct Context* ctx = Identity_cast((struct Context*) vcontext);
Dict* ret = Dict_new(alloc);
Dict* result = Dict_new(alloc);
Dict_putDict(ret, String_new("result", alloc), result, alloc);
Dict_putString(ret, String_new("error", alloc), String_new("none", alloc), alloc);
struct Node_Link* link;
String* ipStr = Dict_getString(args, String_new("parent", alloc));
int64_t* linkNum = Dict_getInt(args, String_new("linkNum", alloc));
uint8_t ip[16];
if (ipStr->len != 39 || AddrTools_parseIp(ip, ipStr->bytes)) {
Dict_remove(ret, String_CONST("result"));
Dict_putString(ret,
String_new("error", alloc),
String_new("Could not parse ip", alloc),
alloc);
} else if ((link = NodeStore_getLink(ctx->store, ip, *linkNum))) {
Dict_putInt(result,
String_new("inverseLinkEncodingFormNumber", alloc),
link->inverseLinkEncodingFormNumber,
alloc);
Dict_putInt(result, String_new("linkState", alloc), link->linkState, alloc);
Dict_putInt(result, String_new("isOneHop", alloc), isOneHop(link), alloc);
String* cannonicalLabel = String_newBinary(NULL, 19, alloc);
AddrTools_printPath(cannonicalLabel->bytes, link->cannonicalLabel);
Dict_putString(result, String_new("cannonicalLabel", alloc), cannonicalLabel, alloc);
String* parent = String_newBinary(NULL, 39, alloc);
AddrTools_printIp(parent->bytes, link->parent->address.ip6.bytes);
Dict_putString(result, String_new("parent", alloc), parent, alloc);
String* child = String_newBinary(NULL, 39, alloc);
AddrTools_printIp(child->bytes, link->child->address.ip6.bytes);
Dict_putString(result, String_new("child", alloc), child, alloc);
}
Admin_sendMessage(ret, txid, ctx->admin);
}
static void getNode(Dict* args, void* vcontext, String* txid, struct Allocator* alloc)
{
struct Context* ctx = Identity_cast((struct Context*) vcontext);
Dict* ret = Dict_new(alloc);
Dict* result = Dict_new(alloc);
Dict_putDict(ret, String_new("result", alloc), result, alloc);
Dict_putString(ret, String_new("error", alloc), String_new("none", alloc), alloc);
// no ipStr specified --> return self-node
struct Node_Two* node = ctx->store->selfNode;
String* ipStr = Dict_getString(args, String_new("ip", alloc));
uint8_t ip[16];
while (ipStr) {
if (ipStr->len != 39 || AddrTools_parseIp(ip, ipStr->bytes)) {
Dict_remove(ret, String_CONST("result"));
Dict_putString(ret,
String_new("error", alloc),
String_new("Could not parse ip", alloc),
alloc);
} else if (!(node = NodeStore_getNode2(ctx->store, ip))) {
// not found
} else {
break;
}
Admin_sendMessage(ret, txid, ctx->admin);
return;
}
Dict_putInt(result, String_new("protocolVersion", alloc), node->version, alloc);
String* key = Key_stringify(node->address.key, alloc);
Dict_putString(result, String_new("key", alloc), key, alloc);
uint32_t linkCount = NodeStore_linkCount(node);
Dict_putInt(result, String_new("linkCount", alloc), linkCount, alloc);
List* encScheme = EncodingScheme_asList(node->encodingScheme, alloc);
Dict_putList(result, String_new("encodingScheme", alloc), encScheme, alloc);
Admin_sendMessage(ret, txid, ctx->admin);
}
static void getRouteLabel(Dict* args, void* vcontext, String* txid, struct Allocator* requestAlloc)
{
struct Context* ctx = Identity_cast((struct Context*) vcontext);
char* err = NULL;
String* pathToParentS = Dict_getString(args, String_CONST("pathToParent"));
uint64_t pathToParent;
if (pathToParentS->len != 19) {
err = "pathToParent incorrect length";
} else if (AddrTools_parsePath(&pathToParent, pathToParentS->bytes)) {
err = "Failed to parse pathToParent";
}
String* childAddressS = Dict_getString(args, String_CONST("childAddress"));
uint8_t childAddress[16];
if (childAddressS->len != 39) {
err = "childAddress of incorrect length, must be a 39 character full ipv6 address";
} else if (AddrTools_parseIp(childAddress, childAddressS->bytes)) {
err = "Failed to parse childAddress";
}
uint64_t label = UINT64_MAX;
if (!err) {
label = NodeStore_getRouteLabel(ctx->store, pathToParent, childAddress);
err = NodeStore_getRouteLabel_strerror(label);
}
Dict* response = Dict_new(requestAlloc);
if (!err) {
String* printedPath = String_newBinary(NULL, 19, requestAlloc);
AddrTools_printPath(printedPath->bytes, label);
Dict_putString(response, String_new("result", requestAlloc), printedPath, requestAlloc);
Dict_putString(response,
String_new("error", requestAlloc),
String_new("none", requestAlloc),
requestAlloc);
Admin_sendMessage(response, txid, ctx->admin);
} else {
Dict_putString(response,
String_new("error", requestAlloc),
String_new(err, requestAlloc),
requestAlloc);
Admin_sendMessage(response, txid, ctx->admin);
}
}
void NodeStore_admin_register(struct NodeStore* nodeStore,
struct Admin* admin,
struct Allocator* alloc)
{
struct Context* ctx = Allocator_clone(alloc, (&(struct Context) {
.admin = admin,
.alloc = alloc,
.store = nodeStore
}));
Identity_set(ctx);
Admin_registerFunction("NodeStore_dumpTable", dumpTable, ctx, false,
((struct Admin_FunctionArg[]) {
{ .name = "page", .required = 1, .type = "Int" },
}), admin);
Admin_registerFunction("NodeStore_getLink", getLink, ctx, true,
((struct Admin_FunctionArg[]) {
{ .name = "parent", .required = 1, .type = "String" },
{ .name = "linkNum", .required = 1, .type = "Int" },
}), admin);