static void randomTest(struct Allocator* parent, struct Random* rand)
{
struct Allocator* alloc = Allocator_child(parent);
struct EncodingScheme* control = randomScheme(rand, alloc);
String* data = EncodingScheme_serialize(control, alloc);
struct EncodingScheme* test = EncodingScheme_deserialize(data, alloc);
assertEqual(control, test);
Allocator_free(alloc);
}
static void nodeInfo(Dict* args, void* vcontext, String* txid, struct Allocator* requestAlloc)
{
struct Context* const ctx = Identity_check((struct Context*) vcontext);
String* myAddr = Address_toString(ctx->nc->myAddress, requestAlloc);
String* schemeStr = EncodingScheme_serialize(ctx->encodingScheme, requestAlloc);
List* schemeList = EncodingScheme_asList(ctx->encodingScheme, requestAlloc);
Dict* out = Dict_new(requestAlloc);
Dict_putStringC(out, "myAddr", myAddr, requestAlloc);
char* schemeHex = Hex_print(schemeStr->bytes, schemeStr->len, requestAlloc);
Dict_putStringCC(out, "compressedSchemeHex", schemeHex, requestAlloc);
Dict_putListC(out, "encodingScheme", schemeList, requestAlloc);
Dict_putIntC(out, "version", Version_CURRENT_PROTOCOL, requestAlloc);
Dict_putStringCC(out, "error", "none", requestAlloc);
Admin_sendMessage(out, txid, ctx->admin);
}
// 111111111111101 00010 01111 15/2/~0 -> 01001111 11110100 11111111 remainder 1
// 11111111111111111011 00100 10100 20/4/~0 -> 00101001 11011001 11111111 remainder 7f
// 111111111111110111 01000 10010 18/8/~0 -> 01111111 10001001 11101110 11111111 remainder 7
// 00000111 <-- appliation of remainder
//
// In bytes:
// 01001111 11110100 11111111 00101001 11011001 11111111
// 01111111 10001001 11101110 11111111 00000111
//
// or \x4f\xf4\xff\x29\xd9\xff\x7f\x89\xee\xff\x07
struct EncodingScheme list = {
.count = 3,
.forms = forms
};
struct Allocator* alloc = Allocator_child(parent);
String* data = EncodingScheme_serialize(&list, alloc);
Assert_true(data->len == 11);
Assert_true(!Bits_memcmp(data->bytes, "\x4f\xf4\xff\x29\xd9\xff\x7f\x89\xee\xff\x07", 11));
Allocator_free(alloc);
}
#define convertLabel_SELF_ROUTE 1
#define convertLabel_TOO_BIG 2
static int convertLabel(struct EncodingScheme_Form* iform,
struct EncodingScheme_Form* oform,
uint64_t label)
{
struct {
struct EncodingScheme scheme;
struct EncodingScheme_Form forms[2];
} s;
static Iface_DEFUN incoming(struct Message* msg, struct Iface* interRouterIf)
{
struct MsgCore_pvt* mcp =
Identity_containerOf(interRouterIf, struct MsgCore_pvt, pub.interRouterIf);
struct Address addr = { .padding = 0 };
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.path = Endian_bigEndianToHost64(hdr->sh.label_be);
Dict* content = NULL;
uint8_t* msgBytes = msg->bytes;
int length = msg->length;
//Log_debug(mcp->log, "Receive msg [%s] from [%s]",
// Escape_getEscaped(msg->bytes, msg->length, msg->alloc),
// Address_toString(&addr, msg->alloc)->bytes);
//
BencMessageReader_readNoExcept(msg, msg->alloc, &content);
if (!content) {
char* esc = Escape_getEscaped(msgBytes, length, msg->alloc);
Log_debug(mcp->log, "DROP Malformed message [%s]", esc);
return NULL;
}
int64_t* verP = Dict_getIntC(content, "p");
if (!verP) {
Log_debug(mcp->log, "DROP Message without version");
return NULL;
}
addr.protocolVersion = *verP;
String* q = Dict_getStringC(content, "q");
if (!Defined(SUBNODE)) {
String* txid = Dict_getStringC(content, "txid");
Assert_true(txid);
if (q) {
if (txid->bytes[0] == '0') {
Log_debug(mcp->log, "DROP query which begins with 0 and is for old pathfinder");
return NULL;
}
} else {
if (txid->bytes[0] != '1') {
Log_debug(mcp->log, "DROP reply which does not begin with 1");
return NULL;
}
String* newTxid = String_newBinary(NULL, txid->len - 1, msg->alloc);
Bits_memcpy(newTxid->bytes, &txid->bytes[1], txid->len - 1);
Dict_putStringC(content, "txid", newTxid, msg->alloc);
txid = newTxid;
}
}
if (q) {
return queryMsg(mcp, content, &addr, msg);
} else {
return replyMsg(mcp, content, &addr, msg);
}
}
struct MsgCore* MsgCore_new(struct EventBase* base,
struct Random* rand,
struct Allocator* allocator,
struct Log* log,
struct EncodingScheme* scheme)
{
struct Allocator* alloc = Allocator_child(allocator);
struct MsgCore_pvt* mcp = Allocator_calloc(alloc, sizeof(struct MsgCore_pvt), 1);
Identity_set(mcp);
mcp->pub.interRouterIf.send = incoming;
mcp->qh = ArrayList_OfQueryHandlers_new(alloc);
mcp->pinger = Pinger_new(base, rand, log, alloc);
mcp->log = log;
mcp->scheme = scheme;
mcp->schemeDefinition = EncodingScheme_serialize(scheme, alloc);
return &mcp->pub;
}
