Initial commit: ccnxlibs.

Change-Id: I1b376527a7dd01a6b9e083a6cb646955902f45c0
Signed-off-by: Luca Muscariello <lumuscar+fdio@cisco.com>

1 files changed, 399 insertions, 0 deletions

diff --git a/libccnx-common/ccnx/common/ccnx_Interest.c b/libccnx-common/ccnx/common/ccnx_Interest.c
new file mode 100755
index 00000000..481be0bc
--- /dev/null
+++ b/libccnx-common/ccnx/common/ccnx_Interest.c
@@ -0,0 +1,399 @@
+/*
+ * Copyright (c) 2017 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ */
+#include <config.h>
+
+#include <LongBow/runtime.h>
+
+#include <ccnx/common/ccnx_Interest.h>
+
+#include <ccnx/common/internal/ccnx_InterestDefault.h>
+#include <ccnx/common/ccnx_InterestPayloadId.h>
+#include <ccnx/common/ccnx_WireFormatMessage.h>
+
+#include <parc/algol/parc_Memory.h>
+
+#include <parc/algol/parc_DisplayIndented.h>
+
+#include <stdio.h>
+
+static const CCNxInterestInterface *_defaultImplementation = &CCNxInterestFacadeV1_Implementation;
+
+CCNxInterest *
+ccnxInterest_Create(const CCNxName *name,
+                    uint32_t lifetime,
+                    const PARCBuffer *keyId,
+                    const PARCBuffer *contentObjectHash)
+{
+    return ccnxInterest_CreateWithImpl(_defaultImplementation,
+                                       name,
+                                       lifetime,
+                                       keyId,
+                                       contentObjectHash,
+                                       CCNxInterestDefault_HopLimit);
+}
+
+CCNxInterest *
+ccnxInterest_CreateWithImpl(const CCNxInterestInterface *impl,
+                            const CCNxName *name,
+                            const uint32_t interestLifetime,
+                            const PARCBuffer *keyId,
+                            const PARCBuffer *contentObjectHash,
+                            const uint32_t hopLimit)
+{
+    CCNxInterest *result = NULL;
+
+    if (impl->create != NULL) {
+        result = impl->create(name, interestLifetime, keyId, contentObjectHash, hopLimit);
+
+        // And set the dictionary's interface pointer to the one we just used to create this.
+        ccnxTlvDictionary_SetMessageInterface(result, impl);
+    } else {
+        trapNotImplemented("Interest implementations must implement create()");
+    }
+    return result;
+}
+
+
+CCNxInterest *
+ccnxInterest_CreateSimple(const CCNxName *name)
+{
+    return ccnxInterest_Create(name,
+                               CCNxInterestDefault_LifetimeMilliseconds,
+                               NULL,
+                               NULL);
+}
+
+void
+ccnxInterest_AssertValid(const CCNxInterest *interest)
+{
+    assertNotNull(interest, "Must be a non-null pointer to a CCNxInterest.");
+
+    // Check for required fields in the underlying dictionary. Case 1036
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+    assertNotNull(impl, "Interest must have an valid implementation pointer.");
+
+    if (impl->assertValid != NULL) {
+        impl->assertValid(interest);
+    }
+}
+
+CCNxInterest *
+ccnxInterest_Acquire(const CCNxInterest *instance)
+{
+    return ccnxTlvDictionary_Acquire(instance);
+}
+
+void
+ccnxInterest_Release(CCNxInterest **instanceP)
+{
+    ccnxTlvDictionary_Release(instanceP);
+}
+
+bool
+ccnxInterest_Equals(const CCNxInterest *a, const CCNxInterest *b)
+{
+    if (a == b) {
+        return true;
+    }
+    if (a == NULL || b == NULL) {
+        return false;
+    }
+
+    CCNxInterestInterface *implA = ccnxInterestInterface_GetInterface(a);
+    CCNxInterestInterface *implB = ccnxInterestInterface_GetInterface(b);
+
+    if (implA != implB) {
+        return false;
+    }
+
+    CCNxName *nameA = implA->getName(a);
+    CCNxName *nameB = implB->getName(b);
+
+    PARCBuffer *keyA = implA->getKeyIdRestriction(a);
+    PARCBuffer *keyB = implB->getKeyIdRestriction(b);
+
+    uint64_t lifetimeA = implA->getLifetime(a);
+    uint64_t lifetimeB = implB->getLifetime(b);
+
+    if (ccnxName_Equals(nameA, nameB)) {
+        if (parcBuffer_Equals(keyA, keyB)) {
+            // Must compare the excludes.
+            if (lifetimeA == lifetimeB) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+CCNxName *
+ccnxInterest_GetName(const CCNxInterest *interest)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    CCNxName *result = NULL;
+
+    if (impl->getName != NULL) {
+        result = impl->getName(interest);
+    } else {
+        trapNotImplemented("ccnxInterest_GetName");
+    }
+    return result;
+}
+
+bool
+ccnxInterest_SetContentObjectHashRestriction(CCNxInterest *interest, const PARCBuffer *contentObjectHash)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    bool result = false;
+
+    if (impl->setContentObjectHashRestriction != NULL) {
+        result = impl->setContentObjectHashRestriction(interest, contentObjectHash);
+    } else {
+        trapNotImplemented("ccnxInterest_SetContentObjectHashRestriction");
+    }
+    return result;
+}
+
+PARCBuffer *
+ccnxInterest_GetContentObjectHashRestriction(const CCNxInterest *interest)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    PARCBuffer *result = NULL;
+
+    if (impl->getContentObjectHashRestriction != NULL) {
+        result = impl->getContentObjectHashRestriction(interest);
+    } else {
+        trapNotImplemented("ccnxInterest_GetContentObjectHash");
+    }
+    return result;
+}
+
+bool
+ccnxInterest_SetKeyIdRestriction(CCNxInterest *interest, const PARCBuffer *keyId)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    bool result = false;
+
+    if (impl->setKeyIdRestriction != NULL) {
+        result = impl->setKeyIdRestriction(interest, keyId);
+    } else {
+        trapNotImplemented("ccnxInterest_SetKeyIdRestriction");
+    }
+    return result;
+}
+
+PARCBuffer *
+ccnxInterest_GetKeyIdRestriction(const CCNxInterest *interest)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    PARCBuffer *result = NULL;
+
+    if (impl->getKeyIdRestriction != NULL) {
+        result = impl->getKeyIdRestriction(interest);
+    } else {
+        trapNotImplemented("ccnxInterest_GetKeyIdRestriction");
+    }
+    return result;
+}
+
+bool
+ccnxInterest_SetLifetime(CCNxInterest *interest, uint32_t lifetime)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    bool result = false;
+
+    if (impl->setLifetime != NULL) {
+        result = impl->setLifetime(interest, lifetime);
+    } else {
+        trapNotImplemented("ccnxInterest_SetLifetime");
+    }
+    return result;
+}
+
+uint32_t
+ccnxInterest_GetLifetime(const CCNxInterest *interest)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    uint32_t result = 0;
+
+    if (impl->getLifetime != NULL) {
+        result = impl->getLifetime(interest);
+    } else {
+        trapNotImplemented("ccnxInterest_GetLifetime");
+    }
+    return result;
+}
+
+bool
+ccnxInterest_SetPayload(CCNxInterest *interest, const PARCBuffer *payload)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    bool result = false;
+
+    if (impl->setPayload != NULL) {
+        result = impl->setPayload(interest, payload);
+    } else {
+        trapNotImplemented("ccnxInterest_SetPayload");
+    }
+    return result;
+}
+
+bool
+ccnxInterest_SetPayloadAndId(CCNxInterest *interest, const PARCBuffer *payload)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    bool result = false;
+
+    if (impl->setPayloadAndId != NULL) {
+        result = impl->setPayloadAndId(interest, payload);
+    } else {
+        trapNotImplemented("ccnxInterest_SetPayloadAndId");
+    }
+    return result;
+}
+
+bool
+ccnxInterest_SetPayloadWithId(CCNxInterest *interest, const PARCBuffer *payload, const CCNxInterestPayloadId *payloadId)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    bool result = false;
+
+    if (impl->setPayloadWithId != NULL) {
+        result = impl->setPayloadWithId(interest, payload, payloadId);
+    } else {
+        trapNotImplemented("ccnxInterest_SetPayloadWithId");
+    }
+    return result;
+}
+
+PARCBuffer *
+ccnxInterest_GetPayload(const CCNxInterest *interest)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    PARCBuffer *result = NULL;
+
+    if (impl->getPayload != NULL) {
+        result = impl->getPayload(interest);
+    } else {
+        trapNotImplemented("ccnxInterest_GetPayload");
+    }
+    return result;
+}
+
+bool
+ccnxInterest_SetHopLimit(CCNxTlvDictionary *interest, uint32_t hopLimit)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    bool result = false;
+
+    if (impl->setHopLimit != NULL) {
+        result = impl->setHopLimit(interest, hopLimit);
+    } else {
+        trapNotImplemented("ccnxInterest_GetSetHopLimit");
+    }
+    // Make sure any attached wire format buffers are in sync with the dictionary
+    ccnxWireFormatMessage_SetHopLimit(interest, hopLimit);
+    return result;
+}
+
+uint32_t
+ccnxInterest_GetHopLimit(const CCNxTlvDictionary *interest)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    uint32_t result = 0;
+
+    if (impl->getHopLimit != NULL) {
+        result = impl->getHopLimit(interest);
+    } else {
+        trapNotImplemented("ccnxInterest_GetHopLimit");
+    }
+    return result;
+}
+
+void
+ccnxInterest_Display(const CCNxInterest *interest, int indentation)
+{
+    ccnxInterest_OptionalAssertValid(interest);
+
+    parcDisplayIndented_PrintLine(indentation, "CCNxInterest@%p {\n", interest);
+    ccnxName_Display(ccnxInterest_GetName(interest), indentation + 1);
+
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    if (impl->display != NULL) {
+        impl->display(interest, 1);
+    }
+
+    parcDisplayIndented_PrintLine(indentation, "}\n");
+}
+
+char *
+ccnxInterest_ToString(const CCNxInterest *interest)
+{
+    char *result = NULL;
+
+    ccnxInterest_OptionalAssertValid(interest);
+
+    CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
+
+    if (impl->toString != NULL) {
+        result = impl->toString(interest);
+    } else {
+        char *name = ccnxName_ToString(ccnxInterest_GetName(interest));
+        uint32_t lifetime = ccnxInterest_GetLifetime(interest);
+
+        char *string;
+        int failure = asprintf(&string, "CCNxInterest{.name=\"%s\" .lifetime=%dms}", name, lifetime);
+        assertTrue(failure > 0, "Error from asprintf");
+
+        parcMemory_Deallocate((void **) &name);
+
+        result = parcMemory_StringDuplicate(string, strlen(string));
+
+        free(string);
+    }
+
+    return result;
+}