static void rpcCallback(struct AdminClient_Promise* p, struct AdminClient_Result* res)
{
struct Context* ctx = p->userData;
Allocator_adopt(ctx->alloc, p->alloc);
ctx->currentResult = res;
EventBase_endLoop(ctx->base);
}
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 uint8_t sendTo(struct Message* msg, struct Interface* iface)
{
struct TestFramework_Link* link =
Identity_cast((struct TestFramework_Link*)iface->senderContext);
struct Interface* dest;
struct TestFramework* srcTf;
if (&link->destIf == iface) {
dest = &link->srcIf;
srcTf = link->dest;
} else if (&link->srcIf == iface) {
dest = &link->destIf;
srcTf = link->src;
} else {
Assert_always(false);
}
printf("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.
struct Message* sendMsg = Message_clone(msg, dest->allocator);
return dest->receiveMessage(sendMsg, dest);
}
int PeerLink_send(struct Message* msg, struct PeerLink* peerLink)
{
struct PeerLink_pvt* pl = Identity_check((struct PeerLink_pvt*) peerLink);
Allocator_adopt(pl->alloc, msg->alloc);
ArrayList_Messages_add(pl->queue, msg);
return pl->queue->length;
}
static void checkRunningInstanceCallback(struct AdminClient_Promise* p,
struct AdminClient_Result* res)
{
struct CheckRunningInstanceContext* ctx = p->userData;
// Prevent this from freeing until after we drop out of the loop.
Allocator_adopt(ctx->alloc, p->alloc);
ctx->res = res;
EventBase_endLoop(ctx->base);
}
static uint8_t receiveMessage(struct Message* msg, struct Interface* iface)
{
struct Context* ctx = Identity_cast((struct Context*) iface->receiverContext);
struct Sockaddr_storage source;
Message_pop(msg, &source, ctx->targetAddr->addrLen, NULL);
if (Bits_memcmp(&source, ctx->targetAddr, ctx->targetAddr->addrLen)) {
Log_info(ctx->logger, "Got spurious message from [%s], expecting messages from [%s]",
Sockaddr_print(&source.addr, msg->alloc),
Sockaddr_print(ctx->targetAddr, msg->alloc));
return 0;
}
// we don't yet know with which message this data belongs,
// the message alloc lives the length of the message reception.
struct Allocator* alloc = Allocator_child(msg->alloc);
struct Reader* reader = ArrayReader_new(msg->bytes, msg->length, alloc);
Dict* d = Dict_new(alloc);
if (StandardBencSerializer_get()->parseDictionary(reader, alloc, d)) {
return 0;
}
String* txid = Dict_getString(d, String_CONST("txid"));
if (!txid || txid->len != 8) {
return 0;
}
// look up the result
uint32_t handle = ~0u;
Hex_decode((uint8_t*)&handle, 4, txid->bytes, 8);
int idx = Map_OfRequestByHandle_indexForHandle(handle, &ctx->outstandingRequests);
if (idx < 0) {
return 0;
}
struct Request* req = ctx->outstandingRequests.values[idx];
// now this data will outlive the life of the message.
Allocator_adopt(req->promise->alloc, alloc);
req->res.responseDict = d;
int len =
(msg->length > AdminClient_MAX_MESSAGE_SIZE) ? AdminClient_MAX_MESSAGE_SIZE : msg->length;
Bits_memset(req->res.messageBytes, 0, AdminClient_MAX_MESSAGE_SIZE);
Bits_memcpy(req->res.messageBytes, msg->bytes, len);
done(req, AdminClient_Error_NONE);
return 0;
}
static Iface_DEFUN receiveMessage(struct Message* msg, struct Iface* addrIface)
{
struct Context* ctx = Identity_containerOf(addrIface, struct Context, addrIface);
struct Sockaddr_storage source;
Message_pop(msg, &source, ctx->targetAddr->addrLen, NULL);
if (Bits_memcmp(&source, ctx->targetAddr, ctx->targetAddr->addrLen)) {
Log_info(ctx->logger, "Got spurious message from [%s], expecting messages from [%s]",
Sockaddr_print(&source.addr, msg->alloc),
Sockaddr_print(ctx->targetAddr, msg->alloc));
return NULL;
}
// we don't yet know with which message this data belongs,
// the message alloc lives the length of the message reception.
struct Allocator* alloc = Allocator_child(msg->alloc);
int origLen = msg->length;
Dict* d = NULL;
char* err = BencMessageReader_readNoExcept(msg, alloc, &d);
if (err) { return NULL; }
Message_shift(msg, origLen, NULL);
String* txid = Dict_getString(d, String_CONST("txid"));
if (!txid || txid->len != 8) { return NULL; }
// look up the result
uint32_t handle = ~0u;
Hex_decode((uint8_t*)&handle, 4, txid->bytes, 8);
int idx = Map_OfRequestByHandle_indexForHandle(handle, &ctx->outstandingRequests);
if (idx < 0) { return NULL; }
struct Request* req = ctx->outstandingRequests.values[idx];
// now this data will outlive the life of the message.
Allocator_adopt(req->promise->alloc, alloc);
req->res.responseDict = d;
int len =
(msg->length > AdminClient_MAX_MESSAGE_SIZE) ? AdminClient_MAX_MESSAGE_SIZE : msg->length;
Bits_memset(req->res.messageBytes, 0, AdminClient_MAX_MESSAGE_SIZE);
Bits_memcpy(req->res.messageBytes, msg->bytes, len);
done(req, AdminClient_Error_NONE);
return NULL;
}
static int handleOutgoing(struct DHTMessage* dmessage, void* vcontext)
{
struct Ducttape_pvt* context = Identity_check((struct Ducttape_pvt*) vcontext);
// Sending a message to yourself?
// Short circuit because setting up a CA session with yourself causes problems.
if (!Bits_memcmp(dmessage->address->key, context->myAddr.key, 32)) {
struct Allocator* alloc = Allocator_child(context->alloc);
Allocator_adopt(alloc, dmessage->binMessage->alloc);
incomingDHT(dmessage->binMessage, dmessage->address, context);
Allocator_free(alloc);
return 0;
}
struct Message* msg = dmessage->binMessage;
{
Message_push(msg, (&(struct Headers_UDPHeader) {
.srcPort_be = 0,
.destPort_be = 0,
.length_be = Endian_hostToBigEndian16(msg->length),
.checksum_be = 0,
}), Headers_UDPHeader_SIZE, NULL);
}
