X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fstack%2Fsrc%2Focpayloadparse.c;h=59c4c62221dccd1626c70827c5ca2ed88c78ca17;hb=refs%2Ftags%2Ftizen_4.0.m2_release;hp=daa94fe4f01cd0fbbc68637d9eb122bf6f145219;hpb=37525f8688c3695054e31c3c022187c2343e8e95;p=platform%2Fupstream%2Fiotivity.git

diff --git a/resource/csdk/stack/src/ocpayloadparse.c b/resource/csdk/stack/src/ocpayloadparse.c
index daa94fe..59c4c62 100755
--- a/resource/csdk/stack/src/ocpayloadparse.c
+++ b/resource/csdk/stack/src/ocpayloadparse.c
@@ -26,6 +26,7 @@
 // Refer http://pubs.opengroup.org/onlinepubs/009695399/
 // Required for strok_r
 #define _POSIX_C_SOURCE 200112L
+
 #include <string.h>
 #include <stdlib.h>
 #include "oic_string.h"
@@ -34,17 +35,17 @@
 #include "ocpayloadcbor.h"
 #include "ocstackinternal.h"
 #include "payload_logging.h"
-#include "rdpayload.h"
+#include "platform_features.h"
 
 #define TAG "OIC_RI_PAYLOADPARSE"
 
 static OCStackResult OCParseDiscoveryPayload(OCPayload **outPayload, CborValue *arrayVal);
-static OCStackResult OCParseDevicePayload(OCPayload **outPayload, CborValue *arrayVal);
-static OCStackResult OCParsePlatformPayload(OCPayload **outPayload, CborValue *arrayVal);
 static CborError OCParseSingleRepPayload(OCRepPayload **outPayload, CborValue *repParent, bool isRoot);
 static OCStackResult OCParseRepPayload(OCPayload **outPayload, CborValue *arrayVal);
+#ifdef WITH_PRESENCE
 static OCStackResult OCParsePresencePayload(OCPayload **outPayload, CborValue *arrayVal);
-static OCStackResult OCParseSecurityPayload(OCPayload **outPayload, CborValue * rrayVal);
+#endif
+static OCStackResult OCParseSecurityPayload(OCPayload **outPayload, const uint8_t *payload, size_t size);
 
 OCStackResult OCParsePayload(OCPayload **outPayload, OCPayloadType payloadType,
         const uint8_t *payload, size_t payloadSize)
@@ -55,7 +56,8 @@ OCStackResult OCParsePayload(OCPayload **outPayload, OCPayloadType payloadType,
     VERIFY_PARAM_NON_NULL(TAG, outPayload, "Conversion of outPayload failed");
     VERIFY_PARAM_NON_NULL(TAG, payload, "Invalid cbor payload value");
 
-    OIC_LOG_V(INFO, TAG, "CBOR Parsing size: %zu", payloadSize);
+    OIC_LOG_V(INFO, TAG, "CBOR Parsing size: %zu of Payload Type: %d, Payload:",
+            payloadSize, payloadType);
 
     CborParser parser;
     CborValue rootValue;
@@ -68,23 +70,16 @@ OCStackResult OCParsePayload(OCPayload **outPayload, OCPayloadType payloadType,
         case PAYLOAD_TYPE_DISCOVERY:
             result = OCParseDiscoveryPayload(outPayload, &rootValue);
             break;
-        case PAYLOAD_TYPE_DEVICE:
-            result = OCParseDevicePayload(outPayload, &rootValue);
-            break;
-        case PAYLOAD_TYPE_PLATFORM:
-            result = OCParsePlatformPayload(outPayload, &rootValue);
-            break;
         case PAYLOAD_TYPE_REPRESENTATION:
             result = OCParseRepPayload(outPayload, &rootValue);
             break;
+#ifdef WITH_PRESENCE
         case PAYLOAD_TYPE_PRESENCE:
             result = OCParsePresencePayload(outPayload, &rootValue);
             break;
+#endif
         case PAYLOAD_TYPE_SECURITY:
-            result = OCParseSecurityPayload(outPayload, &rootValue);
-            break;
-        case PAYLOAD_TYPE_RD:
-            result = OCRDCborToPayload(&rootValue, outPayload);
+            result = OCParseSecurityPayload(outPayload, payload, payloadSize);
             break;
         default:
             OIC_LOG_V(ERROR, TAG, "ParsePayload Type default: %d", payloadType);
@@ -98,35 +93,18 @@ exit:
     return result;
 }
 
-void OCFreeOCStringLL(OCStringLL* ll);
-
-static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* rootValue)
+static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, const uint8_t *payload,
+        size_t size)
 {
-    OCStackResult ret = OC_STACK_MALFORMED_RESPONSE;
-    CborError err;
-    char *securityData = NULL;
-
-    VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid parameter");
-    VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid cbor");
-
-    CborValue strVal;
-
-    err = cbor_value_enter_container(rootValue, &strVal);
-    VERIFY_CBOR_SUCCESS(TAG, err, "Failed entering container");
-    if (cbor_value_is_text_string(&strVal))
+    if (size > 0)
     {
-        size_t len = 0;
-        err = cbor_value_dup_text_string(&strVal, &securityData, &len, NULL);
-        VERIFY_CBOR_SUCCESS(TAG, err, "Failed reading security data");
-        *outPayload = (OCPayload *)OCSecurityPayloadCreate(securityData);
-        VERIFY_PARAM_NON_NULL(TAG, *outPayload, "Invalid cbor");
-        ret = OC_STACK_OK;
+        *outPayload = (OCPayload *)OCSecurityPayloadCreate(payload, size);
     }
-
-exit:
-    OICFree(securityData);
-    return ret;
-
+    else
+    {
+        *outPayload = NULL;
+    }
+    return OC_STACK_OK;
 }
 
 static char* InPlaceStringTrim(char* str)
