//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+// 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"
+
+#if defined(__WITH_TLS__) || defined(__WITH_DTLS__)
+#include "securevirtualresourcetypes.h"
+#endif
#define TAG "OIC_RI_PAYLOAD"
+#define CSV_SEPARATOR ','
static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val);
-static void FreeOCDiscoveryResource(OCResourcePayload* payload);
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));
{
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:
- for(size_t i = 0; i< dimTotal; ++i)
+ case OCREP_PROP_OBJECT: // This case is the temporary fix for string input
+ 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;
{
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)
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);
{
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;
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;
}
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;
}
-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);
+ 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;
}
return;
}
+ OICClearMemory(payload->securityData, payload->payloadSize);
OICFree(payload->securityData);
OICFree(payload);
}
return NULL;
}
-static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t port)
+#if !defined(TCP_ADAPTER) || defined(DISABLE_TCP_SERVER)
+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)
if (!pl->uri)
{
- FreeOCDiscoveryResource(pl);
+ OCDiscoveryResourceDestroy(pl);
return NULL;
}
pl->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
if (!pl->types)
{
- FreeOCDiscoveryResource(pl);
+ OCDiscoveryResourceDestroy(pl);
return NULL;
}
pl->types->value = OICStrdup(typePtr->resourcetypename);
if (!pl->types->value)
{
- FreeOCDiscoveryResource(pl);
+ OCDiscoveryResourceDestroy(pl);
return NULL;
}
cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
if (!cur->next)
{
- FreeOCDiscoveryResource(pl);
+ OCDiscoveryResourceDestroy(pl);
return NULL;
}
cur->next->value = OICStrdup(typePtr->resourcetypename);
if (!cur->next->value)
{
- FreeOCDiscoveryResource(pl);
+ OCDiscoveryResourceDestroy(pl);
return NULL;
}
cur = cur->next;
pl->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
if (!pl->interfaces)
{
- FreeOCDiscoveryResource(pl);
+ OCDiscoveryResourceDestroy(pl);
return NULL;
}
pl->interfaces->value = OICStrdup(ifPtr->name);
if (!pl->interfaces->value)
{
- FreeOCDiscoveryResource(pl);
+ OCDiscoveryResourceDestroy(pl);
return NULL;
}
cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
if (!cur->next)
{
- FreeOCDiscoveryResource(pl);
+ OCDiscoveryResourceDestroy(pl);
return NULL;
}
cur->next->value = OICStrdup(ifPtr->name);
if (!cur->next->value)
{
- FreeOCDiscoveryResource(pl);
+ OCDiscoveryResourceDestroy(pl);
return NULL;
}
cur = cur->next;
}
}
- 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;
+#if defined(TCP_ADAPTER) && !defined(DISABLE_TCP_SERVER)
+ pl->tcpPort = tcpPort;
+#endif
return pl;
}
+#if !defined(TCP_ADAPTER) || defined(DISABLE_TCP_SERVER)
void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource* res,
- uint16_t port)
+ uint16_t securePort)
{
- OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, port));
+ OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, securePort));
}
-
-bool OCResourcePayloadAddResourceType(OCResourcePayload* payload, const char* resourceType)
+#else
+void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource* res,
+ uint16_t securePort, uint16_t tcpPort)
{
- if (!resourceType || !payload)
- {
- return false;
- }
-
- char* dup = OICStrdup(resourceType);
-
- if (!dup)
- {
- return false;
- }
-
- if (!payload->types)
- {
- payload->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-
- if (!payload->types)
- {
- OICFree(dup);
- return false;
- }
-
- payload->types->value = dup;
- return true;
- }
-
- else
- {
- OCStringLL* temp = payload->types;
-
- while(temp->next)
- {
- temp = temp->next;
- }
-
- temp->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
- if (!temp->next)
- {
- OICFree(dup);
- return false;
- }
-
- temp->next->value = dup;
- return true;
- }
+ OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, securePort, tcpPort));
}
+#endif
-bool OCResourcePayloadAddInterface(OCResourcePayload* payload, const char* interface)
+bool OCResourcePayloadAddStringLL(OCStringLL **stringLL, const char *value)
{
- if (!interface || !payload)
- {
- return false;
- }
-
- char* dup = OICStrdup(interface);
-
- if (!dup)
- {
- return false;
- }
+ char *dup = NULL;
+ VERIFY_PARAM_NON_NULL(TAG, value, "Invalid Parameters");
+ dup = OICStrdup(value);
+ VERIFY_PARAM_NON_NULL(TAG, dup, "Failed copying string");
- if (!payload->interfaces)
+ if (!*stringLL)
{
- payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-
- if (!payload->interfaces)
- {
- OICFree(dup);
- return false;
- }
-
- payload->interfaces->value = dup;
+ *stringLL = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
+ VERIFY_PARAM_NON_NULL(TAG, *stringLL, "Failed allocating memory");
+ (*stringLL)->value = dup;
return true;
}
-
else
{
- OCStringLL* temp = payload->interfaces;
-
+ OCStringLL *temp = *stringLL;
while(temp->next)
{
temp = temp->next;
}
-
- temp->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
- if (!temp->next)
- {
- OICFree(dup);
- return false;
- }
-
+ 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)
}
}
-static void FreeOCDiscoveryResource(OCResourcePayload* payload)
+void OCDiscoveryResourceDestroy(OCResourcePayload* payload)
{
if (!payload)
{
OICFree(payload->uri);
OCFreeOCStringLL(payload->types);
OCFreeOCStringLL(payload->interfaces);
- FreeOCDiscoveryResource(payload->next);
+ OCDiscoveryResourceDestroy(payload->next);
OICFree(payload);
}
return;
}
OICFree(payload->sid);
- FreeOCDiscoveryResource(payload->resources);
- OICFree(payload);
-}
-
-OCDevicePayload* OCDevicePayloadCreate(const uint8_t* sid, const char* dname,
- const char* specVer, const char* dmVer)
-{
-
- OCDevicePayload* payload = (OCDevicePayload*)OICCalloc(1, sizeof(OCDevicePayload));
-
- if (!payload)
- {
- return NULL;
- }
-
- payload->base.type = PAYLOAD_TYPE_DEVICE;
-
- 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)
- {
- goto exit;
- }
-
- payload->specVersion = OICStrdup(specVer);
- if (specVer && !payload->specVersion)
- {
- goto exit;
- }
-
- payload->dataModelVersion = OICStrdup(dmVer);
- if (dmVer && !payload->dataModelVersion)
- {
- 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);
- 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->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;
- OCCopyPlatformInfo(platformInfo, payload);
-
- return payload;
-}
-
-void OCPlatformPayloadDestroy(OCPlatformPayload* 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);
+ OICFree(payload->baseURI);
+ OCFreeOCStringLL(payload->type);
+ OICFree(payload->name);
+ OCFreeOCStringLL(payload->iface);
+ OCDiscoveryResourceDestroy(payload->resources);
+ OCDiscoveryPayloadDestroy(payload->next);
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
projects / platform / upstream / iotivity.git / blobdiff