static int
_athenactl_Run(PARCIdentity *identity, int argc, char **argv)
{
if (argc < 1) {
printf("usage: spawn <port | link specification>\n");
return 1;
}
char *linkSpecification = argv[0];
char constructedLinkSpecification[MAXPATHLEN] = { 0 };
// Short-cut, user can specify just a port and we will construct a default tcp listener specification
if (atoi(argv[0]) != 0) {
sprintf(constructedLinkSpecification, "tcp://localhost:%d/listener", atoi(argv[0]));
linkSpecification = constructedLinkSpecification;
}
CCNxName *name = ccnxName_CreateFromURI(CCNxNameAthenaCommand_Run);
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
PARCBuffer *payload = parcBuffer_AllocateCString(linkSpecification);
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;
}
static int
_athenactl_RemoveLink(PARCIdentity *identity, int argc, char **argv)
{
if (argc < 1) {
printf("usage: remove link <linkName>\n");
return 1;
}
CCNxName *name = ccnxName_CreateFromURI(CCNxNameAthenaCommand_LinkDisconnect);
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
PARCBuffer *payload = parcBuffer_AllocateCString(argv[0]);
ccnxInterest_SetPayload(interest, payload);
parcBuffer_Release(&payload);
const char *result = _athenactl_SendInterestControl(identity, interest);
if (result) {
printf("Link: %s\n", result);
parcMemory_Deallocate(&result);
}
ccnxMetaMessage_Release(&interest);
return 0;
}
static int
_athenactl_RemoveRoute(PARCIdentity *identity, int argc, char **argv)
{
if (argc < 2) {
printf("usage: remove route <linkName> <prefix>\n");
return 1;
}
CCNxName *name = ccnxName_CreateFromURI(CCNxNameAthenaCommand_FIBRemoveRoute);
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
char *linkName = argv[0];
char *prefix = argv[1];
// passed in as <linkName> <prefix>, passed on as <prefix> <linkname>
char routeArguments[MAXPATHLEN];
sprintf(routeArguments, "%s %s", prefix, linkName);
PARCBuffer *payload = parcBuffer_AllocateCString(routeArguments);
ccnxInterest_SetPayload(interest, payload);
parcBuffer_Release(&payload);
const char *result = _athenactl_SendInterestControl(identity, interest);
if (result) {
printf("FIB: %s\n", result);
parcMemory_Deallocate(&result);
}
ccnxMetaMessage_Release(&interest);
return 0;
}
PARCJSONValue *
parcJSONValue_CreateFromCString(const char *value)
{
assertNotNull(value, "String cannot be NULL.");
PARCJSONValue *result = _createValue(PARCJSONValueType_String);
if (result != NULL) {
result->value.string = parcBuffer_AllocateCString(value);
}
return result;
}
ssize_t
_appendMetadata(CCNxCodecTlvEncoder *encoder, CCNxManifestHashGroup *group)
{
ssize_t length = 0;
// Pre-populate this field -- we'll come back and fill in the length after we're done
size_t startPosition = ccnxCodecTlvEncoder_Position(encoder);
ccnxCodecTlvEncoder_AppendContainer(encoder, CCNxCodecSchemaV1Types_CCNxManifestHashGroup_Metadata, length);
// Now append all metadata that exists in the hash group.
const CCNxName *locator = ccnxManifestHashGroup_GetLocator(group);
if (locator != NULL) {
char *nameString = ccnxName_ToString(locator);
PARCBuffer *nameBuffer = parcBuffer_AllocateCString(nameString);
length += ccnxCodecTlvEncoder_AppendBuffer(encoder, CCNxCodecSchemaV1Types_CCNxManifestHashGroupMetadata_Locator, nameBuffer);
parcBuffer_Release(&nameBuffer);
parcMemory_Deallocate(&nameString);
}
size_t dataSize = ccnxManifestHashGroup_GetDataSize(group);
if (dataSize > 0) {
length += ccnxCodecTlvEncoder_AppendUint64(encoder, CCNxCodecSchemaV1Types_CCNxManifestHashGroupMetadata_DataSize, dataSize);
}
size_t blockSize = ccnxManifestHashGroup_GetBlockSize(group);
if (blockSize > 0) {
length += ccnxCodecTlvEncoder_AppendUint64(encoder, CCNxCodecSchemaV1Types_CCNxManifestHashGroupMetadata_BlockSize, blockSize);
}
size_t entrySize = ccnxManifestHashGroup_GetEntrySize(group);
if (entrySize > 0) {
length += ccnxCodecTlvEncoder_AppendUint64(encoder, CCNxCodecSchemaV1Types_CCNxManifestHashGroupMetadata_EntrySize, entrySize);
}
size_t treeSize = ccnxManifestHashGroup_GetTreeHeight(group);
if (treeSize > 0) {
length += ccnxCodecTlvEncoder_AppendUint64(encoder, CCNxCodecSchemaV1Types_CCNxManifestHashGroupMetadata_TreeHeight, treeSize);
}
const PARCBuffer *dataDigest = ccnxManifestHashGroup_GetOverallDataDigest(group);
if (dataDigest != NULL) {
length += ccnxCodecTlvEncoder_AppendBuffer(encoder, CCNxCodecSchemaV1Types_CCNxManifestHashGroupMetadata_OverallDataSha256, (PARCBuffer *) dataDigest);
}
// Rewind back to the container opening and fill in the length
size_t endPosition = ccnxCodecTlvEncoder_Position(encoder);
ccnxCodecTlvEncoder_PutUint16(encoder, startPosition, CCNxCodecSchemaV1Types_CCNxManifestHashGroup_Metadata);
ccnxCodecTlvEncoder_PutUint16(encoder, startPosition + 2, length);
ccnxCodecTlvEncoder_SetPosition(encoder, endPosition);
return endPosition - startPosition;
}
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 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;
}
static PARCLogEntry *
_parcLog_CreateEntry(PARCLog *log, PARCLogLevel level, uint64_t messageId, const char *format, va_list ap)
{
char *cString;
int nwritten = vasprintf(&cString, format, ap);
assertTrue(nwritten >= 0, "Error calling vasprintf");
struct timeval timeStamp;
gettimeofday(&timeStamp, NULL);
PARCBuffer *payload = parcBuffer_AllocateCString(cString);
PARCLogEntry *result = parcLogEntry_Create(level,
log->hostName,
log->applicationName,
log->processId,
messageId,
timeStamp,
payload);
parcBuffer_Release(&payload);
free(cString);
return result;
}
LONGBOW_TEST_CASE(Global, ccnxCodecSchemaV1ManifestDecoder_DecodeHashGroup)
{
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();
ccnxCodecTlvDecoder_GetType(decoder); // swallow type
uint16_t length = ccnxCodecTlvDecoder_GetLength(decoder);
CCNxManifestHashGroup *group = ccnxManifestHashGroup_Create();
bool result = _decodeHashGroup(decoder, dict, group, length);
assertTrue(result, "Expected hash group to be decoded correctly.");
PARCBuffer *expectedPointer = parcBuffer_AllocateCString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
CCNxManifestHashGroupPointer *pointer = ccnxManifestHashGroup_GetPointerAtIndex(group, 0);
const PARCBuffer *actualPointer = ccnxManifestHashGroupPointer_GetDigest(pointer);
assertTrue(parcBuffer_Equals(expectedPointer, actualPointer), "Expected decoded pointer to equal %s, got %s", parcBuffer_ToHexString(expectedPointer), parcBuffer_ToHexString(actualPointer));
parcBuffer_Release(&expectedPointer);
ccnxManifestHashGroup_Release(&group);
ccnxManifest_Release(&dict);
ccnxCodecTlvDecoder_Destroy(&decoder);
parcBuffer_Release(&wireFormat);
}
static int
_athenactl_AddConnection(PARCIdentity *identity, int argc, char **argv)
{
if (argc < 4) {
printf("usage: add connection <protocol> <name> <address> <port>\n");
return 1;
}
CCNxName *name = ccnxName_CreateFromURI(CCNxNameAthenaCommand_LinkConnect);
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
ccnxName_Release(&name);
char linkSpecification[MAXPATHLEN];
// Metis compatibility
// ex: add connection udp conn1 ccnx.example.com 9695
if (argv[1][0] != '\0') {
sprintf(linkSpecification, "%s://%s:%s/name=%s", argv[0], argv[2], argv[3], argv[1]);
} else {
sprintf(linkSpecification, "%s://%s:%s", argv[0], argv[2], argv[3]);
}
PARCBuffer *payload = parcBuffer_AllocateCString(linkSpecification);
ccnxInterest_SetPayload(interest, payload);
parcBuffer_Release(&payload);
const char *result = _athenactl_SendInterestControl(identity, interest);
if (result) {
printf("Link: %s\n", result);
parcMemory_Deallocate(&result);
}
ccnxMetaMessage_Release(&interest);
return 0;
}