@@ -153,31 +131,40 @@ static CborError OCParseStringLL(CborValue *map, char *type, OCStringLL **resour
     CborError err = cbor_value_map_find_value(map, type, &val);
     VERIFY_CBOR_SUCCESS(TAG, err, "to find StringLL TAG");
 
-    if (cbor_value_is_text_string(&val))
+    if (cbor_value_is_array(&val))
     {
-        char *input = NULL;
-        char *savePtr = NULL;
-        size_t len = 0;
-
-        err = cbor_value_dup_text_string(&val, &input, &len, NULL);
-        VERIFY_CBOR_SUCCESS(TAG, err, "to find StringLL value");
-
-        if (input)
+        CborValue txtStr;
+        err = cbor_value_enter_container(&val, &txtStr);
+        VERIFY_CBOR_SUCCESS(TAG, err, "to enter container");
+        while (cbor_value_is_text_string(&txtStr))
         {
-            char *curPtr = strtok_r(input, " ", &savePtr);
-            while (curPtr)
+            size_t len = 0;
+            char *input = NULL;
+            err = cbor_value_dup_text_string(&txtStr, &input, &len, NULL);
+            VERIFY_CBOR_SUCCESS(TAG, err, "to find StringLL value.");
+            if (input)
             {
-                char *trimmed = InPlaceStringTrim(curPtr);
-                if (trimmed[0] !='\0')
+                char *savePtr = NULL;
+                char *curPtr = strtok_r(input, " ", &savePtr);
+                while (curPtr)
                 {
-                    if (!OCResourcePayloadAddStringLL(resource, trimmed))
+                    char *trimmed = InPlaceStringTrim(curPtr);
+                    if (trimmed && strlen(trimmed) > 0)
                     {
-                        return CborErrorOutOfMemory;
+                        if (!OCResourcePayloadAddStringLL(resource, trimmed))
+                        {
+                            return CborErrorOutOfMemory;
+                        }
                     }
+                    curPtr = strtok_r(NULL, " ", &savePtr);
                 }
-                curPtr = strtok_r(NULL, " ", &savePtr);
+                OICFree(input);
+            }
+            if (cbor_value_is_text_string(&txtStr))
+            {
+                err = cbor_value_advance(&txtStr);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to advance string value");
             }
-            OICFree(input);
         }
     }
 exit:
@@ -188,295 +175,221 @@ static OCStackResult OCParseDiscoveryPayload(OCPayload **outPayload, CborValue *
 {
     OCStackResult ret = OC_STACK_INVALID_PARAM;
     OCResourcePayload *resource = NULL;
-    OCDiscoveryPayload *out = NULL;
+    OCDiscoveryPayload *temp = NULL;
+    OCDiscoveryPayload *rootPayload = NULL;
+    OCDiscoveryPayload *curPayload = NULL;
     size_t len = 0;
     CborError err = CborNoError;
     *outPayload = NULL;
 
     VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
     VERIFY_PARAM_NON_NULL(TAG, rootValue, "Invalid Parameter rootValue");
+    if (cbor_value_is_array(rootValue))
+    {
+        // Root value is already inside the main root array
+        CborValue rootMap;
 
-    // Root value is already inside the main root array
-    CborValue rootMap;
-    ret = OC_STACK_NO_MEMORY;
-    out = OCDiscoveryPayloadCreate();
-    VERIFY_PARAM_NON_NULL(TAG, out, "Failed error initializing discovery payload");
+        // Enter the main root map
+        ret = OC_STACK_MALFORMED_RESPONSE;
+        err = cbor_value_enter_container(rootValue, &rootMap);
+        VERIFY_CBOR_SUCCESS(TAG, err, "to enter root map container");
+        while (cbor_value_is_map(&rootMap))
+        {
+            ret = OC_STACK_NO_MEMORY;
+            temp = OCDiscoveryPayloadCreate();
+            VERIFY_PARAM_NON_NULL(TAG, temp, "Failed error initializing discovery payload");
+
+            // Look for DI
+            CborValue curVal;
+            err = cbor_value_map_find_value(&rootMap, OC_RSRVD_DEVICE_ID, &curVal);
+            VERIFY_CBOR_SUCCESS(TAG, err, "to find device id tag");
+            if (cbor_value_is_valid(&curVal))
+            {
+                if (cbor_value_is_byte_string(&curVal))
+                {
+                    err = cbor_value_dup_byte_string(&curVal, (uint8_t **)&(temp->sid), &len, NULL);
+                    VERIFY_CBOR_SUCCESS(TAG, err, "to copy device id value");
+                }
+                else if (cbor_value_is_text_string(&curVal))
+                {
+                    err = cbor_value_dup_text_string(&curVal, &(temp->sid), &len, NULL);
+                    VERIFY_CBOR_SUCCESS(TAG, err, "to copy device id value");
+                }
+            }
 
-    // Enter the main root map
-    ret = OC_STACK_MALFORMED_RESPONSE;
-    err = cbor_value_enter_container(rootValue, &rootMap);
-    VERIFY_CBOR_SUCCESS(TAG, err, "to enter root map container");
-
-    // Look for DI
-    CborValue curVal;
-    err = cbor_value_map_find_value(&rootMap, OC_RSRVD_DEVICE_ID, &curVal);
-    VERIFY_CBOR_SUCCESS(TAG, err, "to find device id tag");
-    if (cbor_value_is_valid(&curVal))
-    {
-        if (cbor_value_is_byte_string(&curVal))
-        {
-            err = cbor_value_dup_byte_string(&curVal, (uint8_t **)&(out->sid), &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "to copy device id value");
-        }
-        else if (cbor_value_is_text_string(&curVal))
-        {
-            err = cbor_value_dup_text_string(&curVal, &(out->sid), &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "to copy device id value");
-        }
-    }
+            // BaseURI - Not a mandatory field
+            err = cbor_value_map_find_value(&rootMap, OC_RSRVD_BASE_URI, &curVal);
+            VERIFY_CBOR_SUCCESS(TAG, err, "to find uri tag");
+            if (cbor_value_is_text_string(&curVal))
+            {
+                err = cbor_value_dup_text_string(&curVal, &(temp->baseURI), &len, NULL);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to find base uri value");
+            }
 
-    // BaseURI - Not a mandatory field
-    err = cbor_value_map_find_value(&rootMap, OC_RSRVD_BASE_URI, &curVal);
-    if (cbor_value_is_valid(&curVal))
-    {
-        err = cbor_value_dup_text_string(&curVal, &(out->baseURI), &len, NULL);
-        VERIFY_CBOR_SUCCESS(TAG, err, "to find base uri value");
-    }
+            // RT - Not a mandatory field
+            err = cbor_value_map_find_value(&rootMap, OC_RSRVD_RESOURCE_TYPE, &curVal);
+            if (cbor_value_is_valid(&curVal))
+            {
+                err = OCParseStringLL(&rootMap, OC_RSRVD_RESOURCE_TYPE, &temp->type);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to find resource type");
+            }
 
-    // Look for Links which will have an array as the value
-    CborValue linkMap;
-    err = cbor_value_map_find_value(&rootMap, OC_RSRVD_LINKS, &linkMap);
-    VERIFY_CBOR_SUCCESS(TAG, err, "to find links tag");
+            // IF - Not a mandatory field
+            err = cbor_value_map_find_value(&rootMap, OC_RSRVD_INTERFACE, &curVal);
+            if (cbor_value_is_valid(&curVal))
+            {
+                err =  OCParseStringLL(&rootMap, OC_RSRVD_INTERFACE, &temp->iface);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to find interface");
+            }
 
-    // Enter the links array and start iterating through the array processing
-    // each resource which shows up as a map.
-    CborValue resourceMap;
-    err = cbor_value_enter_container(&linkMap, &resourceMap);
-    VERIFY_CBOR_SUCCESS(TAG, err, "to enter link map");
+            // Name - Not a mandatory field
+            err = cbor_value_map_find_value(&rootMap, OC_RSRVD_DEVICE_NAME, &curVal);
+            if (cbor_value_is_text_string(&curVal))
+            {
+                err = cbor_value_dup_text_string(&curVal, &temp->name, &len, NULL);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to find device name");
+            }
 
-    while (cbor_value_is_map(&resourceMap))
-    {
-        resource = (OCResourcePayload *)OICCalloc(1, sizeof(OCResourcePayload));
-        VERIFY_PARAM_NON_NULL(TAG, resource, "Failed allocating resource payload");
+            // Look for Links which will have an array as the value
+            CborValue linkMap;
+            err = cbor_value_map_find_value(&rootMap, OC_RSRVD_LINKS, &linkMap);
+            VERIFY_CBOR_SUCCESS(TAG, err, "to find links tag");
 
-        // Uri
-        err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_HREF, &curVal);
-        VERIFY_CBOR_SUCCESS(TAG, err, "to find href tag");
-        err = cbor_value_dup_text_string(&curVal, &(resource->uri), &len, NULL);
-        VERIFY_CBOR_SUCCESS(TAG, err, "to find href value");
+            // Enter the links array and start iterating through the array processing
+            // each resource which shows up as a map.
+            CborValue resourceMap;
+            err = cbor_value_enter_container(&linkMap, &resourceMap);
+            VERIFY_CBOR_SUCCESS(TAG, err, "to enter link map");
 
-        // ResourceTypes
-        err =  OCParseStringLL(&resourceMap, OC_RSRVD_RESOURCE_TYPE, &resource->types);
-        VERIFY_CBOR_SUCCESS(TAG, err, "to find resource type tag/value");
+            while (cbor_value_is_map(&resourceMap))
+            {
+                int bitmap;
 
-        // Interface Types
-        err =  OCParseStringLL(&resourceMap, OC_RSRVD_INTERFACE, &resource->interfaces);
-        VERIFY_CBOR_SUCCESS(TAG, err, "to find interface tag/value");
-
-        // Policy
-        CborValue policyMap;
-        err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_POLICY, &policyMap);
-        VERIFY_CBOR_SUCCESS(TAG, err, "to find policy tag");
-
-        // Bitmap
-        err = cbor_value_map_find_value(&policyMap, OC_RSRVD_BITMAP, &curVal);
-        VERIFY_CBOR_SUCCESS(TAG, err, "to find bitmap tag");
-        err = cbor_value_get_int(&curVal, (int *)&resource->bitmap);
-        VERIFY_CBOR_SUCCESS(TAG, err, "to find bitmap value");
-
-        // Secure Flag
-        err = cbor_value_map_find_value(&policyMap, OC_RSRVD_SECURE, &curVal);
-        if (cbor_value_is_valid(&curVal))
-        {
-            err = cbor_value_get_boolean(&curVal, &(resource->secure));
-            VERIFY_CBOR_SUCCESS(TAG, err, "to find secure value");
-        }
+                resource = (OCResourcePayload *)OICCalloc(1, sizeof(OCResourcePayload));
+                VERIFY_PARAM_NON_NULL(TAG, resource, "Failed allocating resource payload");
 
-        // Port
-        err = cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT, &curVal);
-        if (cbor_value_is_valid(&curVal))
-        {
-            err = cbor_value_get_int(&curVal, (int *)&resource->port);
-            VERIFY_CBOR_SUCCESS(TAG, err, "to find port value");
-        }
+                // Uri
+                err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_HREF, &curVal);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to find href tag");
+                err = cbor_value_dup_text_string(&curVal, &(resource->uri), &len, NULL);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to find href value");
 
-        err = cbor_value_advance(&resourceMap);
-        VERIFY_CBOR_SUCCESS(TAG, err, "to advance resource map");
+                // ResourceTypes
+                err =  OCParseStringLL(&resourceMap, OC_RSRVD_RESOURCE_TYPE, &resource->types);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to find resource type tag/value");
 
-        OCDiscoveryPayloadAddNewResource(out, resource);
-    }
+                // Interface Types
+                err =  OCParseStringLL(&resourceMap, OC_RSRVD_INTERFACE, &resource->interfaces);
+                if (CborNoError != err)
+                {
+                    if (!OCResourcePayloadAddStringLL(&resource->interfaces, OC_RSRVD_INTERFACE_LL))
+                    {
+                        OIC_LOG(ERROR, TAG, "Failed to add string to StringLL");
+                        goto exit;
+                    }
+                }
 
-    err = cbor_value_leave_container(rootValue, &resourceMap);
-    VERIFY_CBOR_SUCCESS(TAG, err, "to advance resource map");
+                // Policy
+                CborValue policyMap;
+                err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_POLICY, &policyMap);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to find policy tag");
+
+                // Bitmap
+                err = cbor_value_map_find_value(&policyMap, OC_RSRVD_BITMAP, &curVal);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to find bitmap tag");
+                err = cbor_value_get_int(&curVal, &bitmap);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to find bitmap value");
+                resource->bitmap = (uint8_t)bitmap;
+
+                // Secure Flag
+                err = cbor_value_map_find_value(&policyMap, OC_RSRVD_SECURE, &curVal);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to find secure tag");
+                if (cbor_value_is_boolean(&curVal))
+                {
+                    err = cbor_value_get_boolean(&curVal, &(resource->secure));
+                    VERIFY_CBOR_SUCCESS(TAG, err, "to find secure value");
+                }
 
-    *outPayload = (OCPayload *)out;
-    return OC_STACK_OK;
+                // Port
+                err = cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT, &curVal);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to find port tag");
+                if (cbor_value_is_integer(&curVal))
+                {
+                    int port;
 
-exit:
-    OCDiscoveryResourceDestroy(resource);
-    OCDiscoveryPayloadDestroy(out);
-    return ret;
-}
+                    err = cbor_value_get_int(&curVal, &port);
+                    VERIFY_CBOR_SUCCESS(TAG, err, "to find port value");
+                    resource->port = (uint16_t)port;
+                }
 
