struct EncodingScheme* EncodingScheme_fromList(List* scheme, struct Allocator* alloc)
{
struct EncodingScheme* list = Allocator_malloc(alloc, sizeof(struct EncodingScheme));
list->count = List_size(scheme);
list->forms = Allocator_malloc(alloc, sizeof(struct EncodingScheme_Form) * list->count);
for (int i = 0; i < (int)list->count; i++) {
Dict* form = List_getDict(scheme, i);
uint64_t* prefixLen = Dict_getInt(form, String_CONST("prefixLen"));
uint64_t* bitCount = Dict_getInt(form, String_CONST("bitCount"));
String* prefixStr = Dict_getString(form, String_CONST("prefix"));
if (!prefixLen || !bitCount || !prefixStr || prefixStr->len != 8) {
return NULL;
}
uint32_t prefix_be;
if (Hex_decode((uint8_t*)&prefix_be, 4, prefixStr->bytes, 8) != 4) {
return NULL;
}
list->forms[i].prefixLen = *prefixLen;
list->forms[i].bitCount = *bitCount;
list->forms[i].prefix = Endian_bigEndianToHost32(prefix_be);
}
if (!EncodingScheme_isSane(list)) {
return NULL;
}
return list;
}
static int getUUID(uint64_t output[2])
{
uint8_t buffer[40] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
{
int fd = -1;
int tries = 0;
while ((fd = open("/proc/sys/kernel/random/uuid", O_RDONLY, 0)) < 0) {
if (++tries > MAX_TRIES || errno == ENOENT) {
return -1;
}
sleep(1);
}
tries = 0;
uint8_t* buff = (uint8_t*) buffer;
int count = 37;
while (count > 0) {
int r = read(fd, buff, count);
if (r < 1) {
if (++tries > MAX_TRIES) {
break;
}
sleep(1);
continue;
}
buff += r;
count -= r;
}
close(fd);
if (count != 0) {
return -1;
}
}
// If it isn't in perfect form, fail.
if (!(buffer[8] == '-'
&& buffer[13] == '-'
&& buffer[18] == '-'
&& buffer[23] == '-'
&& buffer[36] == '\n'))
{
return -1;
}
// fold back the last 4 characters into the locations of the dashes.
buffer[8] = buffer[35];
buffer[13] = buffer[34];
buffer[18] = buffer[33];
buffer[23] = buffer[32];
buffer[32] = '\0';
if (Hex_decode((uint8_t*)output, 16, buffer, 32) != 16) {
return -1;
}
return 0;
}
static uint8_t receiveMessage(struct Message* msg, struct Interface* iface)
{
struct Context* ctx = Identity_cast((struct Context*) iface->receiverContext);
struct Sockaddr_storage source;
Message_pop(msg, &source, ctx->targetAddr->addrLen, NULL);
if (Bits_memcmp(&source, ctx->targetAddr, ctx->targetAddr->addrLen)) {
Log_info(ctx->logger, "Got spurious message from [%s], expecting messages from [%s]",
Sockaddr_print(&source.addr, msg->alloc),
Sockaddr_print(ctx->targetAddr, msg->alloc));
return 0;
}
// we don't yet know with which message this data belongs,
// the message alloc lives the length of the message reception.
struct Allocator* alloc = Allocator_child(msg->alloc);
struct Reader* reader = ArrayReader_new(msg->bytes, msg->length, alloc);
Dict* d = Dict_new(alloc);
if (StandardBencSerializer_get()->parseDictionary(reader, alloc, d)) {
return 0;
}
String* txid = Dict_getString(d, String_CONST("txid"));
if (!txid || txid->len != 8) {
return 0;
}
// look up the result
uint32_t handle = ~0u;
Hex_decode((uint8_t*)&handle, 4, txid->bytes, 8);
int idx = Map_OfRequestByHandle_indexForHandle(handle, &ctx->outstandingRequests);
if (idx < 0) {
return 0;
}
struct Request* req = ctx->outstandingRequests.values[idx];
// now this data will outlive the life of the message.
Allocator_adopt(req->promise->alloc, alloc);
req->res.responseDict = d;
int len =
(msg->length > AdminClient_MAX_MESSAGE_SIZE) ? AdminClient_MAX_MESSAGE_SIZE : msg->length;
Bits_memset(req->res.messageBytes, 0, AdminClient_MAX_MESSAGE_SIZE);
Bits_memcpy(req->res.messageBytes, msg->bytes, len);
done(req, AdminClient_Error_NONE);
return 0;
}
static Iface_DEFUN receiveMessage(struct Message* msg, struct Iface* addrIface)
{
struct Context* ctx = Identity_containerOf(addrIface, struct Context, addrIface);
struct Sockaddr_storage source;
Message_pop(msg, &source, ctx->targetAddr->addrLen, NULL);
if (Bits_memcmp(&source, ctx->targetAddr, ctx->targetAddr->addrLen)) {
Log_info(ctx->logger, "Got spurious message from [%s], expecting messages from [%s]",
Sockaddr_print(&source.addr, msg->alloc),
Sockaddr_print(ctx->targetAddr, msg->alloc));
return NULL;
}
// we don't yet know with which message this data belongs,
// the message alloc lives the length of the message reception.
struct Allocator* alloc = Allocator_child(msg->alloc);
int origLen = msg->length;
Dict* d = NULL;
char* err = BencMessageReader_readNoExcept(msg, alloc, &d);
if (err) { return NULL; }
Message_shift(msg, origLen, NULL);
String* txid = Dict_getString(d, String_CONST("txid"));
if (!txid || txid->len != 8) { return NULL; }
// look up the result
uint32_t handle = ~0u;
Hex_decode((uint8_t*)&handle, 4, txid->bytes, 8);
int idx = Map_OfRequestByHandle_indexForHandle(handle, &ctx->outstandingRequests);
if (idx < 0) { return NULL; }
struct Request* req = ctx->outstandingRequests.values[idx];
// now this data will outlive the life of the message.
Allocator_adopt(req->promise->alloc, alloc);
req->res.responseDict = d;
int len =
(msg->length > AdminClient_MAX_MESSAGE_SIZE) ? AdminClient_MAX_MESSAGE_SIZE : msg->length;
Bits_memset(req->res.messageBytes, 0, AdminClient_MAX_MESSAGE_SIZE);
Bits_memcpy(req->res.messageBytes, msg->bytes, len);
done(req, AdminClient_Error_NONE);
return NULL;
}
static void receiveHelloWithNoAuth()
{
struct Allocator* alloc = MallocAllocator_new(1<<20);
struct Context* ctx = setUp(PRIVATEKEY, NULL, NULL, alloc);
struct Message* msg = Message_new(132, 0, alloc);
Assert_true(Hex_decode(msg->bytes, msg->length,
"0000000000ffffffffffffff7fffffffffffffffffffffffffffffffffffffff"
"ffffffffffffffff847c0d2c375234f365e660955187a3735a0f7613d1609d3a"
"6a4d8c53aeaa5a22ea9cf275eee0185edf7f211192f12e8e642a325ed76925fe"
"3c76d313b767a10aca584ca0b979dee990a737da7d68366fa3846d43d541de91"
"29ea3e12", 132*2) > 0);
Assert_true(!CryptoAuth_decrypt(ctx->sess, msg));
Assert_true(msg->length == HELLOWORLDLEN);
Assert_true(Bits_memcmp(HELLOWORLD, msg->bytes, HELLOWORLDLEN) == 0);
Allocator_free(alloc);
//printf("bytes=%s length=%u\n", finalOut->bytes, finalOut->length);
}
static void parsePrivateKey(Dict* config, struct Address* addr, uint8_t privateKey[32])
{
String* privateKeyStr = Dict_getString(config, BSTR("privateKey"));
if (privateKeyStr == NULL) {
fprintf(stderr, "Could not extract private key from configuration.\n");
} else if (privateKeyStr->len != 64) {
fprintf(stderr, "Private key is not 32 bytes long.\n");
} else if (Hex_decode(privateKey, 32, (uint8_t*)privateKeyStr->bytes, 64) != 32) {
fprintf(stderr, "Failed to parse private key.\n");
} else {
crypto_scalarmult_curve25519_base(addr->key, privateKey);
AddressCalc_addressForPublicKey(addr->ip6.bytes, addr->key);
if (addr->ip6.bytes[0] != 0xFC) {
fprintf(stderr, "Ip address is outside of the FC00/8 range, "
"invalid private key.\n");
} else {
return;
}
}
exit(-1);
}
/**
* Parse out an ethernet MAC address.
*
* @param out a pointer to a byte array which will be set to the bytes of the MAC address.
* @param hexAddr a string representation of an ethernet MAC address such as:
* "00:11:22:33:44:55"
* @return 0 if successful, -1 if the hexAddr is malformed.
*/
int AddrTools_parseMac(uint8_t out[6], const uint8_t hexAddr[17])
{
for (int i = 2; i < 15; i += 3) {
if (hexAddr[i] != ':') {
return -1;
}
}
uint8_t hex[12];
int j = 0;
for (int i = 0; i < 18; i++) {
hex[j++] = hexAddr[i++];
hex[j++] = hexAddr[i++];
}
if (Hex_decode(out, 6, hex, 12) != 6) {
return -1;
}
return 0;
}
int main()
{
struct Allocator* alloc = MallocAllocator_new(20000);
struct Random* rand = Random_new(alloc, NULL, NULL);
uint8_t bytes[32];
Random_bytes(rand, bytes, 32);
uint8_t hex[65] = {0};
Assert_true(Hex_encode(hex, 65, bytes, 32) == 64);
//printf("hex encoded: %s\n", hex);
uint8_t bytes2[32];
Assert_true(Hex_decode(bytes2, 32, hex, 64) == 32);
Assert_true(Bits_memcmp(bytes, bytes2, 32) == 0);
Allocator_free(alloc);
return 0;
}
/**
* Parse out a path.
*
* @param out a pointer to a number which will be set to the path in HOST BYTE ORDER.
* @param netAddr a string representation of the path such as "0000.1111.2222.3333" in Big Endian.
* @return 0 if successful, -1 if the netAddr is malformed.
*/
int AddrTools_parsePath(uint64_t* out, const uint8_t netAddr[20])
{
if (netAddr[4] != '.' || netAddr[9] != '.' || netAddr[14] != '.' || netAddr[19] != '\0') {
return -1;
}
uint8_t hex[16] = {
netAddr[ 0],
netAddr[ 1],
netAddr[ 2],
netAddr[ 3],
netAddr[ 5],
netAddr[ 6],
netAddr[ 7],
netAddr[ 8],
netAddr[10],
netAddr[11],
netAddr[12],
netAddr[13],
netAddr[15],
netAddr[16],
netAddr[17],
netAddr[18]
};
uint8_t numberBytes[8];
if (Hex_decode(numberBytes, 8, hex, 16) != 8) {
return -1;
}
uint64_t out_be;
Bits_memcpy(&out_be, numberBytes, 8);
*out = Endian_bigEndianToHost64(out_be);
return 0;
}
static void unsubscribe(Dict* args, void* vcontext, String* txid)
{
struct AdminLog* log = (struct AdminLog*) vcontext;
String* streamIdHex = Dict_getString(args, String_CONST("streamId"));
uint8_t streamId[8];
char* error = NULL;
if (streamIdHex->len != 16 || Hex_decode(streamId, 8, (uint8_t*)streamIdHex->bytes, 16) != 8) {
error = "Invalid streamId.";
} else {
error = "No such subscription.";
for (int i = 0; i < (int)log->subscriptionCount; i++) {
if (!Bits_memcmp(streamId, log->subscriptions[i].streamId, 8)) {
removeSubscription(log, &log->subscriptions[i]);
error = "none";
break;
}
}
}
Dict response = Dict_CONST(
String_CONST("error"), String_OBJ(String_CONST(error)), NULL
);
Admin_sendMessage(&response, txid, log->admin);
}
static void receiveMessage2(struct Message* msg, struct Hermes* hermes, struct Allocator* tempAlloc)
{
#ifdef Log_KEYS
char lastChr = msg->bytes[msg->length - 1];
msg->bytes[msg->length - 1] = '\0';
Log_keys(hermes->logger, "Got message from angel [%s%c]", msg->bytes, lastChr);
msg->bytes[msg->length - 1] = lastChr;
#else
Log_debug(hermes->logger, "Got message from angel");
#endif
Dict* d = NULL;
char* err = BencMessageReader_readNoExcept(msg, tempAlloc, &d);
if (err) {
Log_warn(hermes->logger, "Failed to parse message from angel [%s]", err);
return;
}
String* txid = Dict_getString(d, String_CONST("txid"));
uint32_t handle;
if (!txid || txid->len != 8 || 4 != Hex_decode((uint8_t*)&handle, 4, (uint8_t*)txid->bytes, 8))
{
Log_warn(hermes->logger, "Message from angel; txid missing or unrecognized");
return;
}
int index = Map_RequestSet_indexForHandle(handle, &hermes->requestSet);
if (index < 0) {
Log_warn(hermes->logger, "Message from angel references nonexistant request");
return;
}
struct Request* req = Identity_check((struct Request*) hermes->requestSet.values[index]);
req->onResponse(d, req->onResponseContext);
Allocator_free(req->alloc);
}
/*
* This process is started with 2 parameters, they must all be numeric in base 10.
* toAngel the pipe which is used to send data back to the angel process.
* fromAngel the pipe which is used to read incoming data from the angel.
*
* Upon initialization, this process will wait for an initial configuration to be sent to
* it and then it will send an initial response.
*/
int Core_main(int argc, char** argv)
{
struct Except* eh = NULL;
int toAngel;
int fromAngel;
if (argc != 4
|| !(toAngel = atoi(argv[2]))
|| !(fromAngel = atoi(argv[3])))
{
Except_raise(eh, -1, "This is internal to cjdns and shouldn't started manually.");
}
struct Allocator* alloc = MallocAllocator_new(ALLOCATOR_FAILSAFE);
struct EventBase* eventBase = EventBase_new(alloc);
struct Random* rand = Random_new(alloc, eh);
// -------------------- Setup the Pre-Logger ---------------------- //
struct Writer* logWriter = FileWriter_new(stdout, alloc);
struct Log* preLogger = WriterLog_new(logWriter, alloc);
struct IndirectLog* indirectLogger = IndirectLog_new(alloc);
indirectLogger->wrappedLog = preLogger;
struct Log* logger = &indirectLogger->pub;
// The first read inside of getInitialConfig() will begin it waiting.
struct PipeInterface* pi =
PipeInterface_new(fromAngel, toAngel, eventBase, logger, alloc, rand);
Dict* config = getInitialConfig(&pi->generic, eventBase, alloc, eh);
String* privateKeyHex = Dict_getString(config, String_CONST("privateKey"));
Dict* adminConf = Dict_getDict(config, String_CONST("admin"));
String* pass = Dict_getString(adminConf, String_CONST("pass"));
if (!pass || !privateKeyHex) {
Except_raise(eh, -1, "Expected 'pass' and 'privateKey' in configuration.");
}
Log_keys(logger, "Starting core with admin password [%s]", pass->bytes);
uint8_t privateKey[32];
if (privateKeyHex->len != 64
|| Hex_decode(privateKey, 32, (uint8_t*) privateKeyHex->bytes, 64) != 32)
{
Except_raise(eh, -1, "privateKey must be 64 bytes of hex.");
}
struct Admin* admin = Admin_new(&pi->generic, alloc, logger, eventBase, pass);
Dict adminResponse = Dict_CONST(String_CONST("error"), String_OBJ(String_CONST("none")), NULL);
Admin_sendMessageToAngel(&adminResponse, admin);
// --------------------- Setup the Logger --------------------- //
// the prelogger will nolonger be used.
struct Log* adminLogger = AdminLog_registerNew(admin, alloc, rand);
indirectLogger->wrappedLog = adminLogger;
logger = adminLogger;
// CryptoAuth
struct Address addr;
parsePrivateKey(privateKey, &addr, eh);
struct CryptoAuth* cryptoAuth = CryptoAuth_new(alloc, privateKey, eventBase, logger, rand);
struct SwitchCore* switchCore = SwitchCore_new(logger, alloc);
struct DHTModuleRegistry* registry = DHTModuleRegistry_new(alloc);
ReplyModule_register(registry, alloc);
// Router
struct RouterModule* router = RouterModule_register(registry,
alloc,
addr.key,
eventBase,
logger,
admin,
rand);
SerializationModule_register(registry, logger, alloc);
struct IpTunnel* ipTun = IpTunnel_new(logger, eventBase, alloc, rand);
struct Ducttape* dt = Ducttape_register(privateKey,
registry,
router,
switchCore,
eventBase,
alloc,
logger,
admin,
ipTun,
rand);
struct SwitchPinger* sp =
SwitchPinger_new(&dt->switchPingerIf, eventBase, logger, alloc);
// Interfaces.
struct InterfaceController* ifController =
DefaultInterfaceController_new(cryptoAuth,
switchCore,
router,
logger,
eventBase,
sp,
alloc);
// ------------------- Register RPC functions ----------------------- //
SwitchPinger_admin_register(sp, admin, alloc);
UDPInterface_admin_register(eventBase, alloc, logger, admin, ifController);
#ifdef HAS_ETH_INTERFACE
ETHInterface_admin_register(eventBase, alloc, logger, admin, ifController);
#endif
RouterModule_admin_register(router, admin, alloc);
AuthorizedPasswords_init(admin, cryptoAuth, alloc);
Admin_registerFunction("ping", adminPing, admin, false, NULL, admin);
Admin_registerFunction("Core_exit", adminExit, logger, true, NULL, admin);
Core_admin_register(addr.ip6.bytes, dt, logger, alloc, admin, eventBase);
Security_admin_register(alloc, logger, admin);
IpTunnel_admin_register(ipTun, admin, alloc);
struct MemoryContext* mc =
alloc->clone(sizeof(struct MemoryContext), alloc,
&(struct MemoryContext) {
.allocator = alloc,
.admin = admin
});
static int reconnectionNewEndpointTest(struct InterfaceController* ifController,
uint8_t* pk,
struct Message** fromSwitchPtr,
struct Allocator* alloc,
struct EventBase* eventBase,
struct Log* logger,
struct Interface* routerIf,
struct Random* rand)
{
struct Message* message;
struct Interface iface = {
.sendMessage = messageFromInterface,
.senderContext = &message,
.allocator = alloc
};
uint8_t* buffer = Allocator_malloc(alloc, 512);
struct Message* outgoing =
&(struct Message) { .length = 0, .padding = 512, .bytes = buffer + 512 };
struct CryptoAuth* externalCa = CryptoAuth_new(alloc, NULL, eventBase, logger, rand);
struct Interface* wrapped = CryptoAuth_wrapInterface(&iface, pk, NULL, false, "", externalCa);
CryptoAuth_setAuth(String_CONST("passwd"), 1, wrapped);
struct Interface icIface = {
.allocator = alloc,
.sendMessage = messageFromInterface,
.senderContext = &message
};
InterfaceController_registerPeer(ifController, NULL, NULL, true, false, &icIface);
uint8_t hexBuffer[1025];
for (int i = 0; i < 4; i++) {
outgoing->length = 0;
outgoing->padding = 512;
outgoing->bytes = buffer + 512;
Message_shift(outgoing, 12, NULL);
Bits_memcpyConst(outgoing->bytes, "hello world", 12);
Message_shift(outgoing, SwitchHeader_SIZE, NULL);
Bits_memcpyConst(outgoing->bytes, (&(struct SwitchHeader) {
.label_be = Endian_hostToBigEndian64(1),
.lowBits_be = 0
}), SwitchHeader_SIZE);
wrapped->sendMessage(outgoing, wrapped);
*fromSwitchPtr = NULL;
icIface.receiveMessage(outgoing, &icIface);
message = *fromSwitchPtr;
Assert_true(message);
Assert_true(message->length == 24);
Hex_encode(hexBuffer, 1025, message->bytes, message->length);
printf("%s\n", hexBuffer);
// Need to bounce the packets back when connecting after the first try.
// This is needed to establish the CryptoAuth session and make the InterfaceController
// merge the endpoints.
if (i > 0) {
// Reverse the bits to reverse the path:
uint64_t path;
Bits_memcpyConst(&path, message->bytes, 8);
path = Bits_bitReverse64(path);
Bits_memcpyConst(message->bytes, &path, 8);
printf("sending back response.\n");
routerIf->receiveMessage(message, routerIf);
printf("forwarding response to external cryptoAuth.\n");
iface.receiveMessage(message, &iface);
printf("forwarded.\n");
} else {
printf("not responding because we don't want to establish a connection yet.\n");
}
}
// check everything except the label
Assert_true(!CString_strcmp((char*)hexBuffer+16, "0000000068656c6c6f20776f726c6400"));
// check label: make sure the interface has been switched back into position 0.
uint64_t label_be;
Hex_decode((uint8_t*) &label_be, 8, hexBuffer, 16);
uint64_t rev_label = Bits_bitReverse64(Endian_bigEndianToHost64(label_be));
// check label is decoded to 0
Assert_true(0 == NumberCompress_getDecompressed(rev_label,
NumberCompress_bitsUsedForLabel(rev_label)));
// check no other bits are set
uint64_t out = NumberCompress_getCompressed(0, NumberCompress_bitsUsedForLabel(rev_label));
Assert_true(rev_label == out);
return 0;
}
/*
* This process is started with 2 parameters, they must all be numeric in base 10.
* toAngel the pipe which is used to send data back to the angel process.
* fromAngel the pipe which is used to read incoming data from the angel.
*
* Upon initialization, this process will wait for an initial configuration to be sent to
* it and then it will send an initial response.
*/
int Core_main(int argc, char** argv)
{
struct Except* eh = NULL;
if (argc != 3) {
Except_raise(eh, -1, "This is internal to cjdns and shouldn't started manually.");
}
struct Allocator* alloc = MallocAllocator_new(ALLOCATOR_FAILSAFE);
struct Log* preLogger = FileWriterLog_new(stderr, alloc);
struct EventBase* eventBase = EventBase_new(alloc);
// -------------------- Setup the Pre-Logger ---------------------- //
struct Log* logger = IndirectLog_new(alloc);
IndirectLog_set(logger, preLogger);
// -------------------- Setup the PRNG ---------------------- //
struct Random* rand = LibuvEntropyProvider_newDefaultRandom(eventBase, logger, eh, alloc);
// -------------------- Change Canary Value ---------------------- //
MallocAllocator_setCanary(alloc, (long)Random_int64(rand));
struct Allocator* tempAlloc = Allocator_child(alloc);
// The first read inside of getInitialConfig() will begin it waiting.
struct Pipe* angelPipe = Pipe_named(argv[2], eventBase, eh, alloc);
angelPipe->logger = logger;
angelPipe->onClose = angelDied;
struct Interface* angelIface = FramingInterface_new(65535, &angelPipe->iface, alloc);
Dict* config = getInitialConfig(angelIface, eventBase, tempAlloc, eh);
struct Hermes* hermes = Hermes_new(angelIface, eventBase, logger, alloc);
String* privateKeyHex = Dict_getString(config, String_CONST("privateKey"));
Dict* adminConf = Dict_getDict(config, String_CONST("admin"));
String* pass = Dict_getString(adminConf, String_CONST("pass"));
String* bind = Dict_getString(adminConf, String_CONST("bind"));
if (!(pass && privateKeyHex && bind)) {
if (!pass) {
Except_raise(eh, -1, "Expected 'pass'");
}
if (!bind) {
Except_raise(eh, -1, "Expected 'bind'");
}
if (!privateKeyHex) {
Except_raise(eh, -1, "Expected 'privateKey'");
}
Except_raise(eh, -1, "Expected 'pass', 'privateKey' and 'bind' in configuration.");
}
Log_keys(logger, "Starting core with admin password [%s]", pass->bytes);
uint8_t privateKey[32];
if (privateKeyHex->len != 64
|| Hex_decode(privateKey, 32, (uint8_t*) privateKeyHex->bytes, 64) != 32)
{
Except_raise(eh, -1, "privateKey must be 64 bytes of hex.");
}
struct Sockaddr_storage bindAddr;
if (Sockaddr_parse(bind->bytes, &bindAddr)) {
Except_raise(eh, -1, "bind address [%s] unparsable", bind->bytes);
}
struct AddrInterface* udpAdmin =
UDPAddrInterface_new(eventBase, &bindAddr.addr, alloc, eh, logger);
struct Admin* admin = Admin_new(udpAdmin, alloc, logger, eventBase, pass);
char* boundAddr = Sockaddr_print(udpAdmin->addr, tempAlloc);
Dict adminResponse = Dict_CONST(
String_CONST("bind"), String_OBJ(String_CONST(boundAddr)), NULL
);
Dict response = Dict_CONST(
String_CONST("error"), String_OBJ(String_CONST("none")), Dict_CONST(
String_CONST("admin"), Dict_OBJ(&adminResponse), NULL
));
// This always times out because the angel doesn't respond.
Hermes_callAngel(&response, angelResponse, NULL, alloc, eh, hermes);
// --------------------- Setup the Logger --------------------- //
Dict* logging = Dict_getDict(config, String_CONST("logging"));
String* logTo = Dict_getString(logging, String_CONST("logTo"));
if (logTo && String_equals(logTo, String_CONST("stdout"))) {
// do nothing, continue logging to stdout.
} else {
struct Log* adminLogger = AdminLog_registerNew(admin, alloc, rand);
IndirectLog_set(logger, adminLogger);
logger = adminLogger;
}
// CryptoAuth
struct Address addr;
parsePrivateKey(privateKey, &addr, eh);
struct CryptoAuth* cryptoAuth = CryptoAuth_new(alloc, privateKey, eventBase, logger, rand);
struct Sockaddr* myAddr = Sockaddr_fromBytes(addr.ip6.bytes, Sockaddr_AF_INET6, alloc);
struct SwitchCore* switchCore = SwitchCore_new(logger, alloc);
struct DHTModuleRegistry* registry = DHTModuleRegistry_new(alloc);
ReplyModule_register(registry, alloc);
// Router
struct RouterModule* router = RouterModule_register(registry,
alloc,
addr.key,
eventBase,
logger,
admin,
rand);
SerializationModule_register(registry, logger, alloc);
struct IpTunnel* ipTun = IpTunnel_new(logger, eventBase, alloc, rand, hermes);
struct Ducttape* dt = Ducttape_register(privateKey,
registry,
router,
switchCore,
eventBase,
alloc,
logger,
admin,
ipTun,
rand);
struct SwitchPinger* sp =
SwitchPinger_new(&dt->switchPingerIf, eventBase, logger, alloc);
// Interfaces.
struct InterfaceController* ifController =
DefaultInterfaceController_new(cryptoAuth,
switchCore,
router,
logger,
eventBase,
sp,
rand,
alloc);
// ------------------- Register RPC functions ----------------------- //
SwitchPinger_admin_register(sp, admin, alloc);
UDPInterface_admin_register(eventBase, alloc, logger, admin, ifController);
#ifdef HAS_ETH_INTERFACE
ETHInterface_admin_register(eventBase, alloc, logger, admin, ifController);
#endif
RouterModule_admin_register(router, admin, alloc);
AuthorizedPasswords_init(admin, cryptoAuth, alloc);
Admin_registerFunction("ping", adminPing, admin, false, NULL, admin);
Core_admin_register(myAddr, dt, logger, ipTun, alloc, admin, eventBase);
Security_admin_register(alloc, logger, admin);
IpTunnel_admin_register(ipTun, admin, alloc);
struct Context* ctx = Allocator_clone(alloc, (&(struct Context) {
.allocator = alloc,
.admin = admin,
.logger = logger,
.hermes = hermes
}));
