#define TAG "OIC_RI_PAYLOAD"
static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val);
-static void FreeOCDiscoveryResource(OCResourcePayload* payload);
void OCPayloadDestroy(OCPayload* payload)
{
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;
}
{
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)
}
OICFree(val->arr.ocByteStrArray);
break;
- case OCREP_PROP_OBJECT:
+ 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]);
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;
}
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;
}
{
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)
{
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 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;
}
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;
OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, port));
}
-bool OCResourcePayloadAddResourceType(OCResourcePayload* payload, const char* resourceType)
-{
- 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;
- }
-}
-
-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 = OICStrdup(value);
+ VERIFY_PARAM_NON_NULL(TAG, dup, "Failed copying string");
+ VERIFY_PARAM_NON_NULL(TAG, value, "Invalid Parameters");
- 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->baseURI);
+ OICFree(payload->uri);
+ OICFree(payload->type);
+ OICFree(payload->name);
+ OCFreeOCStringLL(payload->interface);
+ OCDiscoveryResourceDestroy(payload->resources);
OICFree(payload);
}
-OCDevicePayload* OCDevicePayloadCreate(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));
}
payload->base.type = PAYLOAD_TYPE_DEVICE;
-
- if (sid)
+ payload->sid = OICStrdup(sid);
+ if (sid && !payload->sid)
{
- payload->sid = (uint8_t*)OICMalloc(UUID_SIZE);
- if (!payload->sid)
- {
- goto exit;
- }
- memcpy(payload->sid, sid, UUID_SIZE);
+ goto exit;
}
payload->deviceName = OICStrdup(dname);
goto exit;
}
+ payload->types = CloneOCStringLL((OCStringLL *)types);
+ if (types && !payload->types)
+ {
+ goto exit;
+ }
+
return payload;
exit:
OICFree(payload->deviceName);
OICFree(payload->specVersion);
OICFree(payload->dataModelVersion);
+ OCFreeOCStringLL(payload->types);
OICFree(payload);
}
}
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;
}
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);
- 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);
}
projects / platform / upstream / iotivity.git / blobdiff