-static OCStackResult OCParseDevicePayload(OCPayload **outPayload, CborValue *rootValue)
-{
-    OCStackResult ret = OC_STACK_INVALID_PARAM;
-    CborError err = CborNoError;
-    OCDevicePayload *out = NULL;
-    VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid param outPayload");
-    VERIFY_PARAM_NON_NULL(TAG, rootValue, "Invalid param rootValue");
+#ifdef TCP_ADAPTER
+                // TCP Port
+                err = cbor_value_map_find_value(&policyMap, OC_RSRVD_TCP_PORT, &curVal);
+                if (cbor_value_is_integer(&curVal))
+                {
+                    int tcpPort;
 
-    *outPayload = NULL;
+                    err = cbor_value_get_int(&curVal, &tcpPort);
+                    VERIFY_CBOR_SUCCESS(TAG, err, "to find tcp port value");
+                    resource->tcpPort = (uint16_t)tcpPort;
+                }
 
-    out = (OCDevicePayload *)OICCalloc(1, sizeof(OCDevicePayload));
-    VERIFY_PARAM_NON_NULL(TAG, out, "Failed allocating device payload")
-    out->base.type = PAYLOAD_TYPE_DEVICE;
-    ret = OC_STACK_MALFORMED_RESPONSE;
+#ifdef __WITH_TLS__
+                // TLS Port
+                err = cbor_value_map_find_value(&policyMap, OC_RSRVD_TLS_PORT, &curVal);
+                if (cbor_value_is_integer(&curVal))
+                {
+                    int tlsPort;
 
-    if (cbor_value_is_map(rootValue))
-    {
-        // Device ID
-        size_t len = 0;
-        CborValue curVal;
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_ID, &curVal);
-        if (cbor_value_is_valid(&curVal))
-        {
-            if (cbor_value_is_byte_string(&curVal))
+                    err = cbor_value_get_int(&curVal, &tlsPort);
+                    VERIFY_CBOR_SUCCESS(TAG, err, "to find tcp tls port value");
+                    resource->tcpPort = (uint16_t)tlsPort;
+                }
+#endif
+#endif
+
+                err = cbor_value_advance(&resourceMap);
+                VERIFY_CBOR_SUCCESS(TAG, err, "to advance resource map");
+
+                OCDiscoveryPayloadAddNewResource(temp, resource);
+            }
+
+            err = cbor_value_leave_container(&linkMap, &resourceMap);
+            VERIFY_CBOR_SUCCESS(TAG, err, "to leave resource map");
+
+            err = cbor_value_advance(&rootMap);
+            VERIFY_CBOR_SUCCESS(TAG, err, "to advance root map");
+
+            if(rootPayload == NULL)
             {
-                err = cbor_value_dup_byte_string(&curVal, (uint8_t **)&out->sid, &len, NULL);
-                VERIFY_CBOR_SUCCESS(TAG, err, "to find device id in device payload");
+                rootPayload = temp;
+                curPayload = temp;
             }
-            else if (cbor_value_is_text_string(&curVal))
+            else
             {
-                err = cbor_value_dup_text_string(&curVal, &out->sid, &len, NULL);
-                VERIFY_CBOR_SUCCESS(TAG, err, "to find device id in device payload");
+                curPayload->next = temp;
+                curPayload = curPayload->next;
             }
         }
