X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fstack%2Fsrc%2Focpayload.c;h=a80eb210d1c194b8c6eb7fed9d9b7ab353081558;hb=c315c87e07c4080ecd0ef488e7a1047bc3c509b2;hp=5c5a2e7687987827605289ead88f06b39daf2ff1;hpb=f68df5a9eae24122d1df34d8e649e51a5bee5545;p=platform%2Fupstream%2Fiotivity.git

diff --git a/resource/csdk/stack/src/ocpayload.c b/resource/csdk/stack/src/ocpayload.c
old mode 100644
new mode 100755
index 5c5a2e7..a80eb21
--- a/resource/csdk/stack/src/ocpayload.c
+++ b/resource/csdk/stack/src/ocpayload.c
@@ -21,6 +21,7 @@
 // Required for strok_r
 #define _POSIX_C_SOURCE 200112L
 
+#include "iotivity_config.h"
 #include <stdio.h>
 #include "ocpayload.h"
 #include "octypes.h"
@@ -30,7 +31,6 @@
 #include "ocstackinternal.h"
 #include "ocresource.h"
 #include "logger.h"
-#include "rdpayload.h"
 
 #define TAG "OIC_RI_PAYLOAD"
 #define CSV_SEPARATOR ','
@@ -52,27 +52,21 @@ void OCPayloadDestroy(OCPayload* payload)
         case PAYLOAD_TYPE_DISCOVERY:
             OCDiscoveryPayloadDestroy((OCDiscoveryPayload*)payload);
             break;
-        case PAYLOAD_TYPE_DEVICE:
-            OCDevicePayloadDestroy((OCDevicePayload*)payload);
-            break;
-        case PAYLOAD_TYPE_PLATFORM:
-            OCPlatformPayloadDestroy((OCPlatformPayload*)payload);
-            break;
+#ifdef WITH_PRESENCE
         case PAYLOAD_TYPE_PRESENCE:
             OCPresencePayloadDestroy((OCPresencePayload*)payload);
             break;
+#endif
         case PAYLOAD_TYPE_SECURITY:
             OCSecurityPayloadDestroy((OCSecurityPayload*)payload);
             break;
-        case PAYLOAD_TYPE_RD:
-           OCRDPayloadDestroy((OCRDPayload*)payload);
-           break;
         default:
             OIC_LOG_V(ERROR, TAG, "Unsupported payload type in destroy: %d", payload->type);
             OICFree(payload);
             break;
     }
 }
+
 OCRepPayload* OCRepPayloadCreate()
 {
     OCRepPayload* payload = (OCRepPayload*)OICCalloc(1, sizeof(OCRepPayload));
@@ -172,6 +166,15 @@ static void OCCopyPropertyValueArray(OCRepPayloadValue* dest, OCRepPayloadValue*
                 dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
             }
             break;
+        case OCREP_PROP_BYTE_STRING:
+            dest->arr.ocByteStrArray = (OCByteString*)OICMalloc(dimTotal * sizeof(OCByteString));
+            VERIFY_PARAM_NON_NULL(TAG, dest->arr.ocByteStrArray, "Failed allocating memory");
+            for (size_t i = 0; i < dimTotal; ++i)
+            {
+                OCByteStringCopy(&dest->arr.ocByteStrArray[i], &source->arr.ocByteStrArray[i]);
+                VERIFY_PARAM_NON_NULL(TAG, dest->arr.ocByteStrArray[i].bytes, "Failed allocating memory");
+            }
+            break;
         default:
             OIC_LOG(ERROR, TAG, "CopyPropertyValueArray invalid type");
             break;
@@ -221,7 +224,10 @@ static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val)
 
     if (val->type == OCREP_PROP_STRING)
     {
-        OICFree(val->str);
+        if (val->str != NULL)
+        {
+            OICFree(val->str);
+        }
     }
     else if (val->type == OCREP_PROP_BYTE_STRING)
     {
@@ -244,25 +250,37 @@ static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val)
                 OICFree(val->arr.iArray);
                 break;
             case OCREP_PROP_STRING:
