Initial commit: ccnxlibs.

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

1 files changed, 236 insertions, 0 deletions

diff --git a/libccnx-common/ccnx/common/ccnx_KeyLocator.c b/libccnx-common/ccnx/common/ccnx_KeyLocator.c
new file mode 100755
index 00000000..ea61a0c1
--- /dev/null
+++ b/libccnx-common/ccnx/common/ccnx_KeyLocator.c
@@ -0,0 +1,236 @@
+/*
+ * 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 <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <LongBow/runtime.h>
+
+#include <ccnx/common/ccnx_KeyLocator.h>
+
+#include <parc/algol/parc_Memory.h>
+#include <parc/algol/parc_Object.h>
+
+#include <parc/security/parc_Key.h>
+
+struct ccnx_key_locator {
+    union {
+        PARCKey *key;
+        CCNxLink *keyLink;
+    } locator;
+    CCNxKeyLocatorType type;
+};
+
+
+static void
+_Destroy(CCNxKeyLocator **keyLocatorP)
+{
+    if (keyLocatorP != NULL) {
+        CCNxKeyLocator *keyLocator = *keyLocatorP;
+        if (ccnxKeyLocator_IsKey(keyLocator)) {
+            parcKey_Release(&keyLocator->locator.key);
+        } else if (ccnxKeyLocator_IsKeyLink(keyLocator)) {
+            ccnxLink_Release(&keyLocator->locator.keyLink);
+        } else {
+            assertTrue(0, "KeyLocator is not one of %s.", "Key or KeyLink");
+        }
+    }
+}
+
+parcObject_ExtendPARCObject(CCNxKeyLocator, _Destroy, ccnxKeyLocator_Copy, ccnxKeyLocator_ToString, ccnxKeyLocator_Equals, NULL, NULL, NULL);
+
+parcObject_ImplementAcquire(ccnxKeyLocator, CCNxKeyLocator);
+
+parcObject_ImplementRelease(ccnxKeyLocator, CCNxKeyLocator);
+
+static CCNxKeyLocator *
+_Create(void)
+{
+    CCNxKeyLocator *result = parcObject_CreateInstance(CCNxKeyLocator);
+    if (NULL != result) {
+        result->locator.key = NULL;
+        result->type = CCNxKeyLocatorType_None;
+    }
+    return result;
+}
+
+CCNxKeyLocator *
+ccnxKeyLocator_Copy(const CCNxKeyLocator *original)
+{
+    CCNxKeyLocator *copy = NULL;
+
+    switch (original->type) {
+        case CCNxKeyLocatorType_Key: {
+            PARCKey *keyCopy = parcKey_Copy(original->locator.key);
+            copy = ccnxKeyLocator_CreateFromKey(keyCopy);
+            parcKey_Release(&keyCopy);
+        }
+        break;
+
+        case CCNxKeyLocatorType_Link: {
+            CCNxLink *keyLinkCopy = ccnxLink_Copy(original->locator.keyLink);
+            copy = ccnxKeyLocator_CreateFromKeyLink(keyLinkCopy);
+            ccnxLink_Release(&keyLinkCopy);
+        }
+        break;
+
+        case CCNxKeyLocatorType_None:
+            copy = _Create();
+            break;
+    }
+    return copy;
+}
+
+CCNxKeyLocator *
+ccnxKeyLocator_CreateFromKey(PARCKey *key)
+{
+    assertNotNull(key, "Parameter must be a non-null CCNxKey pointer.");
+
+    CCNxKeyLocator *result = _Create();
+    if (result != NULL) {
+        result->locator.key = parcKey_Acquire(key);
+        result->type = CCNxKeyLocatorType_Key;
+    }
+
+    return result;
+}
+
+CCNxKeyLocator *
+ccnxKeyLocator_CreateFromKeyLink(CCNxLink *keyLink)
+{
+    CCNxKeyLocator *result = _Create();
+    if (result != NULL) {
+        result->locator.keyLink = ccnxLink_Acquire(keyLink);
+        result->type = CCNxKeyLocatorType_Link;
+    }
+
+    return result;
+}
+
+bool
+ccnxKeyLocator_Equals(const CCNxKeyLocator *a, const CCNxKeyLocator *b)
+{
+    if (a == b) {
+        return true;
+    }
+    if (a == NULL || b == NULL) {
+        return false;
+    }
+
+    if (a->type == b->type) {
+        switch (a->type) {
+            case CCNxKeyLocatorType_Key:
+                return parcKey_Equals(a->locator.key, b->locator.key);
+
+            case CCNxKeyLocatorType_Link:
+                return ccnxLink_Equals(a->locator.keyLink, b->locator.keyLink);
+
+            default:
+                break;
+                // fall through
+        }
+    }
+    return false;
+}
+
+CCNxKeyLocatorType
+ccnxKeyLocator_GetType(const CCNxKeyLocator *ccnxKeyLocator)
+{
+    assertNotNull(ccnxKeyLocator, "Parameter must be a non-null CCNxKeyLocator pointer.");
+
+    return ccnxKeyLocator->type;
+}
+
+bool
+ccnxKeyLocator_IsKey(const CCNxKeyLocator *keyLocator)
+{
+    return (keyLocator->type == CCNxKeyLocatorType_Key);
+}
+
+bool
+ccnxKeyLocator_IsKeyLink(const CCNxKeyLocator *keyLocator)
+{
+    return (keyLocator->type == CCNxKeyLocatorType_Link);
+}
+
+char *
+ccnxKeyLocator_ToString(const CCNxKeyLocator *keyLocator)
+{
+    char *result;
+
+    if (keyLocator == NULL) {
+        char *nullString = "NULL";
+        result = parcMemory_StringDuplicate(nullString, strlen(nullString));
+    } else {
+        char *locator;
+        if (ccnxKeyLocator_IsKey(keyLocator)) {
+            locator = parcKey_ToString(keyLocator->locator.key);
+        } else if (ccnxKeyLocator_IsKeyLink(keyLocator)) {
+            locator = ccnxLink_ToString(keyLocator->locator.keyLink);
+        } else {
+            char *initString = "not initialised.";
+            locator = parcMemory_StringDuplicate(initString, strlen(initString));
+        }
+        char *string;
+        int failure = asprintf(&string, "KeyLocator { %s }", locator);
+        assertTrue(failure > -1, "Error asprintf");
+
+        parcMemory_Deallocate((void **) &locator);
+
+        result = parcMemory_StringDuplicate(string, strlen(string));
+        free(string);
+    }
+
+    return result;
+}
+
+CCNxLink *
+ccnxKeyLocator_GetKeyLink(const CCNxKeyLocator *keyLocator)
+{
+    assertTrue(keyLocator->type == CCNxKeyLocatorType_Link, "Key Locator must be of type CCNxKeyLocatorType_Link");
+
+    if (keyLocator->type == CCNxKeyLocatorType_Link) {
+        return keyLocator->locator.keyLink;
+    }
+    return NULL;
+}
+
+PARCKey *
+ccnxKeyLocator_GetKey(const CCNxKeyLocator *keyLocator)
+{
+    assertTrue(keyLocator->type == CCNxKeyLocatorType_Key, "Key Locator must be of type CCNxKeyLocatorType_Key");
+
+    if (keyLocator->type == CCNxKeyLocatorType_Key) {
+        return keyLocator->locator.key;
+    }
+    return NULL;
+}
+
+void
+ccnxKeyLocator_AssertValid(const CCNxKeyLocator *keyLocator)
+{
+    assertNotNull(keyLocator, "CCNxKeyLocator pointer was null");
+    if (ccnxKeyLocator_IsKey(keyLocator)) {
+        parcKey_AssertValid(keyLocator->locator.key);
+    } else if (ccnxKeyLocator_IsKeyLink(keyLocator)) {
+        ccnxLink_AssertValid(keyLocator->locator.keyLink);
+    } else {
+        assertTrue(0, "KeyLocator is not one of %s.", "Key or Key Link");
+    }
+}