-        // Device Name
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_NAME, &curVal);
-        if (cbor_value_is_valid(&curVal))
-        {
-            err = cbor_value_dup_text_string(&curVal, &out->deviceName, &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "to find device name in device payload");
-        }
-        // Device Spec Version
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_SPEC_VERSION, &curVal);
-        if (cbor_value_is_valid(&curVal))
-        {
-            err = cbor_value_dup_text_string(&curVal, &out->specVersion, &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "to find spec version in device payload");
-        }
-        // Data Model Version
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_DATA_MODEL_VERSION, &curVal);
-        if (cbor_value_is_valid(&curVal))
-        {
-            err = cbor_value_dup_text_string(&curVal, &out->dataModelVersion, &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "to find data model version in device payload");
-        }
-        err = cbor_value_advance(rootValue);
-        VERIFY_CBOR_SUCCESS(TAG, err, "to advance device payload");
-
-        *outPayload = (OCPayload *)out;
-        return OC_STACK_OK;
-    }
 
-exit:
-    OCDevicePayloadDestroy(out);
-    return ret;
-}
+        err = cbor_value_leave_container(rootValue, &rootMap);
+        VERIFY_CBOR_SUCCESS(TAG, err, "to leave root map");
 
-static OCStackResult OCParsePlatformPayload(OCPayload **outPayload, CborValue *rootValue)
-{
-    OCStackResult ret = OC_STACK_INVALID_PARAM;
-    CborError err = CborNoError;
-    OCPlatformInfo info = {0};
-
-    VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
-
-    if (cbor_value_is_map(rootValue))
+    }
+    else
     {
-        CborValue repVal;
-        size_t len = 0;
-        ret = OC_STACK_MALFORMED_RESPONSE;
-
-        // Platform ID
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_ID, &repVal);
-        if (cbor_value_is_valid(&repVal))
-        {
-            err = cbor_value_dup_text_string(&repVal, &(info.platformID), &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find platformID in the platform payload");
-        }
-         // MFG Name
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_NAME, &repVal);
-        if (cbor_value_is_valid(&repVal))
-        {
-            err = cbor_value_dup_text_string(&repVal, &(info.manufacturerName), &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find manufactureName in the platform payload");
-        }
-        // MFG URL
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_URL, &repVal);
-        if (cbor_value_is_valid(&repVal))
-        {
-            err = cbor_value_dup_text_string(&repVal, &(info.manufacturerUrl), &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find manufactureUrl in the platform payload");
-        }
-        // Model Num
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_MODEL_NUM, &repVal);
-        if (cbor_value_is_valid(&repVal))
-        {
-            err = cbor_value_dup_text_string(&repVal, &(info.modelNumber), &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find modelNumber in the platform payload");
-        }
-        // Date of Mfg
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_DATE, &repVal);
-        if (cbor_value_is_valid(&repVal))
-        {
-            err = cbor_value_dup_text_string(&repVal, &(info.dateOfManufacture), &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find dateOfManufacture in the platform payload");
-        }
-        // Platform Version
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_VERSION, &repVal);
-        if (cbor_value_is_valid(&repVal))
-        {
-            err = cbor_value_dup_text_string(&repVal, &(info.platformVersion), &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find platformVersion in the platform payload");
-        }
-        // OS Version
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_OS_VERSION, &repVal);
-        if (cbor_value_is_valid(&repVal))
-        {
-            err = cbor_value_dup_text_string(&repVal, &(info.operatingSystemVersion), &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find OSVersion in the platform payload");
-        }
-        // Hardware Version
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_HARDWARE_VERSION, &repVal);
-        if(cbor_value_is_valid(&repVal))
-        {
-            err = cbor_value_dup_text_string(&repVal, &(info.hardwareVersion), &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find HWVersion in the platform payload");
-        }
-        // Firmware Version
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_FIRMWARE_VERSION, &repVal);
-        if(cbor_value_is_valid(&repVal))
-        {
-            err = cbor_value_dup_text_string(&repVal, &(info.firmwareVersion), &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find firmwareVersion in the platform payload");
-        }
-        // Support URL
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_SUPPORT_URL, &repVal);
-        if(cbor_value_is_valid(&repVal))
-        {
-            err = cbor_value_dup_text_string(&repVal, &(info.supportUrl), &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find supportUrl in the platform payload");
-        }
-        // System Time
-        err = cbor_value_map_find_value(rootValue, OC_RSRVD_SYSTEM_TIME, &repVal);
-        if(cbor_value_is_valid(&repVal))
-        {
-            err = cbor_value_dup_text_string(&repVal, &(info.systemTime), &len, NULL);
-            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find systemTume in the platform payload");
-        }
+        OIC_LOG(ERROR, TAG, "Malformed packet ");
+        goto exit;
+    }
 