-                for(size_t i = 0; i< dimTotal; ++i)
+                if (val->arr.strArray != NULL)
                 {
-                    OICFree(val->arr.strArray[i]);
+                    for(size_t i = 0; i < dimTotal; ++i)
+                    {
+                        OICFree(val->arr.strArray[i]);
+                    }
+                    OICFree(val->arr.strArray);
                 }
-                OICFree(val->arr.strArray);
                 break;
             case OCREP_PROP_BYTE_STRING:
-                for (size_t i = 0; i< dimTotal; ++i)
+                if (val->arr.ocByteStrArray != NULL)
                 {
-                    OICFree(val->arr.ocByteStrArray[i].bytes);
+                    for (size_t i = 0; i < dimTotal; ++i)
+                    {
+                        if (val->arr.ocByteStrArray[i].bytes)
+                        {
+                            OICFree(val->arr.ocByteStrArray[i].bytes);
+                        }
+                    }
+                    OICFree(val->arr.ocByteStrArray);
                 }
-                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)
+                if (val->arr.objArray != NULL)
                 {
-                    OCRepPayloadDestroy(val->arr.objArray[i]);
+                    for(size_t i = 0; i< dimTotal; ++i)
+                    {
+                        OCRepPayloadDestroy(val->arr.objArray[i]);
+                    }
+                    OICFree(val->arr.objArray);
                 }
-                OICFree(val->arr.objArray);
                 break;
             case OCREP_PROP_NULL:
             case OCREP_PROP_ARRAY:
