static Iface_DEFUN searchReq(struct Message* msg, struct Pathfinder_pvt* pf)
{
uint8_t addr[16];
Message_pop(msg, addr, 16, NULL);
Assert_true(!msg->length);
uint8_t printedAddr[40];
AddrTools_printIp(printedAddr, addr);
Log_debug(pf->log, "Search req [%s]", printedAddr);
struct Node_Two* node = NodeStore_nodeForAddr(pf->nodeStore, addr);
if (node) {
onBestPathChange(pf, node);
} else {
SearchRunner_search(addr, 20, 3, pf->searchRunner, pf->alloc);
}
return NULL;
}
static Iface_DEFUN discoveredPath(struct Message* msg, struct Pathfinder_pvt* pf)
{
struct Address addr;
addressForNode(&addr, msg);
// We're somehow aware of this path (even if it's unused)
if (NodeStore_linkForPath(pf->nodeStore, addr.path)) { return NULL; }
// If we don't already care about the destination, then don't do anything.
struct Node_Two* nn = NodeStore_nodeForAddr(pf->nodeStore, addr.ip6.bytes);
if (!nn) { return NULL; }
// Our best path is "shorter" (label bits which is somewhat representitive of hop count)
// basically this is just to dampen the flood to the RM because otherwise it prevents Janitor
// from getting any actual work done.
if (nn->address.path < addr.path) { return NULL; }
Log_debug(pf->log, "Discovered path [%s]", Address_toString(&addr, msg->alloc)->bytes);
RumorMill_addNode(pf->rumorMill, &addr);
return NULL;
}
static void nodeForAddr(Dict* args, void* vcontext, String* txid, struct Allocator* alloc)
{
struct Context* ctx = Identity_check((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 (AddrTools_parseIp(ip, ipStr->bytes)) {
Dict_remove(ret, String_CONST("result"));
Dict_putString(ret,
String_new("error", alloc),
String_new("parse_ip", alloc),
alloc);
} else if (!(node = NodeStore_nodeForAddr(ctx->store, ip))) {
// not found
} else {
break;
}
Admin_sendMessage(ret, txid, ctx->admin);
return;
}
Dict_putInt(result, String_new("protocolVersion", alloc), node->address.protocolVersion, alloc);
String* key = Key_stringify(node->address.key, alloc);
Dict_putString(result, String_new("key", alloc), key, alloc);
uint32_t count = linkCount(node);
Dict_putInt(result, String_new("linkCount", alloc), count, alloc);
Dict_putInt(result, String_new("cost", alloc), Node_getCost(node), alloc);
List* encScheme = EncodingScheme_asList(node->encodingScheme, alloc);
Dict_putList(result, String_new("encodingScheme", alloc), encScheme, alloc);
Dict* bestParent = Dict_new(alloc);
String* parentIp = String_newBinary(NULL, 39, alloc);
AddrTools_printIp(parentIp->bytes, Node_getBestParent(node)->parent->address.ip6.bytes);
Dict_putString(bestParent, String_CONST("ip"), parentIp, alloc);
String* parentChildLabel = String_newBinary(NULL, 19, alloc);
AddrTools_printPath(parentChildLabel->bytes, Node_getBestParent(node)->cannonicalLabel);
Dict_putString(bestParent, String_CONST("parentChildLabel"), parentChildLabel, alloc);
int isOneHop = Node_isOneHopLink(Node_getBestParent(node));
Dict_putInt(bestParent, String_CONST("isOneHop"), isOneHop, alloc);
Dict_putDict(result, String_CONST("bestParent"), bestParent, alloc);
String* bestLabel = String_newBinary(NULL, 19, alloc);
AddrTools_printPath(bestLabel->bytes, node->address.path);
Dict_putString(result, String_CONST("routeLabel"), bestLabel, alloc);
Admin_sendMessage(ret, txid, ctx->admin);
}
static void getLink(Dict* args, void* vcontext, String* txid, struct Allocator* alloc)
{
struct Context* ctx = Identity_check((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 = NULL;
struct Node_Two* node = NULL;
String* ipStr = Dict_getString(args, String_new("parent", alloc));
int64_t* linkNum = Dict_getInt(args, String_new("linkNum", alloc));
if (ipStr && ipStr->len) {
uint8_t ip[16];
if (AddrTools_parseIp(ip, ipStr->bytes)) {
Dict_remove(ret, String_CONST("result"));
Dict_putString(ret,
String_new("error", alloc),
String_new("parse_parent", alloc),
alloc);
Admin_sendMessage(ret, txid, ctx->admin);
return;
} else if (!(node = NodeStore_nodeForAddr(ctx->store, ip))) {
Dict_putString(ret,
String_new("error", alloc),
String_new("not_found", alloc),
alloc);
Admin_sendMessage(ret, txid, ctx->admin);
return;
} else if (!(link = getLinkByNum(node, *linkNum))) {
Dict_putString(ret,
String_new("error", alloc),
String_new("unknown", alloc),
alloc);
Admin_sendMessage(ret, txid, ctx->admin);
return;
}
} else {
for (int i = 0; i <= *linkNum; i++) {
link = NodeStore_getNextLink(ctx->store, link);
if (!link) { break; }
}
if (!link) {
Dict_putString(ret,
String_new("error", alloc),
String_new("not_found", alloc),
alloc);
Admin_sendMessage(ret, txid, ctx->admin);
return;
}
}
Dict_putInt(result,
String_new("inverseLinkEncodingFormNumber", alloc),
link->inverseLinkEncodingFormNumber,
alloc);
Dict_putInt(result, String_new("linkCost", alloc), link->linkCost, alloc);
Dict_putInt(result, String_new("isOneHop", alloc), Node_isOneHopLink(link), alloc);
int bestParent = (Node_getBestParent(link->child) == link);
Dict_putInt(result, String_new("bestParent", alloc), bestParent, 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 = Address_toString(&link->parent->address, alloc);
Dict_putString(result, String_new("parent", alloc), parent, alloc);
String* child = Address_toString(&link->child->address, alloc);
Dict_putString(result, String_new("child", alloc), child, alloc);
Admin_sendMessage(ret, txid, ctx->admin);
}
