X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fstack%2Fsrc%2Frdpayload.c;h=03788522ddcf573e406e4faa2d9b7c7528428339;hb=390866079e285d2c74918432c0d597d5da52f8a0;hp=5a97219aaff098fb488b03c65072c125719be43e;hpb=3e9402ad71cb3e93266a77796f44d17bab9853fd;p=platform%2Fupstream%2Fiotivity.git

diff --git a/resource/csdk/stack/src/rdpayload.c b/resource/csdk/stack/src/rdpayload.c
index 5a97219..0378852 100644
--- a/resource/csdk/stack/src/rdpayload.c
+++ b/resource/csdk/stack/src/rdpayload.c
@@ -26,295 +26,199 @@
 #include "ocpayload.h"
 #include "payload_logging.h"
 
-#define TAG "OCRDPayload"
+#define TAG "OIC_RI_RDPAYLOAD"
 
 #define CBOR_ROOT_ARRAY_LENGTH 1
 
-static CborError FindStringInMap(CborValue *map, char *tags, char **value);
-static CborError FindIntInMap(CborValue *map, char *tags, uint64_t *value);
-static CborError FindStringLLInMap(const CborValue *linksMap, char *tag, OCStringLL **links);
-static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen, const char *value);
-static int64_t ConditionalAddIntToMap(CborEncoder *map, const char *tags, const size_t size, const uint64_t *value);
-static int64_t AddStringLLToMap(CborEncoder *map, char *tag, const size_t size, OCStringLL *value);
-
-int64_t OCRDPayloadToCbor(const OCRDPayload *rdPayload, uint8_t *outPayload, size_t *size)
+static CborError OCTagsPayloadToCbor(OCTagsPayload *tags, CborEncoder *setMap);
+static CborError OCLinksPayloadToCbor(OCLinksPayload *rtPtr, CborEncoder *setMap);
+static CborError OCTagsCborToPayload(CborValue *tagsMap, OCTagsPayload **tagsPayload);
+static CborError OCLinksCborToPayload(CborValue *linksArray, OCLinksPayload **linksPayload);
+static CborError FindStringInMap(const CborValue *map, const char *tags, char **value);
+static CborError FindIntInMap(const CborValue *map, const char *tags, uint64_t *value);
+static CborError FindStringLLInMap(const CborValue *linksMap, const char *tag, OCStringLL **links);
+static CborError ConditionalAddTextStringToMap(CborEncoder* map, const char* key, const char *value);
+static CborError ConditionalAddIntToMap(CborEncoder *map, const char *tags, const uint64_t *value);
+static CborError AddStringLLToMap(CborEncoder *map, const char *tag, const OCStringLL *value);
+
+CborError OCRDPayloadToCbor(const OCRDPayload *rdPayload, uint8_t *outPayload, size_t *size)
 {
-    if (!outPayload || !size)
-    {
-        OC_LOG(ERROR, TAG, "Invalid parameters.");
-        return OC_STACK_INVALID_PARAM;
-    }
-
-    CborEncoder encoder;
+    CborError cborEncoderResult = CborErrorIO;
     int flags = 0;
+    CborEncoder encoder;
+    VERIFY_PARAM_NON_NULL(TAG, rdPayload, "Invalid input parameter rdPayload");
+    VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid input parameter outPayload");
+    VERIFY_PARAM_NON_NULL(TAG, size, "Invalid input parameter size");
+
     cbor_encoder_init(&encoder, outPayload, *size, flags);
 
-    CborError cborEncoderResult;
     if (rdPayload->rdDiscovery)
     {
         CborEncoder map;
         cborEncoderResult = cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
-        if (CborNoError != cborEncoderResult)
-        {
-            OC_LOG(ERROR, TAG, "Failed creating discovery map.");
-            goto cbor_error;
-        }
-        if (CborNoError != ConditionalAddTextStringToMap(&map, OC_RSRVD_DEVICE_NAME,
-                sizeof(OC_RSRVD_DEVICE_NAME) - 1, (char *)rdPayload->rdDiscovery->n.deviceName))
-        {
-            OC_LOG(ERROR, TAG, "Failed setting OC_RSRVD_DEVICE_NAME.");
-            goto cbor_error;
-        }
-        if (CborNoError != ConditionalAddTextStringToMap(&map, OC_RSRVD_DEVICE_ID,
-                sizeof(OC_RSRVD_DEVICE_ID) - 1, (char *)rdPayload->rdDiscovery->di.id))
-        {
-            OC_LOG(ERROR, TAG, "Failed setting OC_RSRVD_DEVICE_ID.");
-            goto cbor_error;
-        }
-        uint64_t sel = (uint8_t) rdPayload->rdDiscovery->sel;
-        if (CborNoError != ConditionalAddIntToMap(&map, OC_RSRVD_RD_DISCOVERY_SEL,
-            sizeof(OC_RSRVD_RD_DISCOVERY_SEL) - 1, &sel))
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create discovery map");
+
+        cborEncoderResult = ConditionalAddTextStringToMap(&map, OC_RSRVD_DEVICE_NAME,
+            rdPayload->rdDiscovery->n.deviceName);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_NAME in map");
+
+        cborEncoderResult = ConditionalAddTextStringToMap(&map, OC_RSRVD_DEVICE_ID,
+            (char *)rdPayload->rdDiscovery->di.id);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_ID in map");
+
         {
-            OC_LOG(ERROR, TAG, "Failed setting OC_RSRVD_RD_DISCOVERY_SEL.");
-            goto cbor_error;
+            uint64_t value = rdPayload->rdDiscovery->sel;
+            cborEncoderResult = ConditionalAddIntToMap(&map, OC_RSRVD_RD_DISCOVERY_SEL, &value);
+            VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add RD_DISCOVERY_SEL in map");
         }
         cborEncoderResult = cbor_encoder_close_container(&encoder, &map);
-        if (CborNoError != cborEncoderResult)
-        {
-            OC_LOG(ERROR, TAG, "Failed closing discovery map.");
-            goto cbor_error;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing discovery map");
     }
     else if (rdPayload->rdPublish)
     {
         CborEncoder colArray;
         cborEncoderResult = cbor_encoder_create_array(&encoder, &colArray, CborIndefiniteLength);
-        if (CborNoError != cborEncoderResult)
-        {
-            OC_LOG(ERROR, TAG, "Failed creating collection array.");
-            goto cbor_error;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create collection array");
 
         OCResourceCollectionPayload *rdPublish = rdPayload->rdPublish;
         while (rdPublish)
         {
-            if (OC_STACK_OK != OCTagsPayloadToCbor(rdPublish->tags, &colArray))
-            {
-                OC_LOG(ERROR, TAG, "Failed creating tags payload.");
-                goto cbor_error;
-            }
-            if (OC_STACK_OK != OCLinksPayloadToCbor(rdPublish->setLinks, &colArray))
-            {
-                OC_LOG(ERROR, TAG, "Failed creating links payload.");
-                goto cbor_error;
-            }
+            cborEncoderResult = OCTagsPayloadToCbor(rdPublish->tags, &colArray);
+            VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed adding tags payload");
+            cborEncoderResult = OCLinksPayloadToCbor(rdPublish->setLinks, &colArray);
+            VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed adding setLinks payload");
             rdPublish = rdPublish->next;
         }
         cborEncoderResult = cbor_encoder_close_container(&encoder, &colArray);
-        if (CborNoError != cborEncoderResult)
-        {
-            OC_LOG(ERROR, TAG, "Failed closing collection array.");
-            goto cbor_error;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing collection array");
     }
     else
     {
         CborEncoder map;
         cborEncoderResult = cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
-        if (CborNoError != cborEncoderResult)
-        {
-            OC_LOG(ERROR, TAG, "Failed creating discovery map.");
-            goto cbor_error;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed entering discovery map");
         cborEncoderResult = cbor_encoder_close_container(&encoder, &map);
-        if (CborNoError != cborEncoderResult)
-        {
-            OC_LOG(ERROR, TAG, "Failed creating discovery map.");
-            goto cbor_error;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing discovery map");
     }
     *size = encoder.ptr - outPayload;
 
-    return OC_STACK_OK;
-cbor_error:
+    return cborEncoderResult;
+
+exit:
     OICFree(outPayload);
-    return OC_STACK_ERROR;
+    return cborEncoderResult;
 }
 
-OCStackResult OCTagsPayloadToCbor(OCTagsPayload *tags, CborEncoder *setMap)
+static CborError OCTagsPayloadToCbor(OCTagsPayload *tags, CborEncoder *setMap)
 {
     CborEncoder tagsMap;
     CborError cborEncoderResult = cbor_encoder_create_map(setMap, &tagsMap, CborIndefiniteLength);
-    if (CborNoError != cborEncoderResult)
-    {
-        OC_LOG(ERROR, TAG, "Failed creating TAGS map.");
-        return OC_STACK_ERROR;
-    }
+    VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create tags map");
+
+    cborEncoderResult = ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DEVICE_NAME, tags->n.deviceName);
+    VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_NAME in tags map");
+
+    cborEncoderResult = ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DEVICE_ID,
+            (char *)tags->di.id);
+    VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_ID in tags map");
+
+    cborEncoderResult = ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_RTS, tags->rts);
+    VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_RTS in tags map");
+
+    cborEncoderResult = ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DREL, tags->drel);
+    VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DREL in tags map");
+
+    cborEncoderResult = ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_BASE_URI, tags->baseURI);
+    VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_BASE_URI in tags map");
 
-    if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DEVICE_NAME,
-            sizeof(OC_RSRVD_DEVICE_NAME) - 1, (char *)tags->n.deviceName))
-    {
-        OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_DEVICE_NAME in TAGS map.");
-        return OC_STACK_ERROR;
-    }
-    if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DEVICE_ID,
-            sizeof(OC_RSRVD_DEVICE_ID) - 1, (char *)tags->di.id))
-    {
-        OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_DEVICE_ID in TAGS map.");
-        return OC_STACK_ERROR;
-    }
-    if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_RTS,
-            sizeof(OC_RSRVD_RTS) - 1, (char *)tags->rts))
-    {
-        OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_RTS in TAGS map.");
-        return OC_STACK_ERROR;
-    }
-    if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DREL,
-            sizeof(OC_RSRVD_DREL) - 1, (char *)tags->drel))
-    {
-        OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_DREL in TAGS map.");
-        return OC_STACK_ERROR;
-    }
-    if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_BASE_URI,
-            sizeof(OC_RSRVD_BASE_URI) - 1, (char *)tags->baseURI))
-    {
-        OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_BASE_URI in TAGS map.");
-        return OC_STACK_ERROR;
-    }
-    uint64_t temp = (uint64_t)tags->bitmap;
-    if (CborNoError != ConditionalAddIntToMap(&tagsMap, OC_RSRVD_BITMAP,
-            sizeof(OC_RSRVD_BITMAP) - 1, &temp))
-    {
-        OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_BITMAP in TAGS map.");
-        return OC_STACK_ERROR;
-    }
-    temp = (uint64_t)tags->port;
-    if (CborNoError != ConditionalAddIntToMap(&tagsMap, OC_RSRVD_HOSTING_PORT,
-            sizeof(OC_RSRVD_HOSTING_PORT) - 1, &temp))
-    {
-        OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_HOSTING_PORT in TAGS map.");
-        return OC_STACK_ERROR;
-    }
-    temp = (uint64_t)tags->ins;
-    if (CborNoError != ConditionalAddIntToMap(&tagsMap, OC_RSRVD_INS,
-            sizeof(OC_RSRVD_INS) - 1, &temp))
-    {
-        OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_INS in TAGS map.");
-        return OC_STACK_ERROR;
-    }
-    temp = (uint64_t)tags->ttl;
-    if (CborNoError != ConditionalAddIntToMap(&tagsMap, OC_RSRVD_TTL,
-            sizeof(OC_RSRVD_TTL) - 1, &temp))
     {
-        OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_TTL in TAGS map.");
-        return OC_STACK_ERROR;
+        uint64_t value = tags->bitmap;
+        cborEncoderResult = ConditionalAddIntToMap(&tagsMap, OC_RSRVD_BITMAP, &value);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_BITMAP in tags map");
+
+        value = tags->port;
+        cborEncoderResult = ConditionalAddIntToMap(&tagsMap, OC_RSRVD_HOSTING_PORT, &value);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_HOSTING_PORT in tags map");
+
+        value = tags->ins;
+        cborEncoderResult = ConditionalAddIntToMap(&tagsMap, OC_RSRVD_INS, &value);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_INS in tags map");
+
+        value = tags->ttl;
+        cborEncoderResult = ConditionalAddIntToMap(&tagsMap, OC_RSRVD_TTL, &value);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_TTL in tags map");
     }
