Security CBOR cleanup
[platform/upstream/iotivity.git] / resource / csdk / stack / src / ocpayload.c
old mode 100755 (executable)
new mode 100644 (file)
index 6be1ffe..7880b7c
 #include "ocstackinternal.h"
 #include "ocresource.h"
 #include "logger.h"
+#include "rdpayload.h"
+
+#define TAG "OIC_RI_PAYLOAD"
 
-#define TAG "OCPayload"
 static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val);
-static void FreeOCDiscoveryResource(OCResourcePayload* payload);
 
 void OCPayloadDestroy(OCPayload* payload)
 {
-    if(!payload)
+    if (!payload)
     {
         return;
     }
@@ -59,8 +60,11 @@ void OCPayloadDestroy(OCPayload* payload)
         case PAYLOAD_TYPE_SECURITY:
             OCSecurityPayloadDestroy((OCSecurityPayload*)payload);
             break;
+        case PAYLOAD_TYPE_RD:
+           OCRDPayloadDestroy((OCRDPayload*)payload);
+           break;
         default:
-            OC_LOG_V(ERROR, TAG, "Unsupported payload type in destroy: %d", payload->type);
+            OIC_LOG_V(ERROR, TAG, "Unsupported payload type in destroy: %d", payload->type);
             OICFree(payload);
             break;
     }
