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)) {
static void udpInterface(Dict* config, struct Context* ctx)
{
List* ifaces = Dict_getList(config, String_CONST("UDPInterface"));
if (!ifaces) {
ifaces = List_new(ctx->alloc);
List_addDict(ifaces, Dict_getDict(config, String_CONST("UDPInterface")), ctx->alloc);
}
uint32_t count = List_size(ifaces);
for (uint32_t i = 0; i < count; i++) {
Dict *udp = List_getDict(ifaces, i);
if (!udp) {
continue;
}
// Setup the interface.
String* bindStr = Dict_getString(udp, String_CONST("bind"));
Dict* d = Dict_new(ctx->alloc);
if (bindStr) {
Dict_putString(d, String_CONST("bindAddress"), bindStr, ctx->alloc);
}
Dict* resp = NULL;
rpcCall0(String_CONST("UDPInterface_new"), d, ctx, ctx->alloc, &resp, true);
int ifNum = *(Dict_getInt(resp, String_CONST("interfaceNumber")));
// Make the connections.
Dict* connectTo = Dict_getDict(udp, String_CONST("connectTo"));
if (connectTo) {
struct Dict_Entry* entry = *connectTo;
struct Allocator* perCallAlloc = Allocator_child(ctx->alloc);
while (entry != NULL) {
String* key = (String*) entry->key;
if (entry->val->type != Object_DICT) {
Log_critical(ctx->logger, "interfaces.UDPInterface.connectTo: entry [%s] "
"is not a dictionary type.", key->bytes);
exit(-1);
}
Dict* all = entry->val->as.dictionary;
Dict* value = Dict_new(perCallAlloc);
String* pub_d = Dict_getString(all, String_CONST("publicKey"));
String* pss_d = Dict_getString(all, String_CONST("password"));
String* peerName_d = Dict_getString(all, String_CONST("peerName"));
String* login_d = Dict_getString(all, String_CONST("login"));
if ( !pub_d || !pss_d ) {
const char * error_name = "(unknown)";
if ( !pub_d ) {
error_name = "publicKey";
}
if ( !pss_d ) {
error_name = "password";
}
Log_warn(ctx->logger,
"Skipping peer: missing %s for peer [%s]", error_name, key->bytes);
if (abort_if_invalid_ref) {
Assert_failure("Invalid peer reference");
}
else {
entry = entry->next;
continue;
}
}
Dict_putString(value, String_CONST("publicKey"), pub_d, perCallAlloc);
Dict_putString(value, String_CONST("password"), pss_d, perCallAlloc);
Dict_putString(value, String_CONST("peerName"), peerName_d, perCallAlloc);
Dict_putString(value, String_CONST("login"), login_d, perCallAlloc);
Log_keys(ctx->logger, "Attempting to connect to node [%s].", key->bytes);
key = String_clone(key, perCallAlloc);
char* lastColon = CString_strrchr(key->bytes, ':');
if (!Sockaddr_parse(key->bytes, NULL)) {
// it's a sockaddr, fall through
} else if (lastColon) {
// try it as a hostname.
int port = atoi(lastColon+1);
if (!port) {
Log_critical(ctx->logger, "Couldn't get port number from [%s]", key->bytes);
exit(-1);
}
*lastColon = '\0';
struct Sockaddr* adr = Sockaddr_fromName(key->bytes, perCallAlloc);
if (adr != NULL) {
Sockaddr_setPort(adr, port);
key = String_new(Sockaddr_print(adr, perCallAlloc), perCallAlloc);
} else {
Log_warn(ctx->logger, "Failed to lookup hostname [%s]", key->bytes);
entry = entry->next;
continue;
}
}
struct Allocator* child = Allocator_child(ctx->alloc);
struct Message* msg = Message_new(0, AdminClient_MAX_MESSAGE_SIZE + 256, child);
int r = BencMessageWriter_writeDictTry(value, msg, NULL);
const int max_reference_size = 298;
if (r != 0 || msg->length > max_reference_size) {
Log_warn(ctx->logger, "Peer skipped:");
Log_warn(ctx->logger, "Too long peer reference for [%s]", key->bytes);
if (abort_if_invalid_ref) {
Assert_failure("Invalid peer reference");
}
else {
entry = entry->next;
continue;
}
}
Dict_putInt(value, String_CONST("interfaceNumber"), ifNum, perCallAlloc);
Dict_putString(value, String_CONST("address"), key, perCallAlloc);
rpcCall(String_CONST("UDPInterface_beginConnection"), value, ctx, perCallAlloc);
entry = entry->next;
}
Allocator_free(perCallAlloc);
}
}
}
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);
}
static void udpInterface(Dict* config, struct Context* ctx)
{
List* ifaces = Dict_getList(config, String_CONST("UDPInterface"));
if (!ifaces) {
ifaces = List_addDict(ifaces,
Dict_getDict(config, String_CONST("UDPInterface")), ctx->alloc);
}
uint32_t count = List_size(ifaces);
for (uint32_t i = 0; i < count; i++) {
Dict *udp = List_getDict(ifaces, i);
if (!udp) {
continue;
}
// Setup the interface.
String* bindStr = Dict_getString(udp, String_CONST("bind"));
Dict* d = Dict_new(ctx->alloc);
if (bindStr) {
Dict_putString(d, String_CONST("bindAddress"), bindStr, ctx->alloc);
}
rpcCall(String_CONST("UDPInterface_new"), d, ctx, ctx->alloc);
// Make the connections.
Dict* connectTo = Dict_getDict(udp, String_CONST("connectTo"));
if (connectTo) {
struct Dict_Entry* entry = *connectTo;
struct Allocator* perCallAlloc = Allocator_child(ctx->alloc);
while (entry != NULL) {
String* key = (String*) entry->key;
if (entry->val->type != Object_DICT) {
Log_critical(ctx->logger, "interfaces.UDPInterface.connectTo: entry [%s] "
"is not a dictionary type.", key->bytes);
exit(-1);
}
Dict* value = entry->val->as.dictionary;
Log_keys(ctx->logger, "Attempting to connect to node [%s].", key->bytes);
key = String_clone(key, perCallAlloc);
char* lastColon = strrchr(key->bytes, ':');
if (!Sockaddr_parse(key->bytes, NULL)) {
// it's a sockaddr, fall through
} else if (lastColon) {
// try it as a hostname.
int port = atoi(lastColon+1);
if (!port) {
Log_critical(ctx->logger, "Couldn't get port number from [%s]", key->bytes);
exit(-1);
}
*lastColon = '\0';
struct Sockaddr* adr = Sockaddr_fromName(key->bytes, perCallAlloc);
if (adr != NULL) {
Sockaddr_setPort(adr, port);
key = String_new(Sockaddr_print(adr, perCallAlloc), perCallAlloc);
} else {
Log_warn(ctx->logger, "Failed to lookup hostname [%s]", key->bytes);
entry = entry->next;
continue;
}
}
Dict_putString(value, String_CONST("address"), key, perCallAlloc);
rpcCall(String_CONST("UDPInterface_beginConnection"), value, ctx, perCallAlloc);
entry = entry->next;
}
Allocator_free(perCallAlloc);
}
}
}
