static void showConn(struct IpTunnel_Connection* conn,
String* txid,
struct Admin* admin,
struct Allocator* alloc)
{
Dict* d = Dict_new(alloc);
if (!Bits_isZero(conn->connectionIp6, 16)) {
struct Sockaddr* addr = Sockaddr_clone(Sockaddr_LOOPBACK6, alloc);
uint8_t* address;
Assert_true(16 == Sockaddr_getAddress(addr, &address));
Bits_memcpy(address, conn->connectionIp6, 16);
char* printedAddr = Sockaddr_print(addr, alloc);
Dict_putString(d, String_CONST("ip6Address"), String_CONST(printedAddr), alloc);
Dict_putInt(d, String_CONST("ip6Prefix"), conn->connectionIp6Prefix, alloc);
}
if (!Bits_isZero(conn->connectionIp4, 4)) {
struct Sockaddr* addr = Sockaddr_clone(Sockaddr_LOOPBACK, alloc);
uint8_t* address;
Assert_true(4 == Sockaddr_getAddress(addr, &address));
Bits_memcpy(address, conn->connectionIp4, 4);
char* printedAddr = Sockaddr_print(addr, alloc);
Dict_putString(d, String_CONST("ip4Address"), String_CONST(printedAddr), alloc);
Dict_putInt(d, String_CONST("ip4Prefix"), conn->connectionIp4Prefix, alloc);
}
Dict_putString(d, String_CONST("key"),
Key_stringify(conn->routeHeader.publicKey, alloc), alloc);
Dict_putInt(d, String_CONST("outgoing"), (conn->isOutgoing) ? 1 : 0, alloc);
Dict_putString(d, String_CONST("error"), String_CONST("none"), alloc);
Admin_sendMessage(d, txid, admin);
}
static String* getExpectedResponse(struct Sockaddr* sa4, int prefix4, int alloc4,
struct Sockaddr* sa6, int prefix6, int alloc6,
struct Allocator* allocator)
{
Assert_true(alloc6 >= prefix6);
Assert_true(alloc4 >= prefix4);
struct Allocator* alloc = Allocator_child(allocator);
Dict* addresses = Dict_new(alloc);
if (sa4) {
uint8_t* addr = NULL;
Assert_true(Sockaddr_getAddress(sa4, &addr) == 4);
String* addrStr = String_newBinary(addr, 4, alloc);
Dict_putString(addresses, String_new("ip4", alloc), addrStr, alloc);
Dict_putInt(addresses, String_new("ip4Prefix", alloc), prefix4, alloc);
Dict_putInt(addresses, String_new("ip4Alloc", alloc), alloc4, alloc);
}
if (sa6) {
uint8_t* addr = NULL;
Assert_true(Sockaddr_getAddress(sa6, &addr) == 16);
String* addrStr = String_newBinary(addr, 16, alloc);
Dict_putString(addresses, String_new("ip6", alloc), addrStr, alloc);
Dict_putInt(addresses, String_new("ip6Prefix", alloc), prefix6, alloc);
Dict_putInt(addresses, String_new("ip6Alloc", alloc), alloc6, alloc);
}
Dict* output = Dict_new(alloc);
Dict_putDict(output, String_new("addresses", alloc), addresses, alloc);
Dict_putString(output, String_new("txid", alloc), String_new("abcd", alloc), alloc);
struct Message* msg = Message_new(0, 512, alloc);
BencMessageWriter_write(output, msg, NULL);
String* outStr = String_newBinary(msg->bytes, msg->length, allocator);
Allocator_free(alloc);
return outStr;
}
Iface_DEFUN TUNTools_genericIP6Echo(struct Message* msg, struct TUNTools* tt)
{
uint16_t ethertype = TUNMessageType_pop(msg, NULL);
if (ethertype != Ethernet_TYPE_IP6) {
Log_debug(tt->log, "Spurious packet with ethertype [%04x]\n",
Endian_bigEndianToHost16(ethertype));
return 0;
}
struct Headers_IP6Header* header = (struct Headers_IP6Header*) msg->bytes;
if (msg->length != Headers_IP6Header_SIZE + Headers_UDPHeader_SIZE + 12) {
int type = (msg->length >= Headers_IP6Header_SIZE) ? header->nextHeader : -1;
Log_debug(tt->log, "Message of unexpected length [%u] ip6->nextHeader: [%d]\n",
msg->length, type);
return 0;
}
uint8_t* address;
Sockaddr_getAddress(tt->tunDestAddr, &address);
Assert_true(!Bits_memcmp(header->destinationAddr, address, 16));
Sockaddr_getAddress(tt->udpBindTo, &address);
Assert_true(!Bits_memcmp(header->sourceAddr, address, 16));
Sockaddr_getAddress(tt->udpBindTo, &address);
Bits_memcpy(header->destinationAddr, address, 16);
Sockaddr_getAddress(tt->tunDestAddr, &address);
Bits_memcpy(header->sourceAddr, address, 16);
TUNMessageType_push(msg, ethertype, NULL);
return Iface_next(&tt->tunIface, msg);
}
static void checkAddressAndPrefix(struct Sockaddr* sa,
int* addrFam,
char** printedAddr,
void** addr,
struct Allocator* alloc,
struct Except* eh)
{
*printedAddr = Sockaddr_print(sa, alloc);
*addrFam = Sockaddr_getFamily(sa);
if (*addrFam != Sockaddr_AF_INET && *addrFam != Sockaddr_AF_INET6) {
Except_throw(eh, "Unknown address type for address [%s]", *printedAddr);
}
int prefixMax = (*addrFam == Sockaddr_AF_INET6) ? 128 : 32;
if (!(sa->flags & Sockaddr_flags_PREFIX)) {
sa->prefix = prefixMax;
}
if (sa->prefix > prefixMax) {
Except_throw(eh, "prefix [%u] must be less than %d", sa->prefix, prefixMax);
}
int len = Sockaddr_getAddress(sa, addr);
if (len < 0 || len != prefixMax / 8) {
Except_throw(eh, "Invalid sockaddr [%s]", *printedAddr);
}
}
void NetDev_addAddress(const char* ifName,
struct Sockaddr* sa,
int prefixLen,
struct Log* logger,
struct Except* eh)
{
int addrFam = Sockaddr_getFamily(sa);
struct Allocator* alloc;
BufferAllocator_STACK(alloc, 4096);
char* printedAddr = Sockaddr_print(sa, alloc);
if (addrFam != Sockaddr_AF_INET && addrFam != Sockaddr_AF_INET6) {
Except_throw(eh, "Unknown address type for address [%s]", printedAddr);
}
int prefixMax = (addrFam == Sockaddr_AF_INET6) ? 128 : 32;
if (prefixLen < 0 || prefixLen > prefixMax) {
Except_throw(eh, "prefixLen [%d] must be greater than 0 and less than %d",
prefixLen, prefixMax);
}
void* addr;
int len = Sockaddr_getAddress(sa, &addr);
if (len < 0 || len != prefixMax / 8) {
Except_throw(eh, "Invalid sockaddr [%s]", printedAddr);
}
Log_info(logger, "Setting IP address [%s/%d] on interface [%s]",
printedAddr, prefixLen, ifName);
NetPlatform_addAddress(ifName, addr, prefixLen, addrFam, logger, eh);
}
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;
}
/**
* Parse out an address.
*
* @param out a pointer to a byte array which will be set to the bytes of the ipv6 address.
* @param hexAddr a string representation of the ipv6 address such as:
* "fc4f:630d:e499:8f5b:c49f:6e6b:01ae:3120".
* @return 0 if successful, -1 if the hexAddr is malformed.
*/
int AddrTools_parseIp(uint8_t out[16], const uint8_t hexAddr[40])
{
struct Sockaddr_storage ss;
if (Sockaddr_parse((const char*) hexAddr, &ss)
|| Sockaddr_getFamily(&ss.addr) != Sockaddr_AF_INET6)
{
return -1;
}
uint8_t* addr = NULL;
Sockaddr_getAddress(&ss.addr, &addr);
Bits_memcpy(out, addr, 16);
return 0;
}
void TUNTools_echoTest(struct Sockaddr* udpBindTo,
struct Sockaddr* tunDestAddr,
TUNTools_Callback tunMessageHandler,
struct Iface* tun,
struct EventBase* base,
struct Log* logger,
struct Allocator* allocator)
{
struct Allocator* alloc = Allocator_child(allocator);
struct AddrIface* udp = setupUDP(base, udpBindTo, alloc, logger);
struct Sockaddr* dest = Sockaddr_clone(udp->addr, alloc);
uint8_t* tunDestAddrBytes = NULL;
uint8_t* udpDestPointer = NULL;
int len = Sockaddr_getAddress(dest, &udpDestPointer);
Assert_true(len && len == Sockaddr_getAddress(tunDestAddr, &tunDestAddrBytes));
Bits_memcpy(udpDestPointer, tunDestAddrBytes, len);
struct TUNTools_pvt* ctx = Allocator_calloc(alloc, sizeof(struct TUNTools_pvt), 1);
Identity_set(ctx);
ctx->pub.udpIface.send = receiveMessageUDP;
ctx->pub.tunIface.send = receiveMessageTUN;
Iface_plumb(&ctx->pub.udpIface, &udp->iface);
Iface_plumb(&ctx->pub.tunIface, tun);
ctx->pub.cb = tunMessageHandler;
ctx->pub.tunDestAddr = Sockaddr_clone(dest, alloc);
ctx->pub.udpBindTo = Sockaddr_clone(udpBindTo, alloc);
ctx->pub.alloc = alloc;
ctx->pub.log = logger;
ctx->pub.base = base;
Timeout_setInterval(sendHello, ctx, 1000, base, alloc);
Timeout_setTimeout(fail, NULL, 10000, base, alloc);
EventBase_beginLoop(base);
}
struct FakeNetwork_UDPIface* FakeNetwork_iface(struct FakeNetwork* net,
struct Sockaddr* bindAddress,
struct Allocator* allocator)
{
struct FakeNetwork_pvt* fnp = Identity_check((struct FakeNetwork_pvt*) net);
struct Allocator* alloc = Allocator_child(allocator);
struct Sockaddr* addr = Sockaddr_clone(bindAddress, alloc);
uint8_t* addrBytes;
int addrLen = Sockaddr_getAddress(addr, &addrBytes);
if (Sockaddr_getPort(addr) == 0) {
Sockaddr_setPort(addr, ++fnp->lastPort);
// Check for wrapping.
Assert_true(fnp->lastPort != 0);
Assert_true(addrLen == 4);
Bits_memcpy(addrBytes, ((uint8_t[]){127, 0, 0, 1}), 4);
} else if (addrLen == 4 && !Bits_memcmp(addrBytes, "\0\0\0\0", 4)) {
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);
}
static void testAddr(struct Context* ctx,
char* addr4, int prefix4, int alloc4,
char* addr6, int prefix6, int alloc6)
{
struct Allocator* alloc = Allocator_child(ctx->alloc);
struct IpTunnel* ipTun = IpTunnel_new(ctx->log, ctx->base, alloc, ctx->rand, NULL);
struct Sockaddr* sa4 = NULL;
struct Sockaddr_storage ip6ToGive;
struct Sockaddr_storage ip4ToGive;
if (addr4) {
Assert_true(!Sockaddr_parse(addr4, &ip4ToGive));
sa4 = &ip4ToGive.addr;
Assert_true(Sockaddr_getFamily(sa4) == Sockaddr_AF_INET);
}
struct Sockaddr* sa6 = NULL;
if (addr6) {
Assert_true(!Sockaddr_parse(addr6, &ip6ToGive));
sa6 = &ip6ToGive.addr;
Assert_true(Sockaddr_getFamily(sa6) == Sockaddr_AF_INET6);
}
IpTunnel_allowConnection(ctx->pubKey,
sa6, prefix6, alloc6,
sa4, prefix4, alloc4,
ipTun);
struct Message* msg = Message_new(64, 512, alloc);
const char* requestForAddresses =
"d"
"1:q" "21:IpTunnel_getAddresses"
"4:txid" "4:abcd"
"e";
CString_strcpy(msg->bytes, requestForAddresses);
msg->length = CString_strlen(requestForAddresses);
Message_push(msg, NULL, Headers_UDPHeader_SIZE, NULL);
struct Headers_UDPHeader* uh = (struct Headers_UDPHeader*) msg->bytes;
uh->length_be = Endian_hostToBigEndian16(msg->length - Headers_UDPHeader_SIZE);
uint16_t* checksum = &((struct Headers_UDPHeader*) msg->bytes)->checksum_be;
*checksum = 0;
uint32_t length = msg->length;
// Because of old reasons, we need to have at least an empty IPv6 header
Message_push(msg, NULL, Headers_IP6Header_SIZE, NULL);
struct Headers_IP6Header* ip = (struct Headers_IP6Header*) msg->bytes;
Headers_setIpVersion(ip);
ip->payloadLength_be = Endian_hostToBigEndian16(msg->length - Headers_IP6Header_SIZE);
ip->nextHeader = 17;
*checksum = Checksum_udpIp6(ip->sourceAddr, (uint8_t*) uh, length);
pushRouteDataHeaders(ctx, msg);
struct IfaceContext* nodeIf = Allocator_calloc(alloc, sizeof(struct IfaceContext), 1);
nodeIf->ctx = ctx;
nodeIf->iface.send = responseWithIpCallback;
struct IfaceContext* tunIf = Allocator_calloc(alloc, sizeof(struct IfaceContext), 1);
tunIf->ctx = ctx;
tunIf->iface.send = messageToTun;
Iface_plumb(&nodeIf->iface, &ipTun->nodeInterface);
Iface_plumb(&tunIf->iface, &ipTun->tunInterface);
ctx->expectedResponse =
getExpectedResponse(sa4, prefix4, alloc4, sa6, prefix6, alloc6, alloc);
Iface_send(&nodeIf->iface, msg);
Assert_true(ctx->called == 2);
ctx->called = 0;
if (sa4) {
uint8_t* addrBytes = NULL;
Assert_true(Sockaddr_getAddress(sa4, &addrBytes) == 4);
uint32_t addr;
Bits_memcpy(&addr, addrBytes, 4);
addr = Endian_bigEndianToHost32(addr);
// Send from the address specified
Assert_true(trySend4(alloc, addr, &nodeIf->iface, ctx));
if (alloc4 < 32) {
// Send from another (random) address in the prefix
uint32_t flip = Random_uint32(ctx->rand) >> alloc4;
if (prefix4 != 32) {
Assert_true(trySend4(alloc, addr ^ flip, &nodeIf->iface, ctx));
} else {
// If netSize is not specified, we do not allow multi-address
Assert_true(!trySend4(alloc, addr ^ flip, &nodeIf->iface, ctx));
}
} else {
static uint8_t sendMessage(struct Message* message, struct Interface* iface)
{
struct PacketHeaderToUDPAddrInterface_pvt* context =
Identity_check((struct PacketHeaderToUDPAddrInterface_pvt*) iface);
struct Sockaddr_storage ss;
Message_pop(message, &ss, context->pub.addr->addrLen, NULL);
struct Sockaddr* addr = &ss.addr;
struct Headers_UDPHeader udp;
udp.srcPort_be = Endian_hostToBigEndian16(Sockaddr_getPort(context->pub.addr));
udp.destPort_be = Endian_hostToBigEndian16(Sockaddr_getPort(addr));
udp.length_be = Endian_hostToBigEndian16(message->length + Headers_UDPHeader_SIZE);
udp.checksum_be = 0;
Message_push(message, &udp, sizeof(struct Headers_UDPHeader), NULL);
struct Headers_IP6Header ip = {
.nextHeader = 17,
.hopLimit = 255,
};
ip.payloadLength_be = Endian_hostToBigEndian16(message->length);
Headers_setIpVersion(&ip);
uint8_t* addrPtr = NULL;
Assert_true(Sockaddr_getAddress(addr, &addrPtr) == 16);
Bits_memcpyConst(ip.destinationAddr, addrPtr, 16);
Assert_true(Sockaddr_getAddress(context->pub.addr, &addrPtr) == 16);
Bits_memcpyConst(ip.sourceAddr, addrPtr, 16);
uint16_t checksum = Checksum_udpIp6(ip.sourceAddr, message->bytes, message->length);
((struct Headers_UDPHeader*)message->bytes)->checksum_be = checksum;
Message_push(message, &ip, sizeof(struct Headers_IP6Header), NULL);
return Interface_sendMessage(context->wrapped, message);
}
static uint8_t receiveMessage(struct Message* message, struct Interface* iface)
{
struct PacketHeaderToUDPAddrInterface_pvt* context =
Identity_check((struct PacketHeaderToUDPAddrInterface_pvt*) iface->receiverContext);
if (message->length < Headers_IP6Header_SIZE + Headers_UDPHeader_SIZE) {
// runt
return Error_NONE;
}
struct Headers_IP6Header* ip = (struct Headers_IP6Header*) message->bytes;
// udp
if (ip->nextHeader != 17) {
return Error_NONE;
}
struct Allocator* alloc = Allocator_child(message->alloc);
struct Sockaddr* addr = Sockaddr_clone(context->pub.addr, alloc);
uint8_t* addrPtr = NULL;
Assert_true(Sockaddr_getAddress(addr, &addrPtr) == 16);
Bits_memcpyConst(addrPtr, ip->sourceAddr, 16);
struct Headers_UDPHeader* udp = (struct Headers_UDPHeader*) (&ip[1]);
Sockaddr_setPort(addr, Endian_bigEndianToHost16(udp->srcPort_be));
if (Sockaddr_getPort(context->pub.addr) != Endian_bigEndianToHost16(udp->destPort_be)) {
// not the right port
return Error_NONE;
}
Message_shift(message, -(Headers_IP6Header_SIZE + Headers_UDPHeader_SIZE), NULL);
Message_push(message, addr, addr->addrLen, NULL);
return Interface_receiveMessage(&context->pub.generic, message);
}
struct AddrInterface* PacketHeaderToUDPAddrInterface_new(struct Interface* toWrap,
struct Allocator* alloc,
struct Sockaddr* addr)
{
struct PacketHeaderToUDPAddrInterface_pvt* context =
Allocator_malloc(alloc, sizeof(struct PacketHeaderToUDPAddrInterface_pvt));
Bits_memcpyConst(context, (&(struct PacketHeaderToUDPAddrInterface_pvt) {
.pub = {
.generic = {
.sendMessage = sendMessage,
.senderContext = context,
.allocator = alloc
}
},
.wrapped = toWrap
}), sizeof(struct PacketHeaderToUDPAddrInterface_pvt));
static void beginConnection(Dict* args,
void* vcontext,
String* txid,
struct Allocator* requestAlloc)
{
struct Context* ctx = vcontext;
String* password = Dict_getString(args, String_CONST("password"));
String* publicKey = Dict_getString(args, String_CONST("publicKey"));
String* address = Dict_getString(args, String_CONST("address"));
int64_t* interfaceNumber = Dict_getInt(args, String_CONST("interfaceNumber"));
uint32_t ifNum = (interfaceNumber) ? ((uint32_t) *interfaceNumber) : 0;
String* peerName = Dict_getString(args, String_CONST("peerName"));
String* error = NULL;
Log_debug(ctx->logger, "Peering with [%s]", publicKey->bytes);
struct Sockaddr_storage ss;
uint8_t pkBytes[32];
int ret;
if (interfaceNumber && *interfaceNumber < 0) {
error = String_CONST("negative interfaceNumber");
} else if ((ret = Key_parse(publicKey, pkBytes, NULL))) {
error = String_CONST(Key_parse_strerror(ret));
} else if (Sockaddr_parse(address->bytes, &ss)) {
error = String_CONST("unable to parse ip address and port.");
} else if (Sockaddr_getFamily(&ss.addr) != Sockaddr_getFamily(ctx->udpIf->addr)) {
error = String_CONST("different address type than this socket is bound to.");
} else {
struct Sockaddr* addr = &ss.addr;
char* addrPtr = NULL;
int addrLen = Sockaddr_getAddress(&ss.addr, &addrPtr);
Assert_true(addrLen > 0);
struct Allocator* tempAlloc = Allocator_child(ctx->alloc);
if (Bits_isZero(addrPtr, addrLen)) {
// unspec'd address, convert to loopback
if (Sockaddr_getFamily(addr) == Sockaddr_AF_INET) {
addr = Sockaddr_clone(Sockaddr_LOOPBACK, tempAlloc);
} else if (Sockaddr_getFamily(addr) == Sockaddr_AF_INET6) {
addr = Sockaddr_clone(Sockaddr_LOOPBACK6, tempAlloc);
} else {
Assert_failure("Sockaddr which is not AF_INET nor AF_INET6");
}
Sockaddr_setPort(addr, Sockaddr_getPort(&ss.addr));
}
int ret = InterfaceController_bootstrapPeer(
ctx->ic, ifNum, pkBytes, addr, password, peerName, ctx->alloc);
Allocator_free(tempAlloc);
if (ret) {
switch(ret) {
case InterfaceController_bootstrapPeer_BAD_IFNUM:
error = String_CONST("no such interface for interfaceNumber");
break;
case InterfaceController_bootstrapPeer_BAD_KEY:
error = String_CONST("invalid cjdns public key.");
break;
case InterfaceController_bootstrapPeer_OUT_OF_SPACE:
error = String_CONST("no more space to register with the switch.");
break;
default:
error = String_CONST("unknown error");
break;
}
} else {
error = String_CONST("none");
}
}
Dict out = Dict_CONST(String_CONST("error"), String_OBJ(error), NULL);
Admin_sendMessage(&out, txid, ctx->admin);
}