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; }