-        err = cbor_value_advance(rootValue);
-        VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find supportUrl in the platform payload");
+    *outPayload = (OCPayload *)rootPayload;
+    OIC_LOG_PAYLOAD(DEBUG, *outPayload);
 
-        *outPayload = (OCPayload *)OCPlatformPayloadCreateAsOwner(&info);
-        return OC_STACK_OK;
-    }
+    return OC_STACK_OK;
 
 exit:
-    OCPlatformInfoDestroy(&info);
-    OIC_LOG(ERROR, TAG, "CBOR error In ParsePlatformPayload");
+    OCDiscoveryResourceDestroy(resource);
+    OCDiscoveryPayloadDestroy(rootPayload);
     return ret;
 }
 
@@ -489,6 +402,7 @@ static OCRepPayloadPropType DecodeCborType(CborType type)
         case CborIntegerType:
             return OCREP_PROP_INT;
         case CborDoubleType:
+        case CborFloatType:
             return OCREP_PROP_DOUBLE;
         case CborBooleanType:
             return OCREP_PROP_BOOL;
@@ -635,7 +549,19 @@ static CborError OCParseArrayFillArray(const CborValue *parent,
                 case OCREP_PROP_DOUBLE:
                     if (dimensions[1] == 0)
                     {
-                        err = cbor_value_get_double(&insideArray, &(((double*)targetArray)[i]));
+                        double *d = &(((double*)targetArray)[i]);
+                        if (cbor_value_get_type(&insideArray) == CborDoubleType)
+                        {
+                            err = cbor_value_get_double(&insideArray, d);
+                        }
+                        else
+                        {
+                            /* must be float */
+                            float f;
+                            err = cbor_value_get_float(&insideArray, &f);
+                            if (!err)
+                                *d = f;
+                        }
                     }
                     else
                     {
@@ -716,8 +642,10 @@ exit:
 static CborError OCParseArray(OCRepPayload *out, const char *name, CborValue *container)
 {
     void *arr = NULL;
+
     OCRepPayloadPropType type = OCREP_PROP_NULL;
     size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0 };
+
     size_t dimTotal = 0;
     size_t allocSize = 0;
     bool res = true;
@@ -729,8 +657,7 @@ static CborError OCParseArray(OCRepPayload *out, const char *name, CborValue *co
         res = OCRepPayloadSetNull(out, name);
         err = (CborError) !res;
         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting value");
-        err = cbor_value_advance(container);
-        VERIFY_CBOR_SUCCESS(TAG, err, "Failed advancing container");
+        container = container + 1;
         return err;
     }
 
@@ -837,6 +764,7 @@ static CborError OCParseSingleRepPayload(OCRepPayload **outPayload, CborValue *o
                 {
                     err = cbor_value_advance(&repMap);
                     OICFree(name);
+                    name = NULL;
                     continue;
                 }
             }
@@ -946,6 +874,7 @@ static OCStackResult OCParseRepPayload(OCPayload **outPayload, CborValue *root)
     if (cbor_value_is_array(root))
     {
         err = cbor_value_enter_container(root, &rootMap);
+        VERIFY_CBOR_SUCCESS(TAG, err, "Failed entering repMap");
     }
     while (cbor_value_is_valid(&rootMap))
     {
@@ -956,16 +885,23 @@ static OCStackResult OCParseRepPayload(OCPayload **outPayload, CborValue *root)
         CborValue curVal;
         ret = OC_STACK_MALFORMED_RESPONSE;
 
+        // temporary fix to check for malformed cbor payload
+        if (!cbor_value_is_map(&rootMap) && !cbor_value_is_array(&rootMap)){
+            goto exit;
+        }
+
         if (cbor_value_is_map(&rootMap))
         {
             err = cbor_value_map_find_value(&rootMap, OC_RSRVD_HREF, &curVal);
-            if (cbor_value_is_valid(&curVal))
+            VERIFY_CBOR_SUCCESS(TAG, err, "to find href tag");
+            if (cbor_value_is_text_string(&curVal))
             {
                 size_t len = 0;
                 err = cbor_value_dup_text_string(&curVal, &temp->uri, &len, NULL);
                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find uri");
             }
         }
+
         // Resource types
         if (cbor_value_is_map(&rootMap))
         {
@@ -991,6 +927,7 @@ static OCStackResult OCParseRepPayload(OCPayload **outPayload, CborValue *root)
             err = OCParseSingleRepPayload(&temp, &rootMap, true);
             VERIFY_CBOR_SUCCESS(TAG, err, "Failed to parse single rep payload");
         }
+
         if(rootPayload == NULL)
         {
             rootPayload = temp;
@@ -1018,6 +955,7 @@ exit:
     return ret;
 }
 
+#ifdef WITH_PRESENCE
 static OCStackResult OCParsePresencePayload(OCPayload **outPayload, CborValue *rootValue)
 {
     OCStackResult ret = OC_STACK_INVALID_PARAM;
@@ -1035,28 +973,35 @@ static OCStackResult OCParsePresencePayload(OCPayload **outPayload, CborValue *r
     if (cbor_value_is_map(rootValue))
     {
         CborValue curVal;
+        uint64_t temp = 0;
+        uint8_t trigger;
 
         // Sequence Number
         CborError err = cbor_value_map_find_value(rootValue, OC_RSRVD_NONCE, &curVal);
         VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding nonce tag");
-        err = cbor_value_get_uint64(&curVal, (uint64_t *)&payload->sequenceNumber);
+        err = cbor_value_get_uint64(&curVal, &temp);
+        payload->sequenceNumber = (uint32_t)temp;
         VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding nonce value");
 
         // Max Age
         err = cbor_value_map_find_value(rootValue, OC_RSRVD_TTL, &curVal);
         VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding ttl tag");
-        err = cbor_value_get_uint64(&curVal, (uint64_t *)&payload->maxAge);
+        temp = 0;
+        err = cbor_value_get_uint64(&curVal, &temp);
+        payload->maxAge = (uint32_t)temp;
         VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding ttl value");
 
         // Trigger
         err = cbor_value_map_find_value(rootValue, OC_RSRVD_TRIGGER, &curVal);
         VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding trigger tag");
-        err = cbor_value_get_simple_type(&curVal, (uint8_t *)&payload->trigger);
+        err = cbor_value_get_simple_type(&curVal, &trigger);
         VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding trigger value");
+        payload->trigger = (OCPresenceTrigger)trigger;
 
         // Resource type name
         err = cbor_value_map_find_value(rootValue, OC_RSRVD_RESOURCE_TYPE, &curVal);
-        if (cbor_value_is_valid(&curVal))
+        VERIFY_CBOR_SUCCESS(TAG, err, "to find res type tag");
+        if (cbor_value_is_text_string(&curVal))
         {
             size_t len = 0;
             err = cbor_value_dup_text_string(&curVal, &payload->resourceType, &len, NULL);
@@ -1074,3 +1019,4 @@ exit:
     OCPresencePayloadDestroy(payload);
     return ret;
 }
+#endif // WITH_PRESENCE