static struct EncodingScheme* randomScheme(struct Random* rand, struct Allocator* alloc)
{
struct EncodingScheme* out =
Allocator_malloc(alloc, sizeof(struct EncodingScheme));
do {
out->count = Random_uint32(rand) % 32;
} while (out->count < 2);
out->forms = Allocator_malloc(alloc, sizeof(struct EncodingScheme_Form) * out->count);
for (int i = 0; i < (int)out->count; i++) {
randomForm(&out->forms[i], rand);
for (int j = 0; j < i; j++) {
if (out->forms[i].bitCount == out->forms[j].bitCount) {
i--;
break;
}
int minPfx = (out->forms[i].prefixLen < out->forms[j].prefixLen)
? out->forms[i].prefixLen : out->forms[j].prefixLen;
if (((out->forms[j].prefix ^ out->forms[i].prefix) & ((1<<minPfx)-1)) == 0) {
// collision, destroy both entries and try again.
if (j != i-1) {
Bits_memcpyConst(&out->forms[j],
&out->forms[i-1],
sizeof(struct EncodingScheme_Form));
}
i -= 2;
break;
}
}
}
Order_OfEncodingForms_qsort(out->forms, out->count);
return out;
}
// Just make sure random crap doesn't crash it.
static void fuzzTest(struct Allocator* parent, struct Random* rand)
{
struct Allocator* alloc = Allocator_child(parent);
String* data = String_newBinary(NULL, Random_uint32(rand) % 1024, alloc);
Random_bytes(rand, (uint8_t*)data->bytes, data->len);
EncodingScheme_deserialize(data, alloc);
Allocator_free(alloc);
}
static struct Address* createAddress(uint32_t mostSignificantAddressSpaceWord, uint64_t path)
{
// horrible hack...
return Allocator_clone(alloc, (&(struct Address) {
.ip6.ints = {
.three = Endian_bigEndianToHost32(0xfc000000 + Random_uint16(rand)),
.four = Random_uint32(rand),
.one = mostSignificantAddressSpaceWord,
.two = Random_uint32(rand)
},
.path = path
}));
/**
* Check the table for nodes which might need to be pinged, ping a node if necessary.
* If a node has not responded in unresponsiveAfterMilliseconds then mark them as unresponsive
* and if the connection is incoming and the node has not responded in forgetAfterMilliseconds
* then drop them entirely.
* This is called every PING_INTERVAL_MILLISECONDS but pingCallback is a misleading name.
*/
static void pingCallback(void* vic)
{
struct InterfaceController_pvt* ic = Identity_check((struct InterfaceController_pvt*) vic);
if (!ic->peerMap.count) { return; }
uint64_t now = Time_currentTimeMilliseconds(ic->eventBase);
// scan for endpoints have not sent anything recently.
uint32_t startAt = Random_uint32(ic->rand) % ic->peerMap.count;
for (uint32_t i = startAt, count = 0; (!count || i != startAt) && count <= ic->peerMap.count;) {
i = (i + 1) % ic->peerMap.count;
count++;
struct InterfaceController_Peer* ep = ic->peerMap.values[i];
if (now < ep->timeOfLastMessage + ic->pingAfterMilliseconds) {
if (now < ep->timeOfLastPing + ic->pingAfterMilliseconds) {
// Possibly an out-of-date node which is mangling packets, don't ping too often
// because it causes the RumorMill to be filled with this node over and over.
continue;
}
struct Node_Link* link = Router_linkForPath(ic->router, ep->switchLabel);
// It exists, it's parent is the self-node, and it's label is equal to the switchLabel.
if (link
&& Node_getBestParent(link->child)
&& Node_getBestParent(link->child)->parent->address.path == 1
&& Node_getBestParent(link->child)->cannonicalLabel == ep->switchLabel)
{
continue;
}
}
#ifdef Log_DEBUG
uint8_t key[56];
Base32_encode(key, 56, CryptoAuth_getHerPublicKey(ep->cryptoAuthIf), 32);
#endif
if (ep->isIncomingConnection
&& now > ep->timeOfLastMessage + ic->forgetAfterMilliseconds)
{
Log_debug(ic->logger, "Unresponsive peer [%s.k] has not responded in [%u] "
"seconds, dropping connection",
key, ic->forgetAfterMilliseconds / 1024);
Allocator_free(ep->external->allocator);
continue;
}
bool unresponsive = (now > ep->timeOfLastMessage + ic->unresponsiveAfterMilliseconds);
if (unresponsive) {
// our link to the peer is broken...
Router_disconnectedPeer(ic->router, ep->switchLabel);
// Lets skip 87% of pings when they're really down.
if (ep->pingCount % 8) {
ep->pingCount++;
continue;
}
ep->state = InterfaceController_PeerState_UNRESPONSIVE;
}
#ifdef Log_DEBUG
uint32_t lag = (now - ep->timeOfLastMessage) / 1024;
Log_debug(ic->logger,
"Pinging %s peer [%s.k] lag [%u]",
(unresponsive ? "unresponsive" : "lazy"), key, lag);
#endif
sendPing(ep);
// we only ping one node
return;
}
}
static void iciPing(struct InterfaceController_Iface_pvt* ici, struct InterfaceController_pvt* ic)
{
if (!ici->peerMap.count) { return; }
uint64_t now = Time_currentTimeMilliseconds(ic->eventBase);
// scan for endpoints have not sent anything recently.
uint32_t startAt = Random_uint32(ic->rand) % ici->peerMap.count;
for (uint32_t i = startAt, count = 0; count < ici->peerMap.count;) {
i = (i + 1) % ici->peerMap.count;
count++;
struct Peer* ep = ici->peerMap.values[i];
if (now < ep->timeOfLastMessage + ic->pingAfterMilliseconds) {
if (now < ep->timeOfLastPing + ic->pingAfterMilliseconds) {
// Possibly an out-of-date node which is mangling packets, don't ping too often
// because it causes the RumorMill to be filled with this node over and over.
continue;
}
}
uint8_t keyIfDebug[56];
if (Defined(Log_DEBUG)) {
Base32_encode(keyIfDebug, 56, ep->caSession->herPublicKey, 32);
}
if (ep->isIncomingConnection && now > ep->timeOfLastMessage + ic->forgetAfterMilliseconds) {
Log_debug(ic->logger, "Unresponsive peer [%s.k] has not responded in [%u] "
"seconds, dropping connection",
keyIfDebug, ic->forgetAfterMilliseconds / 1024);
sendPeer(0xffffffff, PFChan_Core_PEER_GONE, ep);
Allocator_free(ep->alloc);
continue;
}
bool unresponsive = (now > ep->timeOfLastMessage + ic->unresponsiveAfterMilliseconds);
if (unresponsive) {
// our link to the peer is broken...
// Lets skip 87% of pings when they're really down.
if (ep->pingCount % 8) {
ep->pingCount++;
continue;
}
sendPeer(0xffffffff, PFChan_Core_PEER_GONE, ep);
ep->state = InterfaceController_PeerState_UNRESPONSIVE;
SwitchCore_setInterfaceState(&ep->switchIf,
SwitchCore_setInterfaceState_ifaceState_DOWN);
}
Log_debug(ic->logger,
"Pinging %s peer [%s.k] lag [%u]",
(unresponsive ? "unresponsive" : "lazy"),
keyIfDebug,
(uint32_t)((now - ep->timeOfLastMessage) / 1024));
sendPing(ep);
// we only ping one node
return;
}
}
int main()
{
struct Allocator* mainAlloc = MallocAllocator_new(1<<20);
struct Log* log = FileWriterLog_new(stdout, mainAlloc);
struct Random* rand = Random_new(mainAlloc, log, NULL);
struct Context* ctx = Allocator_malloc(mainAlloc, sizeof(struct Context));
Identity_set(ctx);
struct Interface iface = { .sendMessage = NULL };
struct Interface* fi = FramingInterface_new(4096, &iface, mainAlloc);
fi->receiveMessage = messageOut;
fi->receiverContext = ctx;
for (int i = 0; i < CYCLES; i++) {
struct Allocator* alloc = Allocator_child(mainAlloc);
// max frame size must be at least 5 so that at least 1 byte of data is sent.
int maxFrameSize = ( Random_uint32(rand) % (MAX_FRAME_SZ - 1) ) + 1;
int maxMessageSize = ( Random_uint32(rand) % (MAX_MSG_SZ - MIN_MSG_SZ) ) + MIN_MSG_SZ;
Log_debug(log, "maxFrameSize[%d] maxMessageSize[%d]", maxFrameSize, maxMessageSize);
ctx->alloc = alloc;
ctx->messages = NULL;
ctx->messageCount = 0;
ctx->currentMessage = 0;
// Create one huge message, then create lots of little frames inside of it
// then split it up in random places and send the sections to the framing
// interface.
struct Message* msg = Message_new(WORK_BUFF_SZ, 0, alloc);
Assert_true(WORK_BUFF_SZ == msg->length);
Random_bytes(rand, msg->bytes, msg->length);
Message_shift(msg, -WORK_BUFF_SZ, NULL);
for (;;) {
int len = Random_uint32(rand) % maxFrameSize;
if (!len) {
len++;
}
if (msg->padding < len + 4) {
break;
}
Message_shift(msg, len, NULL);
ctx->messageCount++;
ctx->messages =
Allocator_realloc(alloc, ctx->messages, ctx->messageCount * sizeof(char*));
struct Message* om = ctx->messages[ctx->messageCount-1] = Message_new(len, 0, alloc);
Bits_memcpy(om->bytes, msg->bytes, len);
Message_push32(msg, len, NULL);
}
do {
int nextMessageSize = Random_uint32(rand) % maxMessageSize;
if (!nextMessageSize) {
nextMessageSize++;
}
if (nextMessageSize > msg->length) {
nextMessageSize = msg->length;
}
struct Allocator* msgAlloc = Allocator_child(alloc);
struct Message* m = Message_new(nextMessageSize, 0, msgAlloc);
Message_pop(msg, m->bytes, nextMessageSize, NULL);
Interface_receiveMessage(&iface, m);
Allocator_free(msgAlloc);
} while (msg->length);
Assert_true(ctx->messageCount == ctx->currentMessage);
Allocator_free(alloc);
}
return 0;
}
