LONGBOW_TEST_CASE(Object, parcRandomAccessFile_Write) { char *fname = "tmpfile"; PARCFile *file = parcFile_Create(fname); parcFile_CreateNewFile(file); uint8_t data[128]; for (int i = 0; i < 128; i++) { data[i] = i; } PARCRandomAccessFile *instance = parcRandomAccessFile_Open(file); PARCBuffer *buffer = parcBuffer_Allocate(128); parcBuffer_PutArray(buffer, 128, data); parcBuffer_Flip(buffer); size_t numBytes = parcRandomAccessFile_Write(instance, buffer); assertTrue(numBytes == 128, "Expected 128 bytes to be read, but got %zu", numBytes); parcBuffer_Release(&buffer); parcRandomAccessFile_Close(instance); parcRandomAccessFile_Release(&instance); uint8_t bytes[128]; FILE *fp = fopen(fname, "r"); numBytes = fread(bytes, 1, 128, fp); assertTrue(numBytes == 128, "Expected 128 bytes to be read, but got %zu", numBytes); fclose(fp); assertTrue(memcmp(data, bytes, 128) == 0, "Expected buffers to be equal"); parcFile_Release(&file); }
CCNxInterestPayloadId * ccnxInterestPayloadId_CreateAsSHA256Hash(const PARCBuffer *data) { CCNxInterestPayloadId *result = parcObject_CreateInstance(CCNxInterestPayloadId); PARCCryptoHasher *hasher = parcCryptoHasher_Create(PARCCryptoHashType_SHA256); parcCryptoHasher_Init(hasher); parcCryptoHasher_UpdateBuffer(hasher, data); PARCCryptoHash *hash = parcCryptoHasher_Finalize(hasher); parcCryptoHasher_Release(&hasher); PARCBuffer *hashData = parcCryptoHash_GetDigest(hash); PARCBuffer *codedHash = parcBuffer_Allocate(parcBuffer_Capacity(hashData) + 1); parcBuffer_PutUint8(codedHash, CCNxInterestPayloadId_TypeCode_RFC6920_SHA256); parcBuffer_PutBuffer(codedHash, hashData); parcBuffer_Flip(codedHash); result->nameSegment = ccnxNameSegment_CreateTypeValue(CCNxNameLabelType_PAYLOADID, codedHash); parcBuffer_Release(&codedHash); parcCryptoHash_Release(&hash); return result; }
LONGBOW_TEST_CASE(Global, cpiAddress_CreateFromLink) { uint8_t mac[] = { 0x01, 0x02, 0x03, 0x04, 0xFF, 0x8F }; PARCBuffer *macbuffer = parcBuffer_Flip(parcBuffer_CreateFromArray(mac, sizeof(mac))); CPIAddress *address = cpiAddress_CreateFromLink(mac, sizeof(mac)); // Do not release test, it is the same reference as address->blob PARCBuffer *test = cpiAddress_GetLinkAddress(address); assertNotNull(test, "Got null link address buffer"); assertTrue(parcBuffer_Equals(test, address->blob), "Returned buffer from cpiAddress_GetLinkAddress not equal to address"); assertTrue(cpiAddress_GetType(address) == cpiAddressType_LINK, "Got wrong address type, expected %d, got %d", cpiAddressType_LINK, cpiAddress_GetType(address)); PARCJSON *json = cpiAddress_ToJson(address); CPIAddress *fromjson = cpiAddress_CreateFromJson(json); assertTrue(cpiAddress_GetType(address) == cpiAddress_GetType(fromjson), "fromjson type does not equal known"); assertTrue(parcBuffer_Equals(address->blob, fromjson->blob), "fromjson blob does not equal known address"); assertTrue(cpiAddress_Equals(address, fromjson), "cpiAddress_Equals broken for LINK type"); CPIAddress *copy = cpiAddress_Copy(address); assertTrue(cpiAddress_Equals(copy, address), "Copy and address not equal for LINK"); parcJSON_Release(&json); cpiAddress_Destroy(&address); cpiAddress_Destroy(©); cpiAddress_Destroy(&fromjson); parcBuffer_Release(&macbuffer); }
LONGBOW_TEST_CASE(Global, parc_Chunker_ReverseIterator_BufferSmall) { PARCBuffer *buffer = parcBuffer_Allocate(16); // Special 0xFF to mark the start for (int i = 0; i < 16; i++) { parcBuffer_PutUint8(buffer, 0xFF); } parcBuffer_Flip(buffer); PARCBufferChunker *chunker = parcBufferChunker_Create(buffer, 32); // each chunk is 32 bytes assertNotNull(chunker, "Expected non-NULL Chunker"); PARCIterator *itr = parcBufferChunker_ReverseIterator(chunker); size_t count = 0; while (parcIterator_HasNext(itr)) { PARCBuffer *payload = (PARCBuffer *) parcIterator_Next(itr); uint8_t *contents = parcBuffer_Overlay(payload, 0); for (size_t i = 0; i < 16; i++) { assertTrue(contents[i] == 0xFF, "Expected %zu at index %zu, got %d", (size_t) 0xFF, i, contents[i]); } count++; parcBuffer_Release(&payload); } assertTrue(count == 1, "Expected to iterate over 1 content objects from the chunker, but for %zu", count); parcIterator_Release(&itr); parcBufferChunker_Release(&chunker); parcBuffer_Release(&buffer); }
LONGBOW_TEST_CASE(Object, parcRandomAccessFile_Read) { char *fname = "tmpfile"; PARCFile *file = parcFile_Create(fname); parcFile_CreateNewFile(file); FILE *fp = fopen(fname, "w"); fseek(fp, 0, SEEK_SET); uint8_t data[128]; for (int i = 0; i < 128; i++) { data[i] = i; } fwrite(data, 1, 128, fp); fclose(fp); PARCRandomAccessFile *instance = parcRandomAccessFile_Open(file); parcFile_Release(&file); PARCBuffer *buffer = parcBuffer_Allocate(128); size_t numBytes = parcRandomAccessFile_Read(instance, buffer); assertTrue(numBytes == 128, "Expected 128 bytes to be read, but got %zu", numBytes); parcBuffer_Flip(buffer); uint8_t *bytes = parcBuffer_Overlay(buffer, parcBuffer_Remaining(buffer)); assertTrue(memcmp(data, bytes, 128) == 0, "Expected buffers to be equal"); parcBuffer_Release(&buffer); parcRandomAccessFile_Close(instance); parcRandomAccessFile_Release(&instance); }
LONGBOW_TEST_CASE(Global, parc_Chunker_ReverseIterator_Buffer) { PARCBuffer *buffer = parcBuffer_Allocate(1024); for (size_t i = 0; i < 32; i++) { for (size_t j = 0; j < 32; j++) { parcBuffer_PutUint8(buffer, i); } } parcBuffer_Flip(buffer); PARCBufferChunker *chunker = parcBufferChunker_Create(buffer, 32); // each chunk is 32 bytes assertNotNull(chunker, "Expected non-NULL Chunker"); PARCIterator *itr = parcBufferChunker_ReverseIterator(chunker); size_t count = 0; while (parcIterator_HasNext(itr)) { PARCBuffer *payload = (PARCBuffer *) parcIterator_Next(itr); uint8_t *contents = parcBuffer_Overlay(payload, 0); for (size_t i = 0; i < 32; i++) { assertTrue(contents[i] == (31 - count), "Expected %zu at index %zu, got %d", (31 - count), i, contents[i]); } count++; parcBuffer_Release(&payload); } assertTrue(count == 32, "Expected to iterate over 32 content objects from the chunker, but for %zu", count); parcIterator_Release(&itr); parcBufferChunker_Release(&chunker); parcBuffer_Release(&buffer); }
static PARCBuffer * _encodeControlPlaneInformation(const CCNxControl *cpiControlMessage) { PARCJSON *json = ccnxControl_GetJson(cpiControlMessage); char *str = parcJSON_ToCompactString(json); // include +1 because we need the NULL byte size_t len = strlen(str) + 1; size_t packetLength = sizeof(_MetisTlvFixedHeaderV0) + sizeof(MetisTlvType) + len; PARCBuffer *packet = parcBuffer_Allocate(packetLength); _MetisTlvFixedHeaderV0 hdr; memset(&hdr, 0, sizeof(hdr)); hdr.version = 0; hdr.packetType = METIS_PACKET_TYPE_CONTROL; hdr.payloadLength = htons(len + sizeof(MetisTlvType)); parcBuffer_PutArray(packet, sizeof(hdr), (uint8_t *) &hdr); MetisTlvType tlv = { .type = htons(T_CPI), .length = htons(len) }; parcBuffer_PutArray(packet, sizeof(tlv), (uint8_t *) &tlv); parcBuffer_PutArray(packet, len, (uint8_t *) str); parcMemory_Deallocate((void **) &str); return parcBuffer_Flip(packet); }
/** * If the user specified a device name, set the MAC address in ether->macAddress * * <#Paragraphs Of Explanation#> * * @param [in] ether An allocated MetisGenericEther * @param [in] devstr A C-String of the device name * * Example: * @code * <#example#> * @endcode */ static void _darwinEthernet_SetInterfaceAddress(MetisGenericEther *ether, const char *devstr) { if (devstr) { struct ifaddrs *ifaddr; int failure = getifaddrs(&ifaddr); assertFalse(failure, "Error getifaddrs: (%d) %s", errno, strerror(errno)); struct ifaddrs *next; for (next = ifaddr; next != NULL; next = next->ifa_next) { if (strcmp(next->ifa_name, devstr) == 0) { if (next->ifa_addr->sa_family == AF_LINK) { struct sockaddr_dl *addr_dl = (struct sockaddr_dl *) next->ifa_addr; // addr_dl->sdl_data[12] contains the interface name followed by the MAC address, so // need to offset in to the array past the interface name. PARCBuffer *addr = parcBuffer_Allocate(addr_dl->sdl_alen); parcBuffer_PutArray(addr, addr_dl->sdl_alen, (uint8_t *) &addr_dl->sdl_data[ addr_dl->sdl_nlen]); parcBuffer_Flip(addr); ether->macAddress = addr; // break out of loop and freeifaddrs break; } } } freeifaddrs(ifaddr); } }
PARCBuffer * parcLogFormatText_FormatEntry(const PARCLogEntry *entry) { PARCBuffer *payload = parcLogEntry_GetPayload(entry); char theTime[64]; parcTime_TimevalAsRFC3339(parcLogEntry_GetTimeStamp(entry), theTime); PARCBufferComposer *composer = parcBufferComposer_Allocate(128); parcBufferComposer_PutStrings(composer, theTime, " ", parcLogLevel_ToString(parcLogEntry_GetLevel(entry)), " ", parcLogEntry_GetHostName(entry), " ", parcLogEntry_GetApplicationName(entry), " ", parcLogEntry_GetProcessName(entry), " ", NULL); parcBufferComposer_Format(composer, "%" PRId64 " [ ", parcLogEntry_GetMessageId(entry)); parcBufferComposer_PutBuffer(composer, payload); parcBufferComposer_PutStrings(composer, " ]\n", NULL); PARCBuffer *result = parcBuffer_Flip(parcBuffer_Acquire(parcBufferComposer_GetBuffer(composer))); parcBufferComposer_Release(&composer); return result; }
LONGBOW_TEST_CASE(Global, ccnxCodecSchemaV1ManifestDecoder_DecodeType) { uint8_t rawManifest[40] = { 0x00, 0x07, 0x00, 0x24, 0x00, 0x02, 0x00, 0x20, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46 }; PARCBuffer *wireFormat = parcBuffer_Flip(parcBuffer_CreateFromArray(rawManifest, 40)); CCNxCodecTlvDecoder *decoder = ccnxCodecTlvDecoder_Create(wireFormat); CCNxTlvDictionary *dict = ccnxCodecSchemaV1TlvDictionary_CreateManifest(); uint16_t type = ccnxCodecTlvDecoder_GetType(decoder); uint16_t length = ccnxCodecTlvDecoder_GetLength(decoder); bool result = _decodeType(decoder, dict, type, length); assertTrue(result, "Expected the manifest type to be correctly decoded at the top level"); ccnxManifest_Release(&dict); ccnxCodecTlvDecoder_Destroy(&decoder); parcBuffer_Release(&wireFormat); }
static PARCSignature * _SignDigest(PARCPublicKeySigner *signer, const PARCCryptoHash *digestToSign) { parcSecurity_AssertIsInitialized(); assertNotNull(signer, "Parameter must be non-null CCNxFileKeystore"); assertNotNull(digestToSign, "Buffer to sign must not be null"); // TODO: what is the best way to expose this? PARCKeyStore *keyStore = signer->keyStore; PARCBuffer *privateKeyBuffer = parcKeyStore_GetDEREncodedPrivateKey(keyStore); EVP_PKEY *privateKey = NULL; size_t keySize = parcBuffer_Remaining(privateKeyBuffer); uint8_t *bytes = parcBuffer_Overlay(privateKeyBuffer, keySize); privateKey = d2i_PrivateKey(EVP_PKEY_RSA, &privateKey, (const unsigned char **) &bytes, keySize); parcBuffer_Release(&privateKeyBuffer); RSA *rsa = EVP_PKEY_get1_RSA(privateKey); int opensslDigestType; switch (parcCryptoHash_GetDigestType(digestToSign)) { case PARCCryptoHashType_SHA256: opensslDigestType = NID_sha256; break; case PARCCryptoHashType_SHA512: opensslDigestType = NID_sha512; break; default: trapUnexpectedState("Unknown digest type: %s", parcCryptoHashType_ToString(parcCryptoHash_GetDigestType(digestToSign))); } uint8_t *sig = parcMemory_Allocate(RSA_size(rsa)); assertNotNull(sig, "parcMemory_Allocate(%u) returned NULL", RSA_size(rsa)); unsigned sigLength = 0; PARCBuffer *bb_digest = parcCryptoHash_GetDigest(digestToSign); int result = RSA_sign(opensslDigestType, (unsigned char *) parcByteArray_Array(parcBuffer_Array(bb_digest)), (int) parcBuffer_Remaining(bb_digest), sig, &sigLength, rsa); assertTrue(result == 1, "Got error from RSA_sign: %d", result); RSA_free(rsa); PARCBuffer *bbSign = parcBuffer_Allocate(sigLength); parcBuffer_Flip(parcBuffer_PutArray(bbSign, sigLength, sig)); parcMemory_Deallocate((void **) &sig); PARCSignature *signature = parcSignature_Create(_GetSigningAlgorithm(signer), parcCryptoHash_GetDigestType(digestToSign), bbSign ); parcBuffer_Release(&bbSign); return signature; }
int reader_writer(CCNxPortalFactory *factory, const char *uri) { CCNxPortal *portal = ccnxPortalFactory_GetInstance(factory, ccnxPortalTypeDatagram, ccnxPortalProtocol_TLV, &ccnxPortalAttributes_Blocking); CCNxName *prefix = ccnxName_CreateFromURI(uri); CCNxName *bye = ccnxName_CreateFromURI("lci:/Hello/Goodbye%21"); CCNxName *contentname = ccnxName_CreateFromURI("lci:/Hello/World"); if (ccnxPortal_Listen(portal, prefix, 365 * 86400, CCNxStackTimeout_Never)) { CCNxMetaMessage *msg; while ((msg = ccnxPortal_Receive(portal, CCNxStackTimeout_Never)) != NULL) { if (ccnxMetaMessage_IsInterest(msg)) { CCNxInterest *interest = ccnxMetaMessage_GetInterest(msg); CCNxName *interestName = ccnxInterest_GetName(interest); if (ccnxName_Equals(interestName, contentname)) { const PARCKeyId *publisherKeyId = ccnxPortal_GetKeyId(portal); char buffer[128]; time_t theTime = time(0); sprintf(buffer, "Hello World. The time is %s", ctime(&theTime)); PARCBuffer *payload = parcBuffer_CreateFromArray(buffer, 128); parcBuffer_Flip(payload); PARCBuffer *b = parcBuffer_Acquire(payload); CCNxContentObject *uob = ccnxContentObject_CreateWithDataPayload(contentname, b); // missing NULL check, case 1024 CCNxMetaMessage *message = ccnxMetaMessage_CreateFromContentObject(uob); if (ccnxPortal_Send(portal, message, CCNxTransportStackTimeCCNxStackTimeout_Neverout_Never) == false) { fprintf(stderr, "ccnx_write failed\n"); } // ccnxMessage_Release(message); } else if (ccnxName_Equals(interestName, bye)) { break; } } else { ccnxMetaMessage_Display(msg, 0); } ccnxMetaMessage_Release(&msg); } } ccnxName_Release(&prefix); ccnxName_Release(&bye); ccnxName_Release(&contentname); ccnxPortal_Release(&portal); return 0; }
static PARCCryptoHash * _GetPublickKeyDigest(PARCPkcs12KeyStore *keystore) { parcSecurity_AssertIsInitialized(); assertNotNull(keystore, "Parameter must be non-null PARCPkcs12KeyStore"); if (keystore->public_key_digest == NULL) { AUTHORITY_KEYID *akid = X509_get_ext_d2i(keystore->x509_cert, NID_authority_key_identifier, NULL, NULL); if (akid != NULL) { ASN1_OCTET_STRING *skid = X509_get_ext_d2i(keystore->x509_cert, NID_subject_key_identifier, NULL, NULL); if (skid != NULL) { keystore->public_key_digest = parcBuffer_PutArray(parcBuffer_Allocate(skid->length), skid->length, skid->data); parcBuffer_Flip(keystore->public_key_digest); ASN1_OCTET_STRING_free(skid); } AUTHORITY_KEYID_free(akid); } } // If we could not load the digest from the certificate, then calculate it from the public key. if (keystore->public_key_digest == NULL) { uint8_t digestBuffer[SHA256_DIGEST_LENGTH]; int result = ASN1_item_digest(ASN1_ITEM_rptr(X509_PUBKEY), EVP_sha256(), X509_get_X509_PUBKEY(keystore->x509_cert), digestBuffer, NULL); if (result != 1) { assertTrue(0, "Could not compute digest over certificate public key"); } else { keystore->public_key_digest = parcBuffer_PutArray(parcBuffer_Allocate(SHA256_DIGEST_LENGTH), SHA256_DIGEST_LENGTH, digestBuffer); parcBuffer_Flip(keystore->public_key_digest); } } // This stores a reference, so keystore->public_key_digest will remain valid // even if the cryptoHasher is destroyed return parcCryptoHash_Create(PARC_HASH_SHA256, keystore->public_key_digest); }
/** * Create a symmetric (secret) key of the given bit length (e.g. 256) * * Example: * @code * <#example#> * @endcode */ PARCBuffer * parcSymmetricSignerFileStore_CreateKey(unsigned bits) { assertTrue((bits & 0x07) == 0, "bits must be a multiple of 8"); unsigned keylength = bits / 8; uint8_t buffer[keylength]; RAND_bytes(buffer, keylength); return parcBuffer_Flip(parcBuffer_PutArray(parcBuffer_Allocate(keylength), keylength, buffer)); }
CCNxNameSegment * ccnxNameSegment_CreateTypeValueArray(CCNxNameLabelType type, size_t length, const char array[length]) { PARCBuffer *value = parcBuffer_PutArray(parcBuffer_Allocate(length), length, (const uint8_t *) array); parcBuffer_Flip(value); CCNxNameSegment *result = ccnxNameSegment_CreateTypeValue(type, value); parcBuffer_Release(&value); return result; }
PARCBuffer * parcBuffer_AllocateCString(const char *string) { size_t length = strlen(string); PARCBuffer *buffer = parcBuffer_Allocate(length + 1); parcBuffer_PutArray(buffer, length, (const uint8_t *) string); parcBuffer_PutUint8(buffer, 0); parcBuffer_SetPosition(buffer, buffer->position - 1); parcBuffer_Flip(buffer); return buffer; }
static void * _ccnxChunker_NextFromBuffer(PARCBufferChunker *chunker, _ChunkerState *state) { size_t chunkSize = state->nextChunkSize; parcBuffer_SetPosition(chunker->data, state->position); PARCBuffer *slice = parcBuffer_CreateFromArray(parcBuffer_Overlay(chunker->data, chunkSize), chunkSize); slice = parcBuffer_Flip(slice); _advanceState(chunker, state); return slice; }
LONGBOW_TEST_CASE(Object, parcRandomAccessFile_Seek) { char *fname = "tmpfile"; PARCFile *file = parcFile_Create(fname); parcFile_CreateNewFile(file); FILE *fp = fopen(fname, "w"); fseek(fp, 0, SEEK_SET); uint8_t data[128]; for (int i = 0; i < 128; i++) { data[i] = i; } fwrite(data, 1, 128, fp); fclose(fp); PARCRandomAccessFile *instance = parcRandomAccessFile_Open(file); PARCBuffer *buffer = parcBuffer_Allocate(128); parcRandomAccessFile_Seek(instance, 64, PARCRandomAccessFilePosition_Start); size_t numBytes = parcRandomAccessFile_Read(instance, buffer); assertTrue(numBytes == 64, "Expected 64 bytes to be read, but got %zu", numBytes); parcRandomAccessFile_Seek(instance, 0, PARCRandomAccessFilePosition_End); parcBuffer_Flip(buffer); numBytes = parcRandomAccessFile_Read(instance, buffer); assertTrue(numBytes == 0, "Expected 0 bytes to be read, but got %zu", numBytes); parcRandomAccessFile_Seek(instance, 0, PARCRandomAccessFilePosition_Start); parcBuffer_Flip(buffer); numBytes = parcRandomAccessFile_Read(instance, buffer); assertTrue(numBytes == 128, "Expected 128 bytes to be read, but got %zu", numBytes); parcBuffer_Release(&buffer); parcRandomAccessFile_Close(instance); parcRandomAccessFile_Release(&instance); parcFile_Release(&file); }
static CCNxTlvDictionary * createSignedContentObject(void) { CCNxName *name = ccnxName_CreateFromURI("lci:/some/name"); PARCBuffer *payload = parcBuffer_Flip(parcBuffer_PutArray(parcBuffer_Allocate(20), 11, (uint8_t *) "the payload")); CCNxTlvDictionary *contentObject = ccnxContentObject_CreateWithDataPayload(name, payload); parcBuffer_Release(&payload); ccnxName_Release(&name); PARCBuffer *keyid = parcBuffer_Flip(parcBuffer_PutArray(parcBuffer_Allocate(20), 5, (uint8_t *) "keyid")); ccnxValidationRsaSha256_Set(contentObject, keyid, NULL); parcBuffer_Release(&keyid); PARCBuffer *sigbits = parcBuffer_WrapCString("the signature"); PARCSignature *signature = parcSignature_Create(PARCSigningAlgorithm_RSA, PARC_HASH_SHA256, parcBuffer_Flip(sigbits)); ccnxContentObject_SetSignature(contentObject, keyid, signature, NULL); parcSignature_Release(&signature); parcBuffer_Release(&sigbits); return contentObject; }
PARCURISegment * parcURISegment_Create(size_t length, const unsigned char segment[length]) { PARCURISegment *result = NULL; PARCBuffer *buffer = parcBuffer_Allocate(length); if (buffer != NULL) { parcBuffer_PutArray(buffer, length, segment); parcBuffer_Flip(buffer); result = parcURISegment_CreateFromBuffer(buffer); parcBuffer_Release(&buffer); } return result; }
static void * _parcChunker_NextFromBuffer(PARCFileChunker *chunker, _ChunkerState *state) { size_t chunkSize = state->nextChunkSize; parcRandomAccessFile_Seek(chunker->fhandle, state->position, PARCRandomAccessFilePosition_Start); PARCBuffer *slice = parcBuffer_Allocate(chunkSize); parcRandomAccessFile_Read(chunker->fhandle, slice); slice = parcBuffer_Flip(slice); _advanceState(chunker, state); return slice; }
LONGBOW_TEST_CASE(Global, parc_Chunker_ForwardIterator_BufferPartial) { // Allocate something that's not divisible by the chunk size PARCBuffer *buffer = parcBuffer_Allocate(1030); for (size_t i = 0; i < 32; i++) { for (size_t j = 0; j < 32; j++) { parcBuffer_PutUint8(buffer, i); } } // Special 0xFF to mark the end... for (int i = 0; i < 6; i++) { parcBuffer_PutUint8(buffer, 0xFF); } parcBuffer_Flip(buffer); PARCBufferChunker *chunker = parcBufferChunker_Create(buffer, 32); // each chunk is 32 bytes assertNotNull(chunker, "Expected non-NULL Chunker"); PARCIterator *itr = parcBufferChunker_ForwardIterator(chunker); size_t count = 0; while (parcIterator_HasNext(itr)) { PARCBuffer *payload = (PARCBuffer *) parcIterator_Next(itr); uint8_t *contents = parcBuffer_Overlay(payload, 0); if (count < 32) { for (size_t i = 0; i < 32; i++) { assertTrue(contents[i] == count, "Expected %zu at index %zu, got %d", count, i, contents[i]); } } else { for (size_t i = 0; i < 6; i++) { assertTrue(contents[i] == 0xFF, "Expected %zu at index %zu, got %d", (size_t) 0xFF, i, contents[i]); } } count++; parcBuffer_Release(&payload); } assertTrue(count == 33, "Expected to iterate over 33 content objects from the chunker, but for %zu", count); parcIterator_Release(&itr); parcBufferChunker_Release(&chunker); parcBuffer_Release(&buffer); }
CCNxInterestPayloadId * ccnxInterestPayloadId_Create(const PARCBuffer *data, uint8_t type) { CCNxInterestPayloadId *result = parcObject_CreateInstance(CCNxInterestPayloadId); parcBuffer_AssertValid(data); PARCBuffer *buffer = parcBuffer_Allocate(parcBuffer_Capacity(data) + 1); assertTrue(type > CCNxInterestPayloadId_TypeCode_App, "App type must be greater than 0x80"); parcBuffer_PutUint8(buffer, type); parcBuffer_PutBuffer(buffer, data); parcBuffer_Flip(buffer); result->nameSegment = ccnxNameSegment_CreateTypeValue(CCNxNameLabelType_PAYLOADID, buffer); parcBuffer_Release(&buffer); return result; }
static PARCCryptoHash * _GetCertificateDigest(PARCPkcs12KeyStore *keystore) { parcSecurity_AssertIsInitialized(); assertNotNull(keystore, "Parameter must be non-null PARCPkcs12KeyStore"); if (keystore->certificate_digest == NULL) { uint8_t digestBuffer[SHA256_DIGEST_LENGTH]; int result = X509_digest(keystore->x509_cert, EVP_sha256(), digestBuffer, NULL); if (result) { keystore->certificate_digest = parcBuffer_Flip(parcBuffer_PutArray(parcBuffer_Allocate(SHA256_DIGEST_LENGTH), SHA256_DIGEST_LENGTH, digestBuffer)); } } PARCCryptoHash *hash = parcCryptoHash_Create(PARC_HASH_SHA256, keystore->certificate_digest); return hash; }
LONGBOW_TEST_CASE(Global, parcNetwork_LinkAddress_Parse_dashes) { char *expected = "link://01-23-45-67-89-ab"; PARCBuffer *address = parcNetwork_ParseLinkAddress(expected); parcBuffer_Flip(address); PARCBuffer *e = parcBuffer_Wrap((uint8_t []) { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab }, 6, 0, 6); parcBuffer_SetPosition(address, 0); parcBuffer_SetLimit(address, 6); parcBuffer_SetPosition(e, 0); parcBuffer_SetLimit(e, 6); assertTrue(parcBuffer_Equals(address, e), "Expected result failed."); parcBuffer_Release(&e); parcBuffer_Release(&address); }
/** * Create a PARCBuffer payload containing a JSON string with information about this ContentStore's * size. */ static PARCBuffer * _createStatSizeResponsePayload(const AthenaLRUContentStore *impl, const CCNxName *name, uint64_t chunkNumber) { PARCJSON *json = parcJSON_Create(); parcJSON_AddString(json, "moduleName", AthenaContentStore_LRUImplementation.description); parcJSON_AddInteger(json, "time", parcClock_GetTime(impl->wallClock)); parcJSON_AddInteger(json, "numEntries", impl->numEntries); parcJSON_AddInteger(json, "sizeInBytes", impl->currentSizeInBytes); char *jsonString = parcJSON_ToString(json); parcJSON_Release(&json); PARCBuffer *result = parcBuffer_CreateFromArray(jsonString, strlen(jsonString)); parcMemory_Deallocate(&jsonString); return parcBuffer_Flip(result); }
static PARCBuffer * _GetDEREncodedPrivateKey(PARCPkcs12KeyStore *keystore) { parcSecurity_AssertIsInitialized(); assertNotNull(keystore, "Parameter must be non-null PARCPkcs12KeyStore"); if (keystore->private_key_der == NULL) { uint8_t *der = NULL; // this allocates memory for der int derLength = i2d_PrivateKey(keystore->private_key, &der); if (derLength > 0) { keystore->private_key_der = parcBuffer_Flip(parcBuffer_PutArray(parcBuffer_Allocate(derLength), derLength, der)); } OPENSSL_free(der); } return parcBuffer_Copy(keystore->private_key_der); }
static CCNxMetaMessage * _create_stats_response(Athena *athena, CCNxName *ccnxName) { PARCJSON *json = parcJSON_Create(); struct timeval tv; gettimeofday(&tv, NULL); uint64_t nowInMillis = (tv.tv_sec * 1000) + (tv.tv_usec / 1000); parcJSON_AddString(json, "moduleName", athenaAbout_Name()); parcJSON_AddInteger(json, "time", nowInMillis); parcJSON_AddInteger(json, "numProcessedInterests", athena->stats.numProcessedInterests); parcJSON_AddInteger(json, "numProcessedContentObjects", athena->stats.numProcessedContentObjects); parcJSON_AddInteger(json, "numProcessedControlMessages", athena->stats.numProcessedControlMessages); parcJSON_AddInteger(json, "numProcessedInterestReturns", athena->stats.numProcessedInterestReturns); char *jsonString = parcJSON_ToString(json); parcJSON_Release(&json); PARCBuffer *payload = parcBuffer_CreateFromArray(jsonString, strlen(jsonString)); parcMemory_Deallocate(&jsonString); CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(ccnxName, parcBuffer_Flip(payload)); ccnxContentObject_SetExpiryTime(contentObject, nowInMillis + 100); // this response is good for 100 millis CCNxMetaMessage *result = ccnxMetaMessage_CreateFromContentObject(contentObject); ccnxContentObject_Release(&contentObject); parcBuffer_Release(&payload); return result; }
static void _stressTestNext(PARCSecureRandom *rng) { PARCLinkedList *seen = parcLinkedList_Create(); size_t duplicates = 0; for (size_t i = 0; i < NUM_TESTS; i++) { uint32_t next = parcSecureRandom_Next(rng); PARCBuffer *buffer = parcBuffer_Allocate(sizeof(next)); parcBuffer_Flip(parcBuffer_PutUint32(buffer, next)); if (parcLinkedList_Contains(seen, buffer)) { duplicates++; } else { parcLinkedList_Append(seen, buffer); } parcBuffer_Release(&buffer); } assertFalse(duplicates > (NUM_TESTS * EPSILON), "The RNG failed to generate random values: saw %zu duplicates", duplicates); parcLinkedList_Release(&seen); }
static PARCBuffer * _iovecToParcBuffer(const CCNxCodecNetworkBufferIoVec *iovec) { PARCBuffer *result = NULL; size_t iovcnt = ccnxCodecNetworkBufferIoVec_GetCount((CCNxCodecNetworkBufferIoVec *) iovec); const struct iovec *array = ccnxCodecNetworkBufferIoVec_GetArray((CCNxCodecNetworkBufferIoVec *) iovec); size_t totalbytes = 0; for (int i = 0; i < iovcnt; i++) { totalbytes += array[i].iov_len; } result = parcBuffer_Allocate(totalbytes); for (int i = 0; i < iovcnt; i++) { parcBuffer_PutArray(result, array[i].iov_len, array[i].iov_base); } parcBuffer_Flip(result); return result; }