//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+// Required for strok_r
+#define _POSIX_C_SOURCE 200112L
+#include "iotivity_config.h"
+#include <stdio.h>
#include "ocpayload.h"
#include "octypes.h"
#include <string.h>
#include "ocstackinternal.h"
#include "ocresource.h"
#include "logger.h"
-#include "rdpayload.h"
#define TAG "OIC_RI_PAYLOAD"
+#define CSV_SEPARATOR ','
static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val);
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));
{
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;
+ 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;
}
+exit:
+ return;
}
static void OCCopyPropertyValue (OCRepPayloadValue *dest, OCRepPayloadValue *source)
case OCREP_PROP_STRING:
dest->str = OICStrdup(source->str);
break;
+ case OCREP_PROP_BYTE_STRING:
+ dest->ocByteStr.bytes = (uint8_t*)OICMalloc(source->ocByteStr.len * sizeof(uint8_t));
+ VERIFY_PARAM_NON_NULL(TAG, dest->ocByteStr.bytes, "Failed allocating memory");
+ dest->ocByteStr.len = source->ocByteStr.len;
+ memcpy(dest->ocByteStr.bytes, source->ocByteStr.bytes, dest->ocByteStr.len);
+ break;
case OCREP_PROP_OBJECT:
dest->obj = OCRepPayloadClone(source->obj);
break;
// Nothing to do for the trivially copyable types.
break;
}
+exit:
+ return;
}
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)
{
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:
}
}
-bool OCRepPayloadAddInterface(OCRepPayload* payload, const char* interface)
+bool OCRepPayloadAddInterface(OCRepPayload* payload, const char* iface)
{
- return OCRepPayloadAddInterfaceAsOwner(payload, OICStrdup(interface));
+ return OCRepPayloadAddInterfaceAsOwner(payload, OICStrdup(iface));
}
-bool OCRepPayloadAddInterfaceAsOwner(OCRepPayload* payload, char* interface)
+bool OCRepPayloadAddInterfaceAsOwner(OCRepPayload* payload, char* iface)
{
- if (!payload || !interface)
+ if (!payload || !iface)
{
return false;
}
{
return false;
}
- cur->next->value = interface;
+ cur->next->value = iface;
return true;
}
else
{
return false;
}
- payload->interfaces->value = interface;
+ payload->interfaces->value = iface;
return true;
}
}
if (!val)
{
- return false;
+ return true;
}
return val->type == OCREP_PROP_NULL;
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;
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);
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);
{
if (!array)
{
- return NULL;
+ return false;
}
size_t dimTotal = calcDimTotal(dimensions);
return false;
}
- if (val->arr.type != OCREP_PROP_DOUBLE)
+ if (val->arr.type == OCREP_PROP_DOUBLE)
{
memcpy(*array, val->arr.dArray, dimTotal * sizeof(double));
}
return headOfClone;
}
+OCStringLL* OCCreateOCStringLL(const char* text)
+{
+ char *token = NULL;
+ char *head = NULL;
+ char *tail = NULL;
+ char *backup = NULL;
+ OCStringLL* result = NULL;
+ OCStringLL* iter = NULL;
+ OCStringLL* prev = NULL;
+ static const char delim[] = { CSV_SEPARATOR, '\0' };
+
+ VERIFY_PARAM_NON_NULL(TAG, text, "Invalid parameter");
+ backup = OICStrdup(text);
+ VERIFY_PARAM_NON_NULL(TAG, backup, "Failed allocating memory");
+
+ for (head = backup; ; head = NULL)
+ {
+ token = (char *) strtok_r(head, delim, &tail);
+ if (!token)
+ {
+ break;
+ }
+ iter = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
+ VERIFY_PARAM_NON_NULL(TAG, iter, "Failed allocating memory");
+ if (!result)
+ {
+ result = iter;
+ }
+ else
+ {
+ prev->next = iter;
+ }
+ iter->value = OICStrdup(token);
+ VERIFY_PARAM_NON_NULL(TAG, iter->value, "Failed allocating memory");
+ prev = iter;
+ }
+ OICFree(backup);
+ return result;
+
+exit:
+ OICFree(backup);
+ OCFreeOCStringLL(result);
+ return NULL;
+}
+
+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;
+
+ for (const OCStringLL *it = ll; it; it = it->next)
+ {
+ len += strlen(it->value) + 1;
+ }
+ len--; // remove trailing separator (just added above)
+ str = (char*) OICMalloc(len + 1);
+ if (!str)
+ {
+ return NULL;
+ }
+
+ pos = str;
+ const OCStringLL *it = ll;
+ while (it)
+ {
+ sublen = strlen(it->value);
+ count = snprintf(pos, len + 1, "%s", it->value);
+ if ((size_t)count < sublen)
+ {
+ OICFree(str);
+ return NULL;
+ }
+ len -= sublen;
+ pos += count;
+
+ it = it->next;
+ if (it)
+ {
+ *pos = CSV_SEPARATOR;
+ len--;
+ *(++pos) = '\0';
+ }
+ }
+
+ 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)
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)
{
return payload;
}
-//TODO : Remove this once all cbor changes land.
-OCSecurityPayload* OCSecurityPayloadCreate(const char* securityData)
+OCSecurityPayload* OCSecurityPayloadCreate(const uint8_t* securityData, size_t size)
{
OCSecurityPayload* payload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
}
payload->base.type = PAYLOAD_TYPE_SECURITY;
- payload->securityData = OICStrdup(securityData);
-
- return payload;
-}
-
-// TODO : To convert this to OCSecurityPayloadCreate once all cbor changes land.
-OCSecurityPayload* OCSecurityPayloadCBORCreate(const uint8_t* securityData, size_t size)
-{
- OCSecurityPayload* payload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
-
- if (!payload)
- {
- return NULL;
- }
-
- payload->base.type = PAYLOAD_TYPE_SECURITY;
- payload->securityData1 = (uint8_t *)OICCalloc(1, size);
- if (!payload->securityData1)
+ payload->securityData = (uint8_t *)OICCalloc(1, size);
+ if (!payload->securityData)
{
OICFree(payload);
return NULL;
}
- memcpy(payload->securityData1, (uint8_t *)securityData, size);
+ memcpy(payload->securityData, (uint8_t *)securityData, size);
payload->payloadSize = size;
return payload;
{
return;
}
- // Remove this once all cbor changes land.
+
+ OICClearMemory(payload->securityData, payload->payloadSize);
OICFree(payload->securityData);
- // OICFree(payload->securityData1);
OICFree(payload);
}
return NULL;
}
-static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t port)
+#ifndef TCP_ADAPTER
+static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t securePort)
+#else
+static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t securePort,
+ uint16_t tcpPort)
+#endif
{
OCResourcePayload* pl = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
if (!pl)
}
}
- pl->bitmap = res->resourceProperties & (OC_OBSERVABLE | OC_DISCOVERABLE);
+ pl->bitmap = res->resourceProperties & (OC_OBSERVABLE | OC_DISCOVERABLE
+#ifdef MQ_PUBLISHER
+ | OC_MQ_PUBLISHER
+#endif
+ );
pl->secure = (res->resourceProperties & OC_SECURE) != 0;
- pl->port = port;
-
+ pl->port = securePort;
+#ifdef TCP_ADAPTER
+ pl->tcpPort = tcpPort;
+#endif
return pl;
}
+#ifndef TCP_ADAPTER
void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource* res,
- uint16_t port)
+ uint16_t securePort)
{
- OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, port));
+ OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, securePort));
}
+#else
+void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource* res,
+ uint16_t securePort, uint16_t tcpPort)
+{
+ OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, securePort, tcpPort));
+}
+#endif
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)
{
*stringLL = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
- VERIFY_PARAM_NON_NULL(TAG, dup, "Failed allocating memory");
+ VERIFY_PARAM_NON_NULL(TAG, *stringLL, "Failed allocating memory");
(*stringLL)->value = dup;
return true;
}
return;
}
OICFree(payload->sid);
+ OICFree(payload->baseURI);
+ OCFreeOCStringLL(payload->type);
+ OICFree(payload->name);
+ OCFreeOCStringLL(payload->iface);
OCDiscoveryResourceDestroy(payload->resources);
+ OCDiscoveryPayloadDestroy(payload->next);
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->dataModelVersion = OICStrdup(dmVer);
- if (dmVer && !payload->dataModelVersion)
- {
- goto exit;
- }
-
- 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);
- OICFree(payload->dataModelVersion);
- OCFreeOCStringLL(payload->types);
- 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 = 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;
-
- 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)
- {
- return;
- }
- OICFree(payload->uri);
- OCPlatformInfoDestroy(&payload->info);
- OICFree(payload->rt);
- OCFreeOCStringLL(payload->interfaces);
- OICFree(payload);
-}
-
+#ifdef WITH_PRESENCE
OCPresencePayload* OCPresencePayloadCreate(uint32_t seqNum, uint32_t maxAge,
OCPresenceTrigger trigger, const char* resourceType)
{
OICFree(payload->resourceType);
OICFree(payload);
}
+#endif // WITH_PRESENCE
\ No newline at end of file