+
     cborEncoderResult = cbor_encoder_close_container(setMap, &tagsMap);
-    if (CborNoError != cborEncoderResult)
-    {
-        OC_LOG(ERROR, TAG, "Failed closing TAGS map.");
-        return OC_STACK_ERROR;
-    }
-    return OC_STACK_OK;
+    VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to close container");
+
+exit:
+    return cborEncoderResult;
 }
 
-OCStackResult OCLinksPayloadToCbor(OCLinksPayload *rtPtr, CborEncoder *setMap)
+static CborError OCLinksPayloadToCbor(OCLinksPayload *rtPtr, CborEncoder *setMap)
 {
     CborEncoder linksArray;
     CborError cborEncoderResult;
 
     cborEncoderResult = cbor_encoder_create_array(setMap, &linksArray, CborIndefiniteLength);
-    if (CborNoError != cborEncoderResult)
-    {
-        OC_LOG(ERROR, TAG, "Failed creating LINKS array.");
-        return OC_STACK_ERROR;
-    }
+    VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create Links array");
+
     while (rtPtr)
     {
         CborEncoder linksMap;
-        cborEncoderResult = cbor_encoder_create_map(&linksArray, &linksMap,
-                CborIndefiniteLength);
-        if (CborNoError != cborEncoderResult)
-        {
-            OC_LOG(ERROR, TAG, "Failed creating LINKS map.");
-            return OC_STACK_ERROR;
-        }
-        if (CborNoError != ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_HREF,
-                sizeof(OC_RSRVD_HREF) - 1, rtPtr->href))
-        {
-            OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_HREF in LINKS map.");
-            return OC_STACK_ERROR;
-        }
-        if (CborNoError != ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_REL,
-                sizeof(OC_RSRVD_REL) - 1,  rtPtr->rel))
-        {
-            OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_REL in LINKS map.");
-            return OC_STACK_ERROR;
-        }
-        if (CborNoError != ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_TITLE,
-                sizeof(OC_RSRVD_TITLE) - 1, rtPtr->title))
-        {
-            OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_TITLE in LINKS map.");
-            return OC_STACK_ERROR;
-        }
-        if (CborNoError != ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_URI,
-                sizeof(OC_RSRVD_URI) - 1, rtPtr->uri))
-        {
-            OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_URI in LINKS map.");
-            return OC_STACK_ERROR;
-        }
-        if (CborNoError != AddStringLLToMap(&linksMap, OC_RSRVD_RESOURCE_TYPE,
-                sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, rtPtr->rt))
-        {
-            OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_RESOURCE_TYPE in LINKS map.");
-            return OC_STACK_ERROR;
-        }
-        if (CborNoError != AddStringLLToMap(&linksMap, OC_RSRVD_INTERFACE,
-                sizeof(OC_RSRVD_INTERFACE) - 1, rtPtr->itf))
-        {
-            OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_INTERFACE in LINKS map.");
-            return OC_STACK_ERROR;
-        }
-        if (CborNoError != AddStringLLToMap(&linksMap, OC_RSRVD_MEDIA_TYPE,
-                sizeof(OC_RSRVD_MEDIA_TYPE) - 1, rtPtr->mt))
-        {
-            OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_MEDIA_TYPE in LINKS map.");
-            return OC_STACK_ERROR;
-        }
-        uint64_t temp = (uint64_t)rtPtr->ins;
-        if (CborNoError != ConditionalAddIntToMap(&linksMap, OC_RSRVD_INS,
-            sizeof(OC_RSRVD_INS) - 1, &temp))
+        cborEncoderResult = cbor_encoder_create_map(&linksArray, &linksMap, CborIndefiniteLength);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create Links map");
+
+        cborEncoderResult = ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_HREF, rtPtr->href);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_HREF in Links map");
+
+        cborEncoderResult = ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_REL, rtPtr->rel);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_REL in Links map");
+
+        cborEncoderResult = ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_TITLE, rtPtr->title);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_TITLE in Links map");
+
+        cborEncoderResult = ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_URI, rtPtr->uri);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_URI in Links map");
+
+        cborEncoderResult = AddStringLLToMap(&linksMap, OC_RSRVD_RESOURCE_TYPE, rtPtr->rt);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_RT in Links map");
+
+        cborEncoderResult = AddStringLLToMap(&linksMap, OC_RSRVD_INTERFACE, rtPtr->itf);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_ITF in Links map");
+
+        cborEncoderResult = AddStringLLToMap(&linksMap, OC_RSRVD_MEDIA_TYPE, rtPtr->mt);
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_MT in Links map");
+
         {
-            OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_INS in LINKS map.");
-            return OC_STACK_ERROR;
+            uint64_t value = rtPtr->ins;
+            cborEncoderResult = ConditionalAddIntToMap(&linksMap, OC_RSRVD_INS, &value);
+            VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_INS in Links map");
         }
