static bool trySend6(struct Allocator* alloc,
uint64_t addrHigh,
uint64_t addrLow,
struct Iface* sendTo,
struct Context* ctx)
{
struct Message* msg6 = Message_new(0, 512, alloc);
Message_push(msg6, "hello world", 12, NULL);
Message_push(msg6, NULL, Headers_IP6Header_SIZE, NULL);
struct Headers_IP6Header* iph = (struct Headers_IP6Header*) msg6->bytes;
Headers_setIpVersion(iph);
uint64_t addrHigh_be = Endian_hostToBigEndian64(addrHigh);
uint64_t addrLow_be = Endian_hostToBigEndian64(addrLow);
Bits_memcpy(iph->sourceAddr, &addrHigh_be, 8);
Bits_memcpy(&iph->sourceAddr[8], &addrLow_be, 8);
Bits_memcpy(ctx->sendingAddress, iph->sourceAddr, 16);
uint8_t destAddr[16] = { 20, 01 };
destAddr[15] = 1;
Bits_memcpy(iph->destinationAddr, destAddr, 16);
pushRouteDataHeaders(ctx, msg6);
Iface_send(sendTo, msg6);
if (ctx->called == 4) {
ctx->called = 0;
return true;
}
Assert_true(ctx->called == 0);
return false;
}
// This is directly called from SwitchCore, message is not encrypted.
static Iface_DEFUN sendFromSwitch(struct Message* msg, struct Iface* switchIf)
{
struct Peer* ep = Identity_check((struct Peer*) switchIf);
ep->bytesOut += msg->length;
int msgs = PeerLink_send(msg, ep->peerLink);
for (int i = 0; i < msgs; i++) {
msg = PeerLink_poll(ep->peerLink);
Assert_true(!CryptoAuth_encrypt(ep->caSession, msg));
Assert_true(!(((uintptr_t)msg->bytes) % 4) && "alignment fault");
// push the lladdr...
Message_push(msg, ep->lladdr, ep->lladdr->addrLen, NULL);
// very noisy
if (Defined(Log_DEBUG) && false) {
char* printedAddr =
Hex_print(&ep->lladdr[1], ep->lladdr->addrLen - Sockaddr_OVERHEAD, msg->alloc);
Log_debug(ep->ici->ic->logger, "Outgoing message to [%s]", printedAddr);
}
Iface_send(&ep->ici->pub.addrIf, msg);
}
return NULL;
}
static void sendBeacon(struct InterfaceController_Iface_pvt* ici, struct Allocator* tempAlloc)
{
if (ici->beaconState < InterfaceController_beaconState_newState_SEND) {
Log_debug(ici->ic->logger, "sendBeacon(%s) -> beaconing disabled", ici->name->bytes);
return;
}
Log_debug(ici->ic->logger, "sendBeacon(%s)", ici->name->bytes);
struct Message* msg = Message_new(0, 128, tempAlloc);
Message_push(msg, &ici->ic->beacon, Headers_Beacon_SIZE, NULL);
if (Defined(Log_DEBUG)) {
char* content = Hex_print(msg->bytes, msg->length, tempAlloc);
Log_debug(ici->ic->logger, "SEND BEACON CONTENT[%s]", content);
}
struct Sockaddr sa = {
.addrLen = Sockaddr_OVERHEAD,
.flags = Sockaddr_flags_BCAST
};
Message_push(msg, &sa, Sockaddr_OVERHEAD, NULL);
Iface_send(&ici->pub.addrIf, msg);
}
static void sendFirstMessageToCore(void* vcontext)
{
struct NodeContext* ctx = Identity_check((struct NodeContext*) vcontext);
struct Allocator* alloc = Allocator_child(ctx->alloc);
struct Message* msg = Message_new(0, 512, alloc);
Dict* d = Dict_new(alloc);
Dict_putString(d, String_CONST("privateKey"), String_new(ctx->privateKeyHex, alloc), alloc);
Dict* logging = Dict_new(alloc);
{
Dict_putString(logging, String_CONST("logTo"), String_CONST("stdout"), alloc);
}
Dict_putDict(d, String_CONST("logging"), logging, alloc);
Dict* admin = Dict_new(alloc);
{
Dict_putString(admin, String_CONST("bind"), ctx->bind, alloc);
Dict_putString(admin, String_CONST("pass"), ctx->pass, alloc);
}
Dict_putDict(d, String_CONST("admin"), admin, alloc);
BencMessageWriter_write(d, msg, NULL);
Iface_send(&ctx->angelIface, msg);
Allocator_free(alloc);
}
static Iface_DEFUN sendTo(struct Message* msg,
struct Iface* dest,
struct TestFramework* srcTf,
struct TestFramework* destTf)
{
Assert_true(!((uintptr_t)msg->bytes % 4) || !"alignment fault");
Assert_true(!(msg->capacity % 4) || !"length fault");
Assert_true(((int)msg->capacity >= msg->length) || !"length fault0");
Log_debug(srcTf->logger, "Transferring message to [%p] - message length [%d]\n",
(void*)dest, msg->length);
// Store the original message and a copy of the original so they can be compared later.
srcTf->lastMsgBackup = Message_clone(msg, srcTf->alloc);
srcTf->lastMsg = msg;
if (msg->alloc) {
// If it's a message which was buffered inside of CryptoAuth then it will be freed
// so by adopting the allocator we can hold it in memory.
Allocator_adopt(srcTf->alloc, msg->alloc);
}
// Copy the original and send that to the other end.
// Can't use Iface_next() when not sending the original msg.
struct Message* sendMsg = Message_clone(msg, destTf->alloc);
Iface_send(dest, sendMsg);
return 0;
}
static void sendMsg(struct MsgCore_pvt* mcp,
Dict* msgDict,
struct Address* addr,
struct Allocator* allocator)
{
struct Allocator* alloc = Allocator_child(allocator);
// Send the encoding scheme definition
Dict_putString(msgDict, CJDHTConstants_ENC_SCHEME, mcp->schemeDefinition, allocator);
// And tell the asker which interface the message came from
int encIdx = EncodingScheme_getFormNum(mcp->scheme, addr->path);
Assert_true(encIdx != EncodingScheme_getFormNum_INVALID);
Dict_putInt(msgDict, CJDHTConstants_ENC_INDEX, encIdx, allocator);
// send the protocol version
Dict_putInt(msgDict, CJDHTConstants_PROTOCOL, Version_CURRENT_PROTOCOL, allocator);
if (!Defined(SUBNODE)) {
String* q = Dict_getStringC(msgDict, "q");
String* sq = Dict_getStringC(msgDict, "sq");
if (q || sq) {
Log_debug(mcp->log, "Send query [%s] to [%s]",
((q) ? q->bytes : sq->bytes),
Address_toString(addr, alloc)->bytes);
String* txid = Dict_getStringC(msgDict, "txid");
Assert_true(txid);
String* newTxid = String_newBinary(NULL, txid->len + 1, alloc);
Bits_memcpy(&newTxid->bytes[1], txid->bytes, txid->len);
newTxid->bytes[0] = '1';
Dict_putStringC(msgDict, "txid", newTxid, alloc);
}
}
struct Message* msg = Message_new(0, 2048, alloc);
BencMessageWriter_write(msgDict, msg, NULL);
//Log_debug(mcp->log, "Sending msg [%s]", Escape_getEscaped(msg->bytes, msg->length, alloc));
// Sanity check (make sure the addr was actually calculated)
Assert_true(addr->ip6.bytes[0] == 0xfc);
struct DataHeader data;
Bits_memset(&data, 0, sizeof(struct DataHeader));
DataHeader_setVersion(&data, DataHeader_CURRENT_VERSION);
DataHeader_setContentType(&data, ContentType_CJDHT);
Message_push(msg, &data, sizeof(struct DataHeader), NULL);
struct RouteHeader route;
Bits_memset(&route, 0, sizeof(struct RouteHeader));
Bits_memcpy(route.ip6, addr->ip6.bytes, 16);
route.version_be = Endian_hostToBigEndian32(addr->protocolVersion);
route.sh.label_be = Endian_hostToBigEndian64(addr->path);
Bits_memcpy(route.publicKey, addr->key, 32);
Message_push(msg, &route, sizeof(struct RouteHeader), NULL);
Iface_send(&mcp->pub.interRouterIf, msg);
}
static void sendHello(void* vctx)
{
struct TUNTools_pvt* ctx = Identity_check((struct TUNTools_pvt*) vctx);
struct Allocator* tempAlloc = Allocator_child(ctx->pub.alloc);
struct Message* msg = Message_new(0, 64, tempAlloc);
Message_push(msg, "Hello World", 12, NULL);
Message_push(msg, ctx->pub.tunDestAddr, ctx->pub.tunDestAddr->addrLen, NULL);
Iface_send(&ctx->pub.udpIface, msg);
Allocator_free(tempAlloc);
}
static Iface_DEFUN sendToPathfinder(struct Message* msg, struct Pathfinder* pf)
{
if (!pf || pf->state != Pathfinder_state_CONNECTED) { return NULL; }
if (pf->bytesSinceLastPing < 8192 && pf->bytesSinceLastPing + msg->length >= 8192) {
struct Message* ping = Message_new(0, 512, msg->alloc);
Message_push32(ping, pf->bytesSinceLastPing, NULL);
Message_push32(ping, PING_MAGIC, NULL);
Message_push32(ping, PFChan_Core_PING, NULL);
Iface_send(&pf->iface, ping);
}
pf->bytesSinceLastPing += msg->length;
return Iface_next(&pf->iface, msg);
}
static int incomingFromDHT(struct DHTMessage* dmessage, void* vpf)
{
struct Pathfinder_pvt* pf = Identity_check((struct Pathfinder_pvt*) vpf);
struct Message* msg = dmessage->binMessage;
struct Address* addr = dmessage->address;
if (addr->path == 1) {
// Message to myself, can't handle this later because encrypting a message to yourself
// causes problems.
DHTModuleRegistry_handleIncoming(dmessage, pf->registry);
return 0;
}
// Sanity check (make sure the addr was actually calculated)
Assert_true(AddressCalc_validAddress(addr->ip6.bytes));
Message_shift(msg, PFChan_Msg_MIN_SIZE, NULL);
struct PFChan_Msg* emsg = (struct PFChan_Msg*) msg->bytes;
Bits_memset(emsg, 0, PFChan_Msg_MIN_SIZE);
DataHeader_setVersion(&emsg->data, DataHeader_CURRENT_VERSION);
DataHeader_setContentType(&emsg->data, ContentType_CJDHT);
Bits_memcpy(emsg->route.ip6, addr->ip6.bytes, 16);
emsg->route.version_be = Endian_hostToBigEndian32(addr->protocolVersion);
emsg->route.sh.label_be = Endian_hostToBigEndian64(addr->path);
emsg->route.flags |= RouteHeader_flags_PATHFINDER;
SwitchHeader_setVersion(&emsg->route.sh, SwitchHeader_CURRENT_VERSION);
Bits_memcpy(emsg->route.publicKey, addr->key, 32);
Assert_true(!Bits_isZero(emsg->route.publicKey, 32));
Assert_true(emsg->route.sh.label_be);
Assert_true(emsg->route.version_be);
Message_push32(msg, PFChan_Pathfinder_SENDMSG, NULL);
if (dmessage->replyTo) {
// see incomingMsg
dmessage->replyTo->pleaseRespond = true;
//Log_debug(pf->log, "send DHT reply");
return 0;
}
//Log_debug(pf->log, "send DHT request");
Iface_send(&pf->pub.eventIf, msg);
return 0;
}
static void sendPeer(uint32_t pathfinderId,
enum PFChan_Core ev,
struct Peer* peer)
{
struct InterfaceController_pvt* ic = Identity_check(peer->ici->ic);
struct Allocator* alloc = Allocator_child(ic->alloc);
struct Message* msg = Message_new(PFChan_Node_SIZE, 512, alloc);
struct PFChan_Node* node = (struct PFChan_Node*) msg->bytes;
Bits_memcpyConst(node->ip6, peer->addr.ip6.bytes, 16);
Bits_memcpyConst(node->publicKey, peer->addr.key, 32);
node->path_be = Endian_hostToBigEndian64(peer->addr.path);
node->metric_be = 0xffffffff;
node->version_be = Endian_hostToBigEndian32(peer->addr.protocolVersion);
Message_push32(msg, pathfinderId, NULL);
Message_push32(msg, ev, NULL);
Iface_send(&ic->eventEmitterIf, msg);
Allocator_free(alloc);
}
static void sendMessage(struct TwoNodes* tn,
char* message,
struct TestFramework* from,
struct TestFramework* to)
{
struct Message* msg;
Message_STACK(msg, 64, 512);
Bits_memcpy(msg->bytes, message, CString_strlen(message) + 1);
msg->length = CString_strlen(message) + 1;
TestFramework_craftIPHeader(msg, from->ip, to->ip);
msg = Message_clone(msg, from->alloc);
struct Iface* fromIf;
if (from == tn->nodeA) {
fromIf = &tn->tunA;
} else if (from == tn->nodeB) {
fromIf = &tn->tunB;
} else {
Assert_true(false);
}
TUNMessageType_push(msg, Ethernet_TYPE_IP6, NULL);
Iface_send(fromIf, msg);
if (to == tn->nodeA) {
Assert_true(tn->messageFrom == TUNA);
} else if (to == tn->nodeB) {
Assert_true(tn->messageFrom == TUNB);
} else {
Assert_true(false);
}
TestFramework_assertLastMessageUnaltered(tn->nodeA);
TestFramework_assertLastMessageUnaltered(tn->nodeB);
tn->messageFrom = 0;
}
static bool trySend4(struct Allocator* alloc,
uint32_t addr,
struct Iface* sendTo,
struct Context* ctx)
{
struct Message* msg4 = Message_new(0, 512, alloc);
Message_push(msg4, "hello world", 12, NULL);
Message_push(msg4, NULL, Headers_IP4Header_SIZE, NULL);
struct Headers_IP4Header* iph = (struct Headers_IP4Header*) msg4->bytes;
Headers_setIpVersion(iph);
uint32_t addr_be = Endian_hostToBigEndian32(addr);
Bits_memcpy(iph->sourceAddr, &addr_be, 4);
Bits_memcpy(ctx->sendingAddress, &addr_be, 4);
Bits_memcpy(iph->destAddr, ((uint8_t[]){ 11, 0, 0, 1 }), 4);
pushRouteDataHeaders(ctx, msg4);
Iface_send(sendTo, msg4);
if (ctx->called == 1) {
ctx->called = 0;
return true;
}
Assert_true(ctx->called == 0);
return false;
}
static Iface_DEFUN incomingMsg(struct Message* msg, struct Pathfinder_pvt* pf)
{
struct Address addr;
struct RouteHeader* hdr = (struct RouteHeader*) msg->bytes;
Message_shift(msg, -(RouteHeader_SIZE + DataHeader_SIZE), NULL);
Bits_memcpy(addr.ip6.bytes, hdr->ip6, 16);
Bits_memcpy(addr.key, hdr->publicKey, 32);
addr.protocolVersion = Endian_bigEndianToHost32(hdr->version_be);
addr.padding = 0;
addr.path = Endian_bigEndianToHost64(hdr->sh.label_be);
//Log_debug(pf->log, "Incoming DHT");
struct DHTMessage dht = {
.address = &addr,
.binMessage = msg,
.allocator = msg->alloc
};
DHTModuleRegistry_handleIncoming(&dht, pf->registry);
struct Message* nodeMsg = Message_new(0, 256, msg->alloc);
Iface_CALL(sendNode, nodeMsg, &addr, 0xfffffff0u, pf);
if (dht.pleaseRespond) {
// what a beautiful hack, see incomingFromDHT
return Iface_next(&pf->pub.eventIf, msg);
}
return NULL;
}
static Iface_DEFUN incomingFromEventIf(struct Message* msg, struct Iface* eventIf)
{
struct Pathfinder_pvt* pf = Identity_containerOf(eventIf, struct Pathfinder_pvt, pub.eventIf);
enum PFChan_Core ev = Message_pop32(msg, NULL);
if (Pathfinder_pvt_state_INITIALIZING == pf->state) {
Assert_true(ev == PFChan_Core_CONNECT);
return connected(pf, msg);
}
// Let the PF send another 128 path changes again because it's basically a new tick.
pf->bestPathChanges = 0;
switch (ev) {
case PFChan_Core_SWITCH_ERR: return switchErr(msg, pf);
case PFChan_Core_SEARCH_REQ: return searchReq(msg, pf);
case PFChan_Core_PEER: return peer(msg, pf);
case PFChan_Core_PEER_GONE: return peerGone(msg, pf);
case PFChan_Core_SESSION: return session(msg, pf);
case PFChan_Core_SESSION_ENDED: return sessionEnded(msg, pf);
case PFChan_Core_DISCOVERED_PATH: return discoveredPath(msg, pf);
case PFChan_Core_MSG: return incomingMsg(msg, pf);
case PFChan_Core_PING: return handlePing(msg, pf);
case PFChan_Core_PONG: return handlePong(msg, pf);
case PFChan_Core_UNSETUP_SESSION:
case PFChan_Core_LINK_STATE:
case PFChan_Core_CTRL_MSG: return NULL;
default:;
}
Assert_failure("unexpected event [%d]", ev);
}
static void sendEvent(struct Pathfinder_pvt* pf, enum PFChan_Pathfinder ev, void* data, int size)
{
struct Allocator* alloc = Allocator_child(pf->alloc);
struct Message* msg = Message_new(0, 512+size, alloc);
Message_push(msg, data, size, NULL);
Message_push32(msg, ev, NULL);
Iface_send(&pf->pub.eventIf, msg);
Allocator_free(alloc);
}
static void init(void* vpf)
{
struct Pathfinder_pvt* pf = Identity_check((struct Pathfinder_pvt*) vpf);
struct PFChan_Pathfinder_Connect conn = {
.superiority_be = Endian_hostToBigEndian32(1),
.version_be = Endian_hostToBigEndian32(Version_CURRENT_PROTOCOL)
};
CString_strncpy(conn.userAgent, "Cjdns internal pathfinder", 64);
sendEvent(pf, PFChan_Pathfinder_CONNECT, &conn, PFChan_Pathfinder_Connect_SIZE);
}
struct Pathfinder* Pathfinder_register(struct Allocator* allocator,
struct Log* log,
struct EventBase* base,
struct Random* rand,
struct Admin* admin)
{
struct Allocator* alloc = Allocator_child(allocator);
struct Pathfinder_pvt* pf = Allocator_calloc(alloc, sizeof(struct Pathfinder_pvt), 1);
Identity_set(pf);
pf->alloc = alloc;
pf->log = log;
pf->base = base;
pf->rand = rand;
pf->admin = admin;
pf->pub.eventIf.send = incomingFromEventIf;
pf->dhtModule.context = pf;
pf->dhtModule.handleOutgoing = incomingFromDHT;
// This needs to be done asynchronously so the pf can be plumbed to the core
Timeout_setTimeout(init, pf, 0, base, alloc);
return &pf->pub;
}
static void switching(struct Context* ctx)
{
Log_info(ctx->log, "Setting up salsa20/poly1305 benchmark (encryption and decryption only)");
struct Allocator* alloc = Allocator_child(ctx->alloc);;
struct SwitchingContext* sc = Allocator_calloc(alloc, sizeof(struct SwitchingContext), 1);
Identity_set(sc);
sc->benchmarkCtx = ctx;
sc->aliceIf.send = aliceToBob;
sc->bobIf.send = bobToAlice;
sc->aliceCtrlIf.send = aliceCtrlRecv;
struct NetCore* alice = NetCore_new(SECRETA, alloc, ctx->base, ctx->rand, ctx->log);
struct InterfaceController_Iface* aliceIci =
InterfaceController_newIface(alice->ifController, String_CONST("alice"), alloc);
Iface_plumb(&sc->aliceIf, &aliceIci->addrIf);
struct NetCore* bob = NetCore_new(SECRETB, alloc, ctx->base, ctx->rand, ctx->log);
struct InterfaceController_Iface* bobIci =
InterfaceController_newIface(bob->ifController, String_CONST("bob"), alloc);
Iface_plumb(&sc->bobIf, &bobIci->addrIf);
CryptoAuth_addUser(String_CONST("abcdefg123"), 1, String_CONST("TEST"), bob->ca);
// Client has pubKey and passwd for the server.
int ret = InterfaceController_bootstrapPeer(alice->ifController,
aliceIci->ifNum,
bob->ca->publicKey,
Sockaddr_LOOPBACK,
String_CONST("abcdefg123"),
alloc);
Assert_true(!ret);
Iface_unplumb(alice->switchAdapter->controlIf.connectedIf, &alice->switchAdapter->controlIf);
Iface_plumb(&alice->switchAdapter->controlIf, &sc->aliceCtrlIf);
struct Message* msg = Message_new(Control_Ping_MIN_SIZE + Control_Header_SIZE, 256, alloc);
struct Control_Header* ch = (struct Control_Header*) msg->bytes;
struct Control_Ping* ping = (struct Control_Ping*) &ch[1];
ping->version_be = Endian_hostToBigEndian32(Version_CURRENT_PROTOCOL);
Message_push32(msg, 0xffffffff, NULL);
uint32_t* handle_be = (uint32_t*)msg->bytes;
Message_push(msg, NULL, SwitchHeader_SIZE, NULL);
struct SwitchHeader* sh = (struct SwitchHeader*) msg->bytes;
// TODO(cjd): this will fail with a different encoding scheme
sh->label_be = Endian_hostToBigEndian64(0x13);
for (int i = 1; i < 6; i++) {
ping->magic = Control_Ping_MAGIC;
ch->type_be = Control_PING_be;
ch->checksum_be = 0;
ch->checksum_be = Checksum_engine((void*)ch, Control_Ping_MIN_SIZE + Control_Header_SIZE);
Iface_send(&sc->aliceCtrlIf, msg);
Assert_true(sc->msgCount == i);
Assert_true(msg->bytes == (void*)sh);
Assert_true(ping->magic == Control_Pong_MAGIC);
Assert_true(ch->type_be = Control_PONG_be);
Assert_true(!Checksum_engine((void*)ch, Control_Ping_MIN_SIZE + Control_Header_SIZE));
}
*handle_be = 0xfffffff0;
int count = 1000000;
begin(ctx, "Switching", count, "packets");
for (int i = 0; i < count; i++) {
sh->versionAndLabelShift = SwitchHeader_CURRENT_VERSION << 6;
Iface_send(&sc->aliceCtrlIf, msg);
Assert_true(msg->bytes == (void*)sh);
}
done(ctx);
Log_info(ctx->log, "DONE");
Allocator_free(alloc);
}
int main()
{
AddressCalc_addressForPublicKey(nodeCjdnsIp6, fakePubKey);
struct Allocator* alloc = MallocAllocator_new(1<<20);
struct Log* logger = FileWriterLog_new(stdout, alloc);
struct Random* rand = Random_new(alloc, logger, NULL);
struct EventBase* eb = EventBase_new(alloc);
struct IpTunnel* ipTun = IpTunnel_new(logger, eb, alloc, rand);
struct Sockaddr_storage ip6ToGive;
Sockaddr_parse("fd01:0101:0101:0101:0101:0101:0101:0101", &ip6ToGive);
IpTunnel_allowConnection(fakePubKey, &ip6ToGive.addr, 0, NULL, 0, ipTun);
struct Message* message;
Message_STACK(message, 64, 512);
message->alloc = alloc;
const char* requestForAddresses =
"d"
"1:q" "21:IpTunnel_getAddresses"
"4:txid" "4:abcd"
"e";
CString_strcpy((char*)message->bytes, requestForAddresses);
message->length = CString_strlen(requestForAddresses);
Message_shift(message, Headers_UDPHeader_SIZE, NULL);
struct Headers_UDPHeader* uh = (struct Headers_UDPHeader*) message->bytes;
uh->srcPort_be = 0;
uh->destPort_be = 0;
uh->length_be = Endian_hostToBigEndian16(message->length - Headers_UDPHeader_SIZE);
uint16_t* checksum = &uh->checksum_be;
*checksum = 0;
uint32_t length = message->length;
Message_shift(message, Headers_IP6Header_SIZE, NULL);
struct Headers_IP6Header* ip = (struct Headers_IP6Header*) message->bytes;
ip->versionClassAndFlowLabel = 0;
ip->flowLabelLow_be = 0;
ip->payloadLength_be = Endian_hostToBigEndian16(length);
ip->nextHeader = 17;
ip->hopLimit = 255;
Bits_memset(ip->sourceAddr, 0, 32);
Headers_setIpVersion(ip);
Message_shift(message, RouteHeader_SIZE + DataHeader_SIZE, NULL);
struct RouteHeader* rh = (struct RouteHeader*) message->bytes;
struct DataHeader* dh = (struct DataHeader*) &rh[1];
Bits_memset(rh, 0, RouteHeader_SIZE + DataHeader_SIZE);
Bits_memcpy(rh->ip6, nodeCjdnsIp6, 16);
Bits_memcpy(rh->publicKey, fakePubKey, 32);
DataHeader_setContentType(dh, ContentType_IPTUN);
*checksum = Checksum_udpIp6(ip->sourceAddr, (uint8_t*) uh, length);
int origCap = message->capacity;
int origLen = message->length;
struct Iface nodeIface = { .send = responseWithIpCallback };
Iface_plumb(&nodeIface, &ipTun->nodeInterface);
struct Iface tunIface = { .send = messageToTun };
Iface_plumb(&tunIface, &ipTun->tunInterface);
Iface_send(&nodeIface, message);
Assert_true(called == 2);
called = 0;
// This is a hack, reusing the message will cause breakage if IpTunnel is refactored.
Message_reset(message);
Message_shift(message, origCap, NULL);
message->length = origLen;
Bits_memcpy(ip->sourceAddr, fakeIp6ToGive, 16);
// This can't be zero.
Bits_memset(ip->destinationAddr, 1, 16);
Iface_send(&nodeIface, message);
Assert_true(called == 1);
Allocator_free(alloc);
return 0;
}
// incoming message from network, pointing to the beginning of the switch header.
static Iface_DEFUN messageFromControlHandler(struct Message* msg, struct Iface* iface)
{
struct SwitchPinger_pvt* ctx = Identity_check((struct SwitchPinger_pvt*) iface);
struct SwitchHeader* switchHeader = (struct SwitchHeader*) msg->bytes;
ctx->incomingLabel = Endian_bigEndianToHost64(switchHeader->label_be);
ctx->incomingVersion = 0;
Message_shift(msg, -SwitchHeader_SIZE, NULL);
uint32_t handle = Message_pop32(msg, NULL);
#ifdef Version_7_COMPAT
if (handle != 0xffffffff) {
Message_push32(msg, handle, NULL);
handle = 0xffffffff;
Assert_true(SwitchHeader_isV7Ctrl(switchHeader));
}
#endif
Assert_true(handle == 0xffffffff);
struct Control* ctrl = (struct Control*) msg->bytes;
if (ctrl->header.type_be == Control_PONG_be) {
Message_shift(msg, -Control_Header_SIZE, NULL);
ctx->error = Error_NONE;
if (msg->length >= Control_Pong_MIN_SIZE) {
struct Control_Ping* pongHeader = (struct Control_Ping*) msg->bytes;
ctx->incomingVersion = Endian_bigEndianToHost32(pongHeader->version_be);
if (pongHeader->magic != Control_Pong_MAGIC) {
Log_debug(ctx->logger, "dropped invalid switch pong");
return NULL;
}
Message_shift(msg, -Control_Pong_HEADER_SIZE, NULL);
} else {
Log_debug(ctx->logger, "got runt pong message, length: [%d]", msg->length);
return NULL;
}
} else if (ctrl->header.type_be == Control_KEYPONG_be) {
Message_shift(msg, -Control_Header_SIZE, NULL);
ctx->error = Error_NONE;
if (msg->length >= Control_KeyPong_HEADER_SIZE && msg->length <= Control_KeyPong_MAX_SIZE) {
struct Control_KeyPing* pongHeader = (struct Control_KeyPing*) msg->bytes;
ctx->incomingVersion = Endian_bigEndianToHost32(pongHeader->version_be);
if (pongHeader->magic != Control_KeyPong_MAGIC) {
Log_debug(ctx->logger, "dropped invalid switch key-pong");
return NULL;
}
Bits_memcpyConst(ctx->incomingKey, pongHeader->key, 32);
Message_shift(msg, -Control_KeyPong_HEADER_SIZE, NULL);
} else if (msg->length > Control_KeyPong_MAX_SIZE) {
Log_debug(ctx->logger, "got overlong key-pong message, length: [%d]", msg->length);
return NULL;
} else {
Log_debug(ctx->logger, "got runt key-pong message, length: [%d]", msg->length);
return NULL;
}
} else if (ctrl->header.type_be == Control_ERROR_be) {
Message_shift(msg, -Control_Header_SIZE, NULL);
Assert_true((uint8_t*)&ctrl->content.error.errorType_be == msg->bytes);
if (msg->length < (Control_Error_HEADER_SIZE + SwitchHeader_SIZE + Control_Header_SIZE)) {
Log_debug(ctx->logger, "runt error packet");
return NULL;
}
ctx->error = Message_pop32(msg, NULL);
Message_push32(msg, 0, NULL);
Message_shift(msg, -(Control_Error_HEADER_SIZE + SwitchHeader_SIZE), NULL);
struct Control* origCtrl = (struct Control*) msg->bytes;
Log_debug(ctx->logger, "error [%s] was caused by our [%s]",
Error_strerror(ctx->error),
Control_typeString(origCtrl->header.type_be));
int shift;
if (origCtrl->header.type_be == Control_PING_be) {
shift = -(Control_Header_SIZE + Control_Ping_HEADER_SIZE);
} else if (origCtrl->header.type_be == Control_KEYPING_be) {
shift = -(Control_Header_SIZE + Control_KeyPing_HEADER_SIZE);
} else {
Assert_failure("problem in Ducttape.c");
}
if (msg->length < -shift) {
Log_debug(ctx->logger, "runt error packet");
}
Message_shift(msg, shift, NULL);
} else {
// If it gets here then Ducttape.c is failing.
Assert_true(false);
}
String* msgStr = &(String) { .bytes = (char*) msg->bytes, .len = msg->length };
Pinger_pongReceived(msgStr, ctx->pinger);
Bits_memset(ctx->incomingKey, 0, 32);
return NULL;
}
static void onPingResponse(String* data, uint32_t milliseconds, void* vping)
{
struct Ping* p = Identity_check((struct Ping*) vping);
enum SwitchPinger_Result err = SwitchPinger_Result_OK;
uint64_t label = p->context->incomingLabel;
if (data) {
if (label != p->label) {
err = SwitchPinger_Result_LABEL_MISMATCH;
} else if ((p->data || data->len > 0) && !String_equals(data, p->data)) {
err = SwitchPinger_Result_WRONG_DATA;
} else if (p->context->error == Error_LOOP_ROUTE) {
err = SwitchPinger_Result_LOOP_ROUTE;
} else if (p->context->error) {
err = SwitchPinger_Result_ERROR_RESPONSE;
}
} else {
err = SwitchPinger_Result_TIMEOUT;
}
uint32_t version = p->context->incomingVersion;
struct SwitchPinger_Response* resp =
Allocator_calloc(p->pub.pingAlloc, sizeof(struct SwitchPinger_Response), 1);
resp->version = p->context->incomingVersion;
resp->res = err;
resp->label = label;
resp->data = data;
resp->milliseconds = milliseconds;
resp->version = version;
Bits_memcpyConst(resp->key, p->context->incomingKey, 32);
resp->ping = &p->pub;
p->onResponse(resp, p->pub.onResponseContext);
}
static void sendPing(String* data, void* sendPingContext)
{
struct Ping* p = Identity_check((struct Ping*) sendPingContext);
struct Message* msg = Message_new(0, data->len + 512, p->pub.pingAlloc);
while (((uintptr_t)msg->bytes - data->len) % 4) {
Message_push8(msg, 0, NULL);
}
msg->length = 0;
Message_push(msg, data->bytes, data->len, NULL);
Assert_true(!((uintptr_t)msg->bytes % 4) && "alignment fault");
if (p->pub.keyPing) {
Message_shift(msg, Control_KeyPing_HEADER_SIZE, NULL);
struct Control_KeyPing* keyPingHeader = (struct Control_KeyPing*) msg->bytes;
keyPingHeader->magic = Control_KeyPing_MAGIC;
keyPingHeader->version_be = Endian_hostToBigEndian32(Version_CURRENT_PROTOCOL);
Bits_memcpyConst(keyPingHeader->key, p->context->myAddr->key, 32);
} else {
Message_shift(msg, Control_Ping_HEADER_SIZE, NULL);
struct Control_Ping* pingHeader = (struct Control_Ping*) msg->bytes;
pingHeader->magic = Control_Ping_MAGIC;
pingHeader->version_be = Endian_hostToBigEndian32(Version_CURRENT_PROTOCOL);
}
Message_shift(msg, Control_Header_SIZE, NULL);
struct Control* ctrl = (struct Control*) msg->bytes;
ctrl->header.checksum_be = 0;
ctrl->header.type_be = (p->pub.keyPing) ? Control_KEYPING_be : Control_PING_be;
ctrl->header.checksum_be = Checksum_engine(msg->bytes, msg->length);
#ifdef Version_7_COMPAT
if (0) {
#endif
Message_push32(msg, 0xffffffff, NULL);
#ifdef Version_7_COMPAT
}
#endif
Message_shift(msg, SwitchHeader_SIZE, NULL);
struct SwitchHeader* switchHeader = (struct SwitchHeader*) msg->bytes;
Bits_memset(switchHeader, 0, SwitchHeader_SIZE);
switchHeader->label_be = Endian_hostToBigEndian64(p->label);
SwitchHeader_setVersion(switchHeader, SwitchHeader_CURRENT_VERSION);
#ifdef Version_7_COMPAT
// v7 detects ctrl packets by the bit which has been
// re-appropriated for suppression of errors.
switchHeader->congestAndSuppressErrors = 1;
SwitchHeader_setVersion(switchHeader, 0);
#endif
Iface_send(&p->context->pub.controlHandlerIf, msg);
}
static String* RESULT_STRING_OK = String_CONST_SO("pong");
static String* RESULT_STRING_LABEL_MISMATCH = String_CONST_SO("diff_label");
static String* RESULT_STRING_WRONG_DATA = String_CONST_SO("diff_data");
static String* RESULT_STRING_ERROR_RESPONSE = String_CONST_SO("err_switch");
static String* RESULT_STRING_TIMEOUT = String_CONST_SO("timeout");
static String* RESULT_STRING_UNKNOWN = String_CONST_SO("err_unknown");
static String* RESULT_STRING_LOOP = String_CONST_SO("err_loop");
String* SwitchPinger_resultString(enum SwitchPinger_Result result)
{
switch (result) {
case SwitchPinger_Result_OK:
return RESULT_STRING_OK;
case SwitchPinger_Result_LABEL_MISMATCH:
return RESULT_STRING_LABEL_MISMATCH;
case SwitchPinger_Result_WRONG_DATA:
return RESULT_STRING_WRONG_DATA;
case SwitchPinger_Result_ERROR_RESPONSE:
return RESULT_STRING_ERROR_RESPONSE;
case SwitchPinger_Result_TIMEOUT:
return RESULT_STRING_TIMEOUT;
case SwitchPinger_Result_LOOP_ROUTE:
return RESULT_STRING_LOOP;
default:
return RESULT_STRING_UNKNOWN;
};
}
static int onPingFree(struct Allocator_OnFreeJob* job)
{
struct Ping* ping = Identity_check((struct Ping*)job->userData);
struct SwitchPinger_pvt* ctx = Identity_check(ping->context);
ctx->outstandingPings--;
Assert_true(ctx->outstandingPings >= 0);
return 0;
}
struct SwitchPinger_Ping* SwitchPinger_newPing(uint64_t label,
String* data,
uint32_t timeoutMilliseconds,
SwitchPinger_ResponseCallback onResponse,
struct Allocator* alloc,
struct SwitchPinger* context)
{
struct SwitchPinger_pvt* ctx = Identity_check((struct SwitchPinger_pvt*)context);
if (data && data->len > Control_Ping_MAX_SIZE) {
return NULL;
}
if (ctx->outstandingPings > ctx->maxConcurrentPings) {
Log_debug(ctx->logger, "Skipping switch ping because there are already [%d] outstanding",
ctx->outstandingPings);
return NULL;
}
struct Pinger_Ping* pp =
Pinger_newPing(data, onPingResponse, sendPing, timeoutMilliseconds, alloc, ctx->pinger);
struct Ping* ping = Allocator_clone(pp->pingAlloc, (&(struct Ping) {
.pub = {
.pingAlloc = pp->pingAlloc
},
.label = label,
.data = String_clone(data, pp->pingAlloc),
.context = ctx,
.onResponse = onResponse,
.pingerPing = pp
}));
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 Iface_DEFUN sendMessage(struct Message* msg, struct Iface* iface)
{
struct ETHInterface_pvt* ctx =
Identity_containerOf(iface, struct ETHInterface_pvt, pub.generic.iface);
struct Sockaddr* sa = (struct Sockaddr*) msg->bytes;
Assert_true(msg->length >= Sockaddr_OVERHEAD);
Assert_true(sa->addrLen <= ETHInterface_Sockaddr_SIZE);
struct ETHInterface_Sockaddr sockaddr = { .generic = { .addrLen = 0 } };
Message_pop(msg, &sockaddr, sa->addrLen, NULL);
struct sockaddr_ll addr;
Bits_memcpy(&addr, &ctx->addrBase, sizeof(struct sockaddr_ll));
if (sockaddr.generic.flags & Sockaddr_flags_BCAST) {
Bits_memset(addr.sll_addr, 0xff, 6);
} else {
Bits_memcpy(addr.sll_addr, sockaddr.mac, 6);
}
struct ETHInterface_Header hdr = {
.version = ETHInterface_CURRENT_VERSION,
.zero = 0,
.length_be = Endian_hostToBigEndian16(msg->length + ETHInterface_Header_SIZE),
.fc00_be = Endian_hostToBigEndian16(0xfc00)
};
Message_push(msg, &hdr, ETHInterface_Header_SIZE, NULL);
struct Except* eh = NULL;
sendMessageInternal(msg, &addr, ctx, eh);
return NULL;
}
static void handleEvent2(struct ETHInterface_pvt* context, struct Allocator* messageAlloc)
{
struct Message* msg = Message_new(MAX_PACKET_SIZE, PADDING, messageAlloc);
struct sockaddr_ll addr;
uint32_t addrLen = sizeof(struct sockaddr_ll);
// Knock it out of alignment by 2 bytes so that it will be
// aligned when the idAndPadding is shifted off.
Message_shift(msg, 2, NULL);
int rc = recvfrom(context->socket,
msg->bytes,
msg->length,
0,
(struct sockaddr*) &addr,
&addrLen);
if (rc < ETHInterface_Header_SIZE) {
Log_debug(context->logger, "Failed to receive eth frame");
return;
}
Assert_true(msg->length >= rc);
msg->length = rc;
//Assert_true(addrLen == SOCKADDR_LL_LEN);
struct ETHInterface_Header hdr;
Message_pop(msg, &hdr, ETHInterface_Header_SIZE, NULL);
// here we could put a switch statement to handle different versions differently.
if (hdr.version != ETHInterface_CURRENT_VERSION) {
Log_debug(context->logger, "DROP unknown version");
return;
}
uint16_t reportedLength = Endian_bigEndianToHost16(hdr.length_be);
reportedLength -= ETHInterface_Header_SIZE;
if (msg->length != reportedLength) {
if (msg->length < reportedLength) {
Log_debug(context->logger, "DROP size field is larger than frame");
return;
}
msg->length = reportedLength;
}
if (hdr.fc00_be != Endian_hostToBigEndian16(0xfc00)) {
Log_debug(context->logger, "DROP bad magic");
return;
}
struct ETHInterface_Sockaddr sockaddr = { .zero = 0 };
Bits_memcpy(sockaddr.mac, addr.sll_addr, 6);
sockaddr.generic.addrLen = ETHInterface_Sockaddr_SIZE;
if (addr.sll_pkttype == PACKET_BROADCAST) {
sockaddr.generic.flags |= Sockaddr_flags_BCAST;
}
Message_push(msg, &sockaddr, ETHInterface_Sockaddr_SIZE, NULL);
Assert_true(!((uintptr_t)msg->bytes % 4) && "Alignment fault");
Iface_send(&context->pub.generic.iface, msg);
}
static void handleEvent(void* vcontext)
{
struct ETHInterface_pvt* context = Identity_check((struct ETHInterface_pvt*) vcontext);
struct Allocator* messageAlloc = Allocator_child(context->pub.generic.alloc);
handleEvent2(context, messageAlloc);
Allocator_free(messageAlloc);
}
List* ETHInterface_listDevices(struct Allocator* alloc, struct Except* eh)
{
List* out = List_new(alloc);
#ifndef android
struct ifaddrs* ifaddr = NULL;
if (getifaddrs(&ifaddr) || ifaddr == NULL) {
Except_throw(eh, "getifaddrs() -> errno:%d [%s]", errno, strerror(errno));
}
for (struct ifaddrs* ifa = ifaddr; ifa; ifa = ifa->ifa_next) {
if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_PACKET) {
List_addString(out, String_new(ifa->ifa_name, alloc), alloc);
}
}
freeifaddrs(ifaddr);
#endif
return out;
}
static int closeSocket(struct Allocator_OnFreeJob* j)
{
struct ETHInterface_pvt* ctx = Identity_check((struct ETHInterface_pvt*) j->userData);
close(ctx->socket);
return 0;
}
struct ETHInterface* ETHInterface_new(struct EventBase* eventBase,
const char* bindDevice,
struct Allocator* alloc,
struct Except* exHandler,
struct Log* logger)
{
struct ETHInterface_pvt* ctx = Allocator_calloc(alloc, sizeof(struct ETHInterface_pvt), 1);
Identity_set(ctx);
ctx->pub.generic.iface.send = sendMessage;
ctx->pub.generic.alloc = alloc;
ctx->logger = logger;
struct ifreq ifr = { .ifr_ifindex = 0 };
ctx->socket = socket(AF_PACKET, SOCK_DGRAM, Ethernet_TYPE_CJDNS);
if (ctx->socket == -1) {
Except_throw(exHandler, "call to socket() failed. [%s]", strerror(errno));
}
Allocator_onFree(alloc, closeSocket, ctx);
CString_strncpy(ifr.ifr_name, bindDevice, IFNAMSIZ - 1);
ctx->ifName = String_new(bindDevice, alloc);
if (ioctl(ctx->socket, SIOCGIFINDEX, &ifr) == -1) {
Except_throw(exHandler, "failed to find interface index [%s]", strerror(errno));
}
ctx->ifindex = ifr.ifr_ifindex;
if (ioctl(ctx->socket, SIOCGIFFLAGS, &ifr) < 0) {
Except_throw(exHandler, "ioctl(SIOCGIFFLAGS) [%s]", strerror(errno));
}
if (!((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))) {
Log_info(logger, "Bringing up interface [%s]", ifr.ifr_name);
ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
if (ioctl(ctx->socket, SIOCSIFFLAGS, &ifr) < 0) {
Except_throw(exHandler, "ioctl(SIOCSIFFLAGS) [%s]", strerror(errno));
}
}
ctx->addrBase = (struct sockaddr_ll) {
.sll_family = AF_PACKET,
.sll_protocol = Ethernet_TYPE_CJDNS,
.sll_ifindex = ctx->ifindex,
.sll_hatype = ARPHRD_ETHER,
.sll_pkttype = PACKET_OTHERHOST,
.sll_halen = ETH_ALEN
};
if (bind(ctx->socket, (struct sockaddr*) &ctx->addrBase, sizeof(struct sockaddr_ll))) {
Except_throw(exHandler, "call to bind() failed [%s]", strerror(errno));
}
Socket_makeNonBlocking(ctx->socket);
Event_socketRead(handleEvent, ctx, ctx->socket, eventBase, alloc, exHandler);
return &ctx->pub;
}
static int handleFromPathfinder(enum PFChan_Pathfinder ev,
struct Message* msg,
struct EventEmitter_pvt* ee,
struct Pathfinder* pf)
{
switch (ev) {
default: return false;
case PFChan_Pathfinder_CONNECT: {
struct PFChan_Pathfinder_Connect connect;
Message_shift(msg, -8, NULL);
Message_pop(msg, &connect, PFChan_Pathfinder_Connect_SIZE, NULL);
pf->superiority = Endian_bigEndianToHost32(connect.superiority_be);
pf->version = Endian_bigEndianToHost32(connect.version_be);
Bits_memcpy(pf->userAgent, connect.userAgent, 64);
pf->state = Pathfinder_state_CONNECTED;
struct PFChan_Core_Connect resp;
resp.version_be = Endian_bigEndianToHost32(Version_CURRENT_PROTOCOL);
resp.pathfinderId_be = Endian_hostToBigEndian32(pf->pathfinderId);
Bits_memcpy(resp.publicKey, ee->publicKey, 32);
Message_push(msg, &resp, PFChan_Core_Connect_SIZE, NULL);
Message_push32(msg, PFChan_Core_CONNECT, NULL);
struct Message* sendMsg = Message_clone(msg, msg->alloc);
Iface_CALL(sendToPathfinder, sendMsg, pf);
break;
}
case PFChan_Pathfinder_SUPERIORITY: {
Message_shift(msg, -8, NULL);
pf->superiority = Message_pop32(msg, NULL);
struct Message* resp = pathfinderMsg(PFChan_Core_PATHFINDER, pf, msg->alloc);
Iface_CALL(incomingFromCore, resp, &ee->trickIf);
break;
}
case PFChan_Pathfinder_PING: {
struct Message* sendMsg = Message_clone(msg, msg->alloc);
Iface_send(&pf->iface, sendMsg);
break;
}
case PFChan_Pathfinder_PONG: {
Message_shift(msg, -8, NULL);
uint32_t cookie = Message_pop32(msg, NULL);
uint32_t count = Message_pop32(msg, NULL);
if (cookie != PING_MAGIC || count > pf->bytesSinceLastPing) {
pf->state = Pathfinder_state_ERROR;
struct Message* resp = pathfinderMsg(PFChan_Core_PATHFINDER_GONE, pf, msg->alloc);
Iface_CALL(incomingFromCore, resp, &ee->trickIf);
} else {
pf->bytesSinceLastPing -= count;
}
break;
}
case PFChan_Pathfinder_PATHFINDERS: {
for (int i = 0; i < ee->pathfinders->length; i++) {
struct Pathfinder* xpf = ArrayList_Pathfinders_get(ee->pathfinders, i);
if (!xpf || xpf->state != Pathfinder_state_CONNECTED) { continue; }
struct Allocator* alloc = Allocator_child(msg->alloc);
struct Message* resp = pathfinderMsg(PFChan_Core_PATHFINDER, pf, alloc);
Iface_CALL(sendToPathfinder, resp, pf);
Allocator_free(alloc);
}
break;
}
}
return true;
}
