static PARCJSONValue *
_parcJSONValue_ArrayParser(PARCJSONParser *parser)
{
PARCJSONValue *result = NULL;
if (parcJSONParser_NextChar(parser) == '[') {
PARCJSONArray *array = parcJSONArray_Create();
while (parcJSONParser_Remaining(parser)) {
char peek = parcJSONParser_PeekNextChar(parser);
if (peek == ',') {
parcJSONParser_NextChar(parser);
} else if (peek == ']') {
parcJSONParser_NextChar(parser); // absorb the ']' character
result = parcJSONValue_CreateFromJSONArray(array);
parcJSONArray_Release(&array);
break;
} else {
PARCJSONValue *value = NULL;
if (peek == 'n') {
value = _parcJSONValue_NullParser(parser);
} else if (peek == 't') {
value = _parcJSONValue_TrueParser(parser);
} else if (peek == 'f') {
value = _parcJSONValue_FalseParser(parser);
} else if (peek == '"') {
value = _parcJSONValue_StringParser(parser);
} else if (peek == '{') {
value = parcJSONValue_ObjectParser(parser);
} else if (peek == '[') {
value = _parcJSONValue_ArrayParser(parser);
} else {
value = _parcJSONValue_NumberParser(parser);
}
if (value != NULL) {
parcJSONArray_AddValue(array, value);
parcJSONValue_Release(&value);
} else {
parcJSONArray_Release(&array);
break;
}
}
}
}
return result;
}
PARCJSON *
ccnxManifest_ToJSON(const CCNxManifest *manifest)
{
PARCJSON *root = parcJSON_Create();
char *nameString = ccnxName_ToString(ccnxManifest_GetName(manifest));
parcJSON_AddString(root, "locator", nameString);
parcMemory_Deallocate(&nameString);
PARCJSONArray *array = parcJSONArray_Create();
for (size_t i = 0; i < ccnxManifest_GetNumberOfHashGroups(manifest); i++) {
CCNxManifestHashGroup *group = ccnxManifest_GetHashGroupByIndex(manifest, i);
PARCJSON *groupJson = ccnxManifestHashGroup_ToJson(group);
PARCJSONValue *jsonValue = parcJSONValue_CreateFromJSON(groupJson);
parcJSONArray_AddValue(array, jsonValue);
parcJSONValue_Release(&jsonValue);
parcJSON_Release(&groupJson);
ccnxManifestHashGroup_Release(&group);
}
parcJSON_AddArray(root, "HashGroups", array);
parcJSONArray_Release(&array);
return root;
}
LONGBOW_TEST_CASE(parc_JSONArray, parcJSONArray_BuildString)
{
PARCJSONArray *array = parcJSONArray_Create();
PARCJSONValue *expected = parcJSONValue_CreateFromInteger(10);
parcJSONArray_AddValue(array, expected);
PARCBufferComposer *composer = parcBufferComposer_Create();
parcJSONArray_BuildString(array, composer, false);
PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(composer);
parcBufferComposer_Release(&composer);
char *result = parcBuffer_ToString(tempBuffer);
parcBuffer_Release(&tempBuffer);
assertTrue(strlen(result) > 0, "Expected non-empty string result");
parcMemory_Deallocate((void **) &result);
composer = parcBufferComposer_Create();
parcJSONArray_BuildString(array, composer, true);
tempBuffer = parcBufferComposer_ProduceBuffer(composer);
parcBufferComposer_Release(&composer);
result = parcBuffer_ToString(tempBuffer);
parcBuffer_Release(&tempBuffer);
assertTrue(strlen(result) > 0, "Expected non-empty string result");
parcMemory_Deallocate((void **) &result);
parcJSONValue_Release(&expected);
parcJSONArray_Release(&array);
}
LONGBOW_TEST_CASE(Global, metisSystem_Interfaces)
{
MetisForwarder *metis = metisForwarder_Create(NULL);
CPIInterfaceSet *set = metisSystem_Interfaces(metis);
assertNotNull(set, "metisSystem_Interfaces return null set");
// XXX we need some sort of validation test. e.g. open a socket, then ioctl to
// XXX get the interface name, then verify its in the list.
size_t length = cpiInterfaceSet_Length(set);
assertTrue(length > 0, "metisSystem_Interfaces returned no interfaces");
for (size_t i = 0; i < length; i++) {
CPIInterface *iface = cpiInterfaceSet_GetByOrdinalIndex(set, i);
printf("Interface Index %u\n", cpiInterface_GetInterfaceIndex(iface));
const CPIAddressList *list = cpiInterface_GetAddresses(iface);
PARCJSONArray *jsonArray = cpiAddressList_ToJson(list);
char *str = parcJSONArray_ToString(jsonArray);
printf("%s\n", str);
parcMemory_Deallocate((void **) &str);
parcJSONArray_Release(&jsonArray);
}
cpiInterfaceSet_Destroy(&set);
metisForwarder_Destroy(&metis);
}
LONGBOW_TEST_CASE(parc_JSONArray, parcJSONArray_CreateRelease)
{
PARCJSONArray *expected = parcJSONArray_Create();
parcJSONArray_AssertValid(expected);
assertNotNull(expected, "Expected non-null return value from parcJSONArray_Create");
PARCJSONArray *actual = parcJSONArray_Acquire(expected);
parcJSONArray_AssertValid(actual);
parcJSONArray_Release(&actual);
assertNull(actual, "Expected null value set by parcJSONArray_Release");
parcJSONArray_AssertValid(expected);
parcJSONArray_Release(&expected);
assertNull(expected, "Expected null value set by parcJSONArray_Release");
}
LONGBOW_TEST_CASE(JSON, parcJSON_AddArray)
{
PARCJSON *json = parcJSON_Create();
char *expectedName = "array";
PARCJSONArray *array = parcJSONArray_Create();
PARCJSONValue *value = parcJSONValue_CreateFromCString("Some Pig");
parcJSONArray_AddValue(array, value);
parcJSON_AddArray(json, expectedName, array);
parcJSONArray_Release(&array);
const PARCJSONPair *pair = parcJSON_GetPairByName(json, expectedName);
PARCBuffer *actualName = parcJSONPair_GetName(pair);
PARCJSONValue *actualValue = parcJSONPair_GetValue(pair);
assertTrue(strcmp(expectedName, parcBuffer_Overlay(actualName, 0)) == 0,
"Expected name %s, actual %s", expectedName, (char *) parcBuffer_ToString(actualName));
assertTrue(parcJSONValue_IsArray(actualValue), "Expect value to be type PARCJSONArray");
array = parcJSONValue_GetArray(actualValue);
PARCJSONValue *result = parcJSONArray_GetValue(array, 0);
assertTrue(parcBuffer_Equals(parcJSONValue_GetString(result), parcJSONValue_GetString(value)),
"Expected %s actual %s",
parcJSONValue_ToString(value),
parcJSONValue_ToString(result));
parcJSONValue_Release(&value);
parcJSON_Release(&json);
}
PARCJSON *
ccnxManifestHashGroup_ToJson(const CCNxManifestHashGroup *group)
{
PARCJSON *root = parcJSON_Create();
PARCJSONArray *ptrList = parcJSONArray_Create();
for (size_t i = 0; i < parcLinkedList_Size(group->pointers); i++) {
CCNxManifestHashGroupPointer *ptr = (CCNxManifestHashGroupPointer *) parcLinkedList_GetAtIndex(group->pointers, i);
PARCJSON *ptrJson = parcJSON_Create();
// Type.
parcJSON_AddInteger(ptrJson, "type", ccnxManifestHashGroupPointer_GetType(ptr));
// Digest.
char *digestString = parcBuffer_ToHexString(ptr->digest);
parcJSON_AddString(ptrJson, "digest", digestString);
parcMemory_Deallocate(&digestString);
// Add the tuple to the list.
PARCJSONValue *val = parcJSONValue_CreateFromJSON(ptrJson);
parcJSONArray_AddValue(ptrList, val);
// Cleanup
parcJSONValue_Release(&val);
parcJSON_Release(&ptrJson);
}
root = parcJSON_AddArray(root, "HashGroup", ptrList);
parcJSONArray_Release(&ptrList);
if (group->overallDataDigest != NULL) {
char *digestString = parcBuffer_ToHexString(group->overallDataDigest);
root = parcJSON_AddString(root, "overallDataDigest", digestString);
parcMemory_Deallocate((void **) &digestString);
}
if (group->locator != NULL) {
char *locatorString = ccnxName_ToString(group->locator);
root = parcJSON_AddString(root, "locator", locatorString);
parcMemory_Deallocate((void **) &locatorString);
}
if (group->entrySize > 0) {
root = parcJSON_AddInteger(root, "entrySize", group->entrySize);
}
if (group->dataSize > 0) {
root = parcJSON_AddInteger(root, "dataSize", group->dataSize);
}
if (group->blockSize > 0) {
root = parcJSON_AddInteger(root, "blockSize", group->blockSize);
}
if (group->treeHeight > 0) {
root = parcJSON_AddInteger(root, "treeHeight", group->treeHeight);
}
return root;
}
LONGBOW_TEST_CASE(parc_JSONArray, parcJSONArray_Equals)
{
PARCJSONArray *x = parcJSONArray_Create();
PARCJSONArray *y = parcJSONArray_Create();
PARCJSONArray *z = parcJSONArray_Create();
PARCJSONArray *notEqual1 = parcJSONArray_Create();
PARCJSONValue *value = parcJSONValue_CreateFromCString("Hello");
parcJSONArray_AddValue(notEqual1, value);
parcJSONValue_Release(&value);
parcObjectTesting_AssertEqualsFunction(parcJSONArray_Equals, x, y, z, notEqual1);
parcJSONArray_Release(&x);
parcJSONArray_Release(&y);
parcJSONArray_Release(&z);
parcJSONArray_Release(¬Equal1);
}
LONGBOW_TEST_CASE(parc_JSONArray, parcJSONArray_AddValue)
{
PARCJSONArray *expected = parcJSONArray_Create();
PARCJSONValue *value = parcJSONValue_CreateFromInteger(10);
parcJSONArray_AddValue(expected, value);
parcJSONValue_Release(&value);
parcJSONArray_Release(&expected);
}
LONGBOW_TEST_CASE(parc_JSONArray, parcJSONArray_GetLength)
{
PARCJSONArray *expected = parcJSONArray_Create();
PARCJSONValue *value = parcJSONValue_CreateFromInteger(10);
parcJSONArray_AddValue(expected, value);
parcJSONValue_Release(&value);
assertTrue(parcJSONArray_GetLength(expected) == 1, "Expected a length of 1");
parcJSONArray_Release(&expected);
}
LONGBOW_TEST_CASE(parc_JSONArray, parcJSONArray_Display)
{
PARCJSONArray *array = parcJSONArray_Create();
PARCJSONValue *expected = parcJSONValue_CreateFromInteger(10);
parcJSONArray_AddValue(array, expected);
parcJSONValue_Release(&expected);
parcJSONArray_Display(array, 0);
parcJSONArray_Release(&array);
}
LONGBOW_TEST_CASE(parc_JSONArray, parcJSONArray_GetValue)
{
PARCJSONArray *array = parcJSONArray_Create();
PARCJSONValue *expected = parcJSONValue_CreateFromInteger(10);
parcJSONArray_AddValue(array, expected);
PARCJSONValue *actual = parcJSONArray_GetValue(array, 0);
assertTrue(expected == actual, "Expected different value");
parcJSONValue_Release(&expected);
parcJSONArray_Release(&array);
}
LONGBOW_TEST_CASE(parc_JSONArray, parcJSONArray_ToString)
{
PARCJSONArray *array = parcJSONArray_Create();
PARCJSONValue *expected = parcJSONValue_CreateFromInteger(10);
parcJSONArray_AddValue(array, expected);
parcJSONValue_Release(&expected);
const char *string = parcJSONArray_ToString(array);
parcMemory_Deallocate((void **) &string);
parcJSONArray_Release(&array);
}
static void
_parcJSONValueDestroy(PARCJSONValue **valuePtr)
{
if (valuePtr != NULL) {
PARCJSONValue *value = *valuePtr;
if (value->type == PARCJSONValueType_Array) {
parcJSONArray_Release(&value->value.array);
} else if (value->type == PARCJSONValueType_JSON) {
parcJSON_Release(&value->value.object);
} else if (value->type == PARCJSONValueType_String) {
parcBuffer_Release(&value->value.string);
}
}
}
LONGBOW_TEST_CASE(Global, cpiAddressList_ToFromJSON)
{
CPIAddressList *truth_list = cpiAddressList_Create();
int loops = 2;
for (int i = 0; i < loops; i++) {
cpiAddressList_Append(truth_list, cpiAddress_CreateFromInterface(i));
}
PARCJSONArray *json = cpiAddressList_ToJson(truth_list);
CPIAddressList *test_list = cpiAddressList_CreateFromJson(json);
assertTrue(cpiAddressList_Equals(truth_list, test_list), "Lists did not match!");
cpiAddressList_Destroy(&truth_list);
cpiAddressList_Destroy(&test_list);
parcJSONArray_Release(&json);
}
LONGBOW_TEST_CASE(Global, cpiAddressList_ToJSON)
{
char truth[] = "[{\"ADDRESSTYPE\":\"IFACE\",\"DATA\":\"AAAAAA==\"},{\"ADDRESSTYPE\":\"IFACE\",\"DATA\":\"AAAAAQ==\"}]";
CPIAddressList *a = cpiAddressList_Create();
int loops = 2;
for (int i = 0; i < loops; i++) {
cpiAddressList_Append(a, cpiAddress_CreateFromInterface(i));
}
PARCJSONArray *jsonArray = cpiAddressList_ToJson(a);
char *test = parcJSONArray_ToCompactString(jsonArray);
assertTrue(strcmp(truth, test) == 0, "JSON strings did not match, got '%s' expected '%s'", test, truth);
cpiAddressList_Destroy(&a);
parcMemory_Deallocate((void **) &test);
parcJSONArray_Release(&jsonArray);
}
PARCJSON *
cpiConnectionList_ToJson(const CPIConnectionList *list)
{
assertNotNull(list, "Parameter must be non-null");
PARCJSONArray *inner_json = parcJSONArray_Create();
size_t length = parcArrayList_Size(list->listOfConnections);
for (size_t i = 0; i < length; i++) {
CPIConnection *tunnel = (CPIConnection *) parcArrayList_Get(list->listOfConnections, i);
PARCJSON *json = cpiConnection_ToJson(tunnel);
PARCJSONValue *value = parcJSONValue_CreateFromJSON(json);
parcJSON_Release(&json);
parcJSONArray_AddValue(inner_json, value);
parcJSONValue_Release(&value);
}
PARCJSON *outter_json = parcJSON_Create();
parcJSON_AddArray(outter_json, cpi_ConnectionList, inner_json);
parcJSONArray_Release(&inner_json);
return outter_json;
}
PARCJSON *
cpiInterfaceSet_ToJson(CPIInterfaceSet *set)
{
assertNotNull(set, "Parameter must be non-null");
PARCJSONArray *interfaceList = parcJSONArray_Create();
size_t length = parcArrayList_Size(set->listOfInterfaces);
for (size_t i = 0; i < length; i++) {
CPIInterface *iface = (CPIInterface *) parcArrayList_Get(set->listOfInterfaces, i);
PARCJSON *json = cpiInterface_ToJson(iface);
PARCJSONValue *value = parcJSONValue_CreateFromJSON(json);
parcJSON_Release(&json);
parcJSONArray_AddValue(interfaceList, value);
parcJSONValue_Release(&value);
}
PARCJSON *result = parcJSON_Create();
parcJSON_AddArray(result, cpi_InterfaceList, interfaceList);
parcJSONArray_Release(&interfaceList);
return result;
}
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;
}
