CCNxControl *
cpi_CreateResponse(CCNxControl *request, PARCJSON *operation)
{
    PARCJSON *requestJson = ccnxControl_GetJson(request);

    // use the same key as the request
    uint64_t seqnum = controlPlaneInterface_GetSequenceNumber(requestJson);

    PARCJSONValue *value = parcJSON_GetValueByName(requestJson, cpiRequest);
    assertNotNull(value, "Could not get request or response");
    assertTrue(parcJSONValue_IsJSON(value), "cpiRequest should be a JSON object");

    PARCJSON *operationJson = parcJSONValue_GetJSON(value);
    PARCJSONPair *pair = parcJSON_GetPairByIndex(operationJson, 1);
    const PARCBuffer *opKeyBuf = parcJSONPair_GetName(pair);
    const char *opKey = parcBuffer_ToString(opKeyBuf);

    PARCJSON *response = parcJSON_Create();
    parcJSON_AddInteger(response, cpiSeqnum, (int) seqnum);
    parcJSON_AddObject(response, opKey, operation);
    parcMemory_Deallocate(&opKey);

    PARCJSON *responseJson = parcJSON_Create();
    parcJSON_AddObject(responseJson, cpiResponse, response);
    parcJSON_Release(&response);

    CCNxControl *result = ccnxControl_CreateCPIRequest(responseJson);

    parcJSON_Release(&responseJson);

    return result;
}
LONGBOW_TEST_CASE(Global, cpiAck_CreateNack)
{
    CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
    CPIRouteEntry *route = cpiRouteEntry_CreateRouteToSelf(name);
    PARCJSON *request = cpiForwarding_CreateAddRouteRequest(route);

    PARCJSON *actual = cpiAcks_CreateNack(request);

    assertFalse(cpiAcks_IsAck(actual), "Expected cpiAcks_IsAck to return false.");

    parcJSON_Release(&actual);
    parcJSON_Release(&request);
    cpiRouteEntry_Destroy(&route);
    ccnxName_Release(&name);
}
Esempio n. 3
0
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;
}
Esempio n. 4
0
LONGBOW_TEST_CASE(JSON, parcJSON_AddValue)
{
    PARCJSON *json = parcJSON_Create();

    char *expectedName = "value";

    PARCJSONValue *value = parcJSONValue_CreateFromCString("Some Pig");

    parcJSON_AddValue(json, expectedName, value);

    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_IsString(actualValue), "Expect value to be type PARCJSONArray");
    assertTrue(parcBuffer_Equals(parcJSONValue_GetString(actualValue), parcJSONValue_GetString(value)),
               "Expected %s actual %s",
               parcJSONValue_ToString(value),
               parcJSONValue_ToString(actualValue));

    parcJSONValue_Release(&value);

    parcJSON_Release(&json);
}
Esempio n. 5
0
static CCNxControl *
metisConfiguration_ProcessConnectionList(MetisConfiguration *config, CCNxControl *request, unsigned ingressId)
{
    CPIConnectionList *tunnelList = cpiConnectionList_Create();

    MetisConnectionTable *table = metisForwarder_GetConnectionTable(config->metis);
    MetisConnectionList *connList = metisConnectionTable_GetEntries(table);

    for (size_t i = 0; i < metisConnectionList_Length(connList); i++) {
        // Don't release original, we're not storing it
        MetisConnection *original = metisConnectionList_Get(connList, i);
        const MetisAddressPair *addressPair = metisConnection_GetAddressPair(original);
        CPIAddress *localAddress = cpiAddress_Copy(metisAddressPair_GetLocal(addressPair));
        CPIAddress *remoteAddress = cpiAddress_Copy(metisAddressPair_GetRemote(addressPair));

        CPIConnectionType type = metisIoOperations_GetConnectionType(metisConnection_GetIoOperations(original));

        CPIConnection *cpiConn = cpiConnection_Create(metisConnection_GetConnectionId(original),
                                                      localAddress,
                                                      remoteAddress,
                                                      type);

        cpiConnection_SetState(cpiConn, metisConnection_IsUp(original) ? CPI_IFACE_UP : CPI_IFACE_DOWN);
        cpiConnectionList_Append(tunnelList, cpiConn);
    }

    PARCJSON *connectListJson = cpiConnectionList_ToJson(tunnelList);
    CCNxControl *response = cpi_CreateResponse(request, connectListJson);
    parcJSON_Release(&connectListJson);
    cpiConnectionList_Destroy(&tunnelList);
    metisConnectionList_Destroy(&connList);

    return response;
}
LONGBOW_TEST_CASE(Global, cpiAddress_CreateFromInterface)
{
    uint32_t ifidx = 0x01020304;
    uint32_t test;

    CPIAddress *address = cpiAddress_CreateFromInterface(ifidx);

    bool success = cpiAddress_GetInterfaceIndex(address, &test);
    assertTrue(success, "Got false converting back address");

    assertTrue(ifidx == test, "Got mismatch addressed");

    assertTrue(cpiAddress_GetType(address) == cpiAddressType_IFACE,
               "Got wrong address type, expected %d, got %d", cpiAddressType_IFACE, cpiAddress_GetType(address));

    PARCJSON *json = cpiAddress_ToJson(address);
    CPIAddress *fromjson = cpiAddress_CreateFromJson(json);

    assertTrue(parcBuffer_Equals(address->blob, fromjson->blob), "fromjson blob does not equal known address");
    assertTrue(cpiAddress_Equals(address, fromjson), "cpiAddress_Equals broken for IFACE type");

    CPIAddress *copy = cpiAddress_Copy(address);
    assertTrue(cpiAddress_Equals(copy, address), "Copy and address not equal for IFACE");

    parcJSON_Release(&json);
    cpiAddress_Destroy(&address);
    cpiAddress_Destroy(&copy);
    cpiAddress_Destroy(&fromjson);
}
Esempio n. 7
0
LONGBOW_TEST_CASE(JSON, parcJSON_CreateRelease)
{
    PARCJSON *json = parcJSON_Create();

    parcJSON_Release(&json);
    assertNull(json, "Expected the NULL pointer side-effect of Release.");
}
LONGBOW_TEST_CASE(Global, cpiAddress_CreateFromUnix)
{
    struct sockaddr_un addr_un;
    struct sockaddr_un addr_test;
    memset(&addr_un, 0, sizeof(struct sockaddr_un));
    char path[] = "/Hello/Cruel/World";
    strcpy(addr_un.sun_path, path);
    addr_un.sun_family = AF_UNIX;

    CPIAddress *address = cpiAddress_CreateFromUnix(&addr_un);

    bool success = cpiAddress_GetUnix(address, &addr_test);
    assertTrue(success, "Got false converting back address");

    assertTrue(memcmp(&addr_un, &addr_test, sizeof(struct sockaddr_un)) == 0, "Got mismatch addressed");

    assertTrue(cpiAddress_GetType(address) == cpiAddressType_UNIX,
               "Got wrong address type, expected %d, got %d", cpiAddressType_UNIX, cpiAddress_GetType(address));

    PARCJSON *json = cpiAddress_ToJson(address);
    CPIAddress *fromjson = cpiAddress_CreateFromJson(json);

    assertTrue(parcBuffer_Equals(address->blob, fromjson->blob), "fromjson blob does not equal known address");
    assertTrue(cpiAddress_Equals(address, fromjson), "cpiAddress_Equals broken for UNIX type");

    CPIAddress *copy = cpiAddress_Copy(address);
    assertTrue(cpiAddress_Equals(copy, address), "Copy and address not equal for UNIX");

    parcJSON_Release(&json);
    cpiAddress_Destroy(&address);
    cpiAddress_Destroy(&copy);
    cpiAddress_Destroy(&fromjson);
}
Esempio n. 9
0
PARCJSON *
parcHashMap_ToJSON(const PARCHashMap *hashMap)
{
    parcHashMap_OptionalAssertValid(hashMap);

    PARCJSON *result = parcJSON_Create();

    PARCIterator *iterator = parcHashMap_CreateKeyIterator((PARCHashMap *) hashMap);

    while (parcIterator_HasNext(iterator)) {
        PARCObject *keyObject = parcIterator_Next(iterator);
        const PARCObject *valueObject = parcHashMap_Get(hashMap, keyObject);
        char *key = parcObject_ToString(keyObject);
        PARCJSON *value = parcObject_ToJSON(valueObject);

        parcJSON_AddObject(result, key, value);

        parcMemory_Deallocate(&key);
        parcJSON_Release(&value);
    }

    parcIterator_Release(&iterator);


    return result;
}
LONGBOW_TEST_CASE(Global, cpiAddress_CreateFromLink)
{
    uint8_t mac[] = { 0x01, 0x02, 0x03, 0x04, 0xFF, 0x8F };
    PARCBuffer *macbuffer = parcBuffer_Flip(parcBuffer_CreateFromArray(mac, sizeof(mac)));

    CPIAddress *address = cpiAddress_CreateFromLink(mac, sizeof(mac));

    // Do not release test, it is the same reference as address->blob
    PARCBuffer *test = cpiAddress_GetLinkAddress(address);
    assertNotNull(test, "Got null link address buffer");
    assertTrue(parcBuffer_Equals(test, address->blob), "Returned buffer from cpiAddress_GetLinkAddress not equal to address");

    assertTrue(cpiAddress_GetType(address) == cpiAddressType_LINK,
               "Got wrong address type, expected %d, got %d", cpiAddressType_LINK, cpiAddress_GetType(address));

    PARCJSON *json = cpiAddress_ToJson(address);
    CPIAddress *fromjson = cpiAddress_CreateFromJson(json);

    assertTrue(cpiAddress_GetType(address) == cpiAddress_GetType(fromjson),
               "fromjson type does not equal known");
    assertTrue(parcBuffer_Equals(address->blob, fromjson->blob),
               "fromjson blob does not equal known address");
    assertTrue(cpiAddress_Equals(address, fromjson),
               "cpiAddress_Equals broken for LINK type");

    CPIAddress *copy = cpiAddress_Copy(address);
    assertTrue(cpiAddress_Equals(copy, address),
               "Copy and address not equal for LINK");

    parcJSON_Release(&json);
    cpiAddress_Destroy(&address);
    cpiAddress_Destroy(&copy);
    cpiAddress_Destroy(&fromjson);
    parcBuffer_Release(&macbuffer);
}
Esempio n. 11
0
static CCNxControl *
metisConfiguration_ProcessRegistrationList(MetisConfiguration *config, CCNxControl *request, unsigned ingressId)
{
    MetisFibEntryList *fibList = metisForwarder_GetFibEntries(config->metis);

    CPIRouteEntryList *routeEntryList = cpiRouteEntryList_Create();
    for (size_t i = 0; i < metisFibEntryList_Length(fibList); i++) {
        const MetisFibEntry *fibEntry = metisFibEntryList_Get(fibList, i);
        MetisTlvName *prefix = metisFibEntry_GetPrefix(fibEntry);
        const MetisNumberSet *nexthops = metisFibEntry_GetNexthops(fibEntry);

        for (int j = 0; j < metisNumberSet_Length(nexthops); j++) {
            CPIRouteEntry *route = cpiRouteEntry_Create(metisTlvName_ToCCNxName(prefix),
                                                        metisNumberSet_GetItem(nexthops, j),
                                                        NULL,
                                                        cpiNameRouteProtocolType_STATIC,
                                                        cpiNameRouteType_LONGEST_MATCH,
                                                        NULL, // lifetime
                                                        1);   // cost
            cpiRouteEntryList_Append(routeEntryList, route);
        }

        metisTlvName_Release(&prefix);
    }
    PARCJSON *entryListJson = cpiRouteEntryList_ToJson(routeEntryList);
    CCNxControl *response = cpi_CreateResponse(request, entryListJson);
    parcJSON_Release(&entryListJson);
    cpiRouteEntryList_Destroy(&routeEntryList);
    metisFibEntryList_Destroy(&fibList);
    return response;
}
LONGBOW_TEST_CASE(Global, cpiAddress_CreateFromInet6)
{
    struct sockaddr_in6 addr_in6;
    memset(&addr_in6, 0, sizeof(struct sockaddr_in6));

    inet_pton(AF_INET6, "2001:720:1500:1::a100", &(addr_in6.sin6_addr));
    addr_in6.sin6_family = AF_INET6;
    addr_in6.sin6_port = 0x0A0B;
    addr_in6.sin6_flowinfo = 0x01020304;

    CPIAddress *address = cpiAddress_CreateFromInet6(&addr_in6);

    struct sockaddr_in6 addr_test;
    bool success = cpiAddress_GetInet6(address, &addr_test);
    assertTrue(success, "Got false converting back address");

    assertTrue(memcmp(&addr_in6, &addr_test, sizeof(struct sockaddr_in6)) == 0, "Got mismatch addressed");

    assertTrue(cpiAddress_GetType(address) == cpiAddressType_INET6,
               "Got wrong address type, expected %d, got %d", cpiAddressType_INET6, cpiAddress_GetType(address));

    PARCJSON *json = cpiAddress_ToJson(address);
    CPIAddress *fromjson = cpiAddress_CreateFromJson(json);

    assertTrue(parcBuffer_Equals(address->blob, fromjson->blob), "fromjson blob does not equal known address");
    assertTrue(cpiAddress_Equals(address, fromjson), "cpiAddress_Equals broken for INET6 type");

    CPIAddress *copy = cpiAddress_Copy(address);
    assertTrue(cpiAddress_Equals(copy, address), "Copy and address not equal for INET6");

    parcJSON_Release(&json);
    cpiAddress_Destroy(&address);
    cpiAddress_Destroy(&copy);
    cpiAddress_Destroy(&fromjson);
}
Esempio n. 13
0
PARCJSONValue *
parcJSONValue_ObjectParser(PARCJSONParser *parser)
{
    PARCJSONValue *result = NULL;

    // absorb the (required) '{' character.
    if (parcJSONParser_NextChar(parser) == '{') {
        PARCJSON *json = parcJSON_Create();

        while (parcJSONParser_Remaining(parser)) {
            char c = parcJSONParser_PeekNextChar(parser);
            if (c == '}') {
                // Absorb the '}' and terminate.
                parcJSONParser_NextChar(parser);
                result = parcJSONValue_CreateFromJSON(json);
                break;
            } else if (c == ',') {
                // absorb the ',' character and continue
                parcJSONParser_NextChar(parser);
            } else if (c == '"') {
                PARCJSONPair *pair = parcJSONPair_Parser(parser);
                if (pair == NULL) {
                    break;
                }
                parcJSON_AddPair(json, pair);
                parcJSONPair_Release(&pair);
            } else {
                break;
            }
        }
        parcJSON_Release(&json);
    }

    return result;
}
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;
}
char *
ccnxManifestHashGroup_ToString(const CCNxManifestHashGroup *section)
{
    PARCJSON *json = ccnxManifestHashGroup_ToJson(section);
    char *stringRep = parcJSON_ToString(json);
    parcJSON_Release(&json);
    return stringRep;
}
CCNxControl *
ccnxControl_CreateRemoveRouteRequest(const CPIRouteEntry *route)
{
    PARCJSON *cpiRequest = cpiForwarding_CreateRemoveRouteRequest(route);
    CCNxControl *result = ccnxControl_CreateCPIRequest(cpiRequest);
    parcJSON_Release(&cpiRequest);
    return result;
}
CCNxControl *
ccnxControl_CreateInterfaceListRequest()
{
    PARCJSON *cpiRequest = cpiLinks_CreateInterfaceListRequest();
    CCNxControl *result = ccnxControl_CreateCPIRequest(cpiRequest);
    parcJSON_Release(&cpiRequest);
    return result;
}
CCNxControl *
ccnxControl_CreateCancelFlowRequest(const CCNxName *name)
{
    PARCJSON *request = cpiCancelFlow_CreateRequest(name);
    CCNxControl *result = ccnxControl_CreateCPIRequest(request);
    parcJSON_Release(&request);
    return result;
}
CCNxControl *
ccnxControl_CreateIPTunnelRequest(const CPIInterfaceIPTunnel *tunnel)
{
    PARCJSON *request = cpiLinks_CreateIPTunnel(tunnel);
    CCNxControl *result = ccnxControl_CreateCPIRequest(request);
    parcJSON_Release(&request);
    return result;
}
CCNxControl *
ccnxControl_CreateFlushRequest(void)
{
    PARCJSON *cpiRequest = cpi_CreateFlushRequest();
    CCNxControl *result = ccnxControl_CreateCPIRequest(cpiRequest);
    parcJSON_Release(&cpiRequest);
    return result;
}
CCNxControl *
ccnxControl_CreatePauseInputRequest()
{
    PARCJSON *cpiRequest = cpi_CreatePauseInputRequest();
    CCNxControl *result = ccnxControl_CreateCPIRequest(cpiRequest);
    parcJSON_Release(&cpiRequest);
    return result;
}
CCNxControl *
ccnxControl_CreateRouteListRequest()
{
    PARCJSON *cpiRequest = cpiForwarding_CreateRouteListRequest();
    CCNxControl *result = ccnxControl_CreateCPIRequest(cpiRequest);
    parcJSON_Release(&cpiRequest);
    return result;
}
Esempio n. 23
0
static void
_parcObjectTesting_AssertToJSON(const PARCObject *instance)
{
    PARCJSON *json = parcObject_ToJSON(instance);
    char *result = parcJSON_ToString(json);
    assertNotNull(result, "Something should be returned");
    parcMemory_Deallocate(&result);
    parcJSON_Release(&json);
}
Esempio n. 24
0
static void
_cmd_Version(_MetisCommandLineInterface_Session *session, _MetisCommandLineInterface_Command *command, const char *params)
{
    PARCJSON *versionJson = metisConfiguration_GetVersion(metisForwarder_GetConfiguration(session->parentCli->metis));
    char *str = parcJSON_ToString(versionJson);
    parcEventQueue_Printf(session->streamBuffer, "%s", str);
    parcMemory_Deallocate((void **) &str);
    parcJSON_Release(&versionJson);
}
Esempio n. 25
0
CCNxPortalAnchor *
ccnxPortalAnchor_Deserialize(PARCBuffer *buffer)
{
    PARCJSON *json = parcJSON_ParseBuffer(buffer);

    CCNxPortalAnchor *result = ccnxPortalAnchor_CreateFromJSON(json);
    parcJSON_Release(&json);
    return result;
}
PARCJSON *
cpi_CreateFlushRequest(void)
{
    PARCJSON *operation = parcJSON_Create();
    PARCJSON *result = cpi_CreateRequest(cpiFlush, operation);
    parcJSON_Release(&operation);

    return result;
}
PARCJSON *
cpi_CreatePauseInputRequest(void)
{
    PARCJSON *operation = parcJSON_Create();
    PARCJSON *result = cpi_CreateRequest(cpiPause, operation);
    parcJSON_Release(&operation);

    return result;
}
Esempio n. 28
0
LONGBOW_TEST_CASE(JSON, parcJSON_Equals)
{
    PARCJSON *x = parcJSON_ParseString("{ \"string\" : \"xyzzy\" }");
    PARCJSON *y = parcJSON_ParseString("{ \"string\" : \"xyzzy\" }");
    PARCJSON *z = parcJSON_ParseString("{ \"string\" : \"xyzzy\" }");

    PARCJSON *notEqual1 = parcJSON_ParseString("{ \"string\" : \"string\" }");

    PARCJSON *notEqual2 = parcJSON_ParseString("{ \"string\" : \"xyzzy\", \"integer\" : 1 }");

    parcObjectTesting_AssertEqualsFunction(parcJSON_Equals, x, y, z, notEqual1, notEqual2);

    parcJSON_Release(&x);
    parcJSON_Release(&y);
    parcJSON_Release(&z);
    parcJSON_Release(&notEqual1);
    parcJSON_Release(&notEqual2);
}
Esempio n. 29
0
LONGBOW_TEST_CASE(Object, parcStopwatch_ToJSON)
{
    PARCStopwatch *instance = parcStopwatch_Create();

    PARCJSON *json = parcStopwatch_ToJSON(instance);

    parcJSON_Release(&json);

    parcStopwatch_Release(&instance);
}
Esempio n. 30
0
LONGBOW_TEST_CASE(JSON, parcJSON_Copy)
{
    TestData *data = longBowTestCase_GetClipBoardData(testCase);

    PARCJSON *copy = parcJSON_Copy(data->json);

    assertTrue(parcJSON_Equals(data->json, copy), "Expect copy to equal original");

    parcJSON_Release(&copy);
}