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);
struct TestFramework* TestFramework_setUp(char* privateKey,
struct Allocator* allocator,
struct EventBase* base,
struct Random* rand,
struct Log* logger)
{
if (!logger) {
struct Writer* logwriter = FileWriter_new(stdout, allocator);
logger = WriterLog_new(logwriter, allocator);
}
if (!rand) {
rand = Random_new(allocator, logger, NULL);
}
if (!base) {
base = EventBase_new(allocator);
}
uint64_t pks[4];
if (!privateKey) {
Random_longs(rand, pks, 4);
privateKey = (char*)pks;
}
struct NetCore* nc = NetCore_new(privateKey, allocator, base, rand, logger);
struct Pathfinder* pf = Pathfinder_register(allocator, logger, base, rand, NULL);
struct ASynchronizer* pfAsync = ASynchronizer_new(allocator, base, logger);
Iface_plumb(&pfAsync->ifA, &pf->eventIf);
EventEmitter_regPathfinderIface(nc->ee, &pfAsync->ifB);
struct TestFramework* tf = Allocator_calloc(allocator, sizeof(struct TestFramework), 1);
Identity_set(tf);
tf->alloc = allocator;
tf->rand = rand;
tf->eventBase = base;
tf->logger = logger;
tf->nc = nc;
tf->tunIf = &nc->tunAdapt->tunIf;
tf->publicKey = nc->myAddress->key;
tf->ip = nc->myAddress->ip6.bytes;
tf->pathfinder = pf;
return tf;
}
static void switching(struct Context* ctx)
{
Log_info(ctx->log, "Setting up salsa20/poly1305 benchmark (encryption and decryption only)");
struct Allocator* alloc = Allocator_child(ctx->alloc);;
struct SwitchingContext* sc = Allocator_calloc(alloc, sizeof(struct SwitchingContext), 1);
Identity_set(sc);
sc->benchmarkCtx = ctx;
sc->aliceIf.send = aliceToBob;
sc->bobIf.send = bobToAlice;
sc->aliceCtrlIf.send = aliceCtrlRecv;
struct NetCore* alice = NetCore_new(SECRETA, alloc, ctx->base, ctx->rand, ctx->log);
struct InterfaceController_Iface* aliceIci =
InterfaceController_newIface(alice->ifController, String_CONST("alice"), alloc);
Iface_plumb(&sc->aliceIf, &aliceIci->addrIf);
struct NetCore* bob = NetCore_new(SECRETB, alloc, ctx->base, ctx->rand, ctx->log);
struct InterfaceController_Iface* bobIci =
InterfaceController_newIface(bob->ifController, String_CONST("bob"), alloc);
Iface_plumb(&sc->bobIf, &bobIci->addrIf);
CryptoAuth_addUser(String_CONST("abcdefg123"), 1, String_CONST("TEST"), bob->ca);
// Client has pubKey and passwd for the server.
int ret = InterfaceController_bootstrapPeer(alice->ifController,
aliceIci->ifNum,
bob->ca->publicKey,
Sockaddr_LOOPBACK,
String_CONST("abcdefg123"),
alloc);
Assert_true(!ret);
Iface_unplumb(alice->switchAdapter->controlIf.connectedIf, &alice->switchAdapter->controlIf);
Iface_plumb(&alice->switchAdapter->controlIf, &sc->aliceCtrlIf);
struct Message* msg = Message_new(Control_Ping_MIN_SIZE + Control_Header_SIZE, 256, alloc);
struct Control_Header* ch = (struct Control_Header*) msg->bytes;
struct Control_Ping* ping = (struct Control_Ping*) &ch[1];
ping->version_be = Endian_hostToBigEndian32(Version_CURRENT_PROTOCOL);
Message_push32(msg, 0xffffffff, NULL);
uint32_t* handle_be = (uint32_t*)msg->bytes;
Message_push(msg, NULL, SwitchHeader_SIZE, NULL);
struct SwitchHeader* sh = (struct SwitchHeader*) msg->bytes;
// TODO(cjd): this will fail with a different encoding scheme
sh->label_be = Endian_hostToBigEndian64(0x13);
for (int i = 1; i < 6; i++) {
ping->magic = Control_Ping_MAGIC;
ch->type_be = Control_PING_be;
ch->checksum_be = 0;
ch->checksum_be = Checksum_engine((void*)ch, Control_Ping_MIN_SIZE + Control_Header_SIZE);
Iface_send(&sc->aliceCtrlIf, msg);
Assert_true(sc->msgCount == i);
Assert_true(msg->bytes == (void*)sh);
Assert_true(ping->magic == Control_Pong_MAGIC);
Assert_true(ch->type_be = Control_PONG_be);
Assert_true(!Checksum_engine((void*)ch, Control_Ping_MIN_SIZE + Control_Header_SIZE));
}
*handle_be = 0xfffffff0;
int count = 1000000;
begin(ctx, "Switching", count, "packets");
for (int i = 0; i < count; i++) {
sh->versionAndLabelShift = SwitchHeader_CURRENT_VERSION << 6;
Iface_send(&sc->aliceCtrlIf, msg);
Assert_true(msg->bytes == (void*)sh);
}
done(ctx);
Log_info(ctx->log, "DONE");
Allocator_free(alloc);
}