@@ -69,7 +73,7 @@ OCRepPayload* OCRepPayloadCreate()
 {
     OCRepPayload* payload = (OCRepPayload*)OICCalloc(1, sizeof(OCRepPayload));
 
-    if(!payload)
+    if (!payload)
     {
         return NULL;
     }
@@ -81,7 +85,7 @@ OCRepPayload* OCRepPayloadCreate()
 
 void OCRepPayloadAppend(OCRepPayload* parent, OCRepPayload* child)
 {
-    if(!parent)
+    if (!parent)
     {
         return;
     }
@@ -97,7 +101,7 @@ void OCRepPayloadAppend(OCRepPayload* parent, OCRepPayload* child)
 
 static OCRepPayloadValue* OCRepPayloadFindValue(const OCRepPayload* payload, const char* name)
 {
-    if(!payload || !name)
+    if (!payload || !name)
     {
         return NULL;
     }
@@ -105,7 +109,7 @@ static OCRepPayloadValue* OCRepPayloadFindValue(const OCRepPayload* payload, con
     OCRepPayloadValue* val = payload->values;
     while(val)
     {
-        if(0 == strcmp(val->name, name))
+        if (0 == strcmp(val->name, name))
         {
             return val;
         }
@@ -113,12 +117,11 @@ static OCRepPayloadValue* OCRepPayloadFindValue(const OCRepPayload* payload, con
     }
 
     return NULL;
-
 }
 
 static void OCCopyPropertyValueArray(OCRepPayloadValue* dest, OCRepPayloadValue* source)
 {
-    if(!dest || !source)
+    if (!dest || !source)
     {
         return;
     }
@@ -128,34 +131,49 @@ static void OCCopyPropertyValueArray(OCRepPayloadValue* dest, OCRepPayloadValue*
     {
         case OCREP_PROP_INT:
             dest->arr.iArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
+            VERIFY_PARAM_NON_NULL(TAG, dest->arr.iArray, "Failed allocating memory");
             memcpy(dest->arr.iArray, source->arr.iArray, dimTotal * sizeof(int64_t));
             break;
         case OCREP_PROP_DOUBLE:
             dest->arr.dArray = (double*)OICMalloc(dimTotal * sizeof(double));
+            VERIFY_PARAM_NON_NULL(TAG, dest->arr.dArray, "Failed allocating memory");
             memcpy(dest->arr.dArray, source->arr.dArray, dimTotal * sizeof(double));
             break;
         case OCREP_PROP_BOOL:
             dest->arr.bArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
+            VERIFY_PARAM_NON_NULL(TAG, dest->arr.bArray, "Failed allocating memory");
             memcpy(dest->arr.bArray, source->arr.bArray, dimTotal * sizeof(bool));
             break;
         case OCREP_PROP_STRING:
             dest->arr.strArray = (char**)OICMalloc(dimTotal * sizeof(char*));
+            VERIFY_PARAM_NON_NULL(TAG, dest->arr.strArray, "Failed allocating memory");
             for(size_t i = 0; i < dimTotal; ++i)
             {
                 dest->arr.strArray[i] = OICStrdup(source->arr.strArray[i]);
             }
             break;
+        case OCREP_PROP_OBJECT:
+            dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
+            VERIFY_PARAM_NON_NULL(TAG, dest->arr.objArray, "Failed allocating memory");
+            for(size_t i = 0; i < dimTotal; ++i)
+            {
+                dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
+            }
+            break;
         case OCREP_PROP_ARRAY:
             dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
+            VERIFY_PARAM_NON_NULL(TAG, dest->arr.objArray, "Failed allocating memory");
             for(size_t i = 0; i < dimTotal; ++i)
             {
                 dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
             }
             break;
         default:
-            OC_LOG(ERROR, TAG, "CopyPropertyValueArray invalid type");
+            OIC_LOG(ERROR, TAG, "CopyPropertyValueArray invalid type");
             break;
     }
+exit:
+    return;
 }
 
 static void OCCopyPropertyValue (OCRepPayloadValue *dest, OCRepPayloadValue *source)
@@ -184,15 +202,19 @@ static void OCCopyPropertyValue (OCRepPayloadValue *dest, OCRepPayloadValue *sou
 
 static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val)
 {
-    if(!val)
+    if (!val)
     {
         return;
     }
 
-    if(val->type == OCREP_PROP_STRING)
+    if (val->type == OCREP_PROP_STRING)
     {
         OICFree(val->str);
     }
+    else if (val->type == OCREP_PROP_BYTE_STRING)
+    {
+        OICFree(val->ocByteStr.bytes);
+    }
     else if (val->type == OCREP_PROP_OBJECT)
     {
         OCRepPayloadDestroy(val->obj);
@@ -210,14 +232,21 @@ static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val)
                 OICFree(val->arr.iArray);
                 break;
             case OCREP_PROP_STRING:
-                for(size_t i = 0; i< dimTotal;++i)
+                for(size_t i = 0; i< dimTotal; ++i)
                 {
                     OICFree(val->arr.strArray[i]);
                 }
                 OICFree(val->arr.strArray);
                 break;
-            case OCREP_PROP_OBJECT:
-                for(size_t i = 0; i< dimTotal;++i)
+            case OCREP_PROP_BYTE_STRING:
+                for (size_t i = 0; i< dimTotal; ++i)
+                {
+                    OICFree(val->arr.ocByteStrArray[i].bytes);
+                }
+                OICFree(val->arr.ocByteStrArray);
+                break;
+            case OCREP_PROP_OBJECT: // This case is the temporary fix for string input
+                for(size_t i = 0; i< dimTotal; ++i)
                 {
                     OCRepPayloadDestroy(val->arr.objArray[i]);
                 }
@@ -225,7 +254,7 @@ static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val)
                 break;
             case OCREP_PROP_NULL:
             case OCREP_PROP_ARRAY:
-                OC_LOG_V(ERROR, TAG, "FreeRepPayloadValueContents: Illegal type\
+                OIC_LOG_V(ERROR, TAG, "FreeRepPayloadValueContents: Illegal type\
                         inside an array: %d", val->arr.type);
                 break;
         }
@@ -234,7 +263,7 @@ static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val)
 
 static void OCFreeRepPayloadValue(OCRepPayloadValue* val)
 {
-    if(!val)
+    if (!val)
     {
         return;
     }
@@ -289,21 +318,21 @@ static OCRepPayloadValue* OCRepPayloadValueClone (OCRepPayloadValue* source)
 static OCRepPayloadValue* OCRepPayloadFindAndSetValue(OCRepPayload* payload, const char* name,
         OCRepPayloadPropType type)
 {
-    if(!payload || !name)
+    if (!payload || !name)
     {
         return NULL;
     }
 
     OCRepPayloadValue* val = payload->values;
-    if(val == NULL)
+    if (val == NULL)
     {
         payload->values = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
-        if(!payload->values)
+        if (!payload->values)
         {
             return NULL;
         }
         payload->values->name = OICStrdup(name);
-        if(!payload->values->name)
+        if (!payload->values->name)
         {
             OICFree(payload->values);
             payload->values = NULL;
@@ -315,21 +344,21 @@ static OCRepPayloadValue* OCRepPayloadFindAndSetValue(OCRepPayload* payload, con
 
     while(val)
     {
-        if(0 == strcmp(val->name, name))
+        if (0 == strcmp(val->name, name))
         {
             OCFreeRepPayloadValueContents(val);
             val->type = type;
             return val;
         }
-        else if(val->next == NULL)
+        else if (val->next == NULL)
         {
             val->next = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
-            if(!val->next)
+            if (!val->next)
             {
                 return NULL;
             }
             val->next->name = OICStrdup(name);
-            if(!val->next->name)
+            if (!val->next->name)
             {
                 OICFree(val->next);
                 val->next = NULL;
@@ -342,7 +371,7 @@ static OCRepPayloadValue* OCRepPayloadFindAndSetValue(OCRepPayload* payload, con
         val = val->next;
     }
 
-    OC_LOG(ERROR, TAG, "FindAndSetValue reached point after while loop, pointer corruption?");
+    OIC_LOG(ERROR, TAG, "FindAndSetValue reached point after while loop, pointer corruption?");
     return NULL;
 }
 
@@ -353,12 +382,12 @@ bool OCRepPayloadAddResourceType(OCRepPayload* payload, const char* resourceType
 
 bool OCRepPayloadAddResourceTypeAsOwner(OCRepPayload* payload, char* resourceType)
 {
-    if(!payload || !resourceType)
+    if (!payload || !resourceType)
     {
         return false;
     }
 
-    if(payload->types)
+    if (payload->types)
     {
         OCStringLL* cur = payload->types;
         while(cur->next)
@@ -367,7 +396,7 @@ bool OCRepPayloadAddResourceTypeAsOwner(OCRepPayload* payload, char* resourceTyp
         }
         cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
 
-        if(!cur->next)
+        if (!cur->next)
         {
             return false;
         }
@@ -378,7 +407,7 @@ bool OCRepPayloadAddResourceTypeAsOwner(OCRepPayload* payload, char* resourceTyp
     else
     {
         payload->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-        if(!payload->types)
+        if (!payload->types)
         {
             return false;
         }
@@ -394,12 +423,12 @@ bool OCRepPayloadAddInterface(OCRepPayload* payload, const char* interface)
 
 bool OCRepPayloadAddInterfaceAsOwner(OCRepPayload* payload, char* interface)
 {
-    if(!payload || !interface)
+    if (!payload || !interface)
     {
         return false;
     }
 
-    if(payload->interfaces)
+    if (payload->interfaces)
     {
         OCStringLL* cur = payload->interfaces;
         while(cur->next)
@@ -408,7 +437,7 @@ bool OCRepPayloadAddInterfaceAsOwner(OCRepPayload* payload, char* interface)
         }
         cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
 
-        if(!cur->next)
+        if (!cur->next)
         {
             return false;
         }
@@ -418,7 +447,7 @@ bool OCRepPayloadAddInterfaceAsOwner(OCRepPayload* payload, char* interface)
     else
     {
         payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-        if(!payload->interfaces)
+        if (!payload->interfaces)
         {
             return false;
         }
@@ -429,11 +458,11 @@ bool OCRepPayloadAddInterfaceAsOwner(OCRepPayload* payload, char* interface)
 
 bool OCRepPayloadSetUri(OCRepPayload* payload, const char*  uri)
 {
-    if(!payload)
+    if (!payload)
     {
         return false;
     }
-
+    OICFree(payload->uri);
     payload->uri = OICStrdup(uri);
     return payload->uri != NULL;
 }
@@ -442,7 +471,7 @@ bool OCRepPayloadIsNull(const OCRepPayload* payload, const char* name)
 {
     OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
 
-    if(!val)
+    if (!val)
     {
         return false;
     }
@@ -454,7 +483,7 @@ static bool OCRepPayloadSetProp(OCRepPayload* payload, const char* name,
         void* value, OCRepPayloadPropType type)
 {
     OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, type);
-    if(!val)
+    if (!val)
     {
         return false;
     }
@@ -475,6 +504,9 @@ static bool OCRepPayloadSetProp(OCRepPayload* payload, const char* name,
         case OCREP_PROP_STRING:
                val->str = (char*)value;
                return val->str != NULL;
+        case OCREP_PROP_BYTE_STRING:
+               val->ocByteStr = *(OCByteString*)value;
+               break;
         case OCREP_PROP_NULL:
                return val != NULL;
         case OCREP_PROP_ARRAY:
@@ -500,7 +532,7 @@ bool OCRepPayloadGetPropInt(const OCRepPayload* payload, const char* name, int64
 {
     OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
 
-    if(!val || val->type != OCREP_PROP_INT)
+    if (!val || val->type != OCREP_PROP_INT)
     {
         return false;
     }
@@ -510,7 +542,7 @@ bool OCRepPayloadGetPropInt(const OCRepPayload* payload, const char* name, int64
 }
 
 bool OCRepPayloadSetPropDouble(OCRepPayload* payload,
-        const char* name, double value)
+                               const char* name, double value)
 {
     return OCRepPayloadSetProp(payload, name, &value, OCREP_PROP_DOUBLE);
 }
@@ -519,13 +551,21 @@ bool OCRepPayloadGetPropDouble(const OCRepPayload* payload, const char* name, do
 {
     OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
 
-    if(!val || val->type != OCREP_PROP_DOUBLE)
+    if (val)
     {
-        return false;
+        if (val->type == OCREP_PROP_DOUBLE)
+        {
+            *value = val->d;
+            return true;
+        }
+        else if (val->type == OCREP_PROP_INT)
+        {
+            *value = val->i;
+            return true;
+        }
     }
 
-    *value = val->d;
-    return true;
+    return false;
 }
 
 bool OCRepPayloadSetPropString(OCRepPayload* payload, const char* name, const char* value)
@@ -533,7 +573,7 @@ bool OCRepPayloadSetPropString(OCRepPayload* payload, const char* name, const ch
     char* temp = OICStrdup(value);
     bool b = OCRepPayloadSetPropStringAsOwner(payload, name, temp);
 
-    if(!b)
+    if (!b)
     {
         OICFree(temp);
     }
@@ -549,7 +589,7 @@ bool OCRepPayloadGetPropString(const OCRepPayload* payload, const char* name, ch
 {
     OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
 
-    if(!val || val->type != OCREP_PROP_STRING)
+    if (!val || val->type != OCREP_PROP_STRING)
     {
         return false;
     }
@@ -558,8 +598,64 @@ bool OCRepPayloadGetPropString(const OCRepPayload* payload, const char* name, ch
     return *value != NULL;
 }
 
+bool OCRepPayloadSetPropByteString(OCRepPayload* payload, const char* name, OCByteString value)
+{
+    if (!value.bytes || !value.len)
+    {
+        return false;
+    }
+
+    OCByteString ocByteStr = {
+                    .bytes = (uint8_t*)OICMalloc(value.len * sizeof(uint8_t)),
+                    .len = value.len };
+
+    if (!ocByteStr.bytes)
+    {
+        return false;
+    }
+    memcpy(ocByteStr.bytes, value.bytes, ocByteStr.len);
+
+    bool b = OCRepPayloadSetPropByteStringAsOwner(payload, name, &ocByteStr);
+
+    if (!b)
+    {
+        OICFree(ocByteStr.bytes);
+    }
+    return b;
+}
+
+bool OCRepPayloadSetPropByteStringAsOwner(OCRepPayload* payload, const char* name, OCByteString* value)
+{
+    return OCRepPayloadSetProp(payload, name, value, OCREP_PROP_BYTE_STRING);
+}
+
+bool OCRepPayloadGetPropByteString(const OCRepPayload* payload, const char* name, OCByteString* value)
+{
+    OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
+
+    if (!val || val->type != OCREP_PROP_BYTE_STRING)
+    {
+        return false;
+    }
+
+    if (!value)
+    {
+        return false;
+    }
+
+    value->bytes = (uint8_t*)OICMalloc(val->ocByteStr.len * sizeof(uint8_t));
+    if (!value->bytes)
+    {
+        return false;
+    }
+    value->len = val->ocByteStr.len;
+    memcpy(value->bytes, val->ocByteStr.bytes, value->len);
+
+    return true;
+}
+
 bool OCRepPayloadSetPropBool(OCRepPayload* payload,
-        const char* name, bool value)
+                             const char* name, bool value)
 {
     return OCRepPayloadSetProp(payload, name, &value, OCREP_PROP_BOOL);
 }
@@ -568,7 +664,7 @@ bool OCRepPayloadGetPropBool(const OCRepPayload* payload, const char* name, bool
 {
     OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
 
-    if(!val || val->type != OCREP_PROP_BOOL)
+    if (!val || val->type != OCREP_PROP_BOOL)
     {
         return false;
     }
@@ -582,7 +678,7 @@ bool OCRepPayloadSetPropObject(OCRepPayload* payload, const char* name, const OC
     OCRepPayload* temp = OCRepPayloadClone(value);
     bool b = OCRepPayloadSetPropObjectAsOwner(payload, name, temp);
 
-    if(!b)
+    if (!b)
     {
         OCRepPayloadDestroy(temp);
     }
@@ -598,7 +694,7 @@ bool OCRepPayloadGetPropObject(const OCRepPayload* payload, const char* name, OC
 {
     OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
 
-    if(!val || val->type != OCREP_PROP_OBJECT)
+    if (!val || val->type != OCREP_PROP_OBJECT)
     {
         return false;
     }
@@ -609,7 +705,7 @@ bool OCRepPayloadGetPropObject(const OCRepPayload* payload, const char* name, OC
 
 size_t calcDimTotal(const size_t dimensions[MAX_REP_ARRAY_DEPTH])
 {
-    if(dimensions[0] == 0)
+    if (dimensions[0] == 0)
     {
         return 0;
     }
@@ -622,12 +718,129 @@ size_t calcDimTotal(const size_t dimensions[MAX_REP_ARRAY_DEPTH])
     return total;
 }
 
+
+bool OCRepPayloadSetByteStringArrayAsOwner(OCRepPayload* payload, const char* name,
+        OCByteString* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
+{
+    OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
+
+    if (!val)
+    {
+        return false;
+    }
+
+    val->arr.type = OCREP_PROP_BYTE_STRING;
+    memcpy(val->arr.dimensions, dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
+    val->arr.ocByteStrArray = array;
+
+    return true;
+}
+
+bool OCRepPayloadSetByteStringArray(OCRepPayload* payload, const char* name,
+        const OCByteString* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
+{
+    if (!array)
+    {
+        return NULL;
+    }
+
+    size_t dimTotal = calcDimTotal(dimensions);
+    if (dimTotal == 0)
+    {
+        return false;
+    }
+
+    OCByteString* newArray = (OCByteString*)OICCalloc(dimTotal, sizeof(OCByteString));
+
+    if (!newArray)
+    {
+        return false;
+    }
+
+    for (size_t i = 0; i < dimTotal; ++i)
+    {
+        newArray[i].bytes = (uint8_t*)OICMalloc(array[i].len * sizeof(uint8_t));
+        if (NULL == newArray[i].bytes)
+        {
+            for (size_t j = 0; j < i; ++j)
+            {
+                OICFree(newArray[j].bytes);
+            }
+
+            OICFree(newArray);
+            return false;
+        }
+        newArray[i].len = array[i].len;
+        memcpy(newArray[i].bytes, array[i].bytes, newArray[i].len);
+    }
+
+    bool b = OCRepPayloadSetByteStringArrayAsOwner(payload, name, newArray, dimensions);
+    if (!b)
+    {
+        for (size_t i = 0; i < dimTotal; ++i)
+        {
+            OICFree(newArray[i].bytes);
+        }
+
+        OICFree(newArray);
+    }
+    return b;
+}
+
+bool OCRepPayloadGetByteStringArray(const OCRepPayload* payload, const char* name,
+        OCByteString** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
+{
+    OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
+
+    if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_BYTE_STRING
+            || !val->arr.ocByteStrArray)
+    {
+        return false;
+    }
+
+    size_t dimTotal = calcDimTotal(val->arr.dimensions);
+    if (dimTotal == 0)
+    {
+        return false;
+    }
+
+    *array = (OCByteString*)OICCalloc(dimTotal, sizeof(OCByteString));
+    if (!*array)
+    {
+        return false;
+    }
+
+    for (size_t i = 0; i < dimTotal; ++i)
+    {
+        OCByteString* tmp = &(*array)[i];
+        tmp->bytes = (uint8_t*)OICMalloc(val->arr.ocByteStrArray[i].len * sizeof(uint8_t));
+        if (NULL == tmp->bytes)
+        {
+            for (size_t j = 0; j < i; ++j)
+            {
+                OCByteString* tmp = &(*array)[j];
+                OICFree(tmp->bytes);
+            }
+            OICFree(*array);
+            *array = NULL;
+
+            return false;
+        }
+        tmp->len = val->arr.ocByteStrArray[i].len;
+        memcpy(tmp->bytes, val->arr.ocByteStrArray[i].bytes, tmp->len);
+    }
+
+    memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
+    return true;
+}
+
+
 bool OCRepPayloadSetIntArrayAsOwner(OCRepPayload* payload, const char* name,
         int64_t* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
 {
     OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
 
-    if(!val)
+    if (!val)
     {
         return false;
     }
@@ -643,14 +856,14 @@ bool OCRepPayloadSetIntArray(OCRepPayload* payload, const char* name,
         const int64_t* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
 {
     size_t dimTotal = calcDimTotal(dimensions);
-    if(dimTotal == 0)
+    if (dimTotal == 0)
     {
         return false;
     }
 
     int64_t* newArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
 
-    if(!newArray)
+    if (!newArray)
     {
         return false;
     }
@@ -659,7 +872,7 @@ bool OCRepPayloadSetIntArray(OCRepPayload* payload, const char* name,
 
 
     bool b = OCRepPayloadSetIntArrayAsOwner(payload, name, newArray, dimensions);
-    if(!b)
+    if (!b)
     {
         OICFree(newArray);
     }
@@ -671,19 +884,19 @@ bool OCRepPayloadGetIntArray(const OCRepPayload* payload, const char* name,
 {
     OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
 
-    if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_INT
+    if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_INT
             || !val->arr.iArray)
     {
         return false;
     }
 
     size_t dimTotal = calcDimTotal(val->arr.dimensions);
-    if(dimTotal == 0)
+    if (dimTotal == 0)
     {
         return false;
     }
     *array = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
-    if(!*array)
+    if (!*array)
     {
         return false;
     }
@@ -698,7 +911,7 @@ bool OCRepPayloadSetDoubleArrayAsOwner(OCRepPayload* payload, const char* name,
 {
     OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
 
-    if(!val)
+    if (!val)
     {
         return false;
     }
@@ -713,14 +926,14 @@ bool OCRepPayloadSetDoubleArray(OCRepPayload* payload, const char* name,
         const double* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
 {
     size_t dimTotal = calcDimTotal(dimensions);
-    if(dimTotal == 0)
+    if (dimTotal == 0)
     {
         return false;
     }
 
     double* newArray = (double*)OICMalloc(dimTotal * sizeof(double));
 
-    if(!newArray)
+    if (!newArray)
     {
         return false;
     }
@@ -728,7 +941,7 @@ bool OCRepPayloadSetDoubleArray(OCRepPayload* payload, const char* name,
     memcpy(newArray, array, dimTotal * sizeof(double));
 
     bool b = OCRepPayloadSetDoubleArrayAsOwner(payload, name, newArray, dimensions);
-    if(!b)
+    if (!b)
     {
         OICFree(newArray);
     }
@@ -740,24 +953,37 @@ bool OCRepPayloadGetDoubleArray(const OCRepPayload* payload, const char* name,
 {
     OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
 
-    if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_DOUBLE
+    if (!val || val->type != OCREP_PROP_ARRAY ||
+        (val->arr.type != OCREP_PROP_DOUBLE && val->arr.type != OCREP_PROP_INT)
             || !val->arr.dArray)
     {
         return false;
     }
 
     size_t dimTotal = calcDimTotal(val->arr.dimensions);
-    if(dimTotal == 0)
+    if (dimTotal == 0)
     {
         return false;
     }
     *array = (double*)OICMalloc(dimTotal * sizeof(double));
-    if(!*array)
+    if (!*array)
     {
         return false;
     }
 
-    memcpy(*array, val->arr.dArray, dimTotal * sizeof(double));
+    if (val->arr.type != OCREP_PROP_DOUBLE)
+    {
+        memcpy(*array, val->arr.dArray, dimTotal * sizeof(double));
+    }
+    else
+    {
+        /* need to convert from integer */
+        size_t n = 0;
+        for ( ; n < dimTotal; ++n)
+        {
+            (*array)[n] = val->arr.iArray[n];
+        }
+    }
     memcpy(dimensions, val->arr.dimensions, MAX_REP_ARRAY_DEPTH * sizeof(size_t));
     return true;
 }
@@ -767,7 +993,7 @@ bool OCRepPayloadSetStringArrayAsOwner(OCRepPayload* payload, const char* name,
 {
     OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
 
-    if(!val)
+    if (!val)
     {
         return false;
     }
@@ -782,14 +1008,14 @@ bool OCRepPayloadSetStringArray(OCRepPayload* payload, const char* name,
         const char** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
 {
     size_t dimTotal = calcDimTotal(dimensions);
-    if(dimTotal == 0)
+    if (dimTotal == 0)
     {
         return false;
     }
 
     char** newArray = (char**)OICMalloc(dimTotal * sizeof(char*));
 
-    if(!newArray)
+    if (!newArray)
     {
         return false;
     }
@@ -801,7 +1027,7 @@ bool OCRepPayloadSetStringArray(OCRepPayload* payload, const char* name,
 
     bool b = OCRepPayloadSetStringArrayAsOwner(payload, name, newArray, dimensions);
 
-    if(!b)
+    if (!b)
     {
         for(size_t i = 0; i < dimTotal; ++i)
         {
@@ -817,19 +1043,19 @@ bool OCRepPayloadGetStringArray(const OCRepPayload* payload, const char* name,
 {
     OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
 
-    if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_STRING
+    if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_STRING
             || !val->arr.strArray)
     {
         return false;
     }
 
     size_t dimTotal = calcDimTotal(val->arr.dimensions);
-    if(dimTotal == 0)
+    if (dimTotal == 0)
     {
         return false;
     }
     *array = (char**)OICMalloc(dimTotal * sizeof(char*));
-    if(!*array)
+    if (!*array)
     {
         return false;
     }
@@ -851,7 +1077,7 @@ bool OCRepPayloadSetBoolArrayAsOwner(OCRepPayload* payload, const char* name,
 
     OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
 
-    if(!val)
+    if (!val)
     {
         return false;
     }
@@ -866,14 +1092,14 @@ bool OCRepPayloadSetBoolArray(OCRepPayload* payload, const char* name,
         const bool* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
 {
     size_t dimTotal = calcDimTotal(dimensions);
-    if(dimTotal == 0)
+    if (dimTotal == 0)
     {
         return false;
     }
 
     bool* newArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
 
-    if(!newArray)
+    if (!newArray)
     {
         return false;
     }
@@ -882,7 +1108,7 @@ bool OCRepPayloadSetBoolArray(OCRepPayload* payload, const char* name,
 
 
     bool b = OCRepPayloadSetBoolArrayAsOwner(payload, name, newArray, dimensions);
-    if(!b)
+    if (!b)
     {
         OICFree(newArray);
     }
@@ -894,19 +1120,19 @@ bool OCRepPayloadGetBoolArray(const OCRepPayload* payload, const char* name,
 {
     OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
 
-    if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_BOOL
+    if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_BOOL
             || !val->arr.bArray)
     {
         return false;
     }
 
     size_t dimTotal = calcDimTotal(val->arr.dimensions);
-    if(dimTotal == 0)
+    if (dimTotal == 0)
     {
         return false;
     }
     *array = (bool*)OICMalloc(dimTotal * sizeof(bool));
-    if(!*array)
+    if (!*array)
     {
         return false;
     }
@@ -921,7 +1147,7 @@ bool OCRepPayloadSetPropObjectArrayAsOwner(OCRepPayload* payload, const char* na
 {
     OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
 
-    if(!val)
+    if (!val)
     {
         return false;
     }
@@ -937,14 +1163,14 @@ bool OCRepPayloadSetPropObjectArray(OCRepPayload* payload, const char* name,
         const OCRepPayload** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
 {
     size_t dimTotal = calcDimTotal(dimensions);
-    if(dimTotal == 0)
+    if (dimTotal == 0)
     {
         return false;
     }
 
     OCRepPayload** newArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
 
-    if(!newArray)
+    if (!newArray)
     {
         return false;
     }
@@ -956,7 +1182,7 @@ bool OCRepPayloadSetPropObjectArray(OCRepPayload* payload, const char* name,
 
     bool b = OCRepPayloadSetPropObjectArrayAsOwner(payload, name, newArray, dimensions);
 
-    if(!b)
+    if (!b)
     {
         for(size_t i = 0; i < dimTotal; ++i)
         {
@@ -972,19 +1198,19 @@ bool OCRepPayloadGetPropObjectArray(const OCRepPayload* payload, const char* nam
 {
     OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
 
-    if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_OBJECT
+    if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_OBJECT
             || !val->arr.objArray)
     {
         return false;
     }
 
     size_t dimTotal = calcDimTotal(val->arr.dimensions);
-    if(dimTotal == 0)
+    if (dimTotal == 0)
     {
         return false;
     }
     *array = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
-    if(!*array)
+    if (!*array)
     {
         return false;
     }
@@ -1001,7 +1227,7 @@ bool OCRepPayloadGetPropObjectArray(const OCRepPayload* payload, const char* nam
 
 void OCFreeOCStringLL(OCStringLL* ll)
 {
-    if(!ll)
+    if (!ll)
     {
         return;
     }
@@ -1072,7 +1298,7 @@ OCRepPayload* OCRepPayloadClone (const OCRepPayload* payload)
 
 void OCRepPayloadDestroy(OCRepPayload* payload)
 {
-    if(!payload)
+    if (!payload)
     {
         return;
     }
@@ -1089,7 +1315,7 @@ OCDiscoveryPayload* OCDiscoveryPayloadCreate()
 {
     OCDiscoveryPayload* payload = (OCDiscoveryPayload*)OICCalloc(1, sizeof(OCDiscoveryPayload));
 
-    if(!payload)
+    if (!payload)
     {
         return NULL;
     }
@@ -1099,24 +1325,31 @@ OCDiscoveryPayload* OCDiscoveryPayloadCreate()
     return payload;
 }
 
-OCSecurityPayload* OCSecurityPayloadCreate(const char* securityData)
+OCSecurityPayload* OCSecurityPayloadCreate(const uint8_t* securityData, size_t size)
 {
     OCSecurityPayload* payload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 
-    if(!payload)
+    if (!payload)
     {
         return NULL;
     }
 
     payload->base.type = PAYLOAD_TYPE_SECURITY;
-    payload->securityData = OICStrdup(securityData);
+    payload->securityData = (uint8_t *)OICCalloc(1, size);
+    if (!payload->securityData)
+    {
+        OICFree(payload);
+        return NULL;
+    }
+    memcpy(payload->securityData, (uint8_t *)securityData, size);
+    payload->payloadSize = size;
 
     return payload;
 }
 
 void OCSecurityPayloadDestroy(OCSecurityPayload* payload)
 {
-    if(!payload)
+    if (!payload)
     {
         return;
     }
@@ -1143,7 +1376,7 @@ OCResourcePayload* OCDiscoveryPayloadGetResource(OCDiscoveryPayload* payload, si
     OCResourcePayload* p = payload->resources;
     while(p)
     {
-        if(i == index)
+        if (i == index)
         {
             return p;
         }
@@ -1156,35 +1389,34 @@ OCResourcePayload* OCDiscoveryPayloadGetResource(OCDiscoveryPayload* payload, si
 static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t port)
 {
     OCResourcePayload* pl = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
-    if(!pl)
+    if (!pl)
     {
         return NULL;
     }
 
     pl->uri = OICStrdup(res->uri);
-    pl->sid = (uint8_t*)OICCalloc(1, UUID_SIZE);
-    if(!pl->uri || ! pl->sid)
+
+    if (!pl->uri)
     {
-        FreeOCDiscoveryResource(pl);
+        OCDiscoveryResourceDestroy(pl);
         return NULL;
     }
-    memcpy(pl->sid, OCGetServerInstanceID(), UUID_SIZE);
 
     // types
     OCResourceType* typePtr = res->rsrcType;
 
-    if(typePtr != NULL)
+    if (typePtr != NULL)
     {
         pl->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-        if(!pl->types)
+        if (!pl->types)
         {
-            FreeOCDiscoveryResource(pl);
+            OCDiscoveryResourceDestroy(pl);
             return NULL;
         }
         pl->types->value = OICStrdup(typePtr->resourcetypename);
-        if(!pl->types->value)
+        if (!pl->types->value)
         {
-            FreeOCDiscoveryResource(pl);
+            OCDiscoveryResourceDestroy(pl);
             return NULL;
         }
 
@@ -1193,15 +1425,15 @@ static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t port)
         while(typePtr)
         {
             cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-            if(!cur->next)
+            if (!cur->next)
             {
-                FreeOCDiscoveryResource(pl);
+                OCDiscoveryResourceDestroy(pl);
                 return NULL;
             }
             cur->next->value = OICStrdup(typePtr->resourcetypename);
-            if(!cur->next->value)
+            if (!cur->next->value)
             {
-                FreeOCDiscoveryResource(pl);
+                OCDiscoveryResourceDestroy(pl);
                 return NULL;
             }
             cur = cur->next;
@@ -1211,18 +1443,18 @@ static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t port)
 
     // interfaces
     OCResourceInterface* ifPtr = res->rsrcInterface;
-    if(ifPtr != NULL)
+    if (ifPtr != NULL)
     {
         pl->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-        if(!pl->interfaces)
+        if (!pl->interfaces)
         {
-            FreeOCDiscoveryResource(pl);
+            OCDiscoveryResourceDestroy(pl);
             return NULL;
         }
         pl->interfaces->value = OICStrdup(ifPtr->name);
-        if(!pl->interfaces->value)
+        if (!pl->interfaces->value)
         {
-            FreeOCDiscoveryResource(pl);
+            OCDiscoveryResourceDestroy(pl);
             return NULL;
         }
 
@@ -1231,15 +1463,15 @@ static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t port)
         while(ifPtr && cur)
         {
             cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-            if(!cur->next)
+            if (!cur->next)
             {
-                FreeOCDiscoveryResource(pl);
+                OCDiscoveryResourceDestroy(pl);
                 return NULL;
             }
             cur->next->value = OICStrdup(ifPtr->name);
-            if(!cur->next->value)
+            if (!cur->next->value)
             {
-                FreeOCDiscoveryResource(pl);
+                OCDiscoveryResourceDestroy(pl);
                 return NULL;
             }
             cur = cur->next;
@@ -1260,9 +1492,44 @@ void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource
     OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, port));
 }
 
+bool OCResourcePayloadAddStringLL(OCStringLL **stringLL, const char *value)
+{
+    char *dup = OICStrdup(value);
+    VERIFY_PARAM_NON_NULL(TAG, dup, "Failed copying string");
+    VERIFY_PARAM_NON_NULL(TAG, value, "Invalid Parameters");
+
+    if (!*stringLL)
+    {
+        *stringLL = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
+        VERIFY_PARAM_NON_NULL(TAG, *stringLL, "Failed allocating memory");
+        (*stringLL)->value = dup;
+        return true;
+    }
+    else
+    {
+        OCStringLL *temp = *stringLL;
+        while(temp->next)
+        {
+            temp = temp->next;
+        }
+        temp->next = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
+        VERIFY_PARAM_NON_NULL(TAG, temp->next, "Failed allocating memory");
+        temp->next->value = dup;
+        return true;
+    }
+exit:
+    OICFree(dup);
+    return false;
+}
+
 void OCDiscoveryPayloadAddNewResource(OCDiscoveryPayload* payload, OCResourcePayload* res)
 {
-    if(!payload->resources)
+    if (!payload)
+    {
+        return;
+    }
+
+    if (!payload->resources)
     {
         payload->resources = res;
     }
@@ -1277,75 +1544,74 @@ void OCDiscoveryPayloadAddNewResource(OCDiscoveryPayload* payload, OCResourcePay
     }
 }
 
-static void FreeOCDiscoveryResource(OCResourcePayload* payload)
+void OCDiscoveryResourceDestroy(OCResourcePayload* payload)
 {
-    if(!payload)
+    if (!payload)
     {
         return;
     }
 
     OICFree(payload->uri);
-    OICFree(payload->sid);
     OCFreeOCStringLL(payload->types);
     OCFreeOCStringLL(payload->interfaces);
-    FreeOCDiscoveryResource(payload->next);
+    OCDiscoveryResourceDestroy(payload->next);
     OICFree(payload);
 
 }
 void OCDiscoveryPayloadDestroy(OCDiscoveryPayload* payload)
 {
-    if(!payload)
+    if (!payload)
     {
         return;
     }
-
-    FreeOCDiscoveryResource(payload->resources);
+    OICFree(payload->sid);
+    OICFree(payload->baseURI);
+    OICFree(payload->uri);
+    OICFree(payload->type);
+    OICFree(payload->name);
+    OCFreeOCStringLL(payload->interface);
+    OCDiscoveryResourceDestroy(payload->resources);
     OICFree(payload);
 }
 
-OCDevicePayload* OCDevicePayloadCreate(const char* uri, const uint8_t* sid, const char* dname,
-        const char* specVer, const char* dmVer)
+OCDevicePayload* OCDevicePayloadCreate(const char* sid, const char* dname,
+        const OCStringLL *types, const char* specVer, const char* dmVer)
 {
 
     OCDevicePayload* payload = (OCDevicePayload*)OICCalloc(1, sizeof(OCDevicePayload));
 
-    if(!payload)
+    if (!payload)
     {
         return NULL;
     }
 
     payload->base.type = PAYLOAD_TYPE_DEVICE;
-
-    payload->uri = OICStrdup(uri);
-    if(uri && !payload->uri)
+    payload->sid = OICStrdup(sid);
+    if (sid && !payload->sid)
     {
         goto exit;
     }
 
-    if(sid)
-    {
-        payload->sid = (uint8_t*)OICMalloc(UUID_SIZE);
-        if(!payload->sid)
-        {
-            goto exit;
-        }
-        memcpy(payload->sid, sid, UUID_SIZE);
-    }
-
     payload->deviceName = OICStrdup(dname);
-    if(dname && !payload->deviceName)
+    if (dname && !payload->deviceName)
     {
         goto exit;
     }
 
     payload->specVersion = OICStrdup(specVer);
-    if(specVer && !payload->specVersion)
+    if (specVer && !payload->specVersion)
     {
         goto exit;
     }
 
     payload->dataModelVersion = OICStrdup(dmVer);
-    if(dmVer && !payload->dataModelVersion)
+    if (dmVer && !payload->dataModelVersion)
+    {
+        goto exit;
+    }
+
+    payload->types = CloneOCStringLL((OCStringLL *)types);
+    if (types && !payload->types)
     {
         goto exit;
     }
@@ -1359,22 +1625,22 @@ exit:
 
 void OCDevicePayloadDestroy(OCDevicePayload* payload)
 {
-    if(!payload)
+    if (!payload)
     {
         return;
     }
 
-    OICFree(payload->uri);
     OICFree(payload->sid);
     OICFree(payload->deviceName);
     OICFree(payload->specVersion);
     OICFree(payload->dataModelVersion);
+    OCFreeOCStringLL(payload->types);
     OICFree(payload);
 }
 
 static void OCCopyPlatformInfo(const OCPlatformInfo* platformInfo, OCPlatformPayload* target)
 {
-    if(!platformInfo || !target)
+    if (!platformInfo || !target)
     {
         return;
     }
@@ -1392,55 +1658,76 @@ static void OCCopyPlatformInfo(const OCPlatformInfo* platformInfo, OCPlatformPay
     target->info.systemTime = OICStrdup(platformInfo->systemTime);
 }
 
-OCPlatformPayload* OCPlatformPayloadCreateAsOwner(char* uri, OCPlatformInfo* platformInfo)
+OCPlatformPayload* OCPlatformPayloadCreateAsOwner(OCPlatformInfo* platformInfo)
 {
     OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
-    if(!payload)
+    if (!payload)
     {
         return NULL;
     }
 
     payload->base.type = PAYLOAD_TYPE_PLATFORM;
-    payload->uri = uri;
+
+    payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
+    if (!payload->interfaces)
+    {
+        return NULL;
+    }
+    payload->interfaces->value = OICStrdup(OC_RSRVD_INTERFACE_READ);
+    payload->rt = OICStrdup(OC_RSRVD_RESOURCE_TYPE_PLATFORM);
     payload->info = *platformInfo;
 
     return payload;
 }
 
-OCPlatformPayload* OCPlatformPayloadCreate(const char* uri, const OCPlatformInfo* platformInfo)
+OCPlatformPayload* OCPlatformPayloadCreate(const OCPlatformInfo* platformInfo)
 {
     OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
 
-    if(!payload)
+    if (!payload)
     {
         return NULL;
     }
 
     payload->base.type = PAYLOAD_TYPE_PLATFORM;
-    payload->uri = OICStrdup(uri);
+
+    payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
+    if (!payload->interfaces)
+    {
+        return NULL;
+    }
+    payload->interfaces->value = OICStrdup(OC_RSRVD_INTERFACE_READ);
+    payload->rt = OICStrdup(OC_RSRVD_RESOURCE_TYPE_PLATFORM);
     OCCopyPlatformInfo(platformInfo, payload);
 
     return payload;
 }
 
+void OCPlatformInfoDestroy(OCPlatformInfo *info)
+{
+    OICFree(info->platformID);
+    OICFree(info->manufacturerName);
+    OICFree(info->manufacturerUrl);
+    OICFree(info->modelNumber);
+    OICFree(info->dateOfManufacture);
+    OICFree(info->platformVersion);
+    OICFree(info->operatingSystemVersion);
+    OICFree(info->hardwareVersion);
+    OICFree(info->firmwareVersion);
+    OICFree(info->supportUrl);
+    OICFree(info->systemTime);
+}
+
 void OCPlatformPayloadDestroy(OCPlatformPayload* payload)
 {
-    if(!payload)
+    if (!payload)
     {
         return;
     }
     OICFree(payload->uri);
-    OICFree(payload->info.platformID);
-    OICFree(payload->info.manufacturerName);
-    OICFree(payload->info.manufacturerUrl);
-    OICFree(payload->info.modelNumber);
-    OICFree(payload->info.dateOfManufacture);
-    OICFree(payload->info.platformVersion);
-    OICFree(payload->info.operatingSystemVersion);
-    OICFree(payload->info.hardwareVersion);
-    OICFree(payload->info.firmwareVersion);
-    OICFree(payload->info.supportUrl);
-    OICFree(payload->info.systemTime);
+    OCPlatformInfoDestroy(&payload->info);
+    OICFree(payload->rt);
+    OCFreeOCStringLL(payload->interfaces);
     OICFree(payload);
 }
 
@@ -1448,7 +1735,7 @@ OCPresencePayload* OCPresencePayloadCreate(uint32_t seqNum, uint32_t maxAge,
         OCPresenceTrigger trigger, const char* resourceType)
 {
     OCPresencePayload* payload = (OCPresencePayload*)OICCalloc(1, sizeof(OCPresencePayload));
-    if(!payload)
+    if (!payload)
     {
         return NULL;
     }
@@ -1463,7 +1750,7 @@ OCPresencePayload* OCPresencePayloadCreate(uint32_t seqNum, uint32_t maxAge,
 
 void OCPresencePayloadDestroy(OCPresencePayload* payload)
 {
-    if(!payload)
+    if (!payload)
     {
         return;
     }