int main(int argc, char** argv)
{
struct Allocator* alloc = MallocAllocator_new(1<<20);
struct EventBase* base = EventBase_new(alloc);
struct Log* log = FileWriterLog_new(stdout, alloc);
struct Sockaddr* addrA = Sockaddr_fromBytes(TUNTools_testIP6AddrA, Sockaddr_AF_INET6, alloc);
struct Sockaddr* addrB = Sockaddr_fromBytes(TUNTools_testIP6AddrB, Sockaddr_AF_INET6, alloc);
char assignedIfName[TUNInterface_IFNAMSIZ];
struct Iface* tap = TUNInterface_new(NULL, assignedIfName, 1, base, log, NULL, alloc);
struct TAPWrapper* tapWrapper = TAPWrapper_new(tap, log, alloc);
// Now setup the NDP server so the tun will work correctly.
struct NDPServer* ndp = NDPServer_new(&tapWrapper->internal, log, TAPWrapper_LOCAL_MAC, alloc);
struct ARPServer* arp = ARPServer_new(&ndp->internal, log, TAPWrapper_LOCAL_MAC, alloc);
addrA->flags |= Sockaddr_flags_PREFIX;
addrA->prefix = 126;
NetDev_addAddress(assignedIfName, addrA, log, NULL);
TUNTools_echoTest(addrA, addrB, TUNTools_genericIP6Echo, &arp->internal, base, log, alloc);
Allocator_free(alloc);
return 0;
}
static void initTunnel2(String* desiredDeviceName,
struct Context* ctx,
uint8_t addressPrefix,
struct Except* eh)
{
Log_debug(ctx->logger, "Initializing TUN device [%s]",
(desiredDeviceName) ? desiredDeviceName->bytes : "<auto>");
char assignedTunName[TUNInterface_IFNAMSIZ];
char* desiredName = (desiredDeviceName) ? desiredDeviceName->bytes : NULL;
struct Iface* tun = TUNInterface_new(
desiredName, assignedTunName, 0, ctx->base, ctx->logger, eh, ctx->alloc);
Iface_plumb(tun, &ctx->nc->tunAdapt->tunIf);
IpTunnel_setTunName(assignedTunName, ctx->ipTunnel);
struct Sockaddr* myAddr =
Sockaddr_fromBytes(ctx->nc->myAddress->ip6.bytes, Sockaddr_AF_INET6, ctx->alloc);
myAddr->prefix = addressPrefix;
myAddr->flags |= Sockaddr_flags_PREFIX;
NetDev_addAddress(assignedTunName, myAddr, ctx->logger, eh);
NetDev_setMTU(assignedTunName, DEFAULT_MTU, ctx->logger, eh);
}
int main(int argc, char** argv)
{
struct Allocator* alloc = MallocAllocator_new(1<<20);
struct EventBase* base = EventBase_new(alloc);
struct Log* logger = FileWriterLog_new(stdout, alloc);
struct Sockaddr* addrA = Sockaddr_fromBytes(TUNTools_testIP6AddrA, Sockaddr_AF_INET6, alloc);
struct Sockaddr* addrB = Sockaddr_fromBytes(TUNTools_testIP6AddrB, Sockaddr_AF_INET6, alloc);
char assignedIfName[TUNInterface_IFNAMSIZ];
struct Iface* tun = TUNInterface_new(NULL, assignedIfName, 0, base, logger, NULL, alloc);
addrA->flags |= Sockaddr_flags_PREFIX;
addrA->prefix = 126;
NetDev_addAddress(assignedIfName, addrA, logger, NULL);
TUNTools_echoTest(addrA, addrB, TUNTools_genericIP6Echo, tun, base, logger, alloc);
Allocator_free(alloc);
return 0;
}
int main(int argc, char** argv)
{
struct Allocator* alloc = MallocAllocator_new(1<<20);
struct EventBase* base = EventBase_new(alloc);
struct Writer* logWriter = FileWriter_new(stdout, alloc);
struct Log* logger = WriterLog_new(logWriter, alloc);
struct Sockaddr* addrA = Sockaddr_fromBytes(testAddrA, Sockaddr_AF_INET6, alloc);
char assignedIfName[TUNInterface_IFNAMSIZ];
struct Interface* tun = TUNInterface_new(NULL, assignedIfName, base, logger, NULL, alloc);
NetDev_addAddress(assignedIfName, addrA, 126, logger, NULL);
struct Sockaddr_storage addr;
Assert_always(!Sockaddr_parse("[fd00::1]", &addr));
#ifdef freebsd
// tun is not setup synchronously in bsd but it lets you bind to the tun's
// address anyway.
sleep(1);
#endif
// Mac OSX and BSD do not set up their TUN devices synchronously.
// We'll just keep on trying until this works.
struct AddrInterface* udp = NULL;
for (int i = 0; i < 20; i++) {
if ((udp = setupUDP(base, &addr.addr, alloc, logger))) {
break;
}
}
Assert_always(udp);
struct Sockaddr* dest = Sockaddr_clone(udp->addr, alloc);
uint8_t* addrBytes;
Assert_always(16 == Sockaddr_getAddress(dest, &addrBytes));
Bits_memcpy(addrBytes, testAddrB, 16);
struct Message* msg;
Message_STACK(msg, 0, 64);
Message_push(msg, "Hello World", 12, NULL);
Message_push(msg, dest, dest->addrLen, NULL);
udp->generic.receiveMessage = receiveMessageUDP;
udp->generic.receiverContext = alloc;
tun->receiveMessage = receiveMessageTUN;
udp->generic.sendMessage(msg, &udp->generic);
Timeout_setTimeout(fail, NULL, 10000, base, alloc);
EventBase_beginLoop(base);
return 0;
}
int main(int argc, char** argv)
{
struct Allocator* alloc = MallocAllocator_new(1<<20);
struct EventBase* base = EventBase_new(alloc);
struct Writer* logWriter = FileWriter_new(stdout, alloc);
struct Log* log = WriterLog_new(logWriter, alloc);
struct Sockaddr* addrA = Sockaddr_fromBytes(testAddrA, Sockaddr_AF_INET6, alloc);
char assignedIfName[TUNInterface_IFNAMSIZ];
struct Interface* tap = TUNInterface_new(NULL, assignedIfName, 1, base, log, NULL, alloc);
struct TAPWrapper* tapWrapper = TAPWrapper_new(tap, log, alloc);
// Now setup the NDP server so the tun will work correctly.
struct NDPServer* ndp = NDPServer_new(&tapWrapper->generic, log, TAPWrapper_LOCAL_MAC, alloc);
ndp->advertisePrefix[0] = 0xfd;
ndp->prefixLen = 8;
struct Interface* tun = &ndp->generic;
NetDev_addAddress(assignedIfName, addrA, 126, log, NULL);
struct Sockaddr_storage addr;
Assert_true(!Sockaddr_parse("[::]", &addr));
struct AddrInterface* udp = TUNTools_setupUDP(base, &addr.addr, alloc, log);
struct Sockaddr* dest = Sockaddr_clone(udp->addr, alloc);
uint8_t* addrBytes;
Assert_true(16 == Sockaddr_getAddress(dest, &addrBytes));
Bits_memcpy(addrBytes, testAddrB, 16);
udp->generic.receiveMessage = receiveMessageUDP;
udp->generic.receiverContext = alloc;
tun->receiveMessage = receiveMessageTUN;
TUNTools_sendHelloWorld(udp, dest, base, alloc);
Timeout_setTimeout(fail, NULL, 10000000, base, alloc);
EventBase_beginLoop(base);
return 0;
}
int main(int argc, char** argv)
{
// TODO: fix TUNConfigurator_addIp4Address() for Illumos, Darwin, BSD.
#if defined(Illumos) || defined(Darwin) || defined(FreeBSD) || defined(OpenBSD)
return 0;
#endif
struct Allocator* alloc = MallocAllocator_new(1<<20);
struct EventBase* base = EventBase_new(alloc);
struct Writer* logWriter = FileWriter_new(stdout, alloc);
struct Log* logger = WriterLog_new(logWriter, alloc);
struct Sockaddr* addrA = Sockaddr_fromBytes(testAddrA, Sockaddr_AF_INET, alloc);
char assignedIfName[TUNInterface_IFNAMSIZ];
struct Interface* tun = TUNInterface_new(NULL, assignedIfName, base, logger, NULL, alloc);
NetDev_addAddress(assignedIfName, addrA, 30, logger, NULL);
struct Sockaddr_storage ss;
Assert_true(!Sockaddr_parse("0.0.0.0", &ss));
struct AddrInterface* udp = UDPAddrInterface_new(base, &ss.addr, alloc, NULL, logger);
struct Sockaddr* dest = Sockaddr_clone(udp->addr, alloc);
uint8_t* addr;
Assert_true(4 == Sockaddr_getAddress(dest, &addr));
Bits_memcpy(addr, testAddrB, 4);
struct Message* msg;
Message_STACK(msg, 0, 64);
Message_push(msg, "Hello World", 12);
Message_push(msg, dest, dest->addrLen);
udp->generic.receiveMessage = receiveMessageUDP;
udp->generic.receiverContext = alloc;
tun->receiveMessage = receiveMessageTUN;
udp->generic.sendMessage(msg, &udp->generic);
Timeout_setTimeout(fail, NULL, 1000, base, alloc);
EventBase_beginLoop(base);
}
/*
* 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
}));
