LONGBOW_TEST_CASE(Global, athenaTransportLinkModuleUDP_P2P)
{
PARCURI *connectionURI;
const char *result;
AthenaTransportLinkAdapter *athenaTransportLinkAdapter = athenaTransportLinkAdapter_Create(_removeLink, NULL);
assertNotNull(athenaTransportLinkAdapter, "athenaTransportLinkAdapter_Create returned NULL");
connectionURI = parcURI_Parse("udp://localhost:40001/src=localhost:40002/name=UDP_0");
result = athenaTransportLinkAdapter_Open(athenaTransportLinkAdapter, connectionURI);
assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed (%s)", strerror(errno));
parcURI_Release(&connectionURI);
connectionURI = parcURI_Parse("udp://localhost:40002/src=localhost:40001/name=UDP_1");
result = athenaTransportLinkAdapter_Open(athenaTransportLinkAdapter, connectionURI);
assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed (%s)", strerror(errno));
parcURI_Release(&connectionURI);
CCNxName *name = ccnxName_CreateFromURI("lci:/foo/bar");
CCNxMetaMessage *ccnxMetaMessage = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
PARCBitVector *sendVector = parcBitVector_Create();
int linkId = athenaTransportLinkAdapter_LinkNameToId(athenaTransportLinkAdapter, "UDP_1");
parcBitVector_Set(sendVector, linkId);
athena_EncodeMessage(ccnxMetaMessage);
PARCBitVector *resultVector;
resultVector = athenaTransportLinkAdapter_Send(athenaTransportLinkAdapter, ccnxMetaMessage, sendVector);
assertNotNull(resultVector, "athenaTransportLinkAdapter_Send failed");
parcBitVector_Release(&resultVector);
ccnxMetaMessage_Release(&ccnxMetaMessage);
parcBitVector_Release(&sendVector);
usleep(1000);
ccnxMetaMessage = athenaTransportLinkAdapter_Receive(athenaTransportLinkAdapter, &resultVector, 0);
assertNotNull(resultVector, "athenaTransportLinkAdapter_Receive failed");
assertTrue(parcBitVector_NumberOfBitsSet(resultVector) == 1, "athenaTransportLinkAdapter_Receive return message with more than one ingress link");
assertNotNull(ccnxMetaMessage, "athenaTransportLinkAdapter_Receive failed to provide message");
parcBitVector_Release(&resultVector);
ccnxMetaMessage_Release(&ccnxMetaMessage);
athenaTransportLinkAdapter_Destroy(&athenaTransportLinkAdapter);
}
LONGBOW_TEST_CASE(Global, ccnxPortal_Receive_NeverTimeout_Hang)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
CCNxPortal *portalIn = ccnxPortalFactory_CreatePortal(data->factory, TEST_STACK);
CCNxMetaMessage *message = ccnxPortal_Receive(portalIn, CCNxStackTimeout_Never);
ccnxMetaMessage_Release(&message);
ccnxPortal_Release(&portalIn);
}
LONGBOW_TEST_CASE(Global, athenaTransportLinkModuleUDP_MTU)
{
PARCURI *connectionURI;
const char *result;
AthenaTransportLinkAdapter *athenaTransportLinkAdapter = athenaTransportLinkAdapter_Create(_removeLink, NULL);
assertNotNull(athenaTransportLinkAdapter, "athenaTransportLinkAdapter_Create returned NULL");
connectionURI = parcURI_Parse("udp://127.0.0.1:40000/Listener/name=UDPListener/mtu=");
result = athenaTransportLinkAdapter_Open(athenaTransportLinkAdapter, connectionURI);
assertTrue(result == NULL, "athenaTransportLinkAdapter_Open failed to detect improper MTU (%s)", strerror(errno));
parcURI_Release(&connectionURI);
connectionURI = parcURI_Parse("udp://127.0.0.1:40000/Listener/name=UDPListener/mtu=20");
result = athenaTransportLinkAdapter_Open(athenaTransportLinkAdapter, connectionURI);
assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed (%s)", strerror(errno));
parcURI_Release(&connectionURI);
connectionURI = parcURI_Parse("udp://127.0.0.1:40000/name=UDP_1/mtu=20");
result = athenaTransportLinkAdapter_Open(athenaTransportLinkAdapter, connectionURI);
assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed (%s)", strerror(errno));
parcURI_Release(&connectionURI);
athenaTransportLinkAdapter_Poll(athenaTransportLinkAdapter, 0);
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
CCNxMetaMessage *ccnxMetaMessage = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
PARCBitVector *sendVector = parcBitVector_Create();
int linkId = athenaTransportLinkAdapter_LinkNameToId(athenaTransportLinkAdapter, "UDP_1");
parcBitVector_Set(sendVector, linkId);
athena_EncodeMessage(ccnxMetaMessage);
PARCBitVector *resultVector;
resultVector = athenaTransportLinkAdapter_Send(athenaTransportLinkAdapter, ccnxMetaMessage, sendVector);
assertTrue(parcBitVector_NumberOfBitsSet(resultVector) == 0, "athenaTransportLinkAdapter_Send should have failed");
assertTrue(errno == EMSGSIZE, "athenaTransportLinkAdapter_Send should have failed with EMSGSIZE (%d): %s", errno, strerror(errno));
parcBitVector_Release(&resultVector);
ccnxMetaMessage_Release(&ccnxMetaMessage);
parcBitVector_Release(&sendVector);
usleep(1000);
ccnxMetaMessage = athenaTransportLinkAdapter_Receive(athenaTransportLinkAdapter, &resultVector, 0);
assertNull(ccnxMetaMessage, "athenaTransportLinkAdapter_Receive should have failed");
int closeResult = athenaTransportLinkAdapter_CloseByName(athenaTransportLinkAdapter, "UDPListener");
assertTrue(closeResult == 0, "athenaTransportLinkAdapter_CloseByName failed (%s)", strerror(errno));
closeResult = athenaTransportLinkAdapter_CloseByName(athenaTransportLinkAdapter, "UDP_1");
assertTrue(closeResult == 0, "athenaTransportLinkAdapter_CloseByName failed (%s)", strerror(errno));
athenaTransportLinkAdapter_Destroy(&athenaTransportLinkAdapter);
}
LONGBOW_TEST_CASE(Global, ccnxMetaMessage_CreateFromInterest)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
CCNxMetaMessage *portalMessage = ccnxMetaMessage_CreateFromInterest(interest);
assertNotNull(portalMessage, "Expected a non-null portal message");
ccnxMetaMessage_Release(&portalMessage);
ccnxInterest_Release(&interest);
ccnxName_Release(&name);
}
int
ccnServe(const PARCIdentity *identity, const CCNxName *listenName, const char *commandString)
{
parcSecurity_Init();
CCNxPortalFactory *factory = ccnxPortalFactory_Create(identity);
CCNxPortal *portal = ccnxPortalFactory_CreatePortal(factory, ccnxPortalRTA_Message);
assertNotNull(portal, "Expected a non-null CCNxPortal pointer.");
if (ccnxPortal_Listen(portal, listenName, 365 * 86400, CCNxStackTimeout_Never)) {
while (true) {
CCNxMetaMessage *request = ccnxPortal_Receive(portal, CCNxStackTimeout_Never);
if (request == NULL) {
break;
}
CCNxInterest *interest = ccnxMetaMessage_GetInterest(request);
if (interest != NULL) {
CCNxName *interestName = ccnxInterest_GetName(interest);
PARCBuffer *payload = makePayload(interestName, commandString);
CCNxContentObject *contentObject = ccnxContentObject_CreateWithDataPayload(interestName, payload);
CCNxMetaMessage *message = ccnxMetaMessage_CreateFromContentObject(contentObject);
if (ccnxPortal_Send(portal, message, CCNxStackTimeout_Never) == false) {
fprintf(stderr, "ccnxPortal_Write failed: %d\n", ccnxPortal_GetError(portal));
}
{
char *name = ccnxName_ToString(interestName);
time_t theTime = time(0);
char *time = ctime(&theTime);
printf("%24.24s %s\n", time, name);
parcMemory_Deallocate((void **) &name);
}
parcBuffer_Release(&payload);
}
ccnxMetaMessage_Release(&request);
}
}
ccnxPortal_Release(&portal);
ccnxPortalFactory_Release(&factory);
parcSecurity_Fini();
return 0;
}
LONGBOW_TEST_CASE(Global, Hello)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
CCNxPortal *portal = ccnxPortalFactory_CreatePortal(data->factory, TEST_STACK);
CCNxPortal *portalIn = ccnxPortalFactory_CreatePortal(data->factory, TEST_STACK);
assertNotNull(portal, "Expected a non-null CCNxPortal pointer.");
CCNxName *name = ccnxName_CreateFromCString("lci:/Hello/World");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
CCNxMetaMessage *interestMessage = ccnxMetaMessage_CreateFromInterest(interest);
if (ccnxPortal_Send(portal, interestMessage, CCNxStackTimeout_Never)) {
for (int responses = 0; responses == 0; ) {
CCNxMetaMessage *message = ccnxPortal_Receive(portalIn, CCNxStackTimeout_Never);
if (message != NULL) {
if (ccnxMetaMessage_IsContentObject(message)) {
CCNxContentObject *contentObject = ccnxMetaMessage_GetContentObject(message);
PARCBuffer *payload = ccnxContentObject_GetPayload(contentObject);
if (parcBuffer_HasRemaining(payload) == false) {
fprintf(stderr, "**************** Content object has arrived WITH EMPTY CONTENT\n");
} else {
char *string = parcBuffer_ToString(payload);
fprintf(stderr, "**************** Content object has arrived: %s\n", string);
parcMemory_Deallocate((void **)&string);
}
responses++;
}
ccnxMetaMessage_Release(&message);
}
}
}
ccnxMetaMessage_Release(&interestMessage);
ccnxPortal_Release(&portal);
}
LONGBOW_TEST_CASE(Global, ccnxMetaMessage_GetInterest)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
CCNxMetaMessage *portalMessage = ccnxMetaMessage_CreateFromInterest(interest);
CCNxInterest *reference = ccnxMetaMessage_GetInterest(portalMessage);
assertTrue(ccnxInterest_Equals(interest, reference), "Expected reference to equal original interest");
ccnxInterest_AssertValid(reference);
ccnxInterest_Release(&reference);
ccnxMetaMessage_Release(&portalMessage);
ccnxName_Release(&name);
}
LONGBOW_TEST_CASE(Global, ccnxMetaMessage_CreateFromContentObject)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
PARCBuffer *payload = parcBuffer_WrapCString("This is some data. It's not good data, but it is data.");
CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(name, payload);
CCNxMetaMessage *portalMessage = ccnxMetaMessage_CreateFromContentObject(contentObject);
assertNotNull(portalMessage, "Expected a non-null portal message");
ccnxMetaMessage_Release(&portalMessage);
ccnxContentObject_Release(&contentObject);
parcBuffer_Release(&payload);
ccnxName_Release(&name);
}
LONGBOW_TEST_CASE(Global, ccnxMetaMessage_Acquire_Release)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
CCNxMetaMessage *portalMessage = ccnxMetaMessage_CreateFromInterest(interest);
CCNxMetaMessage *ref1 = ccnxMetaMessage_Acquire(portalMessage);
CCNxMetaMessage *ref2 = ccnxMetaMessage_Acquire(portalMessage);
CCNxMetaMessage *ref3 = ccnxMetaMessage_Acquire(portalMessage);
ccnxMetaMessage_Release(&ref1);
assertNull(ref1, "Expected pointer to pointer to be null after Release()");
ccnxMetaMessage_Release(&ref2);
assertNull(ref2, "Expected pointer to pointer to be null after Release()");
ccnxMetaMessage_Release(&ref3);
assertNull(ref3, "Expected pointer to pointer to be null after Release()");
ccnxMetaMessage_Release(&portalMessage);
ccnxInterest_Release(&interest);
ccnxName_Release(&name);
}
LONGBOW_TEST_CASE(Global, ccnxPortal_Receive_NeverTimeout)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
CCNxPortal *portalOut = ccnxPortalFactory_CreatePortal(data->factory, TEST_STACK);
CCNxPortal *portalIn = ccnxPortalFactory_CreatePortal(data->factory, TEST_STACK);
CCNxName *name = ccnxName_CreateFromCString("lci:/Hello/World");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
CCNxMetaMessage *interestMessage = ccnxMetaMessage_CreateFromInterest(interest);
ccnxInterest_Release(&interest);
if (ccnxPortal_Send(portalOut, interestMessage, CCNxStackTimeout_Never)) {
ccnxMetaMessage_Release(&interestMessage);
CCNxMetaMessage *message = ccnxPortal_Receive(portalIn, CCNxStackTimeout_Never);
ccnxMetaMessage_Release(&message);
}
ccnxPortal_Release(&portalIn);
ccnxPortal_Release(&portalOut);
}
LONGBOW_TEST_CASE(Global, ccnxMetaMessage_IsInterest)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
CCNxMetaMessage *portalMessage = ccnxMetaMessage_CreateFromInterest(interest);
assertTrue(ccnxMetaMessage_IsInterest(portalMessage), "Expected portal message to be an Interest");
assertFalse(ccnxMetaMessage_IsContentObject(portalMessage), "Did not expect portal message to be a ContentObject");
assertFalse(ccnxMetaMessage_IsControl(portalMessage), "Did not expect portal message to be a Control message");
ccnxMetaMessage_Release(&portalMessage);
ccnxInterest_Release(&interest);
ccnxName_Release(&name);
}
LONGBOW_TEST_CASE(Global, rtaApiConnection_SendToApi)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
RtaApiConnection *apiConnection = rtaConnection_GetPrivateData(data->connection, API_CONNECTOR);
TransportMessage *tm = trafficTools_CreateTransportMessageWithDictionaryInterest(data->connection, CCNxTlvDictionary_SchemaVersion_V1);
RtaComponentStats *stats = rtaConnection_GetStats(data->connection, API_CONNECTOR);
rtaApiConnection_SendToApi(apiConnection, tm, stats);
rtaFramework_NonThreadedStepCount(data->framework, 10);
// Let the dispatcher run
struct pollfd pfd = { .fd = data->api_fds[PAIR_OTHER], .events = POLLIN, .revents = 0 };
int millisecondTimeout = 1000;
int pollvalue = poll(&pfd, 1, millisecondTimeout);
assertTrue(pollvalue == 1, "Did not get an event from the API's side of the socket");
CCNxMetaMessage *testMessage;
ssize_t bytesRead = read(data->api_fds[PAIR_OTHER], &testMessage, sizeof(testMessage));
assertTrue(bytesRead == sizeof(testMessage), "Wrong read size, got %zd expected %zd: (%d) %s",
bytesRead, sizeof(testMessage),
errno, strerror(errno));
assertNotNull(testMessage, "Message read is NULL");
assertTrue(testMessage == transportMessage_GetDictionary(tm),
"Got wrong raw message, got %p expected %p",
(void *) testMessage, (void *) transportMessage_GetDictionary(tm));
ccnxMetaMessage_Release(&testMessage);
transportMessage_Destroy(&tm);
}
LONGBOW_TEST_CASE(Global, rtaApiConnection_BlockDown)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
RtaApiConnection *apiConnection = rtaApiConnection_Create(data->connection);
// make sure we're startined unblocked
short enabled = parcEventQueue_GetEnabled(apiConnection->bev_api);
assertTrue(enabled & PARCEventType_Read, "PARCEventType_Read is not enabled on a new Api Connector: enabled = %04X", enabled);
rtaApiConnection_BlockDown(apiConnection);
enabled = parcEventQueue_GetEnabled(apiConnection->bev_api);
assertFalse(enabled & PARCEventType_Read, "PARCEventType_Read is still enabled after caling BlockDown: enabled = %04X", enabled);
rtaApiConnection_Destroy(&apiConnection);
}
LONGBOW_TEST_CASE(Global, processMessage)
{
AthenaLRUContentStoreConfig config;
config.capacityInMB = 10;
AthenaContentStore *store = athenaContentStore_Create(&AthenaContentStore_LRUImplementation, &config);
CCNxName *name = ccnxName_CreateFromURI(CCNxNameAthena_ContentStore "/stat/size");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
CCNxMetaMessage *message = ccnxMetaMessage_CreateFromInterest(interest);
athena_EncodeMessage(message);
CCNxMetaMessage *result = athenaContentStore_ProcessMessage(store, message);
assertNotNull(result, "Expected a response from the store");
ccnxMetaMessage_Release(&result);
ccnxMetaMessage_Release(&message);
ccnxInterest_Release(&interest);
ccnxName_Release(&name);
athenaContentStore_Release(&store);
}
LONGBOW_TEST_CASE(Global, ccnxPortalStack_Send)
{
CCNxPortalStack *stack = (CCNxPortalStack *) longBowTestCase_GetClipBoardData(testCase);
CCNxName *name = ccnxName_Create();
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
CCNxMetaMessage *message = ccnxMetaMessage_CreateFromInterest(interest);
ccnxInterest_Release(&interest);
bool result = ccnxPortalStack_Send(stack, message, CCNxStackTimeout_Never);
ccnxMetaMessage_Release(&message);
assertTrue(result, "Expected ccnxPortalStack_Ignore to return true.");
}
static void
_UDPLinkData_Destroy(_UDPLinkData **linkData)
{
// remove any queued messages
if ((*linkData)->queue) {
while (parcDeque_Size((*linkData)->queue) > 0) {
CCNxMetaMessage *ccnxMetaMessage = parcDeque_RemoveFirst((*linkData)->queue);
ccnxMetaMessage_Release(&ccnxMetaMessage);
}
parcDeque_Release(&((*linkData)->queue));
}
if ((*linkData)->multiplexTable) {
parcHashCodeTable_Destroy(&((*linkData)->multiplexTable));
}
parcMemory_Deallocate(linkData);
}
LONGBOW_TEST_CASE(Global, ccnxMetaMessage_IsContentObject)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
PARCBuffer *payload = parcBuffer_WrapCString("This is some data. It's not good data, but it is data.");
CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(name, payload);
CCNxMetaMessage *portalMessage = ccnxMetaMessage_CreateFromContentObject(contentObject);
assertTrue(ccnxMetaMessage_IsContentObject(portalMessage), "Expected portal message to be an ContentObject");
assertFalse(ccnxMetaMessage_IsInterest(portalMessage), "Did not expect portal message to be an Interest");
assertFalse(ccnxMetaMessage_IsControl(portalMessage), "Did not expect portal message to be a Control message");
ccnxMetaMessage_Release(&portalMessage);
ccnxContentObject_Release(&contentObject);
parcBuffer_Release(&payload);
ccnxName_Release(&name);
}
//
// Receive a message from a point to point link.
//
static CCNxMetaMessage *
_ETHReceive(AthenaTransportLink *athenaTransportLink)
{
struct _ETHLinkData *linkData = athenaTransportLink_GetPrivateData(athenaTransportLink);
struct ether_addr peerAddress;
socklen_t peerAddressLength;
CCNxMetaMessage *ccnxMetaMessage = _ETHReceiveMessage(athenaTransportLink, &peerAddress, &peerAddressLength);
// If the souce does not match my configured link peer address, drop the message
if (memcmp(&linkData->link.peerAddress, &peerAddress, peerAddressLength) != 0) {
linkData->_stats.receive_PeerNotConfigured++;
ccnxMetaMessage_Release(&ccnxMetaMessage);
return NULL;
}
return ccnxMetaMessage;
}
static int
_athenactl_UnSetDebug(PARCIdentity *identity, int argc, char **argv)
{
CCNxName *name = ccnxName_CreateFromURI(CCNxNameAthenaCommand_Set "/" AthenaCommand_LogLevel "/" AthenaCommand_LogInfo);
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
const char *result = _athenactl_SendInterestControl(identity, interest);
if (result) {
printf("%s\n", result);
parcMemory_Deallocate(&result);
}
ccnxMetaMessage_Release(&interest);
return 0;
}
int
consumer(void)
{
parcSecurity_Init();
CCNxPortalFactory *factory = setupConsumerFactory();
CCNxPortal *portal = ccnxPortalFactory_CreatePortal(factory, ccnxPortalRTA_Message);
assertNotNull(portal, "Expected a non-null CCNxPortal pointer.");
CCNxName *name = ccnxName_CreateFromCString("lci:/Hello/World");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
CCNxMetaMessage *message = ccnxMetaMessage_CreateFromInterest(interest);
if (ccnxPortal_Send(portal, message,CCNxStackTimeout_Never)) {
while (ccnxPortal_IsError(portal) == false) {
CCNxMetaMessage *response = ccnxPortal_Receive(portal,CCNxStackTimeout_Never);
if (response != NULL) {
if (ccnxMetaMessage_IsContentObject(response)) {
CCNxContentObject *contentObject = ccnxMetaMessage_GetContentObject(response);
PARCBuffer *payload = ccnxContentObject_GetPayload(contentObject);
char *string = parcBuffer_ToString(payload);
printf("%s\n", string);
parcMemory_Deallocate((void **)&string);
break;
}
}
ccnxMetaMessage_Release(&response);
}
}
ccnxPortal_Release(&portal);
ccnxPortalFactory_Release(&factory);
parcSecurity_Fini();
return 0;
}
static int
_athenactl_ListFIB(PARCIdentity *identity, int argc, char **argv)
{
CCNxName *name = ccnxName_CreateFromURI(CCNxNameAthenaCommand_FIBList);
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
const char *result = _athenactl_SendInterestControl(identity, interest);
if (result) {
PARCJSON *jsonContent = parcJSON_ParseString(result);
if (jsonContent != NULL) {
PARCJSONValue *resultValue = parcJSON_GetValueByName(jsonContent, JSON_KEY_RESULT);
PARCJSONArray *fibEntryList = parcJSONValue_GetArray(resultValue);
size_t fibEntryListLength = parcJSONArray_GetLength(fibEntryList);
printf("Routes (%d):\n", (int) fibEntryListLength);
if (fibEntryListLength == 0) {
printf(" No Entries\n");
}
for (size_t i = 0; i < fibEntryListLength; ++i) {
PARCJSONValue *elementValue = parcJSONArray_GetValue(fibEntryList, i);
PARCJSON *valueObj = parcJSONValue_GetJSON(elementValue);
PARCJSONValue *value = parcJSON_GetValueByName(valueObj, JSON_KEY_NAME);
char *prefixString = parcBuffer_ToString(parcJSONValue_GetString(value));
value = parcJSON_GetValueByName(valueObj, JSON_KEY_LINK);
char *linkString = parcBuffer_ToString(parcJSONValue_GetString(value));
printf(" %s -> %s\n", prefixString, linkString);
parcMemory_Deallocate(&prefixString);
parcMemory_Deallocate(&linkString);
}
parcJSON_Release(&jsonContent);
} else {
printf("Returned value is not JSON: %s\n", result);
}
parcMemory_Deallocate(&result);
} else {
printf("NULL result recieved from route List request\n");
}
ccnxMetaMessage_Release(&interest);
return 0;
}
LONGBOW_TEST_CASE(Global, ccnxPortal_GetFileId)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
CCNxPortal *portal = ccnxPortalFactory_CreatePortal(data->factory, TEST_STACK);
CCNxName *name = ccnxName_CreateFromCString("lci:/Hello/World");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
CCNxMetaMessage *message = ccnxMetaMessage_CreateFromInterest(interest);
ccnxInterest_Release(&interest);
ccnxPortal_Send(portal, message, CCNxStackTimeout_Never);
ccnxMetaMessage_Release(&message);
ccnxPortal_Flush(portal, CCNxStackTimeout_Never);
int fileId = ccnxPortal_GetFileId(portal);
assertTrue(fileId != -1, "Expected ccnxPortal_GetFileId to not return -1");
ccnxPortal_Release(&portal);
}
static int
_athenactl_Quit(PARCIdentity *identity, int argc, char **argv)
{
CCNxName *name = ccnxName_CreateFromURI(CCNxNameAthenaCommand_Quit);
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
PARCBuffer *payload = parcBuffer_AllocateCString("exit");
ccnxInterest_SetPayload(interest, payload);
parcBuffer_Release(&payload);
const char *result = _athenactl_SendInterestControl(identity, interest);
if (result) {
printf("%s\n", result);
parcMemory_Deallocate(&result);
}
ccnxMetaMessage_Release(&interest);
return 0;
}
int
ccnGet(PARCIdentity *identity, CCNxName *name)
{
CCNxPortalFactory *factory = ccnxPortalFactory_Create(identity);
CCNxPortal *portal = ccnxPortalFactory_CreatePortal(factory, ccnxPortalRTA_Message);
assertNotNull(portal, "Expected a non-null CCNxPortal pointer.");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
CCNxMetaMessage *message = ccnxMetaMessage_CreateFromInterest(interest);
if (ccnxPortal_Send(portal, message, CCNxStackTimeout_Never)) {
while (ccnxPortal_IsError(portal) == false) {
CCNxMetaMessage *response = ccnxPortal_Receive(portal, CCNxStackTimeout_Never);
if (response != NULL) {
if (ccnxMetaMessage_IsContentObject(response)) {
CCNxContentObject *contentObject = ccnxMetaMessage_GetContentObject(response);
PARCBuffer *payload = ccnxContentObject_GetPayload(contentObject);
size_t length = parcBuffer_Remaining(payload);
ssize_t nwritten = write(1, parcBuffer_Overlay(payload, length), length);
assertTrue(nwritten == length, "Did not write whole buffer, got %zd expected %zu", nwritten, length);
break;
}
ccnxMetaMessage_Release(&response);
}
}
}
ccnxPortal_Release(&portal);
ccnxPortalFactory_Release(&factory);
return 0;
}
LONGBOW_TEST_CASE(Global, ccnxMetaMessage_GetContentObject)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
PARCBuffer *payload = parcBuffer_WrapCString("This is some data. It's not good data, but it is data.");
CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(name, payload);
CCNxMetaMessage *portalMessage = ccnxMetaMessage_CreateFromContentObject(contentObject);
CCNxContentObject *reference = ccnxMetaMessage_GetContentObject(portalMessage);
#ifndef BUGZID_712
// TODO: We need a ccnxContentObject_Equals()!
// assertTrue(ccnxContentObject_Equals(contentObject, reference), "Expected reference to equal original contentObject");
#endif // !BUGZID_712
ccnxContentObject_AssertValid(reference);
ccnxMetaMessage_Release(&portalMessage);
ccnxContentObject_Release(&contentObject);
parcBuffer_Release(&payload);
ccnxName_Release(&name);
}
LONGBOW_TEST_CASE(Global, ccnxMetaMessage_EncodeDecode)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
PARCSigner *signer = ccnxValidationCRC32C_CreateSigner(); // Would really be SHA256 or something.
// Encode it to wire format.
PARCBuffer *wireFormatBuffer = ccnxMetaMessage_CreateWireFormatBuffer(interest, signer);
// Now decode it from wireformat.
CCNxMetaMessage *decodedMessage = ccnxMetaMessage_CreateFromWireFormatBuffer(wireFormatBuffer);
// At this point, the unpacked dictionary should be equivalent to the original interest.
assertTrue(ccnxInterest_Equals(interest, decodedMessage), "Expected an equivalent interest to be unpacked");
parcBuffer_Release(&wireFormatBuffer);
ccnxInterest_Release(&interest);
ccnxMetaMessage_Release(&decodedMessage);
parcSigner_Release(&signer);
}
LONGBOW_TEST_CASE(Global, ccnxPortal_IsEOF)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
CCNxPortal *portal = ccnxPortalFactory_CreatePortal(data->factory, TEST_STACK);
CCNxName *name = ccnxName_CreateFromCString("lci:/Hello/World");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
CCNxMetaMessage *message = ccnxMetaMessage_CreateFromInterest(interest);
ccnxPortal_Send(portal, message, CCNxStackTimeout_Never);
ccnxPortal_Flush(portal, CCNxStackTimeout_Never);
bool actual = ccnxPortal_IsEOF(portal);
ccnxInterest_Release(&interest);
ccnxMetaMessage_Release(&message);
ccnxPortal_Release(&portal);
assertFalse(actual, "Expected to not be at EOF");
}
static void
_demuxDelivery(AthenaTransportLink *athenaTransportLink, CCNxMetaMessage *ccnxMetaMessage, struct sockaddr_in *peerAddress, socklen_t peerAddressLength)
{
struct _UDPLinkData *linkData = athenaTransportLink_GetPrivateData(athenaTransportLink);
AthenaTransportLink *demuxLink = parcHashCodeTable_Get(linkData->multiplexTable, (void *) _hashAddress(peerAddress));
// If it's an unknown peer, try to create a new link
if (demuxLink == NULL) {
_UDPLinkData *newLinkData = _UDPLinkData_Create();
// We use our parents fd to send, and receive demux'd messages from our parent on our queue
newLinkData->fd = dup(linkData->fd);
newLinkData->queue = parcDeque_Create();
assertNotNull(newLinkData->queue, "Could not create data queue for new link");
newLinkData->link.myAddressLength = linkData->link.myAddressLength;
memcpy(&newLinkData->link.myAddress, &linkData->link.myAddress, linkData->link.myAddressLength);
newLinkData->link.peerAddressLength = peerAddressLength;
memcpy(&newLinkData->link.peerAddress, peerAddress, peerAddressLength);
demuxLink = _newLink(athenaTransportLink, newLinkData);
if (demuxLink) {
parcHashCodeTable_Add(linkData->multiplexTable, (void *) _hashAddress(peerAddress), demuxLink);
}
}
// If there's no existing link and a new one can't be created, drop the message
if (demuxLink == NULL) {
ccnxMetaMessage_Release(&ccnxMetaMessage);
return;
}
_queueMessage(demuxLink, ccnxMetaMessage);
}
void *
athena_ForwarderEngine(void *arg)
{
Athena *athena = (Athena *) arg;
if (athena) {
while (athena->athenaState == Athena_Running) {
CCNxMetaMessage *ccnxMessage;
PARCBitVector *ingressVector;
int receiveTimeout = -1; // block until message received
ccnxMessage = athenaTransportLinkAdapter_Receive(athena->athenaTransportLinkAdapter,
&ingressVector, receiveTimeout);
if (ccnxMessage) {
athena_ProcessMessage(athena, ccnxMessage, ingressVector);
parcBitVector_Release(&ingressVector);
ccnxMetaMessage_Release(&ccnxMessage);
}
}
usleep(1000); // workaround for coordinating with test infrastructure
athena_Release(&athena);
}
return NULL;
}
static const char *
_athenactl_SendInterestControl(PARCIdentity *identity, CCNxMetaMessage *message)
{
const char *result = NULL;
CCNxPortalFactory *factory = ccnxPortalFactory_Create(identity);
CCNxPortal *portal = ccnxPortalFactory_CreatePortal(factory, ccnxPortalRTA_Message);
assertNotNull(portal, "Expected a non-null CCNxPortal pointer.");
athenactl_EncodeMessage(message);
if (ccnxPortal_Send(portal, message, CCNxStackTimeout_Never)) {
while (ccnxPortal_IsError(portal) == false) {
CCNxMetaMessage *response = ccnxPortal_Receive(portal, CCNxStackTimeout_Never);
if (response != NULL) {
if (ccnxMetaMessage_IsContentObject(response)) {
CCNxContentObject *contentObject = ccnxMetaMessage_GetContentObject(response);
PARCBuffer *payload = ccnxContentObject_GetPayload(contentObject);
if (payload) {
result = parcBuffer_ToString(payload);
}
}
ccnxMetaMessage_Release(&response);
break;
}
}
}
ccnxPortal_Release(&portal);
ccnxPortalFactory_Release(&factory);
return result;
}
static int
_athenactl_SetLogLevel(PARCIdentity *identity, int argc, char **argv)
{
if (argc < 1) {
printf("usage: set level off/notice/info/debug/error/all\n");
return 1;
}
char logLevelURI[MAXPATHLEN];
sprintf(logLevelURI, "%s/level/%s", CCNxNameAthenaCommand_Set, argv[0]);
CCNxName *name = ccnxName_CreateFromURI(logLevelURI);
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
const char *result = _athenactl_SendInterestControl(identity, interest);
if (result) {
printf("%s\n", result);
parcMemory_Deallocate(&result);
}
ccnxMetaMessage_Release(&interest);
return 0;
}