+
         cborEncoderResult = cbor_encoder_close_container(&linksArray, &linksMap);
-        if (CborNoError != cborEncoderResult)
-        {
-            OC_LOG(ERROR, TAG, "Failed closing LINKS map.");
-            return OC_STACK_ERROR;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing Links map");
+
         rtPtr = rtPtr->next;
     }
     cborEncoderResult = cbor_encoder_close_container(setMap, &linksArray);
-    if (CborNoError != cborEncoderResult)
-    {
-        OC_LOG(ERROR, TAG, "Failed closing LINKS array.");
-        return OC_STACK_ERROR;;
-    }
-    return OC_STACK_OK;
+    VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing links array");
+
+exit:
+    return cborEncoderResult;
 }
 
 OCStackResult OCRDCborToPayload(const CborValue *cborPayload, OCPayload **outPayload)
 {
     CborValue *rdCBORPayload = (CborValue *)cborPayload;
+    OCStackResult ret = OC_STACK_NO_MEMORY;
     CborError cborFindResult;
 
     OCRDPayload *rdPayload = OCRDPayloadCreate();
-    if (!rdPayload)
-    {
-        goto no_memory;
-    }
+    VERIFY_PARAM_NON_NULL(TAG, rdPayload, "Failed allocating rdPayload");
+
+    ret = OC_STACK_MALFORMED_RESPONSE;
 
     if (cbor_value_is_array(rdCBORPayload))
     {
@@ -326,140 +230,100 @@ OCStackResult OCRDCborToPayload(const CborValue *cborPayload, OCPayload **outPay
             // enter tags map
             CborValue tags;
             cborFindResult = cbor_value_enter_container(rdCBORPayload, &tags);
-            if (cborFindResult != CborNoError)
-            {
-                goto cbor_error;
-            }
-            if (OC_STACK_OK != OCTagsCborToPayload(&tags, &tagsPayload))
-            {
-                OCFreeTagsResource(tagsPayload);
-                goto cbor_error;
-            }
+            VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed entering tags container.");
+
+            cborFindResult= OCTagsCborToPayload(&tags, &tagsPayload);
+            VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed parsing tags payload.");
             OCTagsLog(DEBUG, tagsPayload);
-            if (OC_STACK_OK != OCLinksCborToPayload(&tags, &linksPayload))
-            {
-                OCFreeLinksResource(linksPayload);
-                OCFreeTagsResource(tagsPayload);
-                goto cbor_error;
-            }
+
+            cborFindResult = OCLinksCborToPayload(&tags, &linksPayload);
+            VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed parsing links payload.");
             OCLinksLog(DEBUG, linksPayload);
+
             // Move from tags payload to links array.
-            if (CborNoError != cbor_value_advance(rdCBORPayload))
-            {
-                OC_LOG(DEBUG, TAG, "Failed advancing from tags payload to links.");
-                OCFreeLinksResource(linksPayload);
-                OCFreeTagsResource(tagsPayload);
-                goto cbor_error;
-            }
+            cborFindResult = cbor_value_advance(rdCBORPayload);
+            VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing rdCborPayload.");
         }
         rdPayload->rdPublish = OCCopyCollectionResource(tagsPayload, linksPayload);
-        if (!rdPayload->rdPublish)
-        {
-            goto cbor_error;
-        }
+        VERIFY_PARAM_NON_NULL(TAG, rdPayload->rdPublish, "Failed allocating rdPayload->rdPublish");
     }
     else if (cbor_value_is_map(rdCBORPayload))
     {
-        char *name = NULL;
-        if (CborNoError != FindStringInMap(rdCBORPayload, OC_RSRVD_DEVICE_NAME, &name))
-        {
-            goto cbor_error;
-        }
-        char *id = NULL;
-        if (CborNoError != FindStringInMap(rdCBORPayload, OC_RSRVD_DEVICE_ID, &id))
-        {
-            goto cbor_error;
-        }
-        uint64_t biasFactor = 0;
-        if (CborNoError != FindIntInMap(rdCBORPayload, OC_RSRVD_RD_DISCOVERY_SEL, &biasFactor))
+        rdPayload->rdDiscovery = (OCRDDiscoveryPayload *)OICCalloc(1, sizeof(OCRDDiscoveryPayload));
+        VERIFY_PARAM_NON_NULL(TAG, rdPayload->rdDiscovery, "Failed allocating discoveryPayload");
+
+        cborFindResult = FindStringInMap(rdCBORPayload, OC_RSRVD_DEVICE_NAME,
+                &rdPayload->rdDiscovery->n.deviceName);
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding OC_RSRVD_DEVICE_NAME.");
+        char *deviceId = NULL;
+        cborFindResult = FindStringInMap(rdCBORPayload, OC_RSRVD_DEVICE_ID, &deviceId);
+        if (deviceId)
         {
-            goto cbor_error;
+            memcpy(rdPayload->rdDiscovery->di.id, deviceId, strlen(deviceId));
+            OICFree(deviceId);
         }
-        rdPayload->rdDiscovery = OCRDDiscoveryPayloadCreate(name, id, (uint8_t)biasFactor);
-        if (!rdPayload->rdDiscovery)
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding OC_RSRVD_DEVICE_ID.");
+
         {
-            goto no_memory;
+            uint64_t value = 0;
+            cborFindResult = FindIntInMap(rdCBORPayload, OC_RSRVD_RD_DISCOVERY_SEL, &value);
+            VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding OC_RSRVD_RD_DISCOVERY_SEL.");
+            rdPayload->rdDiscovery->sel = value;
         }
-        OICFree(id);
-        OICFree(name);
+
         cborFindResult =  cbor_value_advance(rdCBORPayload);
-        if (CborNoError != cborFindResult)
-        {
-            goto cbor_error;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing rdCBORPayload.");
     }
-    OC_LOG_PAYLOAD(DEBUG, (OCPayload *) rdPayload);
+    OIC_LOG_PAYLOAD(DEBUG, (OCPayload *) rdPayload);
     *outPayload = (OCPayload *)rdPayload;
     return OC_STACK_OK;
-no_memory:
-    OC_LOG(ERROR, TAG, "Failed allocating memory.");
-    OCRDPayloadDestroy(rdPayload);
-    return OC_STACK_NO_MEMORY;
 
-cbor_error:
+exit:
     OCRDPayloadDestroy(rdPayload);
-    return OC_STACK_ERROR;
+    return ret;
 }
 
-static CborError FindStringInMap(CborValue *map, char *tags, char **value)
+static CborError FindStringInMap(const CborValue *map, const char *tags, char **value)
 {
     CborValue curVal;
-    size_t len;
     CborError cborFindResult = cbor_value_map_find_value(map, tags, &curVal);
     if (CborNoError == cborFindResult && cbor_value_is_text_string(&curVal))
     {
+        size_t len = 0;
         cborFindResult = cbor_value_dup_text_string(&curVal, value, &len, NULL);
-        if (CborNoError != cborFindResult)
-        {
-            OC_LOG_V(ERROR, TAG, "Failed finding value for tag %s .", tags);
-            return cborFindResult;
-        }
     }
-    return CborNoError;
+    return cborFindResult;
 }
 
-static CborError FindIntInMap(CborValue *map, char *tags, uint64_t *value)
+static CborError FindIntInMap(const CborValue *map, const char *tags, uint64_t *value)
 {
     CborValue curVal;
     CborError cborFindResult = cbor_value_map_find_value(map, tags, &curVal);
     if (CborNoError == cborFindResult && cbor_value_is_unsigned_integer(&curVal))
     {
         cborFindResult = cbor_value_get_uint64(&curVal, value);
-        if (CborNoError != cborFindResult)
-        {
-            OC_LOG_V(ERROR, TAG, "Failed finding value for tag %s .", tags);
-            return cborFindResult;
-        }
     }
-    return CborNoError;
+    return cborFindResult;
 }
 
-static CborError FindStringLLInMap(const CborValue *linksMap, char *tag, OCStringLL **links)
+static CborError FindStringLLInMap(const CborValue *linksMap, const char *tag, OCStringLL **links)
 {
     size_t len;
-    CborError cborFindResult;
     CborValue rtArray;
-    cborFindResult = cbor_value_map_find_value(linksMap, tag, &rtArray);
-    if (CborNoError != cborFindResult)
-    {
-        return CborUnknownError;
-    }
+    OCStringLL* llPtr = *links;
+    CborError cborFindResult = cbor_value_map_find_value(linksMap, tag, &rtArray);
+    VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding tag");
+
     CborValue rtVal;
     cborFindResult = cbor_value_enter_container(&rtArray, &rtVal);
-    if (CborNoError != cborFindResult)
-    {
-        return CborUnknownError;
-    }
-    OCStringLL* llPtr = *links;
+    VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed entering container");
+
     while (cbor_value_is_text_string(&rtVal))
     {
         if (llPtr == NULL)
         {
             llPtr = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
-            if (!llPtr)
-            {
-                return CborUnknownError;
-            }
+            VERIFY_PARAM_NON_NULL(TAG, llPtr, "Failed allocating OCStringLL");
             *links = llPtr;
         }
         else if(llPtr)
@@ -469,182 +333,113 @@ static CborError FindStringLLInMap(const CborValue *linksMap, char *tag, OCStrin
                 llPtr = llPtr->next;
             }
             llPtr->next = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
-            if (!llPtr->next)
-            {
-                return CborUnknownError;
-            }
+            VERIFY_PARAM_NON_NULL(TAG, llPtr->next, "Failed allocating OCStringLL->next");
         }
         cborFindResult = cbor_value_dup_text_string(&rtVal, &(llPtr->value), &len, NULL);
-        if (CborNoError != cborFindResult)
-        {
-            return CborUnknownError;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed duplicating value");
         cborFindResult = cbor_value_advance(&rtVal);
-        if (CborNoError != cborFindResult)
-        {
-            return CborUnknownError;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing OCStringLL");
     }
 
     cborFindResult = cbor_value_leave_container(&rtArray, &rtVal);
+    VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed leaving container");
+
+exit:
     return cborFindResult;
 }
 
-OCStackResult OCTagsCborToPayload(CborValue *tagsMap, OCTagsPayload **tagsPayload)
+static CborError OCTagsCborToPayload(CborValue *tagsMap, OCTagsPayload **tagsPayload)
 {
+    CborError cborFindResult = CborErrorOutOfMemory;
     OCTagsPayload *tags = (OCTagsPayload *)OICCalloc(1, sizeof(OCTagsPayload));
-    if (!tags)
-    {
-        return OC_STACK_NO_MEMORY;
-    }
+    VERIFY_PARAM_NON_NULL(TAG, tags, "Failed allocating tags");
+
     if (cbor_value_is_map(tagsMap))
     {
-        if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_DEVICE_NAME, &tags->n.deviceName))
-        {
-            OCFreeTagsResource(tags);
-            return OC_STACK_ERROR;
-        }
-        if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_DREL, &tags->drel))
-        {
-            OCFreeTagsResource(tags);
-            return OC_STACK_ERROR;
-        }
-        if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_RTS, &tags->rts))
-        {
-            OCFreeTagsResource(tags);
-            return OC_STACK_ERROR;
-        }
-        if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_BASE_URI, &tags->baseURI))
-        {
-            OCFreeTagsResource(tags);
-            return OC_STACK_ERROR;
-        }
-        char *id = NULL;
-        if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_DEVICE_ID, &id))
-        {
-            OCFreeTagsResource(tags);
-            return OC_STACK_ERROR;
-        }
-        if (id)
-        {
-            OICStrcpy((char*)tags->di.id, MAX_IDENTITY_SIZE, id);
-            tags->di.id_length = MAX_IDENTITY_SIZE;
-            OICFree(id);
-        }
-        uint64_t temp;
-        if (CborNoError != FindIntInMap(tagsMap, OC_RSRVD_HOSTING_PORT, &temp))
-        {
-            OCFreeTagsResource(tags);
-            return OC_STACK_ERROR;
-        }
-        tags->port = (uint16_t) temp;
-        if (CborNoError != FindIntInMap(tagsMap, OC_RSRVD_BITMAP, &temp))
-        {
-            OCFreeTagsResource(tags);
-            return OC_STACK_ERROR;
-        }
-        tags->bitmap = (uint8_t) temp;
-        if (CborNoError != FindIntInMap(tagsMap, OC_RSRVD_INS, &temp))
-        {
-            OCFreeTagsResource(tags);
-            return OC_STACK_ERROR;
-        }
-        tags->ins = (uint8_t) temp;
-        if (CborNoError != FindIntInMap(tagsMap, OC_RSRVD_TTL, &temp))
-        {
-            OCFreeTagsResource(tags);
-            return OC_STACK_ERROR;
-        }
-        tags->ttl = (uint32_t) temp;
-
-        if (CborNoError != cbor_value_advance(tagsMap))
-        {
-            OCFreeTagsResource(tags);
-            return OC_STACK_ERROR;
-        }
+        cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_DEVICE_NAME, &tags->n.deviceName);
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding deviceName");
+        cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_DREL, &tags->drel);
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding drel");
+        cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_RTS, &tags->rts);
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding rts");
+        cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_BASE_URI, &tags->baseURI);
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding baseURI");
+        char *deviceId = NULL;
+        cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_DEVICE_ID, &deviceId);
+        if (deviceId)
+        {
+            memcpy(tags->di.id, deviceId, strlen(deviceId));
+            OICFree(deviceId);
+        }
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding deviceId");
+        {
+            uint64_t value = 0;
+            cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_HOSTING_PORT, &value);
+            VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding port");
+            tags->port = value;
+            value = 0;
+            cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_BITMAP, &value);
+            VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding bitmap");
+            tags->bitmap = value;
+            value = 0;
+            cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_INS, &value);
+            VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding ins");
+            tags->ins = value;
+            value = 0;
+            cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_TTL, &value);
+            tags->ttl = value;
+        }
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding ttl");
+        cborFindResult = cbor_value_advance(tagsMap);
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing bitmap");
     }
     *tagsPayload = tags;
