LONGBOW_TEST_CASE(Global, metisMessage_HasGetPublicKey)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *contentWithKey =
metisMessage_CreateFromArray(metisTestDataV1_ContentObject_NameA_KeyId1_RsaSha256,
sizeof(metisTestDataV1_ContentObject_NameA_KeyId1_RsaSha256), 1, 2, logger);
MetisMessage *interestWithKeyIdRestriction =
metisMessage_CreateFromArray(metisTestDataV1_Interest_NameAAndKeyId,
sizeof(metisTestDataV1_Interest_NameAAndKeyId), 1, 2, logger);
metisLogger_Release(&logger);
assertTrue(metisMessage_HasPublicKey(contentWithKey), "Expected to see a public key");
assertFalse(metisMessage_HasPublicKey(interestWithKeyIdRestriction), "Expected to not see a public key");
PARCBuffer *key = metisMessage_GetPublicKey(contentWithKey);
assertNotNull(key, "Expected to retrieve the public key");
metisMessage_Release(&contentWithKey);
metisMessage_Release(&interestWithKeyIdRestriction);
}
LONGBOW_TEST_CASE(Global, metisMessage_IsPublicKeyVerified_False)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *contentWithKey =
metisMessage_CreateFromArray(metisTestDataV1_ContentObject_NameA_KeyId1_RsaSha256,
sizeof(metisTestDataV1_ContentObject_NameA_KeyId1_RsaSha256), 1, 2, logger);
MetisMessage *interestWithKeyIdRestriction =
metisMessage_CreateFromArray(metisTestDataV1_Interest_NameAAndKeyId,
sizeof(metisTestDataV1_Interest_NameAAndKeyId), 1, 2, logger);
metisLogger_Release(&logger);
assertFalse(metisMessage_IsKeyIdVerified(contentWithKey), "Expected key to not be verified.");
// This is an interest. The keyId is actually a KeyId restriction, so will never be verified.
assertFalse(metisMessage_IsKeyIdVerified(interestWithKeyIdRestriction), "Expected key to not be verified.");
PARCBuffer *key = metisMessage_GetPublicKey(contentWithKey);
assertNotNull(key, "Expected to retrieve the public key");
metisMessage_Release(&contentWithKey);
metisMessage_Release(&interestWithKeyIdRestriction);
}
LONGBOW_TEST_CASE(Global, metisMessage_Copy)
{
char message_str[] = "\x00Once upon a time, in a stack far away, a dangling pointer found its way to the top of the heap.";
PARCEventBuffer *buff = parcEventBuffer_Create();
parcEventBuffer_Append(buff, message_str, sizeof(message_str));
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger);
metisLogger_Release(&logger);
assertNotNull(message, "Got null from metisMessage_CreateFromBuffer");
assertTrue(message->refcount == 1, "Incorrect refcount, expected %u got %u", 1, message->refcount);
MetisMessage *copy = metisMessage_Acquire(message);
assertTrue(message->refcount == 2, "Incorrect refcount, expected %u got %u", 2, message->refcount);
metisMessage_Release(&message);
assertTrue(copy->refcount == 1, "Incorrect refcount, expected %u got %u", 1, message->refcount);
metisMessage_Release(©);
assertTrue(parcMemory_Outstanding() == 0, "Memory balance should be zero after destroying last copy, got %u", parcMemory_Outstanding());
}
LONGBOW_TEST_CASE(Global, metisMessage_KeyIdEquals_DifferentValue)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
MetisMessage *b = metisMessage_CreateFromArray(metisTestDataV0_SecondInterest, sizeof(metisTestDataV0_SecondInterest), 1, 2, logger);
metisLogger_Release(&logger);
assertFalse(metisMessage_KeyIdEquals(a, b), "Messages with differnt keyids did compared equal");
metisMessage_Release(&a);
metisMessage_Release(&b);
}
LONGBOW_TEST_CASE(Global, metisMessage_ObjectHashEquals_IsEqual_Lazy)
{
// create messages from content objects, as those are lazy computed
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
MetisMessage *b = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
metisLogger_Release(&logger);
assertTrue(metisMessage_ObjectHashEquals(a, b), "Messages with equal ContentObjectHash did not compare");
metisMessage_Release(&a);
metisMessage_Release(&b);
}
LONGBOW_TEST_CASE(Global, metisMessage_ObjectHashEquals_IsNotEqual)
{
// create messages from different content objects
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
MetisMessage *b = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, sizeof(metisTestDataV0_SecondObject), 1, 2, logger);
metisLogger_Release(&logger);
assertFalse(metisMessage_ObjectHashEquals(a, b), "Messages with unequal ContentObjectHash compared as equal");
metisMessage_Release(&a);
metisMessage_Release(&b);
}
LONGBOW_TEST_CASE(Global, metisMessage_ReadFromBuffer)
{
char message_str[] = "\x00Once upon a time, in a stack far away, a dangling pointer found its way to the top of the heap.";
PARCEventBuffer *buff = parcEventBuffer_Create();
parcEventBuffer_Append(buff, message_str, sizeof(message_str));
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_ReadFromBuffer(1, 2, buff, sizeof(message_str), logger);
metisLogger_Release(&logger);
assertNotNull(message, "Got null from metisMessage_CreateFromBuffer");
assertTrue(parcEventBuffer_GetLength(message->messageBytes) == sizeof(message_str),
"Length of internal buffer wrong, expected %zu got %zu",
sizeof(message_str),
parcEventBuffer_GetLength(message->messageBytes));
uint8_t *p = parcEventBuffer_Pullup(message->messageBytes, sizeof(message_str));
assertTrue(memcmp(p, message_str, sizeof(message_str)) == 0, "Internal buffer contents does not match test");
assertTrue(message->ingressConnectionId == 1, "IngressConnectionId wrong, expected %d got %u", 1, message->ingressConnectionId);
assertTrue(message->receiveTime == 2, "receiveTime wrong, expected %u got %" PRIu64, 2, message->receiveTime);
assertTrue(parcEventBuffer_GetLength(buff) == 0, "Origin buffer not drained, expected 0, got %zu", parcEventBuffer_GetLength(buff));
metisMessage_Release(&message);
parcEventBuffer_Destroy(&buff);
}
bool
metisHopByHopFragmenter_Send(MetisHopByHopFragmenter *fragmenter, MetisMessage *message)
{
bool success = false;
// If the packet will fit in the MTU without fragmentation, do not use fragmentation
if (metisMessage_Length(message) > fragmenter->mtu) {
success = _sendFragments(fragmenter, message);
} else {
MetisMessage *copy = metisMessage_Acquire(message);
success = parcRingBuffer1x1_Put(fragmenter->sendQueue, copy);
if (!success) {
metisMessage_Release(©);
metisLogger_Log(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Warning, __func__,
"Failed to add message %p to send queue", (void *) message);
} else {
if (metisLogger_IsLoggable(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Debug)) {
metisLogger_Log(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Debug, __func__,
"Add message %p to send queue", (void *) message);
}
}
}
return success;
}
static void
_ringBufferDestroyer(void **ptr)
{
MetisMessage *message = *ptr;
metisMessage_Release(&message);
*ptr = NULL;
}
void
metisConfiguration_Receive(MetisConfiguration *config, MetisMessage *message)
{
assertNotNull(config, "Parameter config must be non-null");
assertNotNull(message, "Parameter message must be non-null");
assertTrue(metisMessage_GetType(message) == MetisMessagePacketType_Control,
"Message must be type CPI, expected %02x got %02x",
MetisMessagePacketType_Control, metisMessage_GetType(message));
CCNxControl *control = metisMessage_CreateControlMessage(message);
unsigned ingressId = metisMessage_GetIngressConnectionId(message);
if (metisLogger_IsLoggable(config->logger, MetisLoggerFacility_Config, PARCLogLevel_Debug)) {
char *str = parcJSON_ToCompactString(ccnxControl_GetJson(control));
metisLogger_Log(config->logger, MetisLoggerFacility_Config, PARCLogLevel_Debug, __func__,
"%s received %s\n", __func__, str);
parcMemory_Deallocate((void **) &str);
}
CCNxControl *response = _processControl(config, control, ingressId);
metisConfiguration_SendResponse(config, response, ingressId);
ccnxControl_Release(&response);
ccnxControl_Release(&control);
metisMessage_Release(&message);
}
static MetisNumberSet *
_metisStandardPIT_SatisfyInterest(MetisPIT *generic, const MetisMessage *objectMessage)
{
assertNotNull(generic, "Parameter pit must be non-null");
assertNotNull(objectMessage, "Parameter objectMessage must be non-null");
MetisStandardPIT *pit = metisPIT_Closure(generic);
// we need to look in all three tables to see if there's anything
// to satisy in each of them and take the union of the reverse path sets.
MetisNumberSet *ingressSetUnion = metisNumberSet_Create();
PARCArrayList *list = metisMatchingRulesTable_GetUnion(pit->table, objectMessage);
for (size_t i = 0; i < parcArrayList_Size(list); i++) {
MetisPitEntry *pitEntry = (MetisPitEntry *) parcArrayList_Get(list, i);
// this is a reference counted return
const MetisNumberSet *ingressSet = metisPitEntry_GetIngressSet(pitEntry);
metisNumberSet_AddSet(ingressSetUnion, ingressSet);
// and remove it from the PIT. Key is a reference counted copy of the pit entry message
MetisMessage *key = metisPitEntry_GetMessage(pitEntry);
metisMatchingRulesTable_RemoveFromBest(pit->table, key);
metisMessage_Release(&key);
}
parcArrayList_Destroy(&list);
return ingressSetUnion;
}
/*
* We've reach the END fragment of the reassembly buffer.
* 1) Make a metis message out of the reassembly buffer,
* 2) put the message in the receive queue (discard if queue full)
* 3) allocate a new reassembly buffer
* 4) reset the parser
*/
static void
_finalizeReassemblyBuffer(MetisHopByHopFragmenter *fragmenter)
{
// This takes ownership of fragmenter->currentReceiveBuffer
MetisMessage *reassembled = metisMessage_CreateFromBuffer(fragmenter->currentReceiveBufferIngressId,
fragmenter->currentReceiveBufferStartTicks,
fragmenter->currentReceiveBuffer,
fragmenter->logger);
if (reassembled) {
bool success = parcRingBuffer1x1_Put(fragmenter->receiveQueue, reassembled);
if (success) {
metisLogger_Log(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Debug, __func__,
"Fragmenter %p putting reassembed message %p in receive queue",
(void *) fragmenter, (void *) reassembled);
} else {
metisLogger_Log(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Error, __func__,
"Fragmenter %p failed to put reassembled message in receive queue, dropping",
(void *) fragmenter);
metisMessage_Release(&reassembled);
}
fragmenter->currentReceiveBuffer = parcEventBuffer_Create();
} else {
metisLogger_Log(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Warning, __func__,
"Fragmenter %p failed to parse reassembled packet to MetisMessage, dropping",
(void *) fragmenter);
}
_resetParser(fragmenter);
}
LONGBOW_TEST_CASE(Global, metisMessage_HasKeyId_False)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_InterestWithName, sizeof(metisTestDataV0_InterestWithName), 1, 2, logger);
metisLogger_Release(&logger);
bool hasKeyId = metisMessage_HasKeyId(message);
assertFalse(hasKeyId, "Message without a keyid says it does");
metisMessage_Release(&message);
}
LONGBOW_TEST_CASE(Global, metisMessage_HasKeyId_True)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
metisLogger_Release(&logger);
bool hasKeyId = metisMessage_HasKeyId(message);
assertTrue(hasKeyId, "Message with a keyid says it does not");
metisMessage_Release(&message);
}
LONGBOW_TEST_CASE(Global, metisMessage_HasContentObjectHash_False)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedInterest, sizeof(metisTestDataV0_EncodedInterest), 1, 2, logger);
metisLogger_Release(&logger);
bool hasHash = metisMessage_HasContentObjectHash(message);
assertTrue(hasHash, "Message without a content object hash says it does");
metisMessage_Release(&message);
}
/**
* Fragments a message and puts all the fragments in the send queue
*
* Splits up the message in to fragments. The frist fragment will have the B flag and
* the last fragment will have the E flag. If the message fits in one fragment, it will
* have both the BE flags. Middle messages have no flags.
*
* @param [in] fragmenter An allocated MetisHopByHopFragmenter
* @param [in] message The message to fragment down to MTU size
*
* @return true Message was fragmented and all fragments put on send queue
* @return false Error durring fragmentation (likley full send queue)
*
* Example:
* @code
* {
* <#example#>
* }
* @endcode
*/
static bool
_sendFragments(MetisHopByHopFragmenter *fragmenter, const MetisMessage *message)
{
const size_t length = metisMessage_Length(message);
size_t offset = 0;
const size_t maxPayload = fragmenter->mtu - sizeof(_HopByHopHeader);
_HopByHopHeader header;
memset(&header, 0, sizeof(header));
_hopByHopHeader_SetBFlag(&header);
while (offset < length) {
size_t payloadLength = maxPayload;
const size_t remaining = length - offset;
if (remaining < maxPayload) {
payloadLength = remaining;
_hopByHopHeader_SetEFlag(&header);
}
const size_t packetLength = sizeof(_HopByHopHeader) + payloadLength;
header.version = 1;
header.packetType = METIS_PACKET_TYPE_HOPFRAG;
header.packetLength = htons(packetLength);
header.headerLength = 8;
header.tlvType = htons(T_HOPFRAG_PAYLOAD);
header.tlvLength = htons(payloadLength);
uint32_t seqnum = _nextSendSequenceNumber(fragmenter);
_hopByHopHeader_SetSeqnum(&header, seqnum);
MetisMessage *fragment = metisMessage_Slice(message, offset, payloadLength, sizeof(header), (uint8_t *) &header);
bool goodput = parcRingBuffer1x1_Put(fragmenter->sendQueue, fragment);
if (!goodput) {
metisLogger_Log(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Warning, __func__,
"Fragmenter %p message %p send queue full offset %zu length %zu",
(void *) fragmenter, (void *) message, offset, payloadLength);
metisMessage_Release(&fragment);
break;
}
metisLogger_Log(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Debug, __func__,
"Fragmenter %p message %p send queue fragment %p offset %zu length %zu",
(void *) fragmenter, (void *) message, (void *) fragment, offset, payloadLength);
offset += payloadLength;
memset(&header, 0, sizeof(header));
}
return (offset == length);
}
LONGBOW_TEST_CASE(Global, metisMessage_HasHopLimit_False)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedInterest_no_hoplimit, sizeof(metisTestDataV0_EncodedInterest_no_hoplimit), 1, 2, logger);
metisLogger_Release(&logger);
bool hasHopLimit = metisMessage_HasHopLimit(message);
assertFalse(hasHopLimit, "Message without a hop limit says it does.");
metisMessage_Release(&message);
}
LONGBOW_TEST_CASE(Global, metisMessage_GetMessageType)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
metisLogger_Release(&logger);
MetisMessagePacketType type = metisMessage_GetType(message);
assertTrue(type == MetisMessagePacketType_ContentObject, "wrong type, expected %u got %u", MetisMessagePacketType_ContentObject, type);
metisMessage_Release(&message);
}
LONGBOW_TEST_CASE(Global, metisMessage_GetHopLimit)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedInterest, sizeof(metisTestDataV0_EncodedInterest), 1, 2, logger);
metisLogger_Release(&logger);
uint8_t hoplimit = metisMessage_GetHopLimit(message);
assertTrue(hoplimit == 32, "Wrong hop limit, got %u expected %u.", hoplimit, 32);
metisMessage_Release(&message);
}
LONGBOW_TEST_CASE(Global, metisMessage_HasInterestLifetime)
{
PARCEventBuffer *buff = parcEventBuffer_Create();
parcEventBuffer_Append(buff, metisTestDataV1_Interest_AllFields, sizeof(metisTestDataV1_Interest_AllFields));
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger);
metisLogger_Release(&logger);
assertTrue(metisMessage_HasInterestLifetime(message), "Should have returned true for interest lifetime");
metisMessage_Release(&message);
}
static void
metisConfiguration_SendResponse(MetisConfiguration *config, CCNxControl *response, unsigned egressId)
{
PARCBuffer *responseBuffer = metisTlv_EncodeControlPlaneInformation(response);
MetisMessage *tlvEncodedResponse = metisMessage_CreateFromParcBuffer(responseBuffer, 0, metisForwarder_GetTicks(config->metis), metisForwarder_GetLogger(config->metis));
parcBuffer_Release(&responseBuffer);
MetisConnectionTable *connectionTable = metisForwarder_GetConnectionTable(config->metis);
const MetisConnection *conn = metisConnectionTable_FindById(connectionTable, egressId);
assertNotNull(conn, "Got null connection for control message we just received");
metisConnection_Send(conn, tlvEncodedResponse);
metisMessage_Release(&tlvEncodedResponse);
}
LONGBOW_TEST_CASE(Global, metisMessage_CreateFromArray)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
metisLogger_Release(&logger);
assertNotNull(message, "Got null from metisMessage_CreateFromArray");
assertTrue(message->ingressConnectionId == 1, "IngressConnectionId wrong, expected %d got %u", 1, message->ingressConnectionId);
assertTrue(message->receiveTime == 2, "receiveTime wrong, expected %u got %" PRIu64, 2, message->receiveTime);
metisMessage_Release(&message);
}
LONGBOW_TEST_CASE(Global, metisMessage_GetName)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
metisLogger_Release(&logger);
MetisTlvName *name = metisMessage_GetName(message);
MetisTlvName *truth = metisTlvName_Create(&metisTestDataV0_EncodedObject[metisTestDataV0_EncodedObject_name.offset], metisTestDataV0_EncodedObject_name.length);
assertTrue(metisTlvName_Equals(truth, name), "Did not get back the right name");
metisTlvName_Release(&truth);
metisMessage_Release(&message);
}
LONGBOW_TEST_CASE(Global, metisMessage_ObjectHashHashCode_Lazy)
{
// create messages from content object, as those are precomputed
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
metisLogger_Release(&logger);
uint32_t hashcode;
bool success = metisMessage_GetContentObjectHashHash(a, &hashcode);
assertTrue(success, "Returned false trying to get hash of contentobject hash");
metisMessage_Release(&a);
}
LONGBOW_TEST_CASE(Global, metisMessage_Create_InterestV1)
{
PARCEventBuffer *buff = parcEventBuffer_Create();
parcEventBuffer_Append(buff, metisTestDataV1_Interest_AllFields, sizeof(metisTestDataV1_Interest_AllFields));
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger);
metisLogger_Release(&logger);
assertNotNull(message, "Got null from metisMessage_CreateFromBuffer");
assertTrue(message->ingressConnectionId == 1, "IngressConnectionId wrong, expected %d got %u", 1, message->ingressConnectionId);
assertTrue(message->receiveTime == 2, "receiveTime wrong, expected %u got %" PRIu64, 2, message->receiveTime);
metisMessage_Release(&message);
}
LONGBOW_TEST_CASE(Global, metisMessage_SetGetRecommendedCacheTime)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
// Note: Assumes metisTestDataV0_EncodedObject doesn't have RCT.
MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
metisLogger_Release(&logger);
uint64_t time = 12345;
metisMessage_SetRecommendedCacheTimeTicks(message, time);
assertTrue(time == metisMessage_GetRecommendedCacheTimeTicks(message), "Retrieved unexpected RCT");
metisMessage_Release(&message);
}
LONGBOW_TEST_CASE(Global, metisMessage_GetInterestLifetimeTicks)
{
PARCEventBuffer *buff = parcEventBuffer_Create();
parcEventBuffer_Append(buff, metisTestDataV1_Interest_AllFields, sizeof(metisTestDataV1_Interest_AllFields));
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger);
metisLogger_Release(&logger);
// don't check actual value. It will vary based on METISHZ and rouding errors due to integer math
MetisTicks ticks = metisMessage_GetInterestLifetimeTicks(message);
assertTrue(ticks > 0, "Should have gotten positive value for interest lifetime ticks");
metisMessage_Release(&message);
}
LONGBOW_TEST_CASE(Global, metisMessage_GetKeyIdHash)
{
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
metisLogger_Release(&logger);
uint32_t truthhash = parcHash32_Data(&metisTestDataV0_EncodedObject[metisTestDataV0_EncodedObject_keyid.offset], metisTestDataV0_EncodedObject_keyid.length);
uint32_t testhash;
bool success = metisMessage_GetKeyIdHash(message, &testhash);
assertTrue(success, "Failed metisMessage_GetKeyIdHash, returned false");
assertTrue(truthhash == testhash, "Hash compared wrong, expected %08X, got %08X", truthhash, testhash);
metisMessage_Release(&message);
}
LONGBOW_TEST_CASE(Global, metisMessage_Length)
{
char message_str[] = "\x00Once upon a time, in a stack far away, a dangling pointer found its way to the top of the heap.";
PARCEventBuffer *buff = parcEventBuffer_Create();
parcEventBuffer_Append(buff, message_str, sizeof(message_str));
PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
parcLogReporter_Release(&reporter);
MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger);
metisLogger_Release(&logger);
assertNotNull(message, "Got null from metisMessage_CreateFromBuffer");
size_t length = metisMessage_Length(message);
assertTrue(length == sizeof(message_str), "Wrong length, expected %zu got %zu", sizeof(message_str), length);
metisMessage_Release(&message);
}
void
metisContentStoreEntry_Release(MetisContentStoreEntry **entryPtr)
{
assertNotNull(entryPtr, "Parameter must be non-null double pointer");
assertNotNull(*entryPtr, "Parameter must dereference to non-null pointer");
MetisContentStoreEntry *entry = *entryPtr;
assertTrue(entry->refcount > 0, "Illegal state: has refcount of 0");
entry->refcount--;
if (entry->refcount == 0) {
if (entry->lruEntry) {
metisLruList_EntryDestroy(&entry->lruEntry);
}
metisMessage_Release(&entry->message);
parcMemory_Deallocate((void **) &entry);
}
*entryPtr = NULL;
}
