diff options
Diffstat (limited to 'libccnx-common/ccnx/common/ccnx_Interest.c')
| -rwxr-xr-x | libccnx-common/ccnx/common/ccnx_Interest.c | 399 |
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; +} |