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);
}
void Core_initTunnel(String* desiredDeviceName,
struct Sockaddr* addr,
uint8_t addressPrefix,
struct Ducttape* dt,
struct Log* logger,
struct IpTunnel* ipTunnel,
struct EventBase* eventBase,
struct Allocator* alloc,
struct Except* eh)
{
Log_debug(logger, "Initializing TUN device [%s]",
(desiredDeviceName) ? desiredDeviceName->bytes : "<auto>");
char assignedTunName[TUNInterface_IFNAMSIZ];
char* desiredName = (desiredDeviceName) ? desiredDeviceName->bytes : NULL;
struct Interface* tun =
TUNInterface_new(desiredName, assignedTunName, eventBase, logger, eh, alloc);
IpTunnel_setTunName(assignedTunName, ipTunnel);
Ducttape_setUserInterface(dt, tun);
NetDev_addAddress(assignedTunName, addr, addressPrefix, logger, eh);
NetDev_setMTU(assignedTunName, DEFAULT_MTU, logger, eh);
}
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;
}
void Core_initTunnel(String* desiredDeviceName,
uint8_t ipAddr[16],
uint8_t addressPrefix,
struct Ducttape* dt,
struct Log* logger,
struct IpTunnel* ipTunnel,
struct EventBase* eventBase,
struct Allocator* alloc,
struct Except* eh)
{
Log_debug(logger, "Initializing TUN device [%s]",
(desiredDeviceName) ? desiredDeviceName->bytes : "<auto>");
char assignedTunName[TUNConfigurator_IFNAMSIZ];
void* tunPtr = TUNConfigurator_initTun(((desiredDeviceName) ? desiredDeviceName->bytes : NULL),
assignedTunName,
logger,
eh);
struct TUNInterface* tun = TUNInterface_new(tunPtr, eventBase, alloc, logger);
// broken
//struct ICMP6Generator* icmp = ICMP6Generator_new(alloc);
//InterfaceConnector_connect(&icmp->external, &tun->iface);
//Ducttape_setUserInterface(dt, &icmp->internal);
Ducttape_setUserInterface(dt, &tun->iface);
TUNConfigurator_addIp6Address(assignedTunName, ipAddr, addressPrefix, logger, eh);
TUNConfigurator_setMTU(assignedTunName, DEFAULT_MTU, logger, eh);
IpTunnel_setTunName(assignedTunName, ipTunnel);
}
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;
}
static void registerRouter(Dict* config, uint8_t myPubKey[32], struct Context* context)
{
Dict* iface = Dict_getDict(config, BSTR("interface"));
if (String_equals(Dict_getString(iface, BSTR("type")), BSTR("TUNInterface"))) {
String* tunPath = Dict_getString(iface, BSTR("tunDevice"));
context->routerIf = TUNInterface_new(tunPath, context->base, context->allocator);
}
context->routerModule = RouterModule_register(context->registry,
context->allocator,
myPubKey,
context->base,
context->logger,
context->admin);
}
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* 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);
}
void Core_initTunnel(String* desiredDeviceName,
uint8_t ipAddr[16],
uint8_t addressPrefix,
struct Ducttape* dt,
struct Log* logger,
struct event_base* eventBase,
struct Allocator* alloc,
struct Except* eh)
{
Log_debug(logger, "Initializing TUN device [%s]",
(desiredDeviceName) ? desiredDeviceName->bytes : "<auto>");
char assignedTunName[TUNConfigurator_IFNAMSIZ];
void* tunPtr = TUNConfigurator_initTun(((desiredDeviceName) ? desiredDeviceName->bytes : NULL),
assignedTunName,
logger,
eh);
struct TUNInterface* tun = TUNInterface_new(tunPtr, eventBase, alloc);
Ducttape_setUserInterface(dt, &tun->iface);
TUNConfigurator_setIpAddress(assignedTunName, ipAddr, addressPrefix, logger, eh);
TUNConfigurator_setMTU(assignedTunName, DEFAULT_MTU, logger, eh);
}
int main(int argc, char** argv)
{
#ifdef Log_KEYS
fprintf(stderr, "Log_LEVEL = KEYS, EXPECT TO SEE PRIVATE KEYS IN YOUR LOGS!\n");
#endif
Crypto_init();
Assert_true(argc > 0);
if (argc == 2) {
// one argument
if (strcmp(argv[1], "--help") == 0) {
return usage(argv[0]);
} else if (strcmp(argv[1], "--genconf") == 0) {
return genconf();
} else if (strcmp(argv[1], "--pidfile") == 0) {
// Performed after reading the configuration
} else if (strcmp(argv[1], "--reconf") == 0) {
// Performed after reading the configuration
} else if (strcmp(argv[1], "--bench") == 0) {
return benchmark();
} else if (strcmp(argv[1], "--version") == 0) {
printf("Version ID: %s\n", RouterModule_gitVersion());
return 0;
} else {
fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], argv[1]);
fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]);
return -1;
}
} else if (argc > 2) {
// more than one argument?
fprintf(stderr, "%s: too many arguments\n", argv[0]);
fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]);
return -1;
}
if (isatty(STDIN_FILENO)) {
// We were started from a terminal
// The chances an user wants to type in a configuration
// bij hand are pretty slim so we show him the usage
return usage(argv[0]);
} else {
// We assume stdin is a configuration file and that we should
// start routing
}
struct event_base* eventBase = event_base_new();
// Allow it to allocate 4MB
struct Allocator* allocator = MallocAllocator_new(1<<22);
struct Reader* reader = FileReader_new(stdin, allocator);
Dict config;
if (JsonBencSerializer_get()->parseDictionary(reader, allocator, &config)) {
fprintf(stderr, "Failed to parse configuration.\n");
return -1;
}
// Logging.
struct Writer* logwriter = FileWriter_new(stdout, allocator);
struct Log* logger = &(struct Log) { .writer = logwriter };
// pid file
String* pidFile = Dict_getString(&config, String_CONST("pidFile"));
if (pidFile) {
if (argc == 2 && strcmp(argv[1], "--pidfile") == 0) {
printf("%s", pidFile->bytes);
return 0;
}
Log_info(logger, "Writing pid of process to [%s].\n", pidFile->bytes);
FILE* pf = fopen(pidFile->bytes, "w");
if (!pf) {
Log_critical(logger,
"Failed to open pid file [%s] for writing, errno=%d\n",
pidFile->bytes,
errno);
return -1;
}
fprintf(pf, "%d", (int) getpid());
fclose(pf);
}
// re-configure
if (argc == 2 && strcmp(argv[1], "--reconf") == 0) {
reconf(eventBase, &config, logger, allocator);
return 0;
}
// ca, needed for admin.
struct Address myAddr;
uint8_t privateKey[32];
parsePrivateKey(&config, &myAddr, privateKey);
struct CryptoAuth* cryptoAuth =
CryptoAuth_new(&config, allocator, privateKey, eventBase, logger);
// Admin
char* user = setUser(Dict_getList(&config, String_CONST("security")));
struct Admin* admin = newAdmin(&config, user, logger, eventBase, allocator);
struct SwitchCore* switchCore = SwitchCore_new(logger, allocator);
struct DHTModuleRegistry* registry = DHTModuleRegistry_new(allocator);
ReplyModule_register(registry, allocator);
// Router
struct Interface* routerIf = NULL;
Dict* routerConf = Dict_getDict(&config, String_CONST("router"));
Dict* iface = Dict_getDict(routerConf, String_CONST("interface"));
if (String_equals(Dict_getString(iface, String_CONST("type")), String_CONST("TUNInterface"))) {
String* ifName = Dict_getString(iface, String_CONST("tunDevice"));
char assignedTunName[TUNConfigurator_IFNAMSIZ];
void* tunPtr = TUNConfigurator_initTun(((ifName) ? ifName->bytes : NULL),
assignedTunName,
logger,
AbortHandler_INSTANCE);
struct Jmp jmp;
Jmp_try(jmp) {
TUNConfigurator_setIpAddress(
assignedTunName, myAddr.ip6.bytes, 8, logger, &jmp.handler);
} Jmp_catch {
Log_warn(logger, "Unable to configure ip address [%s]", jmp.message);
}
struct TUNInterface* tun = TUNInterface_new(tunPtr, eventBase, allocator);
routerIf = &tun->iface;
}
