LONGBOW_TEST_CASE(Global, ccnxInterest_Equals)
{
CCNxName *nameA = ccnxName_CreateFromURI("lci:/name");
PARCBuffer *keyA = parcBuffer_Allocate(8);
parcBuffer_PutUint64(keyA, 1234L);
CCNxInterest *interestA = ccnxInterest_Create(nameA,
1000, /* lifetime */
keyA, /* KeyId */
NULL /* ContentObjectHash */
);
CCNxName *nameB = ccnxName_CreateFromURI("lci:/name");
PARCBuffer *keyB = parcBuffer_Allocate(8);
parcBuffer_PutUint64(keyB, 1234L);
CCNxInterest *interestB = ccnxInterest_Create(nameB,
1000, /* lifetime */
keyB, /* KeyId */
NULL /* ContentObjectHash */
);
assertTrue(ccnxInterest_Equals(interestA, interestB), "Expected equivalent interests to be equal.");
ccnxName_Release(&nameA);
ccnxName_Release(&nameB);
parcBuffer_Release(&keyA);
parcBuffer_Release(&keyB);
ccnxInterest_Release(&interestA);
ccnxInterest_Release(&interestB);
}
LONGBOW_TEST_CASE(Global, parcSignature_Equals)
{
PARCBuffer *bits = parcBuffer_Allocate(10); // arbitrary bufer size -- not important
PARCBuffer *otherBits = parcBuffer_Allocate(strlen("hello"));
parcBuffer_PutArray(otherBits, strlen("hello"), (uint8_t *) "hello");
PARCSignature *x = parcSignature_Create(PARCSigningAlgorithm_DSA, PARC_HASH_SHA256, bits);
PARCSignature *y = parcSignature_Create(PARCSigningAlgorithm_DSA, PARC_HASH_SHA256, bits);
PARCSignature *z = parcSignature_Create(PARCSigningAlgorithm_DSA, PARC_HASH_SHA256, bits);
PARCSignature *unequal1 = parcSignature_Create(PARCSigningAlgorithm_HMAC, PARC_HASH_SHA256, bits);
PARCSignature *unequal2 = parcSignature_Create(PARCSigningAlgorithm_DSA, PARC_HASH_CRC32C, bits);
PARCSignature *unequal3 = parcSignature_Create(PARCSigningAlgorithm_DSA, PARC_HASH_SHA256, otherBits);
parcObjectTesting_AssertEqualsFunction(parcSignature_Equals, x, y, z, unequal1, unequal2, unequal3, NULL);
parcSignature_Release(&x);
parcSignature_Release(&y);
parcSignature_Release(&z);
parcSignature_Release(&unequal1);
parcSignature_Release(&unequal2);
parcSignature_Release(&unequal3);
parcBuffer_Release(&bits);
parcBuffer_Release(&otherBits);
}
LONGBOW_TEST_CASE(Global, ccnxLink_Equals)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar/name");
PARCBuffer *keyId = parcBuffer_Allocate(10);
PARCBuffer *contentObjectHash = parcBuffer_Allocate(20);
CCNxLink *x = ccnxLink_Create(name, keyId, contentObjectHash);
ccnxName_Release(&name);
parcBuffer_Release(&keyId);
parcBuffer_Release(&contentObjectHash);
name = ccnxName_CreateFromCString("lci:/foo/bar/name");
keyId = parcBuffer_Allocate(10);
contentObjectHash = parcBuffer_Allocate(20);
CCNxLink *y = ccnxLink_Create(name, keyId, contentObjectHash);
ccnxName_Release(&name);
parcBuffer_Release(&keyId);
parcBuffer_Release(&contentObjectHash);
name = ccnxName_CreateFromCString("lci:/foo/bar/name");
keyId = parcBuffer_Allocate(10);
contentObjectHash = parcBuffer_Allocate(20);
CCNxLink *z = ccnxLink_Create(name, keyId, contentObjectHash);
ccnxName_Release(&name);
parcBuffer_Release(&keyId);
parcBuffer_Release(&contentObjectHash);
name = ccnxName_CreateFromCString("lci:/foo/bar/othername");
keyId = parcBuffer_Allocate(10);
contentObjectHash = parcBuffer_Allocate(20);
CCNxLink *unequal1 = ccnxLink_Create(name, keyId, contentObjectHash);
ccnxName_Release(&name);
parcBuffer_Release(&keyId);
parcBuffer_Release(&contentObjectHash);
name = ccnxName_CreateFromCString("lci:/foo/bar/name");
keyId = NULL;
contentObjectHash = parcBuffer_Allocate(20);
CCNxLink *unequal2 = ccnxLink_Create(name, keyId, contentObjectHash);
ccnxName_Release(&name);
parcBuffer_Release(&contentObjectHash);
name = ccnxName_CreateFromCString("lci:/foo/bar/name");
keyId = parcBuffer_Allocate(10);
contentObjectHash = NULL;
CCNxLink *unequal3 = ccnxLink_Create(name, keyId, contentObjectHash);
ccnxName_Release(&name);
parcBuffer_Release(&keyId);
assertEqualsContract(ccnxLink_Equals, x, y, z, unequal1, unequal2, unequal3);
ccnxLink_Release(&x);
ccnxLink_Release(&y);
ccnxLink_Release(&z);
ccnxLink_Release(&unequal1);
ccnxLink_Release(&unequal2);
ccnxLink_Release(&unequal3);
}
LONGBOW_TEST_CASE(Local, _athenaLRUContentStore_GetMatchByName)
{
AthenaLRUContentStore *impl = _createLRUContentStore();
PARCBuffer *payload = parcBuffer_Allocate(500);
CCNxName *name = ccnxName_CreateFromURI("lci:/boose/roo/pie");
CCNxContentObject *contentObject = ccnxContentObject_CreateWithDataPayload(name, payload);
parcBuffer_Release(&payload);
bool status = _athenaLRUContentStore_PutContentObject(impl, contentObject);
assertTrue(status, "Expected to put content into the store");
PARCBuffer *payload2 = parcBuffer_Allocate(500);
CCNxName *name2 = ccnxName_CreateFromURI("lci:/roo/pie/boose");
CCNxContentObject *contentObject2 = ccnxContentObject_CreateWithDataPayload(name2, payload2);
parcBuffer_Release(&payload2);
bool status2 = _athenaLRUContentStore_PutContentObject(impl, contentObject2);
assertTrue(status2, "Expected to put content into the store");
// At this point, both objects should be in the store.
athenaLRUContentStore_Display(impl, 2);
assertTrue(impl->stats.numAdds == 2, "Expected 2 store adds");
// Now try to fetch each of them.
CCNxInterest *interest1 = ccnxInterest_CreateSimple(name);
CCNxContentObject *match = _athenaLRUContentStore_GetMatch(impl, interest1);
assertTrue(match == contentObject, "Expected to match the first content object");
CCNxInterest *interest2 = ccnxInterest_CreateSimple(name2);
CCNxContentObject *match2 = _athenaLRUContentStore_GetMatch(impl, interest2);
assertTrue(match2 == contentObject2, "Expected to match the second content object");
// Now try to match a non-existent name.
CCNxName *nameNoMatch = ccnxName_CreateFromURI("lci:/pie/roo/boose/this/should/not/match");
CCNxInterest *interest3 = ccnxInterest_CreateSimple(nameNoMatch);
CCNxContentObject *noMatch = _athenaLRUContentStore_GetMatch(impl, interest3);
assertNull(noMatch, "Expected a NULL response from an unmatchable name");
ccnxInterest_Release(&interest1);
ccnxInterest_Release(&interest2);
ccnxInterest_Release(&interest3);
ccnxName_Release(&nameNoMatch);
ccnxName_Release(&name);
ccnxName_Release(&name2);
ccnxContentObject_Release(&contentObject);
ccnxContentObject_Release(&contentObject2);
_athenaLRUContentStore_Release((AthenaContentStoreImplementation *) &impl);
}
LONGBOW_TEST_CASE(Global, ccnxLink_AcquireRelease)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar/name");
PARCBuffer *keyId = parcBuffer_Allocate(10);
PARCBuffer *contentObjectHash = parcBuffer_Allocate(10);
CCNxLink *object = ccnxLink_Create(name, keyId, contentObjectHash);
parcObjectTesting_AssertAcquireReleaseContract(ccnxLink_Acquire, object);
ccnxLink_Release(&object);
ccnxName_Release(&name);
parcBuffer_Release(&keyId);
parcBuffer_Release(&contentObjectHash);
}
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(Local, putTooBig)
{
AthenaLRUContentStoreConfig config;
config.capacityInMB = 1;
AthenaLRUContentStore *impl = _athenaLRUContentStore_Create(&config);
size_t payloadSize = 2 * 1024 * 1024; // 2M
PARCBuffer *payload = parcBuffer_Allocate(payloadSize);
CCNxContentObject *content = _createContentObject("lci:/this/is/content", 10, payload);
assertNotNull(content, "Expected to allocated a content object");
bool status = _athenaLRUContentStore_PutContentObject(impl, content);
assertFalse(status, "Expected insertion of too large a content object to fail.");
ccnxContentObject_Release(&content);
parcBuffer_Release(&payload);
// Make sure that the contentobjects were added, but that the size didn't grow past the capacity
assertTrue(impl->currentSizeInBytes == 0, "expected the current store size to be 0.");
_athenaLRUContentStore_Release((AthenaContentStoreImplementation *) &impl);
}
LONGBOW_TEST_CASE(Local, putContentAndEnforceCapacity)
{
AthenaLRUContentStore *impl = _createLRUContentStore();
size_t lastSizeOfStore = 0;
size_t payloadSize = 100 * 1024;
_athenaLRUContentStore_SetCapacity(impl, 1); // set to 1 MB, or ~10 of our payloads
PARCBuffer *payload = parcBuffer_Allocate(payloadSize); // 1M buffer
int i;
for (i = 0; i < 20; i++) { // Add more than 10 items.
CCNxContentObject *content = _createContentObject("lci:/this/is/content", i, payload);
assertNotNull(content, "Expected to allocated a content object");
bool status = _athenaLRUContentStore_PutContentObject(impl, content);
assertTrue(status, "Expected to be able to insert content");
assertTrue(impl->currentSizeInBytes > lastSizeOfStore, "expected store size in bytes to grow");
ccnxContentObject_Release(&content);
}
// Make sure that the contentobjects were added, but that the size didn't grow past the capacity
assertTrue(impl->currentSizeInBytes < (11 * payloadSize), "expected the current store size to be less than 11 x payload size");
assertTrue(impl->currentSizeInBytes >= (10 * payloadSize), "expected the current store size to be roughly 10 x payload size");
parcBuffer_Release(&payload);
_athenaLRUContentStore_Release((AthenaContentStoreImplementation *) &impl);
}
/**
* 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);
}
}
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);
}
LONGBOW_TEST_CASE(Global, ccnxInterest_SetLifetime)
{
CCNxName *name = ccnxName_CreateFromURI("lci:/name");
PARCBuffer *key = parcBuffer_Allocate(8);
parcBuffer_PutUint64(key, 1234L);
uint32_t lifetime = 5000; // 5 seconds, in milliseconds
CCNxInterest *interest = ccnxInterest_Create(name,
lifetime, /* lifetime */
key, /* KeyId */
NULL /* ContentObjectHash */
);
uint32_t actual = ccnxInterest_GetLifetime(interest);
assertTrue(actual == lifetime, "Expected the retrieved lifetime to be equal to the assigned one.");
lifetime = 2000;
ccnxInterest_SetLifetime(interest, lifetime);
actual = ccnxInterest_GetLifetime(interest);
assertTrue(actual == lifetime, "Expected the retrieved lifetime to be equal to the assigned one.");
ccnxName_Release(&name);
parcBuffer_Release(&key);
ccnxInterest_Release(&interest);
}
LONGBOW_TEST_CASE(Global, ccnxInterest_SetContentObjectHashRestriction)
{
CCNxName *name = ccnxName_CreateFromURI("lci:/name");
PARCBuffer *coh = parcBuffer_Allocate(8);
parcBuffer_PutUint64(coh, 77573L);
CCNxInterest *interest = ccnxInterest_Create(name, CCNxInterestDefault_LifetimeMilliseconds, NULL, NULL);
PARCBuffer *actual = ccnxInterest_GetContentObjectHashRestriction(interest);
assertNull(actual, "Expected retrieved ContentObjectHash to be initially NULL");
ccnxInterest_SetContentObjectHashRestriction(interest, coh);
actual = ccnxInterest_GetContentObjectHashRestriction(interest);
assertTrue(actual == coh, "Expected retrieved ContentObjectHash to be the same as assigned");
// Re-setting is not yet supported. At the moment, you can only put the COHR once.
// Now change it, and validate.
//PARCBuffer *coh2 = parcBuffer_Allocate(8);
//parcBuffer_PutUint64(coh2, 3262L);
//ccnxInterest_SetContentObjectHashRestriction(interest, coh2);
//actual = ccnxInterest_GetContentObjectHashRestriction(interest);
//assertTrue(actual == coh2, "Expected retrieved ContentObjectHash to be the same as assigned");
ccnxName_Release(&name);
ccnxInterest_Release(&interest);
parcBuffer_Release(&coh);
//parcBuffer_Release(&coh2);
}
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, ccnxLink_Create_Full)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar/name");
PARCBuffer *keyId = parcBuffer_Allocate(10);
PARCBuffer *contentObjectHash = parcBuffer_Allocate(10);
CCNxLink *object = ccnxLink_Create(name, keyId, contentObjectHash);
assertNotNull(object, "Expected non-null return value.");
ccnxLink_Release(&object);
ccnxName_Release(&name);
parcBuffer_Release(&keyId);
parcBuffer_Release(&contentObjectHash);
}
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);
}
LONGBOW_TEST_CASE(Global, ccnxContentObject_GetPayloadType)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/name");
PARCBuffer *payload = parcBuffer_Allocate(100);
CCNxPayloadType types[] = {
CCNxPayloadType_DATA,
CCNxPayloadType_KEY,
CCNxPayloadType_LINK,
CCNxPayloadType_MANIFEST,
};
for (int i = 0; i < sizeof(types) / sizeof(CCNxPayloadType); i++) {
CCNxPayloadType type = types[i];
CCNxContentObject *contentObject = ccnxContentObject_CreateWithDataPayload(name, NULL);
ccnxContentObject_SetPayload(contentObject, type, payload);
assertTrue(ccnxContentObject_GetPayloadType(contentObject) == type, "Unexpected PayloadType");
ccnxContentObject_Release(&contentObject);
}
parcBuffer_Release(&payload);
ccnxName_Release(&name);
}
LONGBOW_TEST_CASE(Global, ccnxContentObject_AcquireRelease)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
PARCBuffer *payload = parcBuffer_Allocate(100);
CCNxContentObject *contentObject = ccnxContentObject_CreateWithDataPayload(name, payload);
ccnxContentObject_AssertValid(contentObject);
CCNxContentObject *reference = ccnxContentObject_Acquire(contentObject);
assertTrue(reference == contentObject, "Expected acquired reference to be equal to original");
ccnxName_Release(&name);
parcBuffer_Release(&payload);
ccnxContentObject_AssertValid(contentObject);
ccnxContentObject_AssertValid(reference);
ccnxContentObject_Release(&contentObject);
assertTrue(contentObject == NULL, "Expected contentObject pointer to be null");
ccnxContentObject_AssertValid(reference);
ccnxContentObject_Release(&reference);
assertTrue(reference == NULL, "Expected contentObject pointer to be null");
}
static PARCBuffer *
_createDerivedKey(const char *key, size_t keylength, unsigned char *salt, unsigned int saltlen)
{
unsigned char buffer[SHA256_DIGEST_LENGTH];
HMAC(EVP_sha256(), key, (int) keylength, salt, saltlen, buffer, NULL);
return parcBuffer_PutArray(parcBuffer_Allocate(SHA256_DIGEST_LENGTH), SHA256_DIGEST_LENGTH, buffer);
}
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);
}
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(Global, ccnxContentObject_Equals)
{
CCNxName *nameA = ccnxName_CreateFromCString("lci:/foo/bar/A");
PARCBuffer *payloadA = parcBuffer_Allocate(100);
CCNxContentObject *objectA = ccnxContentObject_CreateWithDataPayload(nameA, payloadA);
ccnxContentObject_AssertValid(objectA);
assertTrue(ccnxContentObject_Equals(objectA, objectA), "Expected same instance to be equal");
CCNxContentObject *objectA2 = ccnxContentObject_CreateWithDataPayload(nameA, payloadA);
ccnxContentObject_AssertValid(objectA2);
assertTrue(ccnxContentObject_Equals(objectA, objectA2), "Expected ContentObject with same payload and name to be equal");
CCNxName *nameB = ccnxName_CreateFromCString("lci:/foo/bar/B");
CCNxContentObject *objectB = ccnxContentObject_CreateWithDataPayload(nameB, payloadA);
ccnxContentObject_AssertValid(objectB);
assertFalse(ccnxContentObject_Equals(objectA, objectB), "Expected ContentObject with same payload and different name");
ccnxName_Release(&nameA);
ccnxName_Release(&nameB);
parcBuffer_Release(&payloadA);
ccnxContentObject_Release(&objectA);
ccnxContentObject_Release(&objectA2);
ccnxContentObject_Release(&objectB);
}
LONGBOW_TEST_CASE(Local, _athenaLRUContentStore_PutManyContentObjects)
{
AthenaLRUContentStore *impl = _createLRUContentStore();
PARCBuffer *payload = parcBuffer_Allocate(1200);
int numEntriesToPut = 100;
for (int i = 0; i < numEntriesToPut; i++) {
// Re-use the payload per contentObject, though the store will think each is seperate (for size calculations)
CCNxContentObject *contentObject = _createContentObject("lci:/boose/roo/pie", i, payload);
bool status = _athenaLRUContentStore_PutContentObject(impl, contentObject);
assertTrue(status, "Expected CO %d to be put in to the store", i);
ccnxContentObject_Release(&contentObject);
}
assertTrue(impl->numEntries == numEntriesToPut, "Expected the numbe of entries put in the store to match");
// Now put the same ones (by name) again. These should kick out the old ones.
for (int i = 0; i < numEntriesToPut; i++) {
// Re-use the payload per contentObject, though the store will think each is seperate (for size calculations)
CCNxContentObject *contentObject = _createContentObject("lci:/boose/roo/pie", i, payload);
bool status = _athenaLRUContentStore_PutContentObject(impl, contentObject);
assertTrue(status, "Expected CO %d to be put in to the store", i);
ccnxContentObject_Release(&contentObject);
}
assertTrue(impl->numEntries == numEntriesToPut, "Expected the numbe of entries put in the store to match");
parcBuffer_Release(&payload);
athenaLRUContentStore_Display(impl, 0);
_athenaLRUContentStore_Release((AthenaContentStoreImplementation *) &impl);
}
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;
}
LONGBOW_TEST_CASE(Global, ccnxLink_Create_ToString)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar/name");
PARCBuffer *keyId = parcBuffer_Allocate(10);
PARCBuffer *contentObjectHash = parcBuffer_Allocate(20);
CCNxLink *object = ccnxLink_Create(name, keyId, contentObjectHash);
char *string = ccnxLink_ToString(object);
assertNotNull(string, "Expected non-null string.");
parcMemory_Deallocate((void **) &string);
ccnxLink_Release(&object);
ccnxName_Release(&name);
parcBuffer_Release(&keyId);
parcBuffer_Release(&contentObjectHash);
}
LONGBOW_TEST_CASE(Global, ccnxLink_GetName)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar/name");
PARCBuffer *keyId = parcBuffer_Allocate(10);
PARCBuffer *contentObjectHash = parcBuffer_Allocate(10);
CCNxLink *object = ccnxLink_Create(name, keyId, contentObjectHash);
const CCNxName *actualName = ccnxLink_GetName(object);
assertNotNull(actualName, "Expected non-null return value.");
assertTrue(ccnxName_Equals(name, actualName), "Expected the same name back");
ccnxLink_Release(&object);
ccnxName_Release(&name);
parcBuffer_Release(&keyId);
parcBuffer_Release(&contentObjectHash);
}
LONGBOW_TEST_CASE(Global, ccnxLink_GetContentObjectHash)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar/name");
PARCBuffer *keyId = parcBuffer_Allocate(10);
PARCBuffer *contentObjectHash = parcBuffer_Allocate(20);
CCNxLink *object = ccnxLink_Create(name, keyId, contentObjectHash);
PARCBuffer *buffer = ccnxLink_GetContentObjectHash(object);
assertNotNull(buffer, "Expected non-null return value.");
assertTrue(parcBuffer_Capacity(buffer) == 20, "Expected the same buffer size back");
ccnxLink_Release(&object);
ccnxName_Release(&name);
parcBuffer_Release(&keyId);
parcBuffer_Release(&contentObjectHash);
}
LONGBOW_TEST_CASE(Specialization, parcSecureRandom_CreateWithSeed)
{
PARCBuffer *seed = parcBuffer_Allocate(1024);
PARCSecureRandom *rng = parcSecureRandom_CreateWithSeed(seed);
assertTrue(parcSecureRandom_IsValid(rng), "Expected parcSecureRandom_CreateWithSeed to result in a valid instance.");
parcSecureRandom_Release(&rng);
parcBuffer_Release(&seed);
}
/**
* 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));
}
LONGBOW_TEST_CASE(Global, ccnxWireFormatMessage_FromInterestPacketType)
{
PARCBuffer *buffer = parcBuffer_Allocate(10);
CCNxWireFormatMessage *message = ccnxWireFormatMessage_FromInterestPacketType(CCNxTlvDictionary_SchemaVersion_V1, buffer);
assertTrue(ccnxTlvDictionary_IsInterest((CCNxTlvDictionary *) message), "Wrong message type");
ccnxWireFormatMessage_Release(&message);
parcBuffer_Release(&buffer);
}
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);
}
