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