-    return OC_STACK_OK;
+    return cborFindResult;
+
+exit:
+    OCFreeTagsResource(tags);
+    return cborFindResult;
 }
 
-OCStackResult OCLinksCborToPayload(CborValue *linksArray, OCLinksPayload **linksPayload)
+static CborError OCLinksCborToPayload(CborValue *linksArray, OCLinksPayload **linksPayload)
 {
     CborValue linksMap;
+    OCLinksPayload *setLinks = NULL;
     CborError cborFindResult = cbor_value_enter_container(linksArray, &linksMap);
-    if (CborNoError != cborFindResult)
-    {
-        OC_LOG(ERROR, TAG, "Failed enter links map");
-        return OC_STACK_ERROR;
-    }
+    VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed entering links map container");
 
     while (cbor_value_is_map(&linksMap))
     {
-        OCLinksPayload *setLinks = (OCLinksPayload *)OICCalloc(1, sizeof(OCLinksPayload));
-        if (!setLinks)
-        {
-            OC_LOG(ERROR, TAG, "Failed allocating memory.");
-            OCFreeLinksResource(*linksPayload);
-            return OC_STACK_NO_MEMORY;
-        }
+        setLinks = (OCLinksPayload *)OICCalloc(1, sizeof(OCLinksPayload));
+        VERIFY_PARAM_NON_NULL(TAG, setLinks, "Failed allocating setLinks");
+
         cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_HREF, &setLinks->href);
-        if (CborNoError != cborFindResult)
-        {
-            OCFreeLinksResource(*linksPayload);
-            OCFreeLinksResource(setLinks);
-            return OC_STACK_ERROR;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding href value");
+
         cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_REL, &setLinks->rel);
-        if (CborNoError != cborFindResult)
-        {
-            OCFreeLinksResource(*linksPayload);
-            OCFreeLinksResource(setLinks);
-            return OC_STACK_ERROR;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding rel value");
 
         cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_TITLE, &setLinks->title);
-        if (CborNoError != cborFindResult)
-        {
-            OCFreeLinksResource(*linksPayload);
-            OCFreeLinksResource(setLinks);
-            return OC_STACK_ERROR;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding title value");
+
         cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_URI, &setLinks->uri);
-        if (CborNoError != cborFindResult)
-        {
-            OCFreeLinksResource(*linksPayload);
-            OCFreeLinksResource(setLinks);
-            return OC_STACK_ERROR;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding uri value");
+
         cborFindResult = FindStringLLInMap(&linksMap, OC_RSRVD_RESOURCE_TYPE, &setLinks->rt);
-        if (CborNoError != cborFindResult)
-        {
-            OCFreeLinksResource(*linksPayload);
-            OCFreeLinksResource(setLinks);
-            return OC_STACK_ERROR;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding rt value");
+
         cborFindResult = FindStringLLInMap(&linksMap, OC_RSRVD_INTERFACE, &setLinks->itf);
-        if (CborNoError != cborFindResult)
-        {
-            OCFreeLinksResource(*linksPayload);
-            OCFreeLinksResource(setLinks);
-            return OC_STACK_ERROR;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding itf value");
+
         cborFindResult = FindStringLLInMap(&linksMap, OC_RSRVD_MEDIA_TYPE, &setLinks->mt);
-        if (CborNoError != cborFindResult)
-        {
-            OCFreeLinksResource(*linksPayload);
-            OCFreeLinksResource(setLinks);
-            return OC_STACK_ERROR;
-        }
-        uint64_t temp;
-        cborFindResult = FindIntInMap(&linksMap, OC_RSRVD_INS, &temp);
-        if (CborNoError != cborFindResult)
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding mt value");
+
         {
-            OCFreeLinksResource(*linksPayload);
-            OCFreeLinksResource(setLinks);
-            return OC_STACK_ERROR;
+            uint64_t value = 0;
+            cborFindResult = FindIntInMap(&linksMap, OC_RSRVD_INS, &value);
+            VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding ins value");
+            setLinks->ins = value;
         }
-        setLinks->ins = (uint8_t) temp;
 
         if (!*linksPayload)
         {
@@ -660,100 +455,84 @@ OCStackResult OCLinksCborToPayload(CborValue *linksArray, OCLinksPayload **links
             temp->next = setLinks;
         }
         cborFindResult = cbor_value_advance(&linksMap);
-        if (CborNoError != cborFindResult)
-        {
-            OC_LOG(ERROR, TAG, "Failed advancing links map");
-            OCFreeLinksResource(*linksPayload);
-            OCFreeLinksResource(setLinks);
-            return OC_STACK_ERROR;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing links map");
     }
-    return OC_STACK_OK;
+
+    return cborFindResult;
+
+exit:
+    OCFreeLinksResource(*linksPayload);
+    OCFreeLinksResource(setLinks);
+    return cborFindResult;
 }
 
-static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
-        const char* value)
+static CborError AddTextStringToMap(CborEncoder* map, const char* key, const char* value)
 {
-    return cbor_encode_text_string(map, key, keylen) |
-           cbor_encode_text_string(map, value, strlen(value));
+    CborError err = cbor_encode_text_string(map, key, strlen(key));
+    VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting key value");
+    err = cbor_encode_text_string(map, value, strlen(value));
+exit:
+    return err;
 }
 
-static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
-        const char* value)
+static CborError ConditionalAddTextStringToMap(CborEncoder* map, const char* key, const char* value)
 {
-    return value ? AddTextStringToMap(map, key, keylen, value) : 0;
+    return value ? AddTextStringToMap(map, key, value) : CborNoError;
 }
 
-static int64_t ConditionalAddIntToMap(CborEncoder *map, const char *tags, const size_t size,
-    const uint64_t *value)
+static CborError ConditionalAddIntToMap(CborEncoder *map, const char *tags, const uint64_t *value)
 {
-    return (*value) ? (cbor_encode_text_string(map, tags, size) |
-                     cbor_encode_uint(map, *value)): 0;
+    CborError err = CborNoError;
+    if (*value)
+    {
+        err = cbor_encode_text_string(map, tags, strlen(tags));
+        VERIFY_CBOR_SUCCESS(TAG, err, "failed setting value");
+        err = cbor_encode_uint(map, *value);
+    }
+exit:
+    return err;
 }
 
-static int64_t AddStringLLToMap(CborEncoder *map, char *tag, const size_t size, OCStringLL *value)
+static CborError AddStringLLToMap(CborEncoder *map, const char *tag, const OCStringLL *strType)
 {
     CborEncoder array;
     CborError cborEncoderResult;
-    cborEncoderResult = cbor_encode_text_string(map, tag, size);
-    if (CborNoError != cborEncoderResult)
-    {
-        return cborEncoderResult;
-    }
+    cborEncoderResult = cbor_encode_text_string(map, tag, strlen(tag));
+    VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed encoding string tag name");
     cborEncoderResult = cbor_encoder_create_array(map, &array, CborIndefiniteLength);
-    if (CborNoError != cborEncoderResult)
-    {
-        return cborEncoderResult;
-    }
-    OCStringLL *strType = value;
+    VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed creating stringLL array");
     while (strType)
     {
         cborEncoderResult = cbor_encode_text_string(&array, strType->value, strlen(strType->value));
-        if (CborNoError != cborEncoderResult)
-        {
-            return cborEncoderResult;
-        }
+        VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed encoding string value");
         strType = strType->next;
     }
     cborEncoderResult = cbor_encoder_close_container(map, &array);
-    if (CborNoError != cborEncoderResult)
-    {
-        return cborEncoderResult;
-    }
+    VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing string array");
+exit:
     return cborEncoderResult;
 }
 
 OCRDPayload *OCRDPayloadCreate()
 {
     OCRDPayload *rdPayload = (OCRDPayload *)OICCalloc(1, sizeof(OCRDPayload));
-
-    if (!rdPayload)
-    {
-        return NULL;
-    }
-
+    VERIFY_PARAM_NON_NULL(TAG, rdPayload, "Failed allocating rdPayload");
     rdPayload->base.type = PAYLOAD_TYPE_RD;
 
+exit:
     return rdPayload;
 }
 
 OCRDDiscoveryPayload *OCRDDiscoveryPayloadCreate(const char *deviceName, const char *id, int biasFactor)
 {
     OCRDDiscoveryPayload *discoveryPayload = (OCRDDiscoveryPayload *)OICCalloc(1, sizeof(OCRDDiscoveryPayload));
-
-    if (!discoveryPayload)
-    {
-        return NULL;
-    }
+    VERIFY_PARAM_NON_NULL(TAG, discoveryPayload, "Failed allocating memory for discovery payload");
 
     if (deviceName)
     {
         discoveryPayload->n.deviceName = OICStrdup(deviceName);
-        if (!discoveryPayload->n.deviceName)
-        {
-            OICFree(discoveryPayload);
-            return NULL;
-        }
+        VERIFY_PARAM_NON_NULL(TAG, discoveryPayload->n.deviceName,
+                "Failed allocating memory for discovery device name");
     }
     if (id)
     {
@@ -761,7 +540,10 @@ OCRDDiscoveryPayload *OCRDDiscoveryPayloadCreate(const char *deviceName, const c
     }
 
     discoveryPayload->sel = biasFactor;
-
+    return discoveryPayload;
+exit:
+    OICFree(discoveryPayload);
+    discoveryPayload = NULL;
     return discoveryPayload;
 }
 
@@ -858,7 +640,7 @@ OCTagsPayload* OCCopyTagsResources(const char *deviceName, const unsigned char *
     return tags;
 
 memory_allocation_failed:
-    OC_LOG(ERROR, TAG, "Memory allocation failed.");
+    OIC_LOG(ERROR, TAG, "Memory allocation failed.");
     OCFreeTagsResource(tags);
     return NULL;
 }
@@ -869,7 +651,7 @@ OCLinksPayload* OCCopyLinksResources(const char *href, OCStringLL *rt, OCStringL
     OCLinksPayload *links = (OCLinksPayload *)OICCalloc(1, sizeof(OCLinksPayload));
     if (!links)
     {
-        OC_LOG(ERROR, TAG, "Failed allocating memory.");
+        OIC_LOG(ERROR, TAG, "Failed allocating memory.");
         return NULL;
     }
     if (href)
@@ -934,72 +716,27 @@ OCLinksPayload* OCCopyLinksResources(const char *href, OCStringLL *rt, OCStringL
     return links;
 
 memory_allocation_failed:
-    OC_LOG(ERROR, TAG, "Memory allocation failed.");
+    OIC_LOG(ERROR, TAG, "Memory allocation failed.");
     OCFreeLinksResource(links);
     return NULL;
 }
 
-void OCLinksAddResource(OCDiscoveryPayload *payload, const char *href, OCStringLL *rt,
-    OCStringLL *itf, const char *rel, bool obs, const char *title, const char *uri,
-    uint8_t ins, OCStringLL *mt)
-{
-    if(!payload->collectionResources->setLinks)
-    {
-        payload->collectionResources->setLinks =
-            OCCopyLinksResources(href, rt, itf, rel, obs, title, uri, ins, mt);
-    }
-    else
-    {
-        OCLinksPayload *p = payload->collectionResources->setLinks;
-        while (p->next)
-        {
-            p = p->next;
-        }
-        p->next = OCCopyLinksResources(href, rt, itf, rel, obs, title, uri, ins, mt);
-    }
-}
-
 OCResourceCollectionPayload* OCCopyCollectionResource(OCTagsPayload *tags, OCLinksPayload *links)
 {
-    if (!tags || !links)
-    {
-        return NULL;
-    }
-    OCResourceCollectionPayload *pl = (OCResourceCollectionPayload *)OICCalloc(1, sizeof(OCResourceCollectionPayload));
-    if(!pl)
-    {
-        OC_LOG(ERROR, TAG, "Failed allocating memory for the OCResourceCollectionPayload.");
-        return NULL;
-    }
+    OCResourceCollectionPayload *pl =  NULL;
+    VERIFY_PARAM_NON_NULL(TAG, tags, "Invalid param tags");
+    VERIFY_PARAM_NON_NULL(TAG, links, "Invalid param links");
+
+    pl = (OCResourceCollectionPayload *)OICCalloc(1, sizeof(OCResourceCollectionPayload));
+    VERIFY_PARAM_NON_NULL(TAG, pl, "Failed allocating memory for the OCResourceCollectionPayload");
+
     pl->tags = tags;
     pl->setLinks = links;
 
+exit:
     return pl;
 }
 
-OCStackResult OCDiscoveryCollectionPayloadAddResource(OCDiscoveryPayload *payload, OCTagsPayload *tags, OCLinksPayload *links)
-{
-    OCResourceCollectionPayload* res = OCCopyCollectionResource(tags, links);
-    if (res == NULL)
-    {
-        return OC_STACK_NO_MEMORY;
-    }
-    if(!payload->collectionResources)
-    {
-        payload->collectionResources = res;
-    }
-    else
-    {
-        OCResourceCollectionPayload *p = payload->collectionResources;
-        while(p->next)
-        {
-            p = p->next;
-        }
-        p->next = res;
-    }
-    return OC_STACK_OK;
-}
-
 void OCFreeLinksResource(OCLinksPayload *payload)
 {
     if (!payload)
@@ -1048,45 +785,37 @@ void OCFreeCollectionResource(OCResourceCollectionPayload *payload)
     OICFree(payload);
 }
 
-void OCDiscoveryCollectionPayloadDestroy(OCDiscoveryPayload* payload)
-{
-    if(!payload)
-    {
-        return;
-    }
-
-    OCFreeCollectionResource(payload->collectionResources);
-    OICFree(payload);
-}
-
-
 void OCTagsLog(const LogLevel level, const OCTagsPayload *tags)
 {
     if (tags)
     {
         if (tags->n.deviceName)
         {
-            OC_LOG_V(level, TAG, " Device Name : %s ",tags->n.deviceName);
+            OIC_LOG_V(level, TAG, " Device Name : %s ",tags->n.deviceName);
         }
         if (tags->baseURI)
         {
-            OC_LOG_V(level, TAG, " Base URI : %s ",tags->baseURI);
+            OIC_LOG_V(level, TAG, " Base URI : %s ",tags->baseURI);
         }
-        OC_LOG_V(level, TAG, " Device ID : %s ",tags->di.id);
-        OC_LOG_V(level, TAG, " Bitmap : %d ",tags->bitmap);
-        OC_LOG_V(level, TAG, " Port : %d ",tags->port);
-        OC_LOG_V(level, TAG, " Ins : %d ",tags->ins);
-        OC_LOG_V(level, TAG, " Ttl : %d ",tags->ttl);
+        OIC_LOG_V(level, TAG, " Device ID : %s ",tags->di.id);
+        OIC_LOG_V(level, TAG, " Bitmap : %d ",tags->bitmap);
+        OIC_LOG_V(level, TAG, " Port : %d ",tags->port);
+        OIC_LOG_V(level, TAG, " Ins : %d ",tags->ins);
+        OIC_LOG_V(level, TAG, " Ttl : %d ",tags->ttl);
 
         if (tags->rts)
         {
-            OC_LOG_V(level, TAG, " RTS : %s ",tags->rts);
+            OIC_LOG_V(level, TAG, " RTS : %s ",tags->rts);
         }
         if (tags->drel)
         {
-            OC_LOG_V(level, TAG, " DREL : %s ",tags->drel);
+            OIC_LOG_V(level, TAG, " DREL : %s ",tags->drel);
         }
     }
+    else
+    {
+        (void) level;
+    }
 }
 
 void OCLinksLog(const LogLevel level, const OCLinksPayload *links)
@@ -1095,52 +824,56 @@ void OCLinksLog(const LogLevel level, const OCLinksPayload *links)
     {
         if (links->href)
         {
-            OC_LOG_V(level, TAG, " href: %s ",links->href);
+            OIC_LOG_V(level, TAG, " href: %s ",links->href);
         }
-        OC_LOG(level, TAG, " RT: ");
+        OIC_LOG(level, TAG, " RT: ");
         OCStringLL *rt = links->rt;
         while (rt)
         {
             if (rt->value)
             {
-                OC_LOG_V(level, TAG, "   %s", rt->value);
+                OIC_LOG_V(level, TAG, "   %s", rt->value);
             }
             rt = rt->next;
         }
-        OC_LOG(level, TAG, " IF: ");
+        OIC_LOG(level, TAG, " IF: ");
         OCStringLL *itf = links->itf;
         while (itf)
         {
             if (itf->value)
             {
-                OC_LOG_V(level, TAG, "   %s", itf->value);
+                OIC_LOG_V(level, TAG, "   %s", itf->value);
             }
             itf = itf->next;
         }
-        OC_LOG(level, TAG, " MT: ");
+        OIC_LOG(level, TAG, " MT: ");
         OCStringLL *mt = links->mt;
         while (mt)
         {
             if (mt->value)
             {
-                OC_LOG_V(level, TAG, "   %s", mt->value);
+                OIC_LOG_V(level, TAG, "   %s", mt->value);
             }
             mt = mt->next;
         }
-        OC_LOG_V(level, TAG, " INS: %d", links->ins);
-        OC_LOG_V(level, TAG, " OBS: %d", links->obs);
+        OIC_LOG_V(level, TAG, " INS: %d", links->ins);
+        OIC_LOG_V(level, TAG, " OBS: %d", links->obs);
         if (links->rel)
         {
-            OC_LOG_V(level, TAG, " REL: %s", links->rel);
+            OIC_LOG_V(level, TAG, " REL: %s", links->rel);
         }
         if (links->title)
         {
-            OC_LOG_V(level, TAG, " TITLE: %s", links->title);
+            OIC_LOG_V(level, TAG, " TITLE: %s", links->title);
         }
         if (links->uri)
         {
-            OC_LOG_V(level, TAG, " URI: %s", links->uri);
+            OIC_LOG_V(level, TAG, " URI: %s", links->uri);
         }
         links = links->next;
     }
+    if (!links)
+    {
+        (void) level;
+    }
 }