@@ -518,6 +536,7 @@ static bool OCRepPayloadSetProp(OCRepPayload* payload, const char* name,
                return val->str != NULL;
         case OCREP_PROP_BYTE_STRING:
                val->ocByteStr = *(OCByteString*)value;
+               return val->ocByteStr.bytes != NULL;
                break;
         case OCREP_PROP_NULL:
                return val != NULL;
@@ -617,18 +636,13 @@ bool OCRepPayloadSetPropByteString(OCRepPayload* payload, const char* name, OCBy
         return false;
     }
 
-    OCByteString ocByteStr = {
-                    .bytes = (uint8_t*)OICMalloc(value.len * sizeof(uint8_t)),
-                    .len = value.len };
+    OCByteString ocByteStr = {NULL, 0};
+    bool b = OCByteStringCopy(&ocByteStr, &value);
 
-    if (!ocByteStr.bytes)
+    if (b)
     {
-        return false;
+        b = OCRepPayloadSetPropByteStringAsOwner(payload, name, &ocByteStr);
     }
-    memcpy(ocByteStr.bytes, value.bytes, ocByteStr.len);
-
-    bool b = OCRepPayloadSetPropByteStringAsOwner(payload, name, &ocByteStr);
-
     if (!b)
     {
         OICFree(ocByteStr.bytes);
@@ -685,6 +699,153 @@ bool OCRepPayloadGetPropBool(const OCRepPayload* payload, const char* name, bool
     return true;
 }
 
+#ifdef __WITH_TLS__
+static char *getStringFromEncodingType(OicEncodingType_t type)
+{
+    char *str = NULL;
+    switch (type)
+    {
+        case OIC_ENCODING_BASE64: str = OC_RSRVD_BASE64; break;
+        case OIC_ENCODING_DER: str = OC_RSRVD_DER; break;
+        case OIC_ENCODING_PEM: str = OC_RSRVD_PEM; break;
+        case OIC_ENCODING_RAW: str = OC_RSRVD_RAW; break;
+        default: str = OC_RSRVD_UNKNOWN; break;
+    }
+    char encoding[32];
+    snprintf(encoding, sizeof(encoding), "%s.%s.%s", OC_OIC_SEC, OC_RSRVD_ENCODING, str);
+
+    return OICStrdup(encoding);
+}
+
+bool OCRepPayloadSetPropPubDataTypeAsOwner(OCRepPayload *payload, const char *name,
+                                           const OicSecKey_t *value)
+{
+    if (!payload || !name || !value)
+    {
+        return false;
+    }
+
+    bool binary_field = false;
+    if (OIC_ENCODING_RAW == value->encoding || OIC_ENCODING_DER == value->encoding)
+    {
+        binary_field = true;
+    }
+
+    OCRepPayload *heplerPayload = OCRepPayloadCreate();
+    if (!heplerPayload)
+    {
+        return false;
+    }
+
+    char *encoding = getStringFromEncodingType(value->encoding);
+    if (!OCRepPayloadSetPropString(heplerPayload, OC_RSRVD_ENCODING, encoding))
+    {
+        OIC_LOG_V(ERROR, TAG, "Can't set %s", OC_RSRVD_ENCODING);
+    }
+
+    OCByteString val = {.bytes = value->data, .len = value->len};
+    if (binary_field)
+    {
+        if (!OCRepPayloadSetPropByteString(heplerPayload, OC_RSRVD_DATA, val))
+        {
+            OIC_LOG_V(ERROR, TAG, "Can't set %s", OC_RSRVD_DATA);
+        }
+    }
+    else
+    {
+        if (!OCRepPayloadSetPropString(heplerPayload, OC_RSRVD_DATA, (char *)val.bytes))
+        {
+            OIC_LOG_V(ERROR, TAG, "Can't set %s", OC_RSRVD_DATA);
+        }
+    }
+
+    if (!OCRepPayloadSetPropObject(payload, name, (const OCRepPayload *)heplerPayload))
+    {
+        OIC_LOG_V(ERROR, TAG, "Can't set %s", name);
+    }
+
+    OCRepPayloadDestroy(heplerPayload);
+    OICFree(encoding);
+
+    return true;
+}
+
+bool OCRepPayloadSetPropPubDataType(OCRepPayload *payload, const char *name,
+                                    const OicSecKey_t *value)
+{
+    return OCRepPayloadSetPropPubDataTypeAsOwner(payload, name, value);
+}
+
+static OicEncodingType_t getEncodingTypeFromString(char *encoding)
+{
+    OicEncodingType_t type = OIC_ENCODING_UNKNOW;
+
+    char *str = strrchr(encoding, '.');
+    if (NULL == str)
+    {
+        OIC_LOG_V(ERROR, TAG, "Can't find . in %s", encoding);
+        return type;
+    }
+    str++; //go to encoding itself
+
+    if (0 == strcmp(str, OC_RSRVD_BASE64)) type = OIC_ENCODING_BASE64;
+    else if (0 == strcmp(str, OC_RSRVD_DER)) type = OIC_ENCODING_DER;
+    else if (0 == strcmp(str, OC_RSRVD_PEM)) type = OIC_ENCODING_PEM;
+    else if (0 == strcmp(str, OC_RSRVD_RAW)) type = OIC_ENCODING_RAW;
+
+    return type;
+}
+
+bool OCRepPayloadGetPropPubDataType(const OCRepPayload *payload, const char *name, OicSecKey_t *value)
+{
+    OCRepPayload *heplerPayload = NULL;
+    char *encoding = NULL;
+    OCByteString val;
+
+    if (!payload || !name || !value)
+    {
+        return false;
+    }
+
+    if (!OCRepPayloadGetPropObject(payload, name, &heplerPayload))
+    {
+        OIC_LOG_V(ERROR, TAG, "Can't get object with name %s", name);
+        return false;
+    }
+
+    if (!OCRepPayloadGetPropString(heplerPayload, OC_RSRVD_ENCODING, &encoding))
+    {
+        OIC_LOG_V(ERROR, TAG, "Can't get %s", OC_RSRVD_ENCODING);
+    }
+    else
+    {
+        value->encoding = getEncodingTypeFromString(encoding);
+        OICFree(encoding);
+    }
+
+    if (!OCRepPayloadGetPropByteString(heplerPayload, OC_RSRVD_DATA, &val))
+    {
+        if (!OCRepPayloadGetPropString(heplerPayload, OC_RSRVD_DATA, (char **)&val.bytes))
+        {
+            OIC_LOG_V(ERROR, TAG, "Can't get: %s", OC_RSRVD_DATA);
+        }
+        else
+        {
+            value->data = val.bytes;
+            value->len  = strlen((char *)val.bytes);
+        }
+    }
+    else
+    {
+        value->data = val.bytes;
+        value->len  = val.len;
+    }
+
+    OCRepPayloadDestroy(heplerPayload);
+    return true;
+}
+#endif
+
 bool OCRepPayloadSetPropObject(OCRepPayload* payload, const char* name, const OCRepPayload* value)
 {
     OCRepPayload* temp = OCRepPayloadClone(value);
@@ -1303,21 +1464,23 @@ OCStringLL* OCCreateOCStringLL(const char* text)
     for (head = backup; ; head = NULL)
     {
         token = (char *) strtok_r(head, delim, &tail);
-        if (!token) break;
-        iter = (OCStringLL *)OICCalloc(1,sizeof(OCStringLL));
+        if (!token)
+        {
+            break;
+        }
+        iter = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
         VERIFY_PARAM_NON_NULL(TAG, iter, "Failed allocating memory");
         if (!result)
         {
-             result = iter;
+            result = iter;
         }
         else
         {
-             prev->next = iter;
+            prev->next = iter;
         }
         iter->value = OICStrdup(token);
         VERIFY_PARAM_NON_NULL(TAG, iter->value, "Failed allocating memory");
         prev = iter;
-        iter = iter->next;
     }
     OICFree(backup);
     return result;
@@ -1330,22 +1493,27 @@ exit:
 
 char* OCCreateString(const OCStringLL* ll)
 {
+    if (!ll)
+    {
+        return NULL;
+    }
+
     char *str = NULL;
     char *pos = NULL;
     size_t len = 0;
     size_t sublen = 0;
     int count = 0;
 
-    if (!ll) return NULL;
-
-    for (const OCStringLL *it = ll; it ; it = it->next )
+    for (const OCStringLL *it = ll; it; it = it->next)
     {
         len += strlen(it->value) + 1;
     }
-    len--; // renove trailing separator (just added above)
-    str = (char*) malloc(len + 1);
+    len--; // remove trailing separator (just added above)
+    str = (char*) OICMalloc(len + 1);
     if (!str)
+    {
         return NULL;
+    }
 
     pos = str;
     const OCStringLL *it = ll;
@@ -1353,13 +1521,13 @@ char* OCCreateString(const OCStringLL* ll)
     {
         sublen = strlen(it->value);
         count = snprintf(pos, len + 1, "%s", it->value);
-        if (count<sublen)
+        if ((size_t)count < sublen)
         {
-            free(str);
+            OICFree(str);
             return NULL;
         }
-        len-=sublen;
-        pos+=count;
+        len -= sublen;
+        pos += count;
 
         it = it->next;
         if (it)
@@ -1373,6 +1541,36 @@ char* OCCreateString(const OCStringLL* ll)
     return str;
 }
 
+bool OCByteStringCopy(OCByteString* dest, const OCByteString* source)
+{
+    VERIFY_PARAM_NON_NULL(TAG, source, "Bad input");
+
+    if (!dest)
+    {
+        dest = (OCByteString *)OICMalloc(sizeof(OCByteString));
+        VERIFY_PARAM_NON_NULL(TAG, dest, "Failed allocating memory");
+    }
+    if (dest->bytes)
+    {
+        OICFree(dest->bytes);
+    }
+    dest->bytes = (uint8_t*)OICMalloc(source->len * sizeof(uint8_t));
+    VERIFY_PARAM_NON_NULL(TAG, dest->bytes, "Failed allocating memory");
+    memcpy(dest->bytes, source->bytes, source->len * sizeof(uint8_t));
+    dest->len = source->len;
+    return true;
+
+exit:
+    if (dest)
+    {
+        dest->len = 0;
+        OICFree(dest->bytes);
+        dest->bytes = NULL;
+    }
+
+    return false;
+}
+
 OCRepPayload* OCRepPayloadClone (const OCRepPayload* payload)
 {
     if (!payload)
@@ -1395,6 +1593,29 @@ OCRepPayload* OCRepPayloadClone (const OCRepPayload* payload)
     return clone;
 }
 
+OCRepPayload* OCRepPayloadBatchClone(const OCRepPayload* repPayload)
+{
+    OCRepPayload *newPayload = OCRepPayloadCreate();
+    if (!newPayload)
+    {
+        return NULL;
+    }
+
+    newPayload->uri = OICStrdup(repPayload->uri);
+    OCRepPayload *clone = OCRepPayloadCreate();
+    if (!clone)
+    {
+        OCPayloadDestroy((OCPayload *)newPayload);
+        return NULL;
+    }
+
+    clone->types  = CloneOCStringLL(repPayload->types);
+    clone->interfaces  = CloneOCStringLL(repPayload->interfaces);
+    clone->values = OCRepPayloadValueClone(repPayload->values);
+    OCRepPayloadSetPropObjectAsOwner(newPayload, OC_RSRVD_REPRESENTATION, clone);
+
+    return newPayload;
+}
 
 void OCRepPayloadDestroy(OCRepPayload* payload)
 {
@@ -1454,6 +1675,7 @@ void OCSecurityPayloadDestroy(OCSecurityPayload* payload)
         return;
     }
 
+    OICClearMemory(payload->securityData, payload->payloadSize);
     OICFree(payload->securityData);
     OICFree(payload);
 }
@@ -1613,9 +1835,10 @@ void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource
 
 bool OCResourcePayloadAddStringLL(OCStringLL **stringLL, const char *value)
 {
-    char *dup = OICStrdup(value);
-    VERIFY_PARAM_NON_NULL(TAG, dup, "Failed copying string");
+    char *dup = NULL;
     VERIFY_PARAM_NON_NULL(TAG, value, "Invalid Parameters");
+    dup = OICStrdup(value);
+    VERIFY_PARAM_NON_NULL(TAG, dup, "Failed copying string");
 
     if (!*stringLL)
     {
@@ -1685,7 +1908,6 @@ void OCDiscoveryPayloadDestroy(OCDiscoveryPayload* payload)
     }
     OICFree(payload->sid);
     OICFree(payload->baseURI);
-    OICFree(payload->uri);
     OCFreeOCStringLL(payload->type);
     OICFree(payload->name);
     OCFreeOCStringLL(payload->iface);
@@ -1694,169 +1916,7 @@ void OCDiscoveryPayloadDestroy(OCDiscoveryPayload* payload)
     OICFree(payload);
 }
 
-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)
-    {
-        return NULL;
-    }
-
-    payload->base.type = PAYLOAD_TYPE_DEVICE;
-    payload->sid = OICStrdup(sid);
-    if (sid && !payload->sid)
-    {
-        goto exit;
-    }
-
-    payload->deviceName = OICStrdup(dname);
-    if (dname && !payload->deviceName)
-    {
-        goto exit;
-    }
-
-    payload->specVersion = OICStrdup(specVer);
-    if (specVer && !payload->specVersion)
-    {
-        goto exit;
-    }
-
-    payload->dataModelVersions = OCCreateOCStringLL(dmVer);
-    if (!payload->dataModelVersions || (dmVer && !payload->dataModelVersions->value))
-    {
-        goto exit;
-    }
-
-    OCResourcePayloadAddStringLL(&payload->interfaces, OC_RSRVD_INTERFACE_DEFAULT);
-    OCResourcePayloadAddStringLL(&payload->interfaces, OC_RSRVD_INTERFACE_READ);
-
-    payload->types = CloneOCStringLL((OCStringLL *)types);
-    if (types && !payload->types)
-    {
-        goto exit;
-    }
-
-    return payload;
-
-exit:
-    OCDevicePayloadDestroy((OCDevicePayload*)payload);
-    return NULL;
-}
-
-void OCDevicePayloadDestroy(OCDevicePayload* payload)
-{
-    if (!payload)
-    {
-        return;
-    }
-
-    OICFree(payload->sid);
-    OICFree(payload->deviceName);
-    OICFree(payload->specVersion);
-    OCFreeOCStringLL(payload->dataModelVersions);
-    OCFreeOCStringLL(payload->types);
-    OCFreeOCStringLL(payload->interfaces);
-    OICFree(payload);
-}
-
-static void OCCopyPlatformInfo(const OCPlatformInfo* platformInfo, OCPlatformPayload* target)
-{
-    if (!platformInfo || !target)
-    {
-        return;
-    }
-
-    target->info.platformID = OICStrdup(platformInfo->platformID);
-    target->info.manufacturerName = OICStrdup(platformInfo->manufacturerName);
-    target->info.manufacturerUrl = OICStrdup(platformInfo->manufacturerUrl);
-    target->info.modelNumber = OICStrdup(platformInfo->modelNumber);
-    target->info.dateOfManufacture = OICStrdup(platformInfo->dateOfManufacture);
-    target->info.platformVersion = OICStrdup(platformInfo->platformVersion);
-    target->info.operatingSystemVersion = OICStrdup(platformInfo->operatingSystemVersion);
-    target->info.hardwareVersion = OICStrdup(platformInfo->hardwareVersion);
-    target->info.firmwareVersion = OICStrdup(platformInfo->firmwareVersion);
-    target->info.supportUrl = OICStrdup(platformInfo->supportUrl);
-    target->info.systemTime = OICStrdup(platformInfo->systemTime);
-}
-
-OCPlatformPayload* OCPlatformPayloadCreateAsOwner(OCPlatformInfo* platformInfo)
-{
-    OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
-    if (!payload)
-    {
-        return NULL;
-    }
-
-    payload->base.type = PAYLOAD_TYPE_PLATFORM;
-
-    payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-    if (!payload->interfaces)
-    {
-        return NULL;
-    }
-    payload->interfaces->value = OICStrdup(OC_RSRVD_INTERFACE_READ);
-    payload->rt = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-    if (!payload->rt)
-    {
-        return NULL;
-    }
-    payload->rt->value = OICStrdup(OC_RSRVD_RESOURCE_TYPE_PLATFORM);
-    payload->info = *platformInfo;
-
-    return payload;
-}
-
-OCPlatformPayload* OCPlatformPayloadCreate(const OCPlatformInfo* platformInfo)
-{
-    OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
-
-    if (!payload)
-    {
-        return NULL;
-    }
-
-    payload->base.type = PAYLOAD_TYPE_PLATFORM;
-    OCResourcePayloadAddStringLL(&payload->rt, OC_RSRVD_RESOURCE_TYPE_PLATFORM);
-
-    OCResourcePayloadAddStringLL(&payload->interfaces, OC_RSRVD_INTERFACE_DEFAULT);
-    OCResourcePayloadAddStringLL(&payload->interfaces, OC_RSRVD_INTERFACE_READ);
-
-    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)
-    {
-        return;
-    }
-    OICFree(payload->uri);
-    OCPlatformInfoDestroy(&payload->info);
-    OCFreeOCStringLL(payload->rt);
-    OCFreeOCStringLL(payload->interfaces);
-    OICFree(payload);
-}
-
+#ifdef WITH_PRESENCE
 OCPresencePayload* OCPresencePayloadCreate(uint32_t seqNum, uint32_t maxAge,
         OCPresenceTrigger trigger, const char* resourceType)
 {
@@ -1883,3 +1943,4 @@ void OCPresencePayloadDestroy(OCPresencePayload* payload)
     OICFree(payload->resourceType);
     OICFree(payload);
 }
+#endif // WITH_PRESENCE
\ No newline at end of file