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_info1(ctx->logger, "Checking authorized password %d.", i);
if (!d) {
Log_critical1(ctx->logger, "Not a dictionary type.", i);
exit(-1);
}
String* passwd = Dict_getString(d, String_CONST("password"));
if (!passwd) {
Log_critical1(ctx->logger, "Must specify a password.", 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_info1(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 udpInterface(Dict* config, struct Context* ctx)
{
Dict* udp = Dict_getDict(config, String_CONST("UDPInterface"));
Dict* connectTo = Dict_getDict(udp, String_CONST("connectTo"));
if (connectTo) {
struct Dict_Entry* entry = *connectTo;
while (entry != NULL) {
String* key = (String*) entry->key;
if (entry->val->type != Object_DICT) {
Log_critical1(ctx->logger, "interfaces.UDPInterface.connectTo: entry [%s] "
"is not a dictionary type.", key->bytes);
exit(-1);
}
Dict* value = entry->val->as.dictionary;
Log_keys1(ctx->logger, "Attempting to connect to node [%s].", key->bytes);
struct Allocator* perCallAlloc = ctx->alloc->child(ctx->alloc);
Dict_putString(value, String_CONST("address"), key, perCallAlloc);
rpcCall(String_CONST("UDPInterface_beginConnection"), value, ctx, perCallAlloc);
perCallAlloc->free(perCallAlloc);
entry = entry->next;
}
}
}
void NodeStore_addNode(struct NodeStore* store,
struct Address* addr,
const int64_t reachDifference)
{
Address_getPrefix(addr);
if (memcmp(addr->ip6.bytes, store->thisNodeAddress, 16) == 0) {
printf("got introduced to ourselves\n");
return;
}
if (addr->ip6.bytes[0] != 0xfc) {
uint8_t address[60];
Address_print(address, addr);
Log_critical1(store->logger,
"tried to insert address %s which does not begin with 0xFC.\n",
address);
assert(false);
}
// TODO: maintain a sorted list.
uint32_t pfx = Address_getPrefix(addr);
if (store->size < store->capacity) {
for (uint32_t i = 0; i < store->size; i++) {
if (store->headers[i].addressPrefix == pfx
&& Address_isSameIp(&store->nodes[i].address, addr))
{
int red = Address_checkRedundantRoute(&store->nodes[i].address, addr);
if (red == 1) {
#ifdef Log_DEBUG
uint8_t nodeAddr[60];
Address_print(nodeAddr, &store->nodes[i].address);
uint8_t newAddr[20];
Address_printNetworkAddress(newAddr, addr);
Log_debug2(store->logger,
"Found a better route to %s via %s\n",
nodeAddr,
newAddr);
struct Node* n =
NodeStore_getNodeByNetworkAddr(addr->networkAddress_be, store);
if (n) {
Log_warn(store->logger, "This route is probably invalid, giving up.\n");
continue;
}
#endif
store->nodes[i].address.networkAddress_be = addr->networkAddress_be;
} else if (red == 0
&& store->nodes[i].address.networkAddress_be != addr->networkAddress_be)
{
// Completely different routes, store seperately.
continue;
}
/*#ifdef Log_DEBUG
uint32_t oldReach = store->headers[i].reach;
#endif*/
adjustReach(&store->headers[i], reachDifference);
/*#ifdef Log_DEBUG
if (oldReach != store->headers[i].reach) {
uint8_t nodeAddr[60];
Address_print(nodeAddr, addr);
Log_debug3(store->logger,
"Altering reach for node %s, old reach %u, new reach %u.\n",
nodeAddr,
oldReach,
store->headers[i].reach);
if (oldReach > store->headers[i].reach) {
Log_debug(store->logger, "Reach was decreased!\n");
}
}
#endif*/
return;
}
#ifdef Log_DEBUG
else if (store->headers[i].addressPrefix == pfx) {
uint8_t realAddr[16];
AddressCalc_addressForPublicKey(realAddr, addr->key);
assert(!memcmp(realAddr, addr->ip6.bytes, 16));
}
#endif
}
#ifdef Log_DEBUG
uint8_t nodeAddr[60];
Address_print(nodeAddr, addr);
Log_debug2(store->logger,
"Discovered node: %s reach %u\n",
nodeAddr,
reachDifference);
#endif
// Free space, regular insert.
replaceNode(&store->nodes[store->size], &store->headers[store->size], addr);
adjustReach(&store->headers[store->size], reachDifference);
store->size++;
return;
}
// The node whose reach OR distance is the least.
// This means nodes who are close and have short reach will be removed
uint32_t indexOfNodeToReplace = 0;
uint32_t leastReachOrDistance = UINT32_MAX;
for (uint32_t i = 0; i < store->size; i++) {
uint32_t distance = store->headers[i].addressPrefix ^ pfx;
if (distance == 0 && Address_isSame(&store->nodes[i].address, addr)) {
// Node already exists
adjustReach(&store->headers[store->size], reachDifference);
return;
}
uint32_t reachOrDistance = store->headers[i].reach | distance;
if (reachOrDistance < leastReachOrDistance) {
leastReachOrDistance = reachOrDistance;
indexOfNodeToReplace = i;
}
}
replaceNode(&store->nodes[indexOfNodeToReplace],
&store->headers[indexOfNodeToReplace],
addr);
adjustReach(&store->headers[indexOfNodeToReplace], reachDifference);
}
