/** * Listen for arriving Interests and respond to them if possible. We expect that the Portal we are passed is * listening for messages matching the specified domainPrefix. * * @param [in] portal The CCNxPortal that we will read from. * @param [in] domainPrefix A CCNxName containing the domain prefix that the specified `portal` is listening for. * @param [in] directoryPath A string containing the path to the directory being served. * * @return true if at least one Interest is received and responded to, false otherwise. */ static bool _receiveAndAnswerInterests(CCNxPortal *portal, const CCNxName *domainPrefix, const char *directoryPath) { bool result = false; CCNxMetaMessage *inboundMessage = NULL; while ((inboundMessage = ccnxPortal_Receive(portal)) != NULL) { if (ccnxMetaMessage_IsInterest(inboundMessage)) { CCNxInterest *interest = ccnxMetaMessage_GetInterest(inboundMessage); CCNxContentObject *response = _createInterestResponse(interest, domainPrefix, directoryPath); // At this point, response has either the requested chunk of the request file/command, // or remains NULL. if (response != NULL) { // We had a response, so send it back through the Portal. CCNxMetaMessage *responseMessage = ccnxMetaMessage_CreateFromContentObject(response); if (ccnxPortal_Send(portal, responseMessage) == false) { fprintf(stderr, "ccnxPortal_Send failed (error %d). Is the Forwarder running?\n", ccnxPortal_GetError(portal)); } ccnxMetaMessage_Release(&responseMessage); ccnxContentObject_Release(&response); result = true; // We have received, and responded to, at least one Interest. } } ccnxMetaMessage_Release(&inboundMessage); } return result; }
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; }
LONGBOW_TEST_CASE(Global, athena_ProcessContentObject) { PARCURI *connectionURI; Athena *athena = athena_Create(100); CCNxName *name = ccnxName_CreateFromCString("lci:/cakes/and/pies"); uint64_t chunkNum = 0; CCNxNameSegment *chunkSegment = ccnxNameSegmentNumber_Create(CCNxNameLabelType_CHUNK, chunkNum); ccnxName_Append(name, chunkSegment); ccnxNameSegment_Release(&chunkSegment); PARCBuffer *payload = parcBuffer_WrapCString("this is a payload"); CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(name, payload); ccnxName_Release(&name); parcBuffer_Release(&payload); connectionURI = parcURI_Parse("tcp://localhost:50100/listener/name=TCPListener"); const char *result = athenaTransportLinkAdapter_Open(athena->athenaTransportLinkAdapter, connectionURI); assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed (%s)", strerror(errno)); parcURI_Release(&connectionURI); connectionURI = parcURI_Parse("tcp://localhost:50100/name=TCP_0"); result = athenaTransportLinkAdapter_Open(athena->athenaTransportLinkAdapter, connectionURI); assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed (%s)", strerror(errno)); parcURI_Release(&connectionURI); int linkId = athenaTransportLinkAdapter_LinkNameToId(athena->athenaTransportLinkAdapter, "TCP_0"); PARCBitVector *ingressVector = parcBitVector_Create(); parcBitVector_Set(ingressVector, linkId); athena_EncodeMessage(contentObject); athena_ProcessMessage(athena, contentObject, ingressVector); parcBitVector_Release(&ingressVector); // Make sure we recover processing a "nameless" content object payload = parcBuffer_WrapCString("Hello World"); CCNxContentObject *reply = ccnxContentObject_CreateWithPayload(payload); parcBuffer_Release(&payload); CCNxMetaMessage *response = ccnxMetaMessage_CreateFromContentObject(reply); ccnxContentObject_Release(&reply); athena_EncodeMessage(response); athena_ProcessMessage(athena, response, ingressVector); assertNull(ingressVector, "Processing nameless content object didn't fail."); ccnxInterest_Release(&contentObject); ccnxInterest_Release(&response); athena_Release(&athena); }
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, 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); }
static CCNxMetaMessage * _mockRead(void *privateData, const uint64_t *microSeconds) { CCNxName *name = ccnxName_Create(); PARCBuffer *payload = parcBuffer_Allocate(10); CCNxContentObject *object = ccnxContentObject_CreateWithNameAndPayload(name, payload); ccnxName_Release(&name); parcBuffer_Release(&payload); CCNxMetaMessage *result = ccnxMetaMessage_CreateFromContentObject(object); ccnxContentObject_Release(&object); return result; }
static CCNxMetaMessage * _athenaLRUContentStore_ProcessMessage(AthenaContentStoreImplementation *store, const CCNxMetaMessage *message) { CCNxMetaMessage *result = NULL; AthenaLRUContentStore *impl = (AthenaLRUContentStore *) store; if (ccnxMetaMessage_IsInterest(message)) { CCNxInterest *interest = ccnxMetaMessage_GetInterest(message); CCNxName *queryName = ccnxInterest_GetName(interest); uint64_t chunkNumber = 0; bool hasChunkNumber = false; _getChunkNumberFromName(queryName, &chunkNumber, &hasChunkNumber); assertFalse(hasChunkNumber, "LRUContentStore queries don't yet support more than 1 chunk."); PARCBuffer *responsePayload = NULL; // Find the arguments to our query. size_t argSegmentIndex = 0; if (_getSegmentIndexOfQueryArgs(queryName, AthenaModule_ContentStore, &argSegmentIndex)) { CCNxNameSegment *queryTypeSegment = ccnxName_GetSegment(queryName, argSegmentIndex); char *queryTypeString = ccnxNameSegment_ToString(queryTypeSegment); // e.g. "stat" char *statString = "stat"; if (strncasecmp(queryTypeString, statString, strlen(statString)) == 0) { responsePayload = _processStatQuery(impl, queryName, argSegmentIndex + 1, chunkNumber); } parcMemory_Deallocate(&queryTypeString); } if (responsePayload != NULL) { CCNxContentObject *contentObjectResponse = ccnxContentObject_CreateWithNameAndPayload( ccnxInterest_GetName(interest), responsePayload); result = ccnxMetaMessage_CreateFromContentObject(contentObjectResponse); ccnxContentObject_SetExpiryTime(contentObjectResponse, parcClock_GetTime(impl->wallClock) + 100); // this response is good for 100 millis ccnxContentObject_Release(&contentObjectResponse); parcBuffer_Release(&responsePayload); } } return result; // could be NULL }
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); }
static CCNxMetaMessage * _create_response(Athena *athena, CCNxName *ccnxName, const char *format, ...) { va_list ap; va_start(ap, format); char responseBuffer[MAXPATHLEN]; vsprintf(responseBuffer, format, ap); PARCBuffer *responsePayload = parcBuffer_AllocateCString(responseBuffer); parcLog_Info(athena->log, responseBuffer); CCNxContentObject *responseContent = ccnxContentObject_CreateWithNameAndPayload(ccnxName, responsePayload); CCNxMetaMessage *responseMessage = ccnxMetaMessage_CreateFromContentObject(responseContent); ccnxContentObject_Release(&responseContent); parcBuffer_Release(&responsePayload); athena_EncodeMessage(responseMessage); return responseMessage; }
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; }
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); }
static CCNxMetaMessage * _create_FIBList_response(Athena *athena, CCNxName *ccnxName, PARCList *fibEntryList) { PARCJSON *jsonPayload = parcJSON_Create(); PARCJSONArray *jsonEntryList = parcJSONArray_Create(); parcJSON_AddArray(jsonPayload, JSON_KEY_RESULT, jsonEntryList); for (size_t i = 0; i < parcList_Size(fibEntryList); ++i) { AthenaFIBListEntry *entry = parcList_GetAtIndex(fibEntryList, i); if (entry != NULL) { CCNxName *prefixName = athenaFIBListEntry_GetName(entry); if (prefixName) { char *prefix = ccnxName_ToString(prefixName); int linkId = athenaFIBListEntry_GetLinkId(entry); const char *linkName = athenaTransportLinkAdapter_LinkIdToName(athena->athenaTransportLinkAdapter, linkId); parcLog_Debug(athena->log, " Route: %s->%s", prefix, linkName); PARCJSON *jsonItem = parcJSON_Create(); parcJSON_AddString(jsonItem, JSON_KEY_NAME, prefix); parcJSON_AddString(jsonItem, JSON_KEY_LINK, linkName); PARCJSONValue *jsonItemValue = parcJSONValue_CreateFromJSON(jsonItem); parcJSON_Release(&jsonItem); parcJSONArray_AddValue(jsonEntryList, jsonItemValue); parcJSONValue_Release(&jsonItemValue); parcMemory_Deallocate(&prefix); } else { int linkId = athenaFIBListEntry_GetLinkId(entry); const char *linkName = athenaTransportLinkAdapter_LinkIdToName(athena->athenaTransportLinkAdapter, linkId); parcLog_Debug(athena->log, " Route: <empty>->%s", linkName); PARCJSON *jsonItem = parcJSON_Create(); parcJSON_AddString(jsonItem, JSON_KEY_NAME, ""); parcJSON_AddString(jsonItem, JSON_KEY_LINK, linkName); PARCJSONValue *jsonItemValue = parcJSONValue_CreateFromJSON(jsonItem); parcJSON_Release(&jsonItem); parcJSONArray_AddValue(jsonEntryList, jsonItemValue); parcJSONValue_Release(&jsonItemValue); } } } char *jsonString = parcJSON_ToString(jsonPayload); parcJSONArray_Release(&jsonEntryList); parcJSON_Release(&jsonPayload); PARCBuffer *payload = parcBuffer_CreateFromArray(jsonString, strlen(jsonString)); CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(ccnxName, parcBuffer_Flip(payload)); struct timeval tv; gettimeofday(&tv, NULL); uint64_t nowInMillis = (tv.tv_sec * 1000) + (tv.tv_usec / 1000); ccnxContentObject_SetExpiryTime(contentObject, nowInMillis + 100); // this response is good for 100 millis CCNxMetaMessage *result = ccnxMetaMessage_CreateFromContentObject(contentObject); ccnxContentObject_Release(&contentObject); parcBuffer_Release(&payload); parcMemory_Deallocate(&jsonString); athena_EncodeMessage(result); return result; }
static CCNxMetaMessage * _create_linkList_response(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, CCNxName *ccnxName) { PARCJSONArray *jsonLinkList = parcJSONArray_Create(); for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->listenerList); index++) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->listenerList, index); const char *linkName = athenaTransportLink_GetName(athenaTransportLink); bool notLocal = athenaTransportLink_IsNotLocal(athenaTransportLink); bool localForced = athenaTransportLink_IsForceLocal(athenaTransportLink); PARCJSON *jsonItem = parcJSON_Create(); parcJSON_AddString(jsonItem, "linkName", linkName); parcJSON_AddInteger(jsonItem, "index", -1); parcJSON_AddBoolean(jsonItem, "notLocal", notLocal); parcJSON_AddBoolean(jsonItem, "localForced", localForced); PARCJSONValue *jsonItemValue = parcJSONValue_CreateFromJSON(jsonItem); parcJSON_Release(&jsonItem); parcJSONArray_AddValue(jsonLinkList, jsonItemValue); parcJSONValue_Release(&jsonItemValue); if (notLocal) { parcLog_Debug(athenaTransportLinkAdapter->log, "\n Link listener%s: %s", localForced ? " (forced remote)" : "", linkName); } else { parcLog_Debug(athenaTransportLinkAdapter->log, "\n Link listener%s: %s", localForced ? " (forced local)" : "", linkName); } } for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->instanceList); index++) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->instanceList, index); if (athenaTransportLink) { const char *linkName = athenaTransportLink_GetName(athenaTransportLink); bool notLocal = athenaTransportLink_IsNotLocal(athenaTransportLink); bool localForced = athenaTransportLink_IsForceLocal(athenaTransportLink); PARCJSON *jsonItem = parcJSON_Create(); parcJSON_AddString(jsonItem, "linkName", linkName); parcJSON_AddInteger(jsonItem, "index", index); parcJSON_AddBoolean(jsonItem, "notLocal", notLocal); parcJSON_AddBoolean(jsonItem, "localForced", localForced); PARCJSONValue *jsonItemValue = parcJSONValue_CreateFromJSON(jsonItem); parcJSON_Release(&jsonItem); parcJSONArray_AddValue(jsonLinkList, jsonItemValue); parcJSONValue_Release(&jsonItemValue); if (notLocal) { parcLog_Debug(athenaTransportLinkAdapter->log, "\n Link instance [%d] %s: %s", index, localForced ? "(forced remote)" : "(remote)", linkName); } else { parcLog_Debug(athenaTransportLinkAdapter->log, "\n Link instance [%d] %s: %s", index, localForced ? "(forced local)" : "(local)", linkName); } } } char *jsonString = parcJSONArray_ToString(jsonLinkList); parcJSONArray_Release(&jsonLinkList); PARCBuffer *payload = parcBuffer_CreateFromArray(jsonString, strlen(jsonString)); CCNxContentObject *contentObject = ccnxContentObject_CreateWithDataPayload(ccnxName, parcBuffer_Flip(payload)); struct timeval tv; gettimeofday(&tv, NULL); uint64_t nowInMillis = (tv.tv_sec * 1000) + (tv.tv_usec / 1000); ccnxContentObject_SetExpiryTime(contentObject, nowInMillis + 100); // this response is good for 100 millis CCNxMetaMessage *result = ccnxMetaMessage_CreateFromContentObject(contentObject); ccnxContentObject_Release(&contentObject); parcBuffer_Release(&payload); parcMemory_Deallocate(&jsonString); athena_EncodeMessage(result); return result; }