Defines a macro for error handling cbor load.
Any error leads to freeing and error details.
Some common functions has been created to ease
in freeing of memory in case of error.
OCDiscoveryCollectionPayloadAddResource is updated to
pass one parameter OCCollectionPayload instead of two
parameter. This is to ease passing param to MACRO.
Change-Id: I58e6c843fcacd8d952dad7b3a14c6327befcf77d
Signed-off-by: Habib Virji <habib.virji@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/4237
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Jon A. Cruz <jon@joncruz.org>
cbor_src = [
os.path.join(cborDir,'src/cborparser.c'),
- os.path.join(cborDir,'src/cborencoder.c')
+ os.path.join(cborDir,'src/cborencoder.c'),
+ os.path.join(cborDir,'src/cborerrorstrings.c'),
]
env['cbor_files'] = cbor_src
{
#endif
+/**
+ * Macro to verify the validity of cbor operation.
+ */
+#define VERIFY_CBOR_SUCCESS(log_tag, err, log_message) \
+ if ((CborNoError != (err)) && (CborErrorOutOfMemory != (err))) \
+ { \
+ if ((log_tag) && (log_message)) \
+ { \
+ OIC_LOG_V(ERROR, (log_tag), "%s with cbor error: \'%s\'.", \
+ (log_message), (cbor_error_string(err))); \
+ } \
+ goto exit; \
+ } \
+
+#define VERIFY_PARAM_NON_NULL(log_tag, err, log_message) \
+ if (NULL == (err)) \
+ { \
+ OIC_LOG_V(FATAL, (log_tag), "%s", (log_message)); \
+ goto exit;\
+ } \
+
+
typedef struct OCResource OCResource;
void OCPayloadDestroy(OCPayload* payload);
void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource* res,
uint16_t port);
void OCDiscoveryPayloadAddNewResource(OCDiscoveryPayload* payload, OCResourcePayload* res);
-bool OCResourcePayloadAddResourceType(OCResourcePayload* payload, const char* resourceType);
-bool OCResourcePayloadAddInterface(OCResourcePayload* payload, const char* interface);
+bool OCResourcePayloadAddStringLL(OCStringLL **payload, const char* type);
size_t OCDiscoveryPayloadGetResourceCount(OCDiscoveryPayload* payload);
OCResourcePayload* OCDiscoveryPayloadGetResource(OCDiscoveryPayload* payload, size_t index);
+void OCDiscoveryResourceDestroy(OCResourcePayload* payload);
void OCDiscoveryPayloadDestroy(OCDiscoveryPayload* payload);
// Device Payload
// Platform Payload
OCPlatformPayload* OCPlatformPayloadCreate(const OCPlatformInfo* platformInfo);
OCPlatformPayload* OCPlatformPayloadCreateAsOwner(OCPlatformInfo* platformInfo);
-
+void OCPlatformInfoDestroy(OCPlatformInfo *info);
void OCPlatformPayloadDestroy(OCPlatformPayload* payload);
// Presence Payload
* structure.
* @param size Length of the payload.
*
- * @return ::OC_STACK_OK returns if successful and OC_STACK_ERROR returns if
- * failed in creating CBOR.
- */
-int64_t OCRDPayloadToCbor(const OCRDPayload *rdPayload, uint8_t *outPayload, size_t *size);
-
-/**
- * Converts tags structure to the tags cbor payload.
- *
- * @param tags Allocated Tag structure
- * @param setMap The cbor map where result will be stored.
- *
- * @return ::OC_STACK_OK returns if successful and OC_STACK_ERROR returns if
+ * @return ::CborNoError returns if successful and other Cbor error in case of error.
* failed in creating CBOR.
*/
-OCStackResult OCTagsPayloadToCbor(OCTagsPayload *tags, CborEncoder *setMap);
-
-/**
- * Converts links structure to cbor map structure
- *
- * @param links Allocated links structure.
- * @param setMap The cbor map where result will be stored.
- *
- * @return ::OC_STACK_OK returns if successful and OC_STACK_ERROR returns if
- * failed in creating CBOR.
- */
-OCStackResult OCLinksPayloadToCbor(OCLinksPayload *rtPtr, CborEncoder *setMap);
+CborError OCRDPayloadToCbor(const OCRDPayload *rdPayload, uint8_t *outPayload, size_t *size);
/**
* Converts CBOR to OCRDPayload.
OCStackResult OCRDCborToPayload(const CborValue *cborPayload, OCPayload **outPayload);
/**
- * Converts cbor map payload to OCTags payload.
- *
- * @param tagstMap CborValue holding tags structure.
- * @param tagsPayload Allocated tags payload.
- *
- * @return ::OC_STACK_OK returns if successful and OC_STACK_ERROR returns if
- * failed in creating CBOR.
- */
-OCStackResult OCTagsCborToPayload(CborValue *tagsMap, OCTagsPayload **tagsPayload);
-
-/**
- * Converts cbor map payload to OCLinks payload.
- *
- * @param tagstMap CborValue holding links structure.
- * @param tagsPayload Allocated links payload.
- *
- * @return ::OC_STACK_OK returns if successful and OC_STACK_ERROR returns if
- * failed in creating CBOR.
- */
-OCStackResult OCLinksCborToPayload(CborValue *linksArray, OCLinksPayload **linksPayload);
-
-/**
* Initializes RD payload structure.
*
* @param payloadType Defines whether payload is RD_PAYLOAD_TYPE_DISCOVERY or
OCResourceCollectionPayload* OCCopyCollectionResource(OCTagsPayload *tags, OCLinksPayload *links);
/**
- * Adds discocvery collection in discovery payload.
- *
- * @param payload Pointer to the discovery payload. It adds allocated collection resource.
- * @param tags Pointer to the tags payload.
- * @param links Pointer to the links payload.
- *
- * @return ::OC_STACK_OK returns if successful and OC_STACK_ERROR returns if
- * failed in creating CBOR.
- */
-
-OCStackResult OCDiscoveryCollectionPayloadAddResource(OCDiscoveryPayload *payload, OCTagsPayload *tags,
- OCLinksPayload *links);
-
-/**
* Destroys tags payload including internal structure allocated
*
* @param tags - Allocated memory of the tags payload.
#define TAG "OIC_RI_PAYLOAD"
static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val);
-static void FreeOCDiscoveryResource(OCResourcePayload* payload);
void OCPayloadDestroy(OCPayload* 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)
+bool OCResourcePayloadAddStringLL(OCStringLL **stringLL, const char *value)
{
- 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)
-{
- 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, dup, "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);
+ OCDiscoveryResourceDestroy(payload->resources);
OICFree(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);
}
// Arbitrarily chosen size that seems to contain the majority of packages
#define INIT_SIZE (255)
-// CBOR Links Map Length
-#define DISCOVERY_CBOR_LINKS_MAP_LEN 4
+// Discovery Links Map Length.
+#define LINKS_MAP_LEN 4
// Functions all return either a CborError, or a negative version of the OC_STACK return values
-static int64_t OCConvertPayloadHelper(OCPayload* payload, uint8_t* outPayload, size_t* size);
-static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t* outPayload,
- size_t* size);
-static int64_t OCConvertDevicePayload(OCDevicePayload* payload, uint8_t* outPayload,
- size_t* size);
-static int64_t OCConvertPlatformPayload(OCPlatformPayload* payload, uint8_t* outPayload,
- size_t* size);
-static int64_t OCConvertRepPayload(OCRepPayload* payload, uint8_t* outPayload, size_t* size);
-static int64_t OCConvertRepMap(CborEncoder *map, const OCRepPayload* payload);
-static int64_t OCConvertPresencePayload(OCPresencePayload* payload, uint8_t* outPayload,
- size_t* size);
-static int64_t OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t* outPayload,
- size_t* size);
-static int64_t OCConvertSingleRepPayload(CborEncoder* parent, const OCRepPayload* payload);
-static int64_t OCConvertArray(CborEncoder* parent, const OCRepPayloadValueArray* valArray);
-
-static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
- const char* value);
-
-static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
- const char* value);
+static CborError OCConvertPayloadHelper(OCPayload *payload, uint8_t *outPayload, size_t *size);
+static CborError OCConvertDiscoveryPayload(OCDiscoveryPayload *payload, uint8_t *outPayload,
+ size_t *size);
+static CborError OCConvertDevicePayload(OCDevicePayload *payload, uint8_t *outPayload,
+ size_t *size);
+static CborError OCConvertPlatformPayload(OCPlatformPayload *payload, uint8_t *outPayload,
+ size_t *size);
+static CborError OCConvertRepPayload(OCRepPayload *payload, uint8_t *outPayload, size_t *size);
+static CborError OCConvertRepMap(CborEncoder *map, const OCRepPayload *payload);
+static CborError OCConvertPresencePayload(OCPresencePayload *payload, uint8_t *outPayload,
+ size_t *size);
+static CborError OCConvertSecurityPayload(OCSecurityPayload *payload, uint8_t *outPayload,
+ size_t *size);
+static CborError OCConvertSingleRepPayload(CborEncoder *parent, const OCRepPayload *payload);
+static CborError OCConvertArray(CborEncoder *parent, const OCRepPayloadValueArray *valArray);
+
+static CborError AddTextStringToMap(CborEncoder *map, const char *key, size_t keylen,
+ const char *value);
+static CborError ConditionalAddTextStringToMap(CborEncoder *map, const char *key, size_t keylen,
+ const char *value);
OCStackResult OCConvertPayload(OCPayload* payload, uint8_t** outPayload, size_t* size)
{
#define CborNeedsUpdating (CborErrorOutOfMemory < CborErrorDataTooLarge)
OC_STATIC_ASSERT(!CborNeedsUpdating, "tinycbor needs to be updated to at least 47a78569c0");
#undef CborNeedsUpdating
- if (!payload)
- {
- OIC_LOG(ERROR, TAG, "Payload parameter NULL");
- return OC_STACK_INVALID_PARAM;
- }
- if (!outPayload || !size)
- {
- OIC_LOG(ERROR, TAG, "Out parameter/s parameter NULL");
- return OC_STACK_INVALID_PARAM;
- }
+ OCStackResult ret = OC_STACK_INVALID_PARAM;
+ CborError err;
+ uint8_t *out = NULL;
+ size_t curSize = INIT_SIZE;
+
+ VERIFY_PARAM_NON_NULL(TAG, payload, "Input param, payload is NULL");
+ VERIFY_PARAM_NON_NULL(TAG, outPayload, "OutPayload parameter is NULL");
+ VERIFY_PARAM_NON_NULL(TAG, size, "size parameter is NULL");
OIC_LOG_V(INFO, TAG, "Converting payload of type %d", payload->type);
- size_t curSize = INIT_SIZE;
- uint8_t* out = (uint8_t*)OICCalloc(1, curSize);
- int64_t err = OCConvertPayloadHelper(payload, out, &curSize);
+ out = (uint8_t *)OICCalloc(1, curSize);
+ VERIFY_PARAM_NON_NULL(TAG, out, "Failed to allocate payload");
+ err = OCConvertPayloadHelper(payload, out, &curSize);
+ ret = OC_STACK_NO_MEMORY;
if (err == CborErrorOutOfMemory)
{
// reallocate "out" and try again!
- uint8_t* out2 = (uint8_t*)OICRealloc(out, curSize);
-
- if (!out2)
- {
- OICFree(out);
- return OC_STACK_NO_MEMORY;
- }
-
+ uint8_t* out2 = (uint8_t *)OICRealloc(out, curSize);
+ VERIFY_PARAM_NON_NULL(TAG, out2, "Failed to increase payload size");
out = out2;
err = OCConvertPayloadHelper(payload, out, &curSize);
}
- if (err == 0)
+ if (err == CborNoError)
{
if (curSize < INIT_SIZE)
{
- uint8_t* out2 = (uint8_t*)OICRealloc(out, curSize);
-
- if (!out2)
- {
- OICFree(out);
- return OC_STACK_NO_MEMORY;
- }
-
+ uint8_t *out2 = (uint8_t *)OICRealloc(out, curSize);
+ VERIFY_PARAM_NON_NULL(TAG, out2, "Failed to increase payload size");
out = out2;
}
*outPayload = out;
return OC_STACK_OK;
}
- else if (err < 0)
- {
- return (OCStackResult)-err;
- }
- else
- {
- return OC_STACK_ERROR;
- }
+
+ //TODO: Proper conversion from CborError to OCStackResult.
+ ret = (OCStackResult)-err;
+
+exit:
+ OICFree(out);
+ return ret;
}
-static int64_t OCConvertPayloadHelper(OCPayload* payload, uint8_t* outPayload, size_t* size)
+static CborError OCConvertPayloadHelper(OCPayload* payload, uint8_t* outPayload, size_t* size)
{
switch(payload->type)
{
return OCRDPayloadToCbor((OCRDPayload*)payload, outPayload, size);
default:
OIC_LOG_V(INFO,TAG, "ConvertPayload default %d", payload->type);
- return OC_STACK_NOTIMPL;
+ return CborErrorUnknownType;
}
}
-static int64_t checkError(int64_t err, CborEncoder* encoder, uint8_t* outPayload, size_t* size)
+static CborError checkError(CborError err, CborEncoder* encoder, uint8_t* outPayload, size_t* size)
{
if (err == CborErrorOutOfMemory)
{
*size += encoder->ptr - encoder->end;
return err;
}
- else if (err != 0)
+ else if (err != CborNoError)
{
- OIC_LOG_V(ERROR, TAG, "Convert Payload failed : %zd", err);
+ OIC_LOG_V(ERROR, TAG, "Convert Payload failed : %s", cbor_error_string(err));
return err;
}
else
{
*size = encoder->ptr - outPayload;
- return 0;
+ return err;
}
}
-static int64_t OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t* outPayload,
+static CborError OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t* outPayload,
size_t* size)
{
CborEncoder encoder;
- int64_t err = 0;
-
cbor_encoder_init(&encoder, outPayload, *size, 0);
CborEncoder map;
+ CborError err = cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Creating security map");
- err = err | cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
-
- if(payload->securityData)
+ if (payload->securityData)
{
- err = err | cbor_encode_text_string(&map, payload->securityData,
- strlen(payload->securityData));
+ err = cbor_encode_text_string(&map, payload->securityData,
+ strlen(payload->securityData));
+ VERIFY_CBOR_SUCCESS(TAG, err, "Retrieving security data");
}
- err = err | cbor_encoder_close_container(&encoder, &map);
+ err = cbor_encoder_close_container(&encoder, &map);
+ VERIFY_CBOR_SUCCESS(TAG, err, "closing security map");
+exit:
return checkError(err, &encoder, outPayload, size);
}
return joinedStr;
}
-static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t* outPayload,
- size_t* size)
+static CborError OCConvertDiscoveryPayload(OCDiscoveryPayload *payload, uint8_t *outPayload,
+ size_t *size)
{
- CborEncoder encoder = {0};
- CborEncoder rootArray = {0};
- int64_t err = 0;
+ CborEncoder encoder;
+ CborError err = CborNoError;
cbor_encoder_init(&encoder, outPayload, *size, 0);
}
]
*/
- CborEncoder rootMap = {0};
- size_t resourceCount = OCDiscoveryPayloadGetResourceCount(payload);
-
// Open the main root array
- err = err | cbor_encoder_create_array(&encoder, &rootArray, 1);
+ CborEncoder rootArray;
+ size_t resourceCount = OCDiscoveryPayloadGetResourceCount(payload);
+ err = cbor_encoder_create_array(&encoder, &rootArray, 1);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating discovery root array");
// Open the root map in the root array
- err = err | cbor_encoder_create_map(&rootArray, &rootMap, CborIndefiniteLength);
+ CborEncoder rootMap;
+ err = cbor_encoder_create_map(&rootArray, &rootMap, CborIndefiniteLength);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating discovery map");
// Insert Device ID into the root map
- err = err | cbor_encode_text_string(&rootMap, OC_RSRVD_DEVICE_ID,
+ err = cbor_encode_text_string(&rootMap, OC_RSRVD_DEVICE_ID,
sizeof(OC_RSRVD_DEVICE_ID) - 1);
- err = err | cbor_encode_byte_string(&rootMap, payload->sid, UUID_SIZE);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting tag device id");
+ err = cbor_encode_byte_string(&rootMap, payload->sid, UUID_SIZE);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting value of device id");
// Insert baseURI if present
- err = err | ConditionalAddTextStringToMap(&rootMap, OC_RSRVD_BASE_URI,
- sizeof(OC_RSRVD_BASE_URI) - 1,
- payload->baseURI);
+ err = ConditionalAddTextStringToMap(&rootMap, OC_RSRVD_BASE_URI,
+ sizeof(OC_RSRVD_BASE_URI) - 1,
+ payload->baseURI);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting baseURI");
// Insert Links into the root map.
- CborEncoder linkArray = {0};
- err = err | cbor_encode_text_string(&rootMap, OC_RSRVD_LINKS,
- sizeof(OC_RSRVD_LINKS) - 1);
- err = err | cbor_encoder_create_array(&rootMap, &linkArray, resourceCount);
+ CborEncoder linkArray;
+ err = cbor_encode_text_string(&rootMap, OC_RSRVD_LINKS, sizeof(OC_RSRVD_LINKS) - 1);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting links array tag");
+ err = cbor_encoder_create_array(&rootMap, &linkArray, resourceCount);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting links array");
for(size_t i = 0; i < resourceCount; ++i)
{
- CborEncoder resourceMapElement = {0};
- OCResourcePayload* resource = OCDiscoveryPayloadGetResource(payload, i);
- if(!resource)
- {
- OICFree(outPayload);
- return OC_STACK_INVALID_PARAM;
- }
+ CborEncoder linkMap;
+ OCResourcePayload *resource = OCDiscoveryPayloadGetResource(payload, i);
+ VERIFY_PARAM_NON_NULL(TAG, resource, "Failed retrieving resource");
// resource map inside the links array.
- err = err | cbor_encoder_create_map(&linkArray, &resourceMapElement,
- DISCOVERY_CBOR_LINKS_MAP_LEN);
+ err = cbor_encoder_create_map(&linkArray, &linkMap, LINKS_MAP_LEN);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating links map");
// Below are insertions of the resource properties into the map.
// Uri
- err = err | AddTextStringToMap(&resourceMapElement, OC_RSRVD_HREF,
- sizeof(OC_RSRVD_HREF) - 1,
- resource->uri);
+ err = AddTextStringToMap(&linkMap, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1,
+ resource->uri);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding uri to links map");
+
// Resource Type
if (resource->types)
{
- char* joinedTypes = OCStringLLJoin(resource->types);
- if (joinedTypes)
- {
- err = err | cbor_encode_text_string(&resourceMapElement, OC_RSRVD_RESOURCE_TYPE,
- sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
- err = err | cbor_encode_text_string(&resourceMapElement, joinedTypes,
- strlen(joinedTypes));
- OICFree(joinedTypes);
- }
- else
- {
- return OC_STACK_NO_MEMORY;
- }
+ err = cbor_encode_text_string(&linkMap, OC_RSRVD_RESOURCE_TYPE,
+ sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource types tag to links map");
+ char *joinedTypes = OCStringLLJoin(resource->types);
+ VERIFY_PARAM_NON_NULL(TAG, joinedTypes, "Failed creating joined string");
+ err = cbor_encode_text_string(&linkMap, joinedTypes, strlen(joinedTypes));
+ OICFree(joinedTypes);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource types value to links map");
}
// Interface Types
if (resource->interfaces)
{
+ err = cbor_encode_text_string(&linkMap, OC_RSRVD_INTERFACE,
+ sizeof(OC_RSRVD_INTERFACE) - 1);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding interfaces tag to links map");
char* joinedInterfaces = OCStringLLJoin(resource->interfaces);
- if (joinedInterfaces)
- {
- err = err | cbor_encode_text_string(&resourceMapElement, OC_RSRVD_INTERFACE,
- sizeof(OC_RSRVD_INTERFACE) - 1);
- err = err | cbor_encode_text_string(&resourceMapElement, joinedInterfaces,
- strlen(joinedInterfaces));
- OICFree(joinedInterfaces);
- }
- else
- {
- return OC_STACK_NO_MEMORY;
- }
+ VERIFY_PARAM_NON_NULL(TAG, joinedInterfaces, "Failed creating joined string");
+ err = cbor_encode_text_string(&linkMap, joinedInterfaces, strlen(joinedInterfaces));
+ OICFree(joinedInterfaces);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding interfaces value to links map");
}
// Policy
- CborEncoder policyMap = {0};
- err = err | cbor_encode_text_string(&resourceMapElement, OC_RSRVD_POLICY,
- sizeof(OC_RSRVD_POLICY) - 1);
- err = err | cbor_encoder_create_map(&resourceMapElement, &policyMap, CborIndefiniteLength);
+ CborEncoder policyMap;
+ err = cbor_encode_text_string(&linkMap, OC_RSRVD_POLICY, sizeof(OC_RSRVD_POLICY) - 1);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding policy tag to links map");
+ err = cbor_encoder_create_map(&linkMap, &policyMap, CborIndefiniteLength);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding policy map to links map");
// Bitmap
- err = err | cbor_encode_text_string(&policyMap, OC_RSRVD_BITMAP,
- sizeof(OC_RSRVD_BITMAP) - 1);
- err = err | cbor_encode_uint(&policyMap, resource->bitmap);
+ err = cbor_encode_text_string(&policyMap, OC_RSRVD_BITMAP, sizeof(OC_RSRVD_BITMAP) - 1);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding bitmap tag to policy map");
+ err = cbor_encode_uint(&policyMap, resource->bitmap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding bitmap value to policy map");
- if(resource->secure)
+ if (resource->secure)
{
- err = err | cbor_encode_text_string(&policyMap, OC_RSRVD_SECURE,
+ err = cbor_encode_text_string(&policyMap, OC_RSRVD_SECURE,
sizeof(OC_RSRVD_SECURE) - 1);
- err = err | cbor_encode_boolean(&policyMap, OC_RESOURCE_SECURE);
-
- if(resource->port != 0)
- {
- err = err | cbor_encode_text_string(&policyMap, OC_RSRVD_HOSTING_PORT,
- sizeof(OC_RSRVD_HOSTING_PORT) - 1);
- err = err | cbor_encode_uint(&policyMap, resource->port);
- }
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure tag to policy map");
+ err = cbor_encode_boolean(&policyMap, OC_RESOURCE_SECURE);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure value to policy map");
}
- if (payload->baseURI)
+ if ((resource->secure && resource->port != 0) || payload->baseURI)
{
- err = err | cbor_encode_text_string(&policyMap, OC_RSRVD_HOSTING_PORT,
- sizeof(OC_RSRVD_HOSTING_PORT) - 1);
- err = err | cbor_encode_uint(&policyMap, resource->port);
+ err = cbor_encode_text_string(&policyMap, OC_RSRVD_HOSTING_PORT,
+ sizeof(OC_RSRVD_HOSTING_PORT) - 1);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure port tag");
+ err = cbor_encode_uint(&policyMap, resource->port);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure port value");
}
- err = err | cbor_encoder_close_container(&resourceMapElement, &policyMap);
+ err = cbor_encoder_close_container(&linkMap, &policyMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing policy map");
// Finsihed encoding a resource, close the map.
- err = err | cbor_encoder_close_container(&linkArray, &resourceMapElement);
+ err = cbor_encoder_close_container(&linkArray, &linkMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing link map");
}
// Close links array inside the root map.
- err = err | cbor_encoder_close_container(&rootMap, &linkArray);
+ err = cbor_encoder_close_container(&rootMap, &linkArray);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing link array");
// close root map inside the root array.
- err = err | cbor_encoder_close_container(&rootArray, &rootMap);
+ err = cbor_encoder_close_container(&rootArray, &rootMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root map");
// Close the final root array.
- err = err | cbor_encoder_close_container(&encoder, &rootArray);
+ err = cbor_encoder_close_container(&encoder, &rootArray);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root array");
}
+exit:
return checkError(err, &encoder, outPayload, size);
}
-static int64_t OCConvertDevicePayload(OCDevicePayload* payload, uint8_t* outPayload,
- size_t* size)
+static CborError OCConvertDevicePayload(OCDevicePayload *payload, uint8_t *outPayload,
+ size_t *size)
{
- CborEncoder encoder = {0};
- int64_t err = 0;
+ CborError err = CborNoError;
+ CborEncoder encoder;
cbor_encoder_init(&encoder, outPayload, *size, 0);
CborEncoder repMap;
- err = err | cbor_encoder_create_map(&encoder, &repMap, CborIndefiniteLength);
+ err = cbor_encoder_create_map(&encoder, &repMap, CborIndefiniteLength);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating device map");
// Device ID
- err = err | cbor_encode_text_string(&repMap, OC_RSRVD_DEVICE_ID,
- sizeof(OC_RSRVD_DEVICE_ID) - 1);
- err = err | cbor_encode_byte_string(&repMap, payload->sid, UUID_SIZE);
+ err = cbor_encode_text_string(&repMap, OC_RSRVD_DEVICE_ID, sizeof(OC_RSRVD_DEVICE_ID) - 1);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding device id tag");
+ err = cbor_encode_byte_string(&repMap, payload->sid, UUID_SIZE);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding data device id");
// Device Name
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_DEVICE_NAME,
- sizeof(OC_RSRVD_DEVICE_NAME) - 1,
- payload->deviceName);
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_DEVICE_NAME,
+ sizeof(OC_RSRVD_DEVICE_NAME) - 1, payload->deviceName);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding device name");
// Device Spec Version
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SPEC_VERSION,
- sizeof(OC_RSRVD_SPEC_VERSION) - 1,
- payload->specVersion);
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SPEC_VERSION,
+ sizeof(OC_RSRVD_SPEC_VERSION) - 1, payload->specVersion);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding data spec version");
// Device data Model Version
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_DATA_MODEL_VERSION,
- sizeof(OC_RSRVD_DATA_MODEL_VERSION) - 1,
- payload->dataModelVersion);
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_DATA_MODEL_VERSION,
+ sizeof(OC_RSRVD_DATA_MODEL_VERSION) - 1, payload->dataModelVersion);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding data model version");
- err = err | cbor_encoder_close_container(&encoder, &repMap);
+ err = cbor_encoder_close_container(&encoder, &repMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing device map");
+exit:
return checkError(err, &encoder, outPayload, size);
}
-static int64_t OCConvertPlatformPayload(OCPlatformPayload* payload, uint8_t* outPayload,
- size_t* size)
+static CborError OCConvertPlatformPayload(OCPlatformPayload *payload, uint8_t *outPayload,
+ size_t *size)
{
- CborEncoder encoder = {0};
- int64_t err = 0;
+ CborError err = CborNoError;
+ CborEncoder encoder;
cbor_encoder_init(&encoder, outPayload, *size, 0);
- {
- CborEncoder repMap;
- err = err | cbor_encoder_create_map(&encoder, &repMap, CborIndefiniteLength);
-
- // Platform ID
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_ID,
- sizeof(OC_RSRVD_PLATFORM_ID) - 1,
- payload->info.platformID);
-
- // MFG Name
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_NAME,
- sizeof(OC_RSRVD_MFG_NAME) - 1,
- payload->info.manufacturerName);
-
- // MFG Url
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_URL,
- sizeof(OC_RSRVD_MFG_URL) - 1,
- payload->info.manufacturerUrl);
-
- // Model Num
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MODEL_NUM,
- sizeof(OC_RSRVD_MODEL_NUM) - 1,
- payload->info.modelNumber);
-
- // Date of Mfg
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_DATE,
- sizeof(OC_RSRVD_MFG_DATE) - 1,
- payload->info.dateOfManufacture);
-
- // Platform Version
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_VERSION,
- sizeof(OC_RSRVD_PLATFORM_VERSION) - 1,
- payload->info.platformVersion);
-
- // OS Version
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_OS_VERSION,
- sizeof(OC_RSRVD_OS_VERSION) - 1,
- payload->info.operatingSystemVersion);
-
- // Hardware Version
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_HARDWARE_VERSION,
- sizeof(OC_RSRVD_HARDWARE_VERSION) - 1,
- payload->info.hardwareVersion);
-
- // Firmware Version
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_FIRMWARE_VERSION,
- sizeof(OC_RSRVD_FIRMWARE_VERSION) - 1,
- payload->info.firmwareVersion);
-
- // Support URL
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SUPPORT_URL,
- sizeof(OC_RSRVD_SUPPORT_URL) - 1,
- payload->info.supportUrl);
-
- // System Time
- err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SYSTEM_TIME,
- sizeof(OC_RSRVD_SYSTEM_TIME) - 1,
- payload->info.systemTime);
-
- // Close Map
- err = err | cbor_encoder_close_container(&encoder, &repMap);
- }
+ CborEncoder repMap;
+ err = cbor_encoder_create_map(&encoder, &repMap, CborIndefiniteLength);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating platform map");
+
+ // Platform ID
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_ID,
+ sizeof(OC_RSRVD_PLATFORM_ID) - 1, payload->info.platformID);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform id");
+
+ // MFG Name
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_NAME, sizeof(OC_RSRVD_MFG_NAME) - 1,
+ payload->info.manufacturerName);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding mfg name");
+
+ // MFG Url
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_URL, sizeof(OC_RSRVD_MFG_URL) - 1,
+ payload->info.manufacturerUrl);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding mfg url");
+
+ // Model Num
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MODEL_NUM, sizeof(OC_RSRVD_MODEL_NUM) -1,
+ payload->info.modelNumber);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding model num");
+
+ // Date of Mfg
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_DATE, sizeof(OC_RSRVD_MFG_DATE) - 1,
+ payload->info.dateOfManufacture);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding mfg date");
+
+ // Platform Version
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_VERSION,
+ sizeof(OC_RSRVD_PLATFORM_VERSION) - 1, payload->info.platformVersion);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform version");
+
+ // OS Version
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_OS_VERSION,
+ sizeof(OC_RSRVD_OS_VERSION) - 1, payload->info.operatingSystemVersion);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding OS version");
+
+ // Hardware Version
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_HARDWARE_VERSION,
+ sizeof(OC_RSRVD_HARDWARE_VERSION) - 1, payload->info.hardwareVersion);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding HW version");
+
+ // Firmware Version
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_FIRMWARE_VERSION,
+ sizeof(OC_RSRVD_FIRMWARE_VERSION) - 1, payload->info.firmwareVersion);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding firmware version");
+
+ // Support URL
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SUPPORT_URL,
+ sizeof(OC_RSRVD_SUPPORT_URL) - 1, payload->info.supportUrl);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding support url");
+
+ // System Time
+ err = ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SYSTEM_TIME,
+ sizeof(OC_RSRVD_SYSTEM_TIME) - 1, payload->info.systemTime);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding system time");
+
+ // Close Map
+ err = cbor_encoder_close_container(&encoder, &repMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep map");
+
+exit:
return checkError(err, &encoder, outPayload, size);
}
-static int64_t OCConvertArrayItem(CborEncoder* array, const OCRepPayloadValueArray* valArray,
+static CborError OCConvertArrayItem(CborEncoder *array, const OCRepPayloadValueArray *valArray,
size_t index)
{
- int64_t err = 0;
+ CborError err = CborNoError;
switch (valArray->type)
{
case OCREP_PROP_NULL:
err = CborUnknownError;
break;
case OCREP_PROP_INT:
- err = err | cbor_encode_int(array, valArray->iArray[index]);
+ err = cbor_encode_int(array, valArray->iArray[index]);
break;
case OCREP_PROP_DOUBLE:
- err = err | cbor_encode_double(array, valArray->dArray[index]);
+ err = cbor_encode_double(array, valArray->dArray[index]);
break;
case OCREP_PROP_BOOL:
- err = err | cbor_encode_boolean(array, valArray->bArray[index]);
+ err = cbor_encode_boolean(array, valArray->bArray[index]);
break;
case OCREP_PROP_STRING:
if (!valArray->strArray[index])
{
- err = err | cbor_encode_null(array);
+ err = cbor_encode_null(array);
}
else
{
- err = err | cbor_encode_text_string(array, valArray->strArray[index],
+ err = cbor_encode_text_string(array, valArray->strArray[index],
strlen(valArray->strArray[index]));
}
break;
case OCREP_PROP_BYTE_STRING:
if (!valArray->strArray[index])
{
- err = err | cbor_encode_null(array);
+ err = cbor_encode_null(array);
}
else
{
- err = err | cbor_encode_byte_string(array, valArray->ocByteStrArray[index].bytes,
+ err = cbor_encode_byte_string(array, valArray->ocByteStrArray[index].bytes,
valArray->ocByteStrArray[index].len);
}
break;
case OCREP_PROP_OBJECT:
if (!valArray->objArray[index])
{
- err = err | cbor_encode_null(array);
+ err = cbor_encode_null(array);
}
else
{
return err;
}
-static int64_t OCConvertArray(CborEncoder* parent, const OCRepPayloadValueArray* valArray)
+
+static CborError OCConvertArray(CborEncoder *parent, const OCRepPayloadValueArray *valArray)
{
+ CborError err = CborNoError;
CborEncoder array;
- int64_t err = 0;
+ err = cbor_encoder_create_array(parent, &array, valArray->dimensions[0]);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array");
- err = err | cbor_encoder_create_array(parent, &array, valArray->dimensions[0]);
-
- for (size_t i = 0; i < valArray->dimensions[0];++i)
+ for (size_t i = 0; i < valArray->dimensions[0]; ++i)
{
- if (valArray->dimensions[1] != 0)
+ if (0 != valArray->dimensions[1])
{
CborEncoder array2;
- err = err | cbor_encoder_create_array(&array, &array2, valArray->dimensions[1]);
+ err = cbor_encoder_create_array(&array, &array2, valArray->dimensions[1]);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array2");
for (size_t j = 0; j < valArray->dimensions[1]; ++j)
{
- if (valArray->dimensions[2] != 0)
+ if (0 != valArray->dimensions[2])
{
CborEncoder array3;
- err = err | cbor_encoder_create_array(&array2, &array3,
- valArray->dimensions[2]);
+ err = cbor_encoder_create_array(&array2, &array3, valArray->dimensions[2]);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array3");
for(size_t k = 0; k < valArray->dimensions[2]; ++k)
{
- OCConvertArrayItem(&array3, valArray,
+ err = OCConvertArrayItem(&array3, valArray,
j * valArray->dimensions[2] +
i * valArray->dimensions[2] * valArray->dimensions[1] +
k);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array3 value");
}
- err = err | cbor_encoder_close_container(&array2, &array3);
+ err = cbor_encoder_close_container(&array2, &array3);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array3");
}
else
{
- OCConvertArrayItem(&array2, valArray,
- i * valArray->dimensions[1] + j);
+ err = OCConvertArrayItem(&array2, valArray, i * valArray->dimensions[1] + j);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array2 value");
}
}
- err = err | cbor_encoder_close_container(&array, &array2);
+ err = cbor_encoder_close_container(&array, &array2);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array2");
}
else
{
- OCConvertArrayItem(&array, valArray, i);
+ err = OCConvertArrayItem(&array, valArray, i);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array value");
}
}
- err = err | cbor_encoder_close_container(parent, &array);
+ err = cbor_encoder_close_container(parent, &array);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array");
+
+exit:
return err;
}
-static int64_t OCConvertRepMap(CborEncoder *map, const OCRepPayload* payload)
+static CborError OCConvertRepMap(CborEncoder *map, const OCRepPayload *payload)
{
- int64_t err = 0;
+ CborError err = CborNoError;
CborEncoder repMap;
- err = err | cbor_encoder_create_map(map, &repMap, CborIndefiniteLength);
- err = err | OCConvertSingleRepPayload(&repMap, payload);
- err = err | cbor_encoder_close_container(map, &repMap);
+ err = cbor_encoder_create_map(map, &repMap, CborIndefiniteLength);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep map");
+ err = OCConvertSingleRepPayload(&repMap, payload);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed converting single rep payload");
+ err = cbor_encoder_close_container(map, &repMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep map");
+exit:
return err;
}
-static int64_t OCConvertSingleRepPayload(CborEncoder* repMap, const OCRepPayload* payload)
+static CborError OCConvertSingleRepPayload(CborEncoder *repMap, const OCRepPayload *payload)
{
- int64_t err = 0;
- OCRepPayloadValue* value = payload->values;
- while(value)
+ CborError err = CborNoError;
+ OCRepPayloadValue *value = payload->values;
+ while (value)
{
- err = err | cbor_encode_text_string(repMap,
- value->name,
- strlen(value->name));
- switch(value->type)
+ err = cbor_encode_text_string(repMap, value->name, strlen(value->name));
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tag name");
+
+ switch (value->type)
{
case OCREP_PROP_NULL:
- err = err | cbor_encode_null(repMap);
+ err = cbor_encode_null(repMap);
break;
case OCREP_PROP_INT:
- err = err | cbor_encode_int(repMap,
- value->i);
+ err = cbor_encode_int(repMap, value->i);
break;
case OCREP_PROP_DOUBLE:
- err = err | cbor_encode_double(repMap,
- value->d);
+ err = cbor_encode_double(repMap, value->d);
break;
case OCREP_PROP_BOOL:
- err = err | cbor_encode_boolean(repMap,
- value->b);
+ err = cbor_encode_boolean(repMap, value->b);
break;
case OCREP_PROP_STRING:
- err = err | cbor_encode_text_string(repMap,
- value->str, strlen(value->str));
+ err = cbor_encode_text_string(repMap, value->str, strlen(value->str));
break;
case OCREP_PROP_BYTE_STRING:
- err = err | cbor_encode_byte_string(repMap,
- value->ocByteStr.bytes, value->ocByteStr.len);
+ err = cbor_encode_byte_string(repMap, value->ocByteStr.bytes, value->ocByteStr.len);
break;
case OCREP_PROP_OBJECT:
- err = err | OCConvertRepMap(repMap, value->obj);
+ err = OCConvertRepMap(repMap, value->obj);
break;
case OCREP_PROP_ARRAY:
- err = err | OCConvertArray(repMap, &value->arr);
+ err = OCConvertArray(repMap, &value->arr);
break;
default:
- OIC_LOG_V(ERROR, TAG, "Invalid Prop type: %d",
- value->type);
+ OIC_LOG_V(ERROR, TAG, "Invalid Prop type: %d", value->type);
break;
}
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding single rep value");
value = value->next;
}
+exit:
return err;
}
-static int64_t OCConvertRepPayload(OCRepPayload* payload, uint8_t* outPayload, size_t* size)
+static CborError OCConvertRepPayload(OCRepPayload *payload, uint8_t *outPayload, size_t *size)
{
- CborEncoder encoder = {0};
- int64_t err = 0;
+ CborEncoder encoder;
+ CborError err = CborNoError;
cbor_encoder_init(&encoder, outPayload, *size, 0);
- CborEncoder rootMap ;
size_t arrayCount = 0;
for (OCRepPayload *temp = payload; temp; temp = temp->next)
CborEncoder rootArray;
if (arrayCount > 1)
{
- err = err | cbor_encoder_create_array(&encoder, &rootArray, arrayCount);
+ err = cbor_encoder_create_array(&encoder, &rootArray, arrayCount);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep root map");
}
while (payload != NULL && (err == CborNoError))
{
- err = err | cbor_encoder_create_map(((arrayCount == 1)? &encoder: &rootArray),
+ CborEncoder rootMap;
+ err = cbor_encoder_create_map(((arrayCount == 1)? &encoder: &rootArray),
&rootMap, CborIndefiniteLength);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating root map");
+
// Only in case of collection href is included.
if (arrayCount > 1 && payload->uri && strlen(payload->uri) > 0)
{
OIC_LOG(INFO, TAG, "Payload has uri");
- err = err | cbor_encode_text_string(&rootMap, OC_RSRVD_HREF,
- strlen(OC_RSRVD_HREF));
- err = err | cbor_encode_text_string(&rootMap, payload->uri,
- strlen(payload->uri));
+ err = cbor_encode_text_string(&rootMap, OC_RSRVD_HREF, strlen(OC_RSRVD_HREF));
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep href tag");
+ err = cbor_encode_text_string(&rootMap, payload->uri, strlen(payload->uri));
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep href value");
}
if (payload->types)
{
OIC_LOG(INFO, TAG, "Payload has types");
+ err = cbor_encode_text_string(&rootMap, OC_RSRVD_RESOURCE_TYPE,
+ sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep resource type tag");
char* joinedTypes = OCStringLLJoin(payload->types);
- if (joinedTypes)
- {
- err = err | cbor_encode_text_string(&rootMap, OC_RSRVD_RESOURCE_TYPE,
- strlen(OC_RSRVD_RESOURCE_TYPE));
- err = err | cbor_encode_text_string(&rootMap, joinedTypes,
- strlen(joinedTypes));
- OICFree(joinedTypes);
- }
- else
- {
- return OC_STACK_NO_MEMORY;
- }
+ VERIFY_PARAM_NON_NULL(TAG, joinedTypes, "Failed creating joined string");
+ err = cbor_encode_text_string(&rootMap, joinedTypes, strlen(joinedTypes));
+ OICFree(joinedTypes);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep resource type value");
}
if (payload->interfaces)
{
OIC_LOG(INFO, TAG, "Payload has interfaces");
+ err = cbor_encode_text_string(&rootMap, OC_RSRVD_INTERFACE,
+ sizeof(OC_RSRVD_INTERFACE) - 1);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep interface tag");
char* joinedInterfaces = OCStringLLJoin(payload->interfaces);
- if (joinedInterfaces)
- {
- err = err | cbor_encode_text_string(&rootMap, OC_RSRVD_INTERFACE,
- strlen(OC_RSRVD_INTERFACE));
- err = err | cbor_encode_text_string(&rootMap, joinedInterfaces,
- strlen(joinedInterfaces));
- OICFree(joinedInterfaces);
- }
- else
- {
- return OC_STACK_NO_MEMORY;
- }
+ VERIFY_PARAM_NON_NULL(TAG, joinedInterfaces, "Failed creating joined string");
+ err = cbor_encode_text_string(&rootMap, joinedInterfaces, strlen(joinedInterfaces));
+ OICFree(joinedInterfaces);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep interface value");
}
- err = err | OCConvertSingleRepPayload(&rootMap, payload);
- err = err | cbor_encoder_close_container(((arrayCount == 1) ? &encoder: &rootArray),
- &rootMap);
+ err = OCConvertSingleRepPayload(&rootMap, payload);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting rep payload");
+
+ // Close main array
+ err = cbor_encoder_close_container(((arrayCount == 1) ? &encoder: &rootArray), &rootMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root map");
payload = payload->next;
}
if (arrayCount > 1)
{
- err = err | cbor_encoder_close_container(&encoder, &rootArray);
+ err = cbor_encoder_close_container(&encoder, &rootArray);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root array");
}
+exit:
return checkError(err, &encoder, outPayload, size);
}
-static int64_t OCConvertPresencePayload(OCPresencePayload* payload,
- uint8_t* outPayload, size_t* size)
+static CborError OCConvertPresencePayload(OCPresencePayload *payload, uint8_t *outPayload,
+ size_t *size)
{
- CborEncoder encoder = {0};
- int64_t err = 0;
+ CborError err = CborNoError;
+ CborEncoder encoder;
cbor_encoder_init(&encoder, outPayload, *size, 0);
CborEncoder map;
- err = err | cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
+ err = cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating presence map");
// Sequence Number
- err = err | cbor_encode_text_string(&map,
- OC_RSRVD_NONCE,
- sizeof(OC_RSRVD_NONCE) - 1);
- err = err | cbor_encode_uint(&map, payload->sequenceNumber);
+ err = cbor_encode_text_string(&map, OC_RSRVD_NONCE, sizeof(OC_RSRVD_NONCE) - 1);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding nonce tag to presence map");
+ err = cbor_encode_uint(&map, payload->sequenceNumber);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding nonce value to presence map");
// Max Age
- err = err | cbor_encode_text_string(&map,
- OC_RSRVD_TTL,
- sizeof(OC_RSRVD_TTL) - 1);
- err = err | cbor_encode_uint(&map, payload->maxAge);
+ err = cbor_encode_text_string(&map, OC_RSRVD_TTL, sizeof(OC_RSRVD_TTL) - 1);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding ttl tag to presence map");
+ err = cbor_encode_uint(&map, payload->maxAge);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding ttl value to presence map");
// Trigger
- const char* triggerStr = convertTriggerEnumToString(payload->trigger);
- err = err | AddTextStringToMap(&map, OC_RSRVD_TRIGGER, sizeof(OC_RSRVD_TRIGGER) - 1,
- triggerStr);
+ err = cbor_encode_text_string(&map, OC_RSRVD_TRIGGER, sizeof(OC_RSRVD_TRIGGER) - 1);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding trigger tag to presence map");
+ err = cbor_encode_simple_value(&map, payload->trigger);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding trigger value to presence map");
// Resource type name
- if(payload->trigger != OC_PRESENCE_TRIGGER_DELETE)
+ if (payload->trigger != OC_PRESENCE_TRIGGER_DELETE)
{
- err = err | ConditionalAddTextStringToMap(&map, OC_RSRVD_RESOURCE_TYPE,
+ err = ConditionalAddTextStringToMap(&map, OC_RSRVD_RESOURCE_TYPE,
sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, payload->resourceType);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type to presence map");
}
// Close Map
- err = err | cbor_encoder_close_container(&encoder, &map);
+ err = cbor_encoder_close_container(&encoder, &map);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing presence map");
+exit:
return checkError(err, &encoder, outPayload, size);
}
-static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
+static CborError AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
const char* value)
{
- return cbor_encode_text_string(map, key, keylen) |
- cbor_encode_text_string(map, value, strlen(value));
+ CborError err = cbor_encode_text_string(map, key, keylen);
+ if (CborNoError != err)
+ {
+ return err;
+ }
+ return cbor_encode_text_string(map, value, strlen(value));
}
-static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
+static CborError ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
const char* value)
{
- return value ? AddTextStringToMap(map, key, keylen, value) : 0;
+ return value ? AddTextStringToMap(map, key, keylen, value) : CborNoError;
}
// Required for strok_r
#define _POSIX_C_SOURCE 200112L
#include <string.h>
-#include "ocpayloadcbor.h"
#include <stdlib.h>
-#include "logger.h"
#include "oic_string.h"
#include "oic_malloc.h"
-#include "ocstackinternal.h"
#include "ocpayload.h"
-#include "cbor.h"
-#include "oic_string.h"
+#include "ocpayloadcbor.h"
+#include "ocstackinternal.h"
#include "payload_logging.h"
#include "rdpayload.h"
#define TAG "OIC_RI_PAYLOADPARSE"
-static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* arrayVal);
-static OCStackResult OCParseDevicePayload(OCPayload** outPayload, CborValue* arrayVal);
-static OCStackResult OCParsePlatformPayload(OCPayload** outPayload, CborValue* arrayVal);
-static bool OCParseSingleRepPayload(OCRepPayload** outPayload, CborValue* repParent);
-static OCStackResult OCParseRepPayload(OCPayload** outPayload, CborValue* arrayVal);
-static OCStackResult OCParsePresencePayload(OCPayload** outPayload, CborValue* arrayVal);
-static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* arrayVal);
+static OCStackResult OCParseDiscoveryPayload(OCPayload **outPayload, CborValue *arrayVal);
+static OCStackResult OCParseDevicePayload(OCPayload **outPayload, CborValue *arrayVal);
+static OCStackResult OCParsePlatformPayload(OCPayload **outPayload, CborValue *arrayVal);
+static CborError OCParseSingleRepPayload(OCRepPayload **outPayload, CborValue *repParent);
+static OCStackResult OCParseRepPayload(OCPayload **outPayload, CborValue *arrayVal);
+static OCStackResult OCParsePresencePayload(OCPayload **outPayload, CborValue *arrayVal);
+static OCStackResult OCParseSecurityPayload(OCPayload **outPayload, CborValue * rrayVal);
-OCStackResult OCParsePayload(OCPayload** outPayload, OCPayloadType payloadType,
- const uint8_t* payload, size_t payloadSize)
+OCStackResult OCParsePayload(OCPayload **outPayload, OCPayloadType payloadType,
+ const uint8_t *payload, size_t payloadSize)
{
+ OCStackResult result = OC_STACK_MALFORMED_RESPONSE;
+ CborError err;
+
+ VERIFY_PARAM_NON_NULL(TAG, outPayload, "Conversion of outPayload failed");
+ VERIFY_PARAM_NON_NULL(TAG, payload, "Invalid cbor payload value");
+
+ OIC_LOG_V(INFO, TAG, "CBOR Parsing size: %zu", payloadSize);
+
CborParser parser;
CborValue rootValue;
- bool err = false;
- OIC_LOG_V(INFO, TAG, "CBOR Parsing size: %zu", payloadSize);
- if((err = cbor_parser_init(payload, payloadSize, 0, &parser, &rootValue)) != false)
- {
- OIC_LOG_V(ERROR, TAG, "CBOR Parser init failed: %d", err);
- return OC_STACK_ERROR;
- }
+ err = cbor_parser_init(payload, payloadSize, 0, &parser, &rootValue);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed initializing init value")
- OCStackResult result = OC_STACK_ERROR;
switch(payloadType)
{
case PAYLOAD_TYPE_DISCOVERY:
break;
default:
OIC_LOG_V(ERROR, TAG, "ParsePayload Type default: %d", payloadType);
- result = OC_STACK_ERROR;
+ result = OC_STACK_INVALID_PARAM;
break;
}
- if(result != OC_STACK_OK)
- {
- OIC_LOG_V(INFO, TAG, "Finished parse payload, result is %d", result);
- }
+ OIC_LOG_V(INFO, TAG, "Finished parse payload, result is %d", result);
+exit:
return result;
}
static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* rootValue)
{
- if (!outPayload)
- {
- return OC_STACK_INVALID_PARAM;
- }
+ OCStackResult ret = OC_STACK_MALFORMED_RESPONSE;
+ CborError err;
+ char *securityData = NULL;
- bool err = false;
- char * securityData = NULL;
- CborValue strVal = {0};
- size_t len = 0;
+ VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid parameter");
+ VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid cbor");
+
+ CborValue strVal;
err = cbor_value_enter_container(rootValue, &strVal);
- if(CborNoError == err && cbor_value_is_text_string(&strVal))
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed entering container");
+ if (cbor_value_is_text_string(&strVal))
{
+ size_t len = 0;
err = cbor_value_dup_text_string(&strVal, &securityData, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed reading security data");
+ *outPayload = (OCPayload *)OCSecurityPayloadCreate(securityData);
+ VERIFY_PARAM_NON_NULL(TAG, *outPayload, "Invalid cbor");
+ ret = OC_STACK_OK;
}
- if(err)
- {
- OIC_LOG(ERROR, TAG, "Cbor in error condition");
- OICFree(securityData);
- return OC_STACK_MALFORMED_RESPONSE;
- }
-
- *outPayload = (OCPayload*)OCSecurityPayloadCreate(securityData);
+exit:
OICFree(securityData);
-
- return OC_STACK_OK;
+ return ret;
}
return str;
}
-static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* rootValue)
+static CborError OCParseStringLL(CborValue *map, char *type, OCStringLL **resource)
{
- if (!outPayload)
+ CborValue val;
+ CborError err = cbor_value_map_find_value(map, type, &val);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find StringLL TAG");
+
+ if (cbor_value_is_text_string(&val))
{
- return OC_STACK_INVALID_PARAM;
- }
+ char *input = NULL;
+ char *savePtr = NULL;
+ size_t len = 0;
- bool err = false;
- OCResourcePayload* resource = NULL;
- uint16_t resourceCount = 0;
- CborValue resourceMap = { 0 };
+ err = cbor_value_dup_text_string(&val, &input, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find StringLL value");
- OCDiscoveryPayload* out = OCDiscoveryPayloadCreate();
- if(!out)
- {
- return OC_STACK_NO_MEMORY;
+ if (input)
+ {
+ char *curPtr = strtok_r(input, " ", &savePtr);
+ while (curPtr)
+ {
+ char *trimmed = InPlaceStringTrim(curPtr);
+ if (trimmed[0] !='\0')
+ {
+ if (!OCResourcePayloadAddStringLL(resource, trimmed))
+ {
+ return CborErrorOutOfMemory;
+ }
+ }
+ curPtr = strtok_r(NULL, " ", &savePtr);
+ }
+ OICFree(input);
+ }
}
+exit:
+ return err;
+}
+
+static OCStackResult OCParseDiscoveryPayload(OCPayload **outPayload, CborValue *rootValue)
+{
+ OCStackResult ret = OC_STACK_INVALID_PARAM;
+ OCResourcePayload *resource = NULL;
+ OCDiscoveryPayload *out = NULL;
+ size_t len = 0;
+ CborError err = CborNoError;
+ *outPayload = NULL;
+
+ VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
+ VERIFY_PARAM_NON_NULL(TAG, rootValue, "Invalid Parameter rootValue");
// Root value is already inside the main root array
- CborValue rootMap = { 0 };
+ CborValue rootMap;
+ ret = OC_STACK_NO_MEMORY;
+ out = OCDiscoveryPayloadCreate();
+ VERIFY_PARAM_NON_NULL(TAG, out, "Failed error initializing discovery payload");
// Enter the main root map
- err = err || cbor_value_enter_container(rootValue, &rootMap);
+ ret = OC_STACK_MALFORMED_RESPONSE;
+ err = cbor_value_enter_container(rootValue, &rootMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to enter root map container");
+
// Look for DI
- CborValue curVal = { 0 };
+ CborValue curVal;
err = cbor_value_map_find_value(&rootMap, OC_RSRVD_DEVICE_ID, &curVal);
- if (CborNoError != err)
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find device id tag");
{
- OIC_LOG(ERROR, TAG, "Cbor find value failed.");
- goto malformed_cbor;
+ err = cbor_value_dup_byte_string(&curVal, &(out->sid), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to copy device id value");
}
- size_t len;
- err = cbor_value_dup_byte_string(&curVal, &(out->sid), &len, NULL);
// BaseURI - Not a mandatory field
err = cbor_value_map_find_value(&rootMap, OC_RSRVD_BASE_URI, &curVal);
- if (CborNoError == err && cbor_value_is_valid(&curVal))
+ if (cbor_value_is_valid(&curVal))
{
err = cbor_value_dup_text_string(&curVal, &(out->baseURI), &len, NULL);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "baseURI failed.");
- goto malformed_cbor;
- }
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find base uri value");
}
// Look for Links which will have an array as the value
- err = cbor_value_map_find_value(&rootMap, OC_RSRVD_LINKS, &curVal);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor find value failed.");
- goto malformed_cbor;
- }
+ CborValue linkMap;
+ err = cbor_value_map_find_value(&rootMap, OC_RSRVD_LINKS, &linkMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find links tag");
// Enter the links array and start iterating through the array processing
// each resource which shows up as a map.
- err = err || cbor_value_enter_container(&curVal, &resourceMap);
+ CborValue resourceMap;
+ err = cbor_value_enter_container(&linkMap, &resourceMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to enter link map");
while (cbor_value_is_map(&resourceMap))
{
- resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
- if(!resource)
- {
- OIC_LOG(ERROR, TAG, "Memory allocation failed");
- OCDiscoveryPayloadDestroy(out);
- return OC_STACK_NO_MEMORY;
- }
+ resource = (OCResourcePayload *)OICCalloc(1, sizeof(OCResourcePayload));
+ VERIFY_PARAM_NON_NULL(TAG, resource, "Failed allocating resource payload");
// Uri
- CborValue uriVal = { 0 };
- err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_HREF, &uriVal);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding href type failed.");
- goto malformed_cbor;
- }
- err = cbor_value_dup_text_string(&uriVal, &(resource->uri), &len, NULL);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding href value failed.");
- goto malformed_cbor;
- }
- // ResourceTypes
- CborValue rtVal = { 0 };
- err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_RESOURCE_TYPE, &rtVal);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding rt type failed.");
- goto malformed_cbor;
- }
- if (cbor_value_is_text_string(&rtVal))
- {
- char* input = NULL;
- char* savePtr;
- err = cbor_value_dup_text_string(&rtVal, &input, &len, NULL);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding rt value failed.");
- goto malformed_cbor;
- }
- if (input)
- {
- char* curPtr = strtok_r(input, " ", &savePtr);
+ err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_HREF, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find href tag");
+ err = cbor_value_dup_text_string(&curVal, &(resource->uri), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find href value");
- while (curPtr)
- {
- char* trimmed = InPlaceStringTrim(curPtr);
- if (trimmed[0] !='\0')
- {
- if (!OCResourcePayloadAddResourceType(resource, trimmed))
- {
- OICFree(resource->uri);
- OCFreeOCStringLL(resource->types);
- OICFree(resource);
- OCDiscoveryPayloadDestroy(out);
- return OC_STACK_NO_MEMORY;
- }
- }
- curPtr = strtok_r(NULL, " ", &savePtr);
- }
- OICFree(input);
- }
- }
+ // ResourceTypes
+ err = OCParseStringLL(&resourceMap, OC_RSRVD_RESOURCE_TYPE, &resource->types);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find resource type tag/value");
// Interface Types
- CborValue ifVal = { 0 };
- err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_INTERFACE, &ifVal);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding if type failed.");
- goto malformed_cbor;
- }
- if (!err && cbor_value_is_text_string(&ifVal))
- {
- char* input = NULL;
- char* savePtr;
- err = cbor_value_dup_text_string(&ifVal, &input, &len, NULL);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding if value failed.");
- goto malformed_cbor;
- }
- if (input)
- {
- char* curPtr = strtok_r(input, " ", &savePtr);
-
- while (curPtr)
- {
- char* trimmed = InPlaceStringTrim(curPtr);
- if (trimmed[0] !='\0')
- {
- if (!OCResourcePayloadAddInterface(resource, trimmed))
- {
- OICFree(resource->uri);
- OCFreeOCStringLL(resource->types);
- OICFree(resource);
- OCDiscoveryPayloadDestroy(out);
- return OC_STACK_NO_MEMORY;
- }
- }
- curPtr = strtok_r(NULL, " ", &savePtr);
- }
- OICFree(input);
- }
- }
+ err = OCParseStringLL(&resourceMap, OC_RSRVD_INTERFACE, &resource->interfaces);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find interface tag/value");
// Policy
- CborValue policyMap = { 0 };
+ CborValue policyMap;
err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_POLICY, &policyMap);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding policy type failed.");
- goto malformed_cbor;
- }
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find policy tag");
+
// Bitmap
- CborValue val = { 0 };
- err = cbor_value_map_find_value(&policyMap, OC_RSRVD_BITMAP, &val);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding bitmap type failed.");
- goto malformed_cbor;
- }
- uint64_t temp = 0;
- err = cbor_value_get_uint64(&val, &temp);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding bitmap value failed.");
- goto malformed_cbor;
- }
- resource->bitmap = (uint8_t)temp;
+ err = cbor_value_map_find_value(&policyMap, OC_RSRVD_BITMAP, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find bitmap tag");
+ err = cbor_value_get_int(&curVal, (int *)&resource->bitmap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find bitmap value");
+
// Secure Flag
- err = cbor_value_map_find_value(&policyMap, OC_RSRVD_SECURE, &val);
- if (CborNoError != err)
+ err = cbor_value_map_find_value(&policyMap, OC_RSRVD_SECURE, &curVal);
+ if (cbor_value_is_valid(&curVal))
{
- OIC_LOG(ERROR, TAG, "Cbor finding secure type failed.");
- goto malformed_cbor;
+ err = cbor_value_get_boolean(&curVal, &(resource->secure));
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find secure value");
}
- if(cbor_value_is_valid(&val))
- {
- err = cbor_value_get_boolean(&val, &(resource->secure));
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding secure value failed.");
- goto malformed_cbor;
- }
- // Port
- CborValue port = { 0 };
- err = cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT,
- &port);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding port type failed.");
- goto malformed_cbor;
- }
- if (cbor_value_is_valid(&port))
- {
- err = cbor_value_get_uint64(&port, &temp);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding port value failed.");
- goto malformed_cbor;
- }
- resource->port = (uint16_t)temp;
- }
- }
- else if (out->baseURI)
+
+ // Port
+ err = cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT, &curVal);
+ if (cbor_value_is_valid(&curVal))
{
- // Port
- CborValue port = { 0 };
- err = cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT, &port);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding port type failed.");
- goto malformed_cbor;
- }
- if(cbor_value_is_valid(&port))
- {
- err = cbor_value_get_uint64(&port, &temp);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor finding port value failed.");
- goto malformed_cbor;
- }
- resource->port = (uint16_t)temp;
- }
+ err = cbor_value_get_int(&curVal, (int *)&resource->port);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find port value");
}
err = cbor_value_advance(&resourceMap);
- if (CborNoError != err)
- {
- OIC_LOG(ERROR, TAG, "Cbor advance value failed.");
- goto malformed_cbor;
- }
- ++resourceCount;
+ VERIFY_CBOR_SUCCESS(TAG, err, "to advance resource map");
+
OCDiscoveryPayloadAddNewResource(out, resource);
}
- err = err || cbor_value_leave_container(rootValue, &resourceMap);
+ err = cbor_value_leave_container(rootValue, &resourceMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to advance resource map");
- *outPayload = (OCPayload*)out;
+ *outPayload = (OCPayload *)out;
return OC_STACK_OK;
-malformed_cbor:
- OICFree(resource->uri);
- OCFreeOCStringLL(resource->types);
- OCFreeOCStringLL(resource->interfaces);
- OICFree(resource);
+exit:
+ OCDiscoveryResourceDestroy(resource);
OCDiscoveryPayloadDestroy(out);
- return OC_STACK_MALFORMED_RESPONSE;
+ return ret;
}
-static OCStackResult OCParseDevicePayload(OCPayload** outPayload, CborValue* rootValue)
+static OCStackResult OCParseDevicePayload(OCPayload **outPayload, CborValue *rootValue)
{
- if (!outPayload)
- {
- return OC_STACK_INVALID_PARAM;
- }
+ OCStackResult ret = OC_STACK_INVALID_PARAM;
+ CborError err = CborNoError;
+ OCDevicePayload *out = NULL;
+ VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid param outPayload");
+ VERIFY_PARAM_NON_NULL(TAG, rootValue, "Invalid param rootValue");
- bool err = false;
+ *outPayload = NULL;
- if(cbor_value_is_map(rootValue))
- {
- uint8_t* sid = NULL;
- char* dname = NULL;
- char* specVer = NULL;
- char* dmVer = NULL;
+ out = (OCDevicePayload *)OICCalloc(1, sizeof(OCDevicePayload));
+ VERIFY_PARAM_NON_NULL(TAG, out, "Failed allocating device payload")
+ out->base.type = PAYLOAD_TYPE_DEVICE;
+ ret = OC_STACK_MALFORMED_RESPONSE;
- CborValue repVal;
+ if (cbor_value_is_map(rootValue))
+ {
// Device ID
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_ID, &repVal);
- size_t len;
- if(cbor_value_is_valid(&repVal))
+ size_t len = 0;
+ CborValue curVal;
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_ID, &curVal);
+ if (cbor_value_is_valid(&curVal))
{
- err = err || cbor_value_dup_byte_string(&repVal, &sid, &len, NULL);
+ err = cbor_value_dup_byte_string(&curVal, &out->sid, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find device id in device payload");
}
// Device Name
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_NAME, &repVal);
- if(cbor_value_is_valid(&repVal))
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_NAME, &curVal);
+ if (cbor_value_is_valid(&curVal))
{
- err = err || cbor_value_dup_text_string(&repVal, &dname, &len, NULL);
+ err = cbor_value_dup_text_string(&curVal, &out->deviceName, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find device name in device payload");
}
// Device Spec Version
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_SPEC_VERSION, &repVal);
- if(cbor_value_is_valid(&repVal))
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_SPEC_VERSION, &curVal);
+ if (cbor_value_is_valid(&curVal))
{
- err = err || cbor_value_dup_text_string(&repVal, &specVer, &len, NULL);
+ err = cbor_value_dup_text_string(&curVal, &out->specVersion, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find spec version in device payload");
}
-
// Data Model Version
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_DATA_MODEL_VERSION, &repVal);
- if (cbor_value_is_valid(&repVal))
- {
- err = err || cbor_value_dup_text_string(&repVal, &dmVer, &len, NULL);
- }
-
- err = err || cbor_value_advance(rootValue);
-
- if(err)
- {
- OICFree(sid);
- OICFree(dname);
- OICFree(specVer);
- OICFree(dmVer);
- OIC_LOG_V(ERROR, TAG, "CBOR in error condition %d", err);
- return OC_STACK_MALFORMED_RESPONSE;
- }
-
- *outPayload = (OCPayload*)OCDevicePayloadCreate(sid, dname, specVer, dmVer);
-
- OICFree(sid);
- OICFree(dname);
- OICFree(specVer);
- OICFree(dmVer);
- if(!*outPayload)
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_DATA_MODEL_VERSION, &curVal);
+ if (cbor_value_is_valid(&curVal))
{
- return OC_STACK_NO_MEMORY;
+ err = cbor_value_dup_text_string(&curVal, &out->dataModelVersion, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find data model version in device payload");
}
+ err = cbor_value_advance(rootValue);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to advance device payload");
+ *outPayload = (OCPayload *)out;
return OC_STACK_OK;
}
- else
- {
- OIC_LOG(ERROR, TAG, "Root device node was not a map");
- return OC_STACK_MALFORMED_RESPONSE;
- }
+exit:
+ OCDevicePayloadDestroy(out);
+ return ret;
}
-static OCStackResult OCParsePlatformPayload(OCPayload** outPayload, CborValue* rootValue)
+static OCStackResult OCParsePlatformPayload(OCPayload **outPayload, CborValue *rootValue)
{
- if (!outPayload)
- {
- return OC_STACK_INVALID_PARAM;
- }
+ OCStackResult ret = OC_STACK_INVALID_PARAM;
+ CborError err = CborNoError;
+ OCPlatformInfo info = {0};
- bool err = false;
+ VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
- if(cbor_value_is_map(rootValue))
+ if (cbor_value_is_map(rootValue))
{
- OCPlatformInfo info = {0};
-
CborValue repVal;
- size_t len;
- // Platform ID
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_ID, &repVal);
- if(cbor_value_is_valid(&repVal))
- {
- err = err || cbor_value_dup_text_string(&repVal, &(info.platformID), &len, NULL);
- }
+ size_t len = 0;
+ ret = OC_STACK_MALFORMED_RESPONSE;
+ // Platform ID
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_ID, &repVal);
+ if (cbor_value_is_valid(&repVal))
+ {
+ err = cbor_value_dup_text_string(&repVal, &(info.platformID), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find platformID in the platform payload");
+ }
// MFG Name
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_NAME, &repVal);
- if(cbor_value_is_valid(&repVal))
- {
- err = err || cbor_value_dup_text_string(&repVal, &(info.manufacturerName), &len, NULL);
- }
-
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_NAME, &repVal);
+ if (cbor_value_is_valid(&repVal))
+ {
+ err = cbor_value_dup_text_string(&repVal, &(info.manufacturerName), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find manufactureName in the platform payload");
+ }
// MFG URL
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_URL, &repVal);
- if(cbor_value_is_valid(&repVal))
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_URL, &repVal);
+ if (cbor_value_is_valid(&repVal))
{
- err = err || cbor_value_dup_text_string(&repVal, &(info.manufacturerUrl), &len, NULL);
+ err = cbor_value_dup_text_string(&repVal, &(info.manufacturerUrl), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find manufactureUrl in the platform payload");
}
-
// Model Num
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MODEL_NUM, &repVal);
- if(cbor_value_is_valid(&repVal))
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_MODEL_NUM, &repVal);
+ if (cbor_value_is_valid(&repVal))
{
- err = err || cbor_value_dup_text_string(&repVal, &(info.modelNumber), &len, NULL);
+ err = cbor_value_dup_text_string(&repVal, &(info.modelNumber), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find modelNumber in the platform payload");
}
-
// Date of Mfg
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_DATE, &repVal);
- if(cbor_value_is_valid(&repVal))
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_DATE, &repVal);
+ if (cbor_value_is_valid(&repVal))
{
- err = err || cbor_value_dup_text_string(&repVal, &(info.dateOfManufacture), &len,
- NULL);
+ err = cbor_value_dup_text_string(&repVal, &(info.dateOfManufacture), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find dateOfManufacture in the platform payload");
}
-
// Platform Version
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_VERSION, &repVal);
- if(cbor_value_is_valid(&repVal))
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_VERSION, &repVal);
+ if (cbor_value_is_valid(&repVal))
{
- err = err || cbor_value_dup_text_string(&repVal, &(info.platformVersion), &len, NULL);
+ err = cbor_value_dup_text_string(&repVal, &(info.platformVersion), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find platformVersion in the platform payload");
}
-
// OS Version
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_OS_VERSION, &repVal);
- if(cbor_value_is_valid(&repVal))
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_OS_VERSION, &repVal);
+ if (cbor_value_is_valid(&repVal))
{
- err = err || cbor_value_dup_text_string(&repVal, &(info.operatingSystemVersion),
- &len, NULL);
+ err = cbor_value_dup_text_string(&repVal, &(info.operatingSystemVersion), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find OSVersion in the platform payload");
}
-
// Hardware Version
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_HARDWARE_VERSION, &repVal);
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_HARDWARE_VERSION, &repVal);
if(cbor_value_is_valid(&repVal))
{
- err = err || cbor_value_dup_text_string(&repVal, &(info.hardwareVersion), &len,
- NULL);
+ err = cbor_value_dup_text_string(&repVal, &(info.hardwareVersion), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find HWVersion in the platform payload");
}
-
// Firmware Version
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_FIRMWARE_VERSION, &repVal);
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_FIRMWARE_VERSION, &repVal);
if(cbor_value_is_valid(&repVal))
{
- err = err || cbor_value_dup_text_string(&repVal, &(info.firmwareVersion), &len,
- NULL);
+ err = cbor_value_dup_text_string(&repVal, &(info.firmwareVersion), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find firmwareVersion in the platform payload");
}
-
// Support URL
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_SUPPORT_URL, &repVal);
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_SUPPORT_URL, &repVal);
if(cbor_value_is_valid(&repVal))
{
- err = err || cbor_value_dup_text_string(&repVal, &(info.supportUrl), &len, NULL);
+ err = cbor_value_dup_text_string(&repVal, &(info.supportUrl), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find supportUrl in the platform payload");
}
-
// System Time
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_SYSTEM_TIME, &repVal);
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_SYSTEM_TIME, &repVal);
if(cbor_value_is_valid(&repVal))
{
- err = err || cbor_value_dup_text_string(&repVal, &(info.systemTime), &len, NULL);
+ err = cbor_value_dup_text_string(&repVal, &(info.systemTime), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find systemTume in the platform payload");
}
- err = err || cbor_value_advance(rootValue);
-
- if(err)
- {
- OICFree(info.dateOfManufacture);
- OICFree(info.firmwareVersion);
- OICFree(info.hardwareVersion);
- OICFree(info.manufacturerName);
- OICFree(info.manufacturerUrl);
- OICFree(info.modelNumber);
- OICFree(info.operatingSystemVersion);
- OICFree(info.platformID);
- OICFree(info.platformVersion);
- OICFree(info.supportUrl);
- OICFree(info.systemTime);
- OIC_LOG(ERROR, TAG, "CBOR error In ParsePlatformPayload");
- return OC_STACK_MALFORMED_RESPONSE;
- }
-
- *outPayload = (OCPayload*)OCPlatformPayloadCreateAsOwner(&info);
-
- if(!*outPayload)
- {
- return OC_STACK_NO_MEMORY;
- }
+ err = cbor_value_advance(rootValue);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find supportUrl in the platform payload");
+ *outPayload = (OCPayload *)OCPlatformPayloadCreateAsOwner(&info);
return OC_STACK_OK;
}
- else
- {
- OIC_LOG(ERROR, TAG, "Root device node was not a map");
- return OC_STACK_MALFORMED_RESPONSE;
- }
+
+exit:
+ OCPlatformInfoDestroy(&info);
+ OIC_LOG(ERROR, TAG, "CBOR error In ParsePlatformPayload");
+ return ret;
}
static OCRepPayloadPropType DecodeCborType(CborType type)
{
switch (type)
{
- case CborNullType:
- return OCREP_PROP_NULL;
- case CborIntegerType:
- return OCREP_PROP_INT;
- case CborDoubleType:
- return OCREP_PROP_DOUBLE;
- case CborBooleanType:
- return OCREP_PROP_BOOL;
- case CborTextStringType:
- return OCREP_PROP_STRING;
- case CborByteStringType:
- return OCREP_PROP_BYTE_STRING;
- case CborMapType:
- return OCREP_PROP_OBJECT;
- case CborArrayType:
- return OCREP_PROP_ARRAY;
- default:
- return OCREP_PROP_NULL;
+ case CborNullType:
+ return OCREP_PROP_NULL;
+ case CborIntegerType:
+ return OCREP_PROP_INT;
+ case CborDoubleType:
+ return OCREP_PROP_DOUBLE;
+ case CborBooleanType:
+ return OCREP_PROP_BOOL;
+ case CborTextStringType:
+ return OCREP_PROP_STRING;
+ case CborByteStringType:
+ return OCREP_PROP_BYTE_STRING;
+ case CborMapType:
+ return OCREP_PROP_OBJECT;
+ case CborArrayType:
+ return OCREP_PROP_ARRAY;
+ default:
+ return OCREP_PROP_NULL;
}
}
-static bool OCParseArrayFindDimensionsAndType(const CborValue* parent, size_t dimensions[MAX_REP_ARRAY_DEPTH],
- OCRepPayloadPropType* type)
+static CborError OCParseArrayFindDimensionsAndType(const CborValue *parent,
+ size_t dimensions[MAX_REP_ARRAY_DEPTH], OCRepPayloadPropType *type)
{
- bool err = false;
CborValue insideArray;
*type = OCREP_PROP_NULL;
dimensions[0] = dimensions[1] = dimensions[2] = 0;
- err = err || cbor_value_enter_container(parent, &insideArray);
+ CborError err = cbor_value_enter_container(parent, &insideArray);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to enter container");
while (cbor_value_is_valid(&insideArray))
{
{
size_t subdim[MAX_REP_ARRAY_DEPTH];
tempType = OCREP_PROP_NULL;
- err = err || OCParseArrayFindDimensionsAndType(&insideArray, subdim, &tempType);
+ err = OCParseArrayFindDimensionsAndType(&insideArray, subdim, &tempType);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to parse array");
if (subdim[2] != 0)
{
dimensions[1] = dimensions[1] >= subdim[0] ? dimensions[1] : subdim[0];
dimensions[2] = dimensions[2] >= subdim[1] ? dimensions[2] : subdim[1];
- if (*type != OCREP_PROP_NULL && tempType != OCREP_PROP_NULL
- && *type != tempType)
+ if (*type != OCREP_PROP_NULL && tempType != OCREP_PROP_NULL && *type != tempType)
{
OIC_LOG(ERROR, TAG, "Array parse failed, mixed arrays not allowed (subtype)");
- return true;
+ return CborUnknownError;
}
else if (*type == OCREP_PROP_NULL)
{
{
// this is an invalid situation!
OIC_LOG(ERROR, TAG, "Array parse failed, mixed arrays not allowed");
- return true;
+ return CborUnknownError;
}
++dimensions[0];
- cbor_value_advance(&insideArray);
+ err = cbor_value_advance(&insideArray);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to advance array");
}
+exit:
return err;
}
elementNum;
}
-static bool OCParseArrayFillArray(const CborValue* parent, size_t dimensions[MAX_REP_ARRAY_DEPTH],
- OCRepPayloadPropType type, void* targetArray)
+static CborError OCParseArrayFillArray(const CborValue *parent,
+ size_t dimensions[MAX_REP_ARRAY_DEPTH], OCRepPayloadPropType type, void *targetArray)
{
- bool err = false;
CborValue insideArray;
- err = err || cbor_value_enter_container(parent, &insideArray);
-
size_t i = 0;
- char* tempStr = NULL;
+ char *tempStr = NULL;
OCByteString ocByteStr = { .bytes = NULL, .len = 0};
size_t tempLen = 0;
- OCRepPayload* tempPl = NULL;
+ OCRepPayload *tempPl = NULL;
size_t newdim[MAX_REP_ARRAY_DEPTH];
newdim[0] = dimensions[1];
newdim[1] = dimensions[2];
newdim[2] = 0;
+ CborError err = cbor_value_enter_container(parent, &insideArray);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to enter container");
+
while (!err && i < dimensions[0] && cbor_value_is_valid(&insideArray))
{
bool noAdvance = false;
case OCREP_PROP_INT:
if (dimensions[1] == 0)
{
- err = err || cbor_value_get_int64(&insideArray,
- &(((int64_t*)targetArray)[i]));
+ err = cbor_value_get_int64(&insideArray, &(((int64_t*)targetArray)[i]));
}
else
{
- err = err || OCParseArrayFillArray(&insideArray, newdim,
- type,
- &(((int64_t*)targetArray)[arrayStep(dimensions, i)])
- );
+ err = OCParseArrayFillArray(&insideArray, newdim, type,
+ &(((int64_t*)targetArray)[arrayStep(dimensions, i)]));
}
break;
case OCREP_PROP_DOUBLE:
if (dimensions[1] == 0)
{
- err = err || cbor_value_get_double(&insideArray,
- &(((double*)targetArray)[i]));
+ err = cbor_value_get_double(&insideArray, &(((double*)targetArray)[i]));
}
else
{
- err = err || OCParseArrayFillArray(&insideArray, newdim,
- type,
- &(((double*)targetArray)[arrayStep(dimensions, i)])
- );
+ err = OCParseArrayFillArray(&insideArray, newdim, type,
+ &(((double*)targetArray)[arrayStep(dimensions, i)]));
}
break;
case OCREP_PROP_BOOL:
if (dimensions[1] == 0)
{
- err = err || cbor_value_get_boolean(&insideArray,
- &(((bool*)targetArray)[i]));
+ err = cbor_value_get_boolean(&insideArray, &(((bool*)targetArray)[i]));
}
else
{
- err = err || OCParseArrayFillArray(&insideArray, newdim,
- type,
- &(((bool*)targetArray)[arrayStep(dimensions, i)])
- );
+ err = OCParseArrayFillArray(&insideArray, newdim, type,
+ &(((bool*)targetArray)[arrayStep(dimensions, i)]));
}
break;
case OCREP_PROP_STRING:
if (dimensions[1] == 0)
{
- err = err || cbor_value_dup_text_string(&insideArray,
- &tempStr, &tempLen, NULL);
+ err = cbor_value_dup_text_string(&insideArray, &tempStr, &tempLen, NULL);
((char**)targetArray)[i] = tempStr;
tempStr = NULL;
}
else
{
- err = err || OCParseArrayFillArray(&insideArray, newdim,
- type,
- &(((char**)targetArray)[arrayStep(dimensions, i)])
- );
+ err = OCParseArrayFillArray(&insideArray, newdim, type,
+ &(((char**)targetArray)[arrayStep(dimensions, i)]));
}
break;
case OCREP_PROP_BYTE_STRING:
if (dimensions[1] == 0)
{
- err = err || cbor_value_dup_byte_string(&insideArray,
- &(ocByteStr.bytes), &(ocByteStr.len), NULL);
+ err = cbor_value_dup_byte_string(&insideArray, &(ocByteStr.bytes),
+ &(ocByteStr.len), NULL);
((OCByteString*)targetArray)[i] = ocByteStr;
}
else
{
- err = err || OCParseArrayFillArray(&insideArray, newdim,
- type,
- &(((OCByteString*)targetArray)[arrayStep(dimensions, i)])
- );
+ err = OCParseArrayFillArray(&insideArray, newdim, type,
+ &(((OCByteString*)targetArray)[arrayStep(dimensions, i)]));
}
break;
case OCREP_PROP_OBJECT:
if (dimensions[1] == 0)
{
- err = err || OCParseSingleRepPayload(&tempPl, &insideArray);
+ err = OCParseSingleRepPayload(&tempPl, &insideArray);
((OCRepPayload**)targetArray)[i] = tempPl;
tempPl = NULL;
noAdvance = true;
}
else
{
- err = err || OCParseArrayFillArray(&insideArray, newdim,
- type,
- &(((OCRepPayload**)targetArray)[arrayStep(dimensions, i)])
- );
+ err = OCParseArrayFillArray(&insideArray, newdim, type,
+ &(((OCRepPayload**)targetArray)[arrayStep(dimensions, i)]));
}
break;
default:
OIC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
- err = true;
+ err = CborErrorUnknownType;
break;
}
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting repPayload");
}
++i;
if (!noAdvance && cbor_value_is_valid(&insideArray))
{
- err = err || cbor_value_advance(&insideArray);
+ err = cbor_value_advance(&insideArray);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed advnce insideArray");
}
}
+exit:
return err;
}
-static bool OCParseArray(OCRepPayload* out, const char* name, CborValue* container)
+static CborError OCParseArray(OCRepPayload *out, const char *name, CborValue *container)
{
+ void *arr = NULL;
OCRepPayloadPropType type;
size_t dimensions[MAX_REP_ARRAY_DEPTH];
- bool err = OCParseArrayFindDimensionsAndType(container, dimensions, &type);
-
- if (err)
- {
- OIC_LOG(ERROR, TAG, "Array details weren't clear");
- return err;
- }
+ size_t dimTotal;
+ size_t allocSize;
+ bool res = true;
+ CborError err = OCParseArrayFindDimensionsAndType(container, dimensions, &type);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Array details weren't clear");
if (type == OCREP_PROP_NULL)
{
- err = err || OCRepPayloadSetNull(out, name);
- err = err || cbor_value_advance(container);
+ res = OCRepPayloadSetNull(out, name);
+ err = (CborError) !res;
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting value");
+ err = cbor_value_advance(container);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed advancing container");
return err;
}
- size_t dimTotal = calcDimTotal(dimensions);
- size_t allocSize = getAllocSize(type);
- void* arr = OICCalloc(dimTotal, allocSize);
+ dimTotal = calcDimTotal(dimensions);
+ allocSize = getAllocSize(type);
+ arr = OICCalloc(dimTotal, allocSize);
+ VERIFY_PARAM_NON_NULL(TAG, arr, "Array Parse allocation failed");
- if (!arr)
- {
- OIC_LOG(ERROR, TAG, "Array Parse allocation failed");
- return true;
- }
-
- err = err || OCParseArrayFillArray(container, dimensions, type, arr);
+ res = OCParseArrayFillArray(container, dimensions, type, arr);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed parse array");
switch (type)
{
case OCREP_PROP_INT:
- if (err || !OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t*)arr, dimensions))
- {
- OICFree(arr);
- err = true;
- }
+ res = OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t *)arr, dimensions);
break;
case OCREP_PROP_DOUBLE:
- if (err || !OCRepPayloadSetDoubleArrayAsOwner(out, name, (double*)arr, dimensions))
- {
- OICFree(arr);
- err = true;
- }
+ res = OCRepPayloadSetDoubleArrayAsOwner(out, name, (double *)arr, dimensions);
break;
case OCREP_PROP_BOOL:
- if (err || !OCRepPayloadSetBoolArrayAsOwner(out, name, (bool*)arr, dimensions))
- {
- OICFree(arr);
- err = true;
- }
+ res = OCRepPayloadSetBoolArrayAsOwner(out, name, (bool *)arr, dimensions);
break;
case OCREP_PROP_STRING:
- if (err || !OCRepPayloadSetStringArrayAsOwner(out, name, (char**)arr, dimensions))
- {
- for(size_t i = 0; i < dimTotal; ++i)
- {
- OICFree(((char**)arr)[i]);
- }
- OICFree(arr);
- err = true;
- }
+ res = OCRepPayloadSetStringArrayAsOwner(out, name, (char **)arr, dimensions);
break;
case OCREP_PROP_BYTE_STRING:
- if (err || !OCRepPayloadSetByteStringArrayAsOwner(out, name, (OCByteString*)arr, dimensions))
- {
- for (size_t i = 0; i < dimTotal; ++i)
- {
- OICFree(((OCByteString*)arr)[i].bytes);
- }
- OICFree(arr);
- err = true;
- }
+ res = OCRepPayloadSetByteStringArrayAsOwner(out, name, (OCByteString *)arr, dimensions);
break;
case OCREP_PROP_OBJECT:
- if (err || !OCRepPayloadSetPropObjectArrayAsOwner(out, name, (OCRepPayload**)arr, dimensions))
- {
- for(size_t i = 0; i < dimTotal; ++i)
- {
- OCRepPayloadDestroy(((OCRepPayload**)arr)[i]);
- }
- OICFree(arr);
- err = true;
- }
+ res = OCRepPayloadSetPropObjectArrayAsOwner(out, name, (OCRepPayload**)arr, dimensions);
break;
default:
OIC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
- err = true;
break;
}
-
+ err = (CborError) !res;
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting array parameter");
+ return CborNoError;
+exit:
+ if (type == OCREP_PROP_STRING)
+ {
+ for(size_t i = 0; i < dimTotal; ++i)
+ {
+ OICFree(((char**)arr)[i]);
+ }
+ }
+ if (type == OCREP_PROP_BYTE_STRING)
+ {
+ for(size_t i = 0; i < dimTotal; ++i)
+ {
+ OICFree(((OCByteString*)arr)[i].bytes);
+ }
+ }
+ if (type == OCREP_PROP_OBJECT)
+ {
+ for(size_t i = 0; i < dimTotal; ++i)
+ {
+ OCRepPayloadDestroy(((OCRepPayload**)arr)[i]);
+ }
+ }
+ OICFree(arr);
return err;
}
-static bool OCParseSingleRepPayload(OCRepPayload** outPayload, CborValue *objMap)
+static CborError OCParseSingleRepPayload(OCRepPayload **outPayload, CborValue *objMap)
{
- if (!outPayload)
- {
- return false;
- }
-
- bool err = false;
+ CborError err = CborUnknownError;
+ char *name = NULL;
+ bool res;
+ VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
+ VERIFY_PARAM_NON_NULL(TAG, objMap, "Invalid Parameter objMap");
if (cbor_value_is_map(objMap))
{
if (!*outPayload)
{
*outPayload = OCRepPayloadCreate();
- if(!*outPayload)
+ if (!*outPayload)
{
return CborErrorOutOfMemory;
}
}
- OCRepPayload* curPayload = *outPayload;
+ OCRepPayload *curPayload = *outPayload;
+
size_t len = 0;
- CborValue repMap = *objMap;
- err = err || cbor_value_enter_container(objMap, &repMap);
+ CborValue repMap;
+ err = cbor_value_enter_container(objMap, &repMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed entering repMap");
+
while (!err && cbor_value_is_valid(&repMap))
{
- char *name = NULL;
if (cbor_value_is_text_string(&repMap))
{
- err = err || cbor_value_dup_text_string(&repMap, &name, &len, NULL);
- err = err || cbor_value_advance(&repMap);
+ err = cbor_value_dup_text_string(&repMap, &name, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding tag name in the map");
+ err = cbor_value_advance(&repMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed advancing rootMap");
if (name &&
((0 == strcmp(OC_RSRVD_HREF, name)) ||
(0 == strcmp(OC_RSRVD_RESOURCE_TYPE, name)) ||
(0 == strcmp(OC_RSRVD_INTERFACE, name))))
{
- err = err || cbor_value_advance(&repMap);
+ err = cbor_value_advance(&repMap);
OICFree(name);
continue;
}
-
}
CborType type = cbor_value_get_type(&repMap);
-
- switch(type)
+ switch (type)
{
case CborNullType:
- err = !OCRepPayloadSetNull(curPayload, name);
+ res = OCRepPayloadSetNull(curPayload, name);
break;
case CborIntegerType:
{
int64_t intval = 0;
- err = err || cbor_value_get_int64(&repMap, &intval);
- if (!err)
- {
- err = !OCRepPayloadSetPropInt(curPayload, name, intval);
- }
+ err = cbor_value_get_int64(&repMap, &intval);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting int value");
+ res = OCRepPayloadSetPropInt(curPayload, name, intval);
}
break;
case CborDoubleType:
{
double doubleval = 0;
- err = err || cbor_value_get_double(&repMap, &doubleval);
- if (!err)
- {
- err = !OCRepPayloadSetPropDouble(curPayload, name, doubleval);
- }
+ err = cbor_value_get_double(&repMap, &doubleval);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting double value");
+ res = OCRepPayloadSetPropDouble(curPayload, name, doubleval);
}
break;
case CborBooleanType:
{
bool boolval = false;
- err = err || cbor_value_get_boolean(&repMap, &boolval);
- if (!err)
- {
- err = !OCRepPayloadSetPropBool(curPayload, name, boolval);
- }
+ err = cbor_value_get_boolean(&repMap, &boolval);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting boolean value");
+ res = OCRepPayloadSetPropBool(curPayload, name, boolval);
}
break;
case CborTextStringType:
{
- char* strval = NULL;
- err = err || cbor_value_dup_text_string(&repMap, &strval, &len, NULL);
- if (!err)
- {
- err = !OCRepPayloadSetPropStringAsOwner(curPayload, name, strval);
- }
+ char *strval = NULL;
+ err = cbor_value_dup_text_string(&repMap, &strval, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting string value");
+ res = OCRepPayloadSetPropStringAsOwner(curPayload, name, strval);
}
break;
case CborByteStringType:
{
uint8_t* bytestrval = NULL;
- err = err || cbor_value_dup_byte_string(&repMap, &bytestrval, &len, NULL);
- if (!err)
- {
- OCByteString tmp = {.bytes = bytestrval, .len = len};
- err = !OCRepPayloadSetPropByteStringAsOwner(curPayload, name, &tmp);
- }
+ err = cbor_value_dup_byte_string(&repMap, &bytestrval, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting byte string value");
+ OCByteString tmp = {.bytes = bytestrval, .len = len};
+ res = OCRepPayloadSetPropByteStringAsOwner(curPayload, name, &tmp);
}
break;
case CborMapType:
{
OCRepPayload *pl = NULL;
- err = err || OCParseSingleRepPayload(&pl, &repMap);
- if (!err)
- {
- err = !OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl);
- }
+ err = OCParseSingleRepPayload(&pl, &repMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting parse single rep");
+ res = OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl);
}
break;
case CborArrayType:
- err = err || OCParseArray(curPayload, name, &repMap);
+ err = OCParseArray(curPayload, name, &repMap);
break;
default:
OIC_LOG_V(ERROR, TAG, "Parsing rep property, unknown type %d", repMap.type);
- err = true;
+ res = false;
}
+ if (type != CborArrayType)
+ {
+ err = (CborError) !res;
+ }
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting value");
if (type != CborMapType && cbor_value_is_valid(&repMap))
{
- err = err || cbor_value_advance(&repMap);
+ err = cbor_value_advance(&repMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed advance repMap");
}
OICFree(name);
+ name = NULL;
}
if (cbor_value_is_container(objMap))
{
- err = err || cbor_value_leave_container(objMap, &repMap);
- }
- if (err)
- {
- OCRepPayloadDestroy(*outPayload);
- *outPayload = NULL;
+ err = cbor_value_leave_container(objMap, &repMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to leave container");
}
+ return err;
}
+exit:
+ OICFree(name);
+ OCRepPayloadDestroy(*outPayload);
+ *outPayload = NULL;
return err;
}
-static OCStackResult OCParseRepPayload(OCPayload** outPayload, CborValue* root)
+static OCStackResult OCParseRepPayload(OCPayload **outPayload, CborValue *root)
{
- if (!outPayload)
- {
- return OC_STACK_INVALID_PARAM;
- }
-
+ OCStackResult ret = OC_STACK_INVALID_PARAM;
+ CborError err;
+ OCRepPayload *temp = NULL;
OCRepPayload *rootPayload = NULL;
OCRepPayload *curPayload = NULL;
-
- CborValue curVal;
- bool err = false;
- size_t len = 0;
CborValue rootMap = *root;
+ VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
+ VERIFY_PARAM_NON_NULL(TAG, root, "Invalid Parameter root");
+
+
+ *outPayload = NULL;
if (cbor_value_is_array(root))
{
- cbor_value_enter_container(root, &rootMap);
+ err = cbor_value_enter_container(root, &rootMap);
}
- while (!err && cbor_value_is_valid(&rootMap))
+ while (cbor_value_is_valid(&rootMap))
{
- OCRepPayload *temp = OCRepPayloadCreate();
- if (!temp)
- {
- return OC_STACK_NO_MEMORY;
- }
- if (!err && cbor_value_is_map(&rootMap))
+ temp = OCRepPayloadCreate();
+ ret = OC_STACK_NO_MEMORY;
+ VERIFY_PARAM_NON_NULL(TAG, temp, "Failed allocating memory");
+
+ CborValue curVal;
+ ret = OC_STACK_MALFORMED_RESPONSE;
+
+ if (cbor_value_is_map(&rootMap))
{
- err = err || cbor_value_map_find_value(&rootMap, OC_RSRVD_HREF, &curVal);
+ err = cbor_value_map_find_value(&rootMap, OC_RSRVD_HREF, &curVal);
if (cbor_value_is_valid(&curVal))
{
- err = err || cbor_value_dup_text_string(&curVal, &temp->uri, &len, NULL);
+ size_t len = 0;
+ err = cbor_value_dup_text_string(&curVal, &temp->uri, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find uri");
}
}
- if (!err && cbor_value_is_map(&rootMap))
+ // Resource types
+ if (cbor_value_is_map(&rootMap))
{
- err = err || cbor_value_map_find_value(&rootMap, OC_RSRVD_RESOURCE_TYPE, &curVal);
- if(cbor_value_is_text_string(&curVal))
+ if (CborNoError == cbor_value_map_find_value(&rootMap, OC_RSRVD_RESOURCE_TYPE, &curVal))
{
- char* allRt = NULL;
- err = err || cbor_value_dup_text_string(&curVal, &allRt, &len, NULL);
- if (allRt)
- {
- char* savePtr;
- char* curPtr = strtok_r(allRt, " ", &savePtr);
- while (curPtr)
- {
- char* trimmed = InPlaceStringTrim(curPtr);
- if (trimmed[0] != '\0')
- {
- OCRepPayloadAddResourceType(temp, curPtr);
- }
- curPtr = strtok_r(NULL, " ", &savePtr);
- }
- }
- OICFree(allRt);
+ err = OCParseStringLL(&rootMap, OC_RSRVD_RESOURCE_TYPE, &temp->types);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find rt type tag/value");
}
}
- if (!err && cbor_value_is_map(&rootMap))
+
+ // Interface Types
+ if (cbor_value_is_map(&rootMap))
{
- err = err || cbor_value_map_find_value(&rootMap, OC_RSRVD_INTERFACE, &curVal);
- if(cbor_value_is_text_string(&curVal))
+ if (CborNoError == cbor_value_map_find_value(&rootMap, OC_RSRVD_INTERFACE, &curVal))
{
- char* allIf = NULL;
- err = err || cbor_value_dup_text_string(&curVal, &allIf, &len, NULL);
- if (allIf)
- {
- char* savePtr;
- char* curPtr = strtok_r(allIf, " ", &savePtr);
- while (curPtr)
- {
- char* trimmed = InPlaceStringTrim(curPtr);
- if (trimmed[0] != '\0')
- {
- OCRepPayloadAddInterface(temp, curPtr);
- }
- curPtr = strtok_r(NULL, " ", &savePtr);
- }
- }
- OICFree(allIf);
+ err = OCParseStringLL(&rootMap, OC_RSRVD_INTERFACE, &temp->interfaces);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find interfaces tag/value");
}
}
- if (!err && cbor_value_is_map(&rootMap))
+
+ if (cbor_value_is_map(&rootMap))
{
- err = err || OCParseSingleRepPayload(&temp, &rootMap);
+ err = OCParseSingleRepPayload(&temp, &rootMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to parse single rep payload");
}
- if (rootPayload == NULL)
+ if(rootPayload == NULL)
{
rootPayload = temp;
curPayload = temp;
curPayload->next = temp;
curPayload = curPayload->next;
}
- if (err)
- {
- OCRepPayloadDestroy(rootPayload);
- OIC_LOG(ERROR, TAG, "CBOR error in ParseRepPayload");
- return OC_STACK_MALFORMED_RESPONSE;
- }
+
if (cbor_value_is_array(&rootMap))
{
- err = err || cbor_value_advance(&rootMap);
+ err = cbor_value_advance(&rootMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to advance single rep payload");
}
}
*outPayload = (OCPayload *)rootPayload;
-
return OC_STACK_OK;
+
+exit:
+ OCRepPayloadDestroy(temp);
+ OCRepPayloadDestroy(rootPayload);
+ OIC_LOG(ERROR, TAG, "CBOR error in ParseRepPayload");
+ return ret;
}
-static OCStackResult OCParsePresencePayload(OCPayload** outPayload, CborValue* rootValue)
+static OCStackResult OCParsePresencePayload(OCPayload **outPayload, CborValue *rootValue)
{
- if (!outPayload)
- {
- return OC_STACK_INVALID_PARAM;
- }
+ OCStackResult ret = OC_STACK_INVALID_PARAM;
+ OCPresencePayload *payload = NULL;
+ VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
- bool err = false;
+ *outPayload = NULL;
- if(cbor_value_is_map(rootValue))
- {
- uint64_t seqNum = 0;
- uint64_t maxAge = 0;
- OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE;
- char* tempStr = NULL;
- size_t len = 0;
+ payload = (OCPresencePayload *)OICCalloc(1, sizeof(OCPresencePayload));
+ ret = OC_STACK_NO_MEMORY;
+ VERIFY_PARAM_NON_NULL(TAG, payload, "Failed allocating presence payload");
+ payload->base.type = PAYLOAD_TYPE_PRESENCE;
+ ret = OC_STACK_MALFORMED_RESPONSE;
+ if (cbor_value_is_map(rootValue))
+ {
CborValue curVal;
+
// Sequence Number
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_NONCE, &curVal);
- err = err || cbor_value_get_uint64(&curVal, &seqNum);
+ CborError err = cbor_value_map_find_value(rootValue, OC_RSRVD_NONCE, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding nonce tag");
+ err = cbor_value_get_uint64(&curVal, (uint64_t *)&payload->sequenceNumber);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding nonce value");
// Max Age
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_TTL, &curVal);
- err = err || cbor_value_get_uint64(&curVal, &maxAge);
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_TTL, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding ttl tag");
+ err = cbor_value_get_uint64(&curVal, (uint64_t *)&payload->maxAge);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding ttl value");
// Trigger
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_TRIGGER, &curVal);
- err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL);
- trigger = convertTriggerStringToEnum(tempStr);
- OICFree(tempStr);
- tempStr = NULL;
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_TRIGGER, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding trigger tag");
+ err = cbor_value_get_simple_type(&curVal, (uint8_t *)&payload->trigger);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding trigger value");
// Resource type name
- err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_RESOURCE_TYPE, &curVal);
- if(cbor_value_is_valid(&curVal))
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_RESOURCE_TYPE, &curVal);
+ if (cbor_value_is_valid(&curVal))
{
- err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL);
+ size_t len = 0;
+ err = cbor_value_dup_text_string(&curVal, &payload->resourceType, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding resource type value");
}
- err = err || cbor_value_advance(rootValue);
-
- if(!err)
- {
- *outPayload = (OCPayload*)OCPresencePayloadCreate(seqNum, maxAge, trigger, tempStr);
- }
- OICFree(tempStr);
-
- if(err)
- {
- OCPayloadDestroy(*outPayload);
- OIC_LOG(ERROR, TAG, "CBOR error Parse Presence Payload");
- return OC_STACK_MALFORMED_RESPONSE;
- }
-
- if(!*outPayload)
- {
- return OC_STACK_NO_MEMORY;
- }
+ err = cbor_value_advance(rootValue);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed advancing root value");
+ *outPayload = (OCPayload *)payload;
return OC_STACK_OK;
}
- else
- {
- OIC_LOG(ERROR, TAG, "Root presence node was not a map");
- return OC_STACK_MALFORMED_RESPONSE;
- }
+exit:
+ OIC_LOG(ERROR, TAG, "CBOR error Parse Presence Payload");
+ OCPresencePayloadDestroy(payload);
+ return ret;
}
#define CBOR_ROOT_ARRAY_LENGTH 1
+static CborError OCTagsPayloadToCbor(OCTagsPayload *tags, CborEncoder *setMap);
+static CborError OCLinksPayloadToCbor(OCLinksPayload *rtPtr, CborEncoder *setMap);
+static CborError OCTagsCborToPayload(CborValue *tagsMap, OCTagsPayload **tagsPayload);
+static CborError OCLinksCborToPayload(CborValue *linksArray, OCLinksPayload **linksPayload);
static CborError FindStringInMap(CborValue *map, char *tags, char **value);
static CborError FindIntInMap(CborValue *map, char *tags, uint64_t *value);
static CborError FindStringLLInMap(const CborValue *linksMap, char *tag, OCStringLL **links);
-static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen, const char *value);
-static int64_t ConditionalAddIntToMap(CborEncoder *map, const char *tags, const size_t size, const uint64_t *value);
-static int64_t AddStringLLToMap(CborEncoder *map, char *tag, const size_t size, OCStringLL *value);
+static CborError ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen, const char *value);
+static CborError ConditionalAddIntToMap(CborEncoder *map, const char *tags, const size_t size, const uint64_t *value);
+static CborError AddStringLLToMap(CborEncoder *map, char *tag, const size_t size, OCStringLL *value);
-int64_t OCRDPayloadToCbor(const OCRDPayload *rdPayload, uint8_t *outPayload, size_t *size)
+CborError OCRDPayloadToCbor(const OCRDPayload *rdPayload, uint8_t *outPayload, size_t *size)
{
- if (!outPayload || !size)
- {
- OIC_LOG(ERROR, TAG, "Invalid parameters.");
- return OC_STACK_INVALID_PARAM;
- }
-
- CborEncoder encoder;
+ CborError cborEncoderResult = CborErrorIO;
int flags = 0;
+ CborEncoder encoder;
+ VERIFY_PARAM_NON_NULL(TAG, rdPayload, "Invalid input parameter rdPayload");
+ VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid input parameter outPayload");
+ VERIFY_PARAM_NON_NULL(TAG, size, "Invalid input parameter size");
+
cbor_encoder_init(&encoder, outPayload, *size, flags);
- CborError cborEncoderResult;
if (rdPayload->rdDiscovery)
{
CborEncoder map;
cborEncoderResult = cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
- if (CborNoError != cborEncoderResult)
- {
- OIC_LOG(ERROR, TAG, "Failed creating discovery map.");
- goto cbor_error;
- }
- if (CborNoError != ConditionalAddTextStringToMap(&map, OC_RSRVD_DEVICE_NAME,
- sizeof(OC_RSRVD_DEVICE_NAME) - 1, (char *)rdPayload->rdDiscovery->n.deviceName))
- {
- OIC_LOG(ERROR, TAG, "Failed setting OC_RSRVD_DEVICE_NAME.");
- goto cbor_error;
- }
- if (CborNoError != ConditionalAddTextStringToMap(&map, OC_RSRVD_DEVICE_ID,
- sizeof(OC_RSRVD_DEVICE_ID) - 1, (char *)rdPayload->rdDiscovery->di.id))
- {
- OIC_LOG(ERROR, TAG, "Failed setting OC_RSRVD_DEVICE_ID.");
- goto cbor_error;
- }
- uint64_t sel = (uint8_t) rdPayload->rdDiscovery->sel;
- if (CborNoError != ConditionalAddIntToMap(&map, OC_RSRVD_RD_DISCOVERY_SEL,
- sizeof(OC_RSRVD_RD_DISCOVERY_SEL) - 1, &sel))
- {
- OIC_LOG(ERROR, TAG, "Failed setting OC_RSRVD_RD_DISCOVERY_SEL.");
- goto cbor_error;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create discovery map");
+
+ cborEncoderResult = ConditionalAddTextStringToMap(&map, OC_RSRVD_DEVICE_NAME,
+ sizeof(OC_RSRVD_DEVICE_NAME) - 1, (char *)rdPayload->rdDiscovery->n.deviceName);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_NAME in map");
+
+ cborEncoderResult = ConditionalAddTextStringToMap(&map, OC_RSRVD_DEVICE_ID,
+ sizeof(OC_RSRVD_DEVICE_ID) - 1, (char *)rdPayload->rdDiscovery->di.id);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_ID in map");
+
+ cborEncoderResult = ConditionalAddIntToMap(&map, OC_RSRVD_RD_DISCOVERY_SEL,
+ sizeof(OC_RSRVD_RD_DISCOVERY_SEL) - 1, (uint64_t *)&rdPayload->rdDiscovery->sel);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add RD_DISCOVERY_SEL in map");
+
cborEncoderResult = cbor_encoder_close_container(&encoder, &map);
- if (CborNoError != cborEncoderResult)
- {
- OIC_LOG(ERROR, TAG, "Failed closing discovery map.");
- goto cbor_error;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing discovery map");
}
else if (rdPayload->rdPublish)
{
CborEncoder colArray;
cborEncoderResult = cbor_encoder_create_array(&encoder, &colArray, CborIndefiniteLength);
- if (CborNoError != cborEncoderResult)
- {
- OIC_LOG(ERROR, TAG, "Failed creating collection array.");
- goto cbor_error;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create collection array");
OCResourceCollectionPayload *rdPublish = rdPayload->rdPublish;
while (rdPublish)
{
- if (OC_STACK_OK != OCTagsPayloadToCbor(rdPublish->tags, &colArray))
- {
- OIC_LOG(ERROR, TAG, "Failed creating tags payload.");
- goto cbor_error;
- }
- if (OC_STACK_OK != OCLinksPayloadToCbor(rdPublish->setLinks, &colArray))
- {
- OIC_LOG(ERROR, TAG, "Failed creating links payload.");
- goto cbor_error;
- }
+ cborEncoderResult = OCTagsPayloadToCbor(rdPublish->tags, &colArray);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed adding tags payload");
+ cborEncoderResult = OCLinksPayloadToCbor(rdPublish->setLinks, &colArray);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed adding setLinks payload");
rdPublish = rdPublish->next;
}
cborEncoderResult = cbor_encoder_close_container(&encoder, &colArray);
- if (CborNoError != cborEncoderResult)
- {
- OIC_LOG(ERROR, TAG, "Failed closing collection array.");
- goto cbor_error;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing collection array");
}
else
{
CborEncoder map;
cborEncoderResult = cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
- if (CborNoError != cborEncoderResult)
- {
- OIC_LOG(ERROR, TAG, "Failed creating discovery map.");
- goto cbor_error;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed entering discovery map");
cborEncoderResult = cbor_encoder_close_container(&encoder, &map);
- if (CborNoError != cborEncoderResult)
- {
- OIC_LOG(ERROR, TAG, "Failed creating discovery map.");
- goto cbor_error;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing discovery map");
}
*size = encoder.ptr - outPayload;
- return OC_STACK_OK;
-cbor_error:
+ return cborEncoderResult;
+
+exit:
OICFree(outPayload);
- return OC_STACK_ERROR;
+ return cborEncoderResult;
}
-OCStackResult OCTagsPayloadToCbor(OCTagsPayload *tags, CborEncoder *setMap)
+static CborError OCTagsPayloadToCbor(OCTagsPayload *tags, CborEncoder *setMap)
{
CborEncoder tagsMap;
CborError cborEncoderResult = cbor_encoder_create_map(setMap, &tagsMap, CborIndefiniteLength);
- if (CborNoError != cborEncoderResult)
- {
- OIC_LOG(ERROR, TAG, "Failed creating TAGS map.");
- return OC_STACK_ERROR;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create tags map");
+
+ cborEncoderResult = ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DEVICE_NAME,
+ sizeof(OC_RSRVD_DEVICE_NAME) - 1, (char *)tags->n.deviceName);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_NAME in tags map");
+
+ cborEncoderResult = ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DEVICE_ID,
+ sizeof(OC_RSRVD_DEVICE_ID) - 1, (char *)tags->di.id);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_ID in tags map");
+
+ cborEncoderResult = ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_RTS,
+ sizeof(OC_RSRVD_RTS) - 1, (char *)tags->rts);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_RTS in tags map");
+
+ cborEncoderResult = ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DREL,
+ sizeof(OC_RSRVD_DREL) - 1, (char *)tags->drel);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DREL in tags map");
+
+ cborEncoderResult = ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_BASE_URI,
+ sizeof(OC_RSRVD_BASE_URI) - 1, (char *)tags->baseURI);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_BASE_URI in tags map");
+
+ cborEncoderResult = ConditionalAddIntToMap(&tagsMap, OC_RSRVD_BITMAP,
+ sizeof(OC_RSRVD_BITMAP) - 1, (uint64_t *)&tags->bitmap);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_BITMAP in tags map");
+
+ cborEncoderResult = ConditionalAddIntToMap(&tagsMap, OC_RSRVD_HOSTING_PORT,
+ sizeof(OC_RSRVD_HOSTING_PORT) - 1, (uint64_t *)&tags->port);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_HOSTING_PORT in tags map");
+
+ cborEncoderResult = ConditionalAddIntToMap(&tagsMap, OC_RSRVD_INS, sizeof(OC_RSRVD_INS) - 1,
+ (uint64_t *)&tags->ins);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_INS in tags map");
+
+ cborEncoderResult = ConditionalAddIntToMap(&tagsMap, OC_RSRVD_TTL, sizeof(OC_RSRVD_TTL) - 1,
+ (uint64_t *)&tags->ttl);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_TTL in tags map");
- if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DEVICE_NAME,
- sizeof(OC_RSRVD_DEVICE_NAME) - 1, (char *)tags->n.deviceName))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_DEVICE_NAME in TAGS map.");
- return OC_STACK_ERROR;
- }
- if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DEVICE_ID,
- sizeof(OC_RSRVD_DEVICE_ID) - 1, (char *)tags->di.id))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_DEVICE_ID in TAGS map.");
- return OC_STACK_ERROR;
- }
- if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_RTS,
- sizeof(OC_RSRVD_RTS) - 1, (char *)tags->rts))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_RTS in TAGS map.");
- return OC_STACK_ERROR;
- }
- if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DREL,
- sizeof(OC_RSRVD_DREL) - 1, (char *)tags->drel))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_DREL in TAGS map.");
- return OC_STACK_ERROR;
- }
- if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_BASE_URI,
- sizeof(OC_RSRVD_BASE_URI) - 1, (char *)tags->baseURI))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_BASE_URI in TAGS map.");
- return OC_STACK_ERROR;
- }
- uint64_t temp = (uint64_t)tags->bitmap;
- if (CborNoError != ConditionalAddIntToMap(&tagsMap, OC_RSRVD_BITMAP,
- sizeof(OC_RSRVD_BITMAP) - 1, &temp))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_BITMAP in TAGS map.");
- return OC_STACK_ERROR;
- }
- temp = (uint64_t)tags->port;
- if (CborNoError != ConditionalAddIntToMap(&tagsMap, OC_RSRVD_HOSTING_PORT,
- sizeof(OC_RSRVD_HOSTING_PORT) - 1, &temp))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_HOSTING_PORT in TAGS map.");
- return OC_STACK_ERROR;
- }
- temp = (uint64_t)tags->ins;
- if (CborNoError != ConditionalAddIntToMap(&tagsMap, OC_RSRVD_INS,
- sizeof(OC_RSRVD_INS) - 1, &temp))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_INS in TAGS map.");
- return OC_STACK_ERROR;
- }
- temp = (uint64_t)tags->ttl;
- if (CborNoError != ConditionalAddIntToMap(&tagsMap, OC_RSRVD_TTL,
- sizeof(OC_RSRVD_TTL) - 1, &temp))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_TTL in TAGS map.");
- return OC_STACK_ERROR;
- }
cborEncoderResult = cbor_encoder_close_container(setMap, &tagsMap);
- if (CborNoError != cborEncoderResult)
- {
- OIC_LOG(ERROR, TAG, "Failed closing TAGS map.");
- return OC_STACK_ERROR;
- }
- return OC_STACK_OK;
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to close container");
+
+exit:
+ return cborEncoderResult;
}
-OCStackResult OCLinksPayloadToCbor(OCLinksPayload *rtPtr, CborEncoder *setMap)
+static CborError OCLinksPayloadToCbor(OCLinksPayload *rtPtr, CborEncoder *setMap)
{
CborEncoder linksArray;
CborError cborEncoderResult;
cborEncoderResult = cbor_encoder_create_array(setMap, &linksArray, CborIndefiniteLength);
- if (CborNoError != cborEncoderResult)
- {
- OIC_LOG(ERROR, TAG, "Failed creating LINKS array.");
- return OC_STACK_ERROR;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create Links array");
+
while (rtPtr)
{
CborEncoder linksMap;
- cborEncoderResult = cbor_encoder_create_map(&linksArray, &linksMap,
- CborIndefiniteLength);
- if (CborNoError != cborEncoderResult)
- {
- OIC_LOG(ERROR, TAG, "Failed creating LINKS map.");
- return OC_STACK_ERROR;
- }
- if (CborNoError != ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_HREF,
- sizeof(OC_RSRVD_HREF) - 1, rtPtr->href))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_HREF in LINKS map.");
- return OC_STACK_ERROR;
- }
- if (CborNoError != ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_REL,
- sizeof(OC_RSRVD_REL) - 1, rtPtr->rel))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_REL in LINKS map.");
- return OC_STACK_ERROR;
- }
- if (CborNoError != ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_TITLE,
- sizeof(OC_RSRVD_TITLE) - 1, rtPtr->title))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_TITLE in LINKS map.");
- return OC_STACK_ERROR;
- }
- if (CborNoError != ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_URI,
- sizeof(OC_RSRVD_URI) - 1, rtPtr->uri))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_URI in LINKS map.");
- return OC_STACK_ERROR;
- }
- if (CborNoError != AddStringLLToMap(&linksMap, OC_RSRVD_RESOURCE_TYPE,
- sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, rtPtr->rt))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_RESOURCE_TYPE in LINKS map.");
- return OC_STACK_ERROR;
- }
- if (CborNoError != AddStringLLToMap(&linksMap, OC_RSRVD_INTERFACE,
- sizeof(OC_RSRVD_INTERFACE) - 1, rtPtr->itf))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_INTERFACE in LINKS map.");
- return OC_STACK_ERROR;
- }
- if (CborNoError != AddStringLLToMap(&linksMap, OC_RSRVD_MEDIA_TYPE,
- sizeof(OC_RSRVD_MEDIA_TYPE) - 1, rtPtr->mt))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_MEDIA_TYPE in LINKS map.");
- return OC_STACK_ERROR;
- }
- uint64_t temp = (uint64_t)rtPtr->ins;
- if (CborNoError != ConditionalAddIntToMap(&linksMap, OC_RSRVD_INS,
- sizeof(OC_RSRVD_INS) - 1, &temp))
- {
- OIC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_INS in LINKS map.");
- return OC_STACK_ERROR;
- }
+ cborEncoderResult = cbor_encoder_create_map(&linksArray, &linksMap, CborIndefiniteLength);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create Links map");
+
+ cborEncoderResult = ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_HREF,
+ sizeof(OC_RSRVD_HREF) - 1, rtPtr->href);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_HREF in Links map");
+
+ cborEncoderResult = ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_REL,
+ sizeof(OC_RSRVD_REL) - 1, rtPtr->rel);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_REL in Links map");
+
+ cborEncoderResult = ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_TITLE,
+ sizeof(OC_RSRVD_TITLE) - 1, rtPtr->title);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_TITLE in Links map");
+
+ cborEncoderResult = ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_URI,
+ sizeof(OC_RSRVD_URI) - 1, rtPtr->uri);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_URI in Links map");
+
+ cborEncoderResult = AddStringLLToMap(&linksMap, OC_RSRVD_RESOURCE_TYPE,
+ sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, rtPtr->rt);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_RT in Links map");
+
+ cborEncoderResult = AddStringLLToMap(&linksMap, OC_RSRVD_INTERFACE,
+ sizeof(OC_RSRVD_INTERFACE) - 1, rtPtr->itf);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_ITF in Links map");
+
+ cborEncoderResult = AddStringLLToMap(&linksMap, OC_RSRVD_MEDIA_TYPE,
+ sizeof(OC_RSRVD_MEDIA_TYPE) - 1, rtPtr->mt);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_MT in Links map");
+
+ cborEncoderResult = ConditionalAddIntToMap(&linksMap, OC_RSRVD_INS,
+ sizeof(OC_RSRVD_INS) - 1, (uint64_t *)&rtPtr->ins);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_INS in Links map");
+
cborEncoderResult = cbor_encoder_close_container(&linksArray, &linksMap);
- if (CborNoError != cborEncoderResult)
- {
- OIC_LOG(ERROR, TAG, "Failed closing LINKS map.");
- return OC_STACK_ERROR;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing Links map");
+
rtPtr = rtPtr->next;
}
cborEncoderResult = cbor_encoder_close_container(setMap, &linksArray);
- if (CborNoError != cborEncoderResult)
- {
- OIC_LOG(ERROR, TAG, "Failed closing LINKS array.");
- return OC_STACK_ERROR;;
- }
- return OC_STACK_OK;
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing links array");
+
+exit:
+ return cborEncoderResult;
}
OCStackResult OCRDCborToPayload(const CborValue *cborPayload, OCPayload **outPayload)
{
CborValue *rdCBORPayload = (CborValue *)cborPayload;
+ OCStackResult ret = OC_STACK_NO_MEMORY;
CborError cborFindResult;
OCRDPayload *rdPayload = OCRDPayloadCreate();
- if (!rdPayload)
- {
- goto no_memory;
- }
+ VERIFY_PARAM_NON_NULL(TAG, rdPayload, "Failed allocating rdPayload");
+
+ ret = OC_STACK_MALFORMED_RESPONSE;
if (cbor_value_is_array(rdCBORPayload))
{
// enter tags map
CborValue tags;
cborFindResult = cbor_value_enter_container(rdCBORPayload, &tags);
- if (cborFindResult != CborNoError)
- {
- goto cbor_error;
- }
- if (OC_STACK_OK != OCTagsCborToPayload(&tags, &tagsPayload))
- {
- OCFreeTagsResource(tagsPayload);
- goto cbor_error;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed entering tags container.");
+
+ cborFindResult= OCTagsCborToPayload(&tags, &tagsPayload);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed parsing tags payload.");
OCTagsLog(DEBUG, tagsPayload);
- if (OC_STACK_OK != OCLinksCborToPayload(&tags, &linksPayload))
- {
- OCFreeLinksResource(linksPayload);
- OCFreeTagsResource(tagsPayload);
- goto cbor_error;
- }
+
+ cborFindResult = OCLinksCborToPayload(&tags, &linksPayload);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed parsing links payload.");
OCLinksLog(DEBUG, linksPayload);
+
// Move from tags payload to links array.
- if (CborNoError != cbor_value_advance(rdCBORPayload))
- {
- OIC_LOG(DEBUG, TAG, "Failed advancing from tags payload to links.");
- OCFreeLinksResource(linksPayload);
- OCFreeTagsResource(tagsPayload);
- goto cbor_error;
- }
+ cborFindResult = cbor_value_advance(rdCBORPayload);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing rdCborPayload.");
}
rdPayload->rdPublish = OCCopyCollectionResource(tagsPayload, linksPayload);
- if (!rdPayload->rdPublish)
- {
- goto cbor_error;
- }
+ VERIFY_PARAM_NON_NULL(TAG, rdPayload->rdPublish, "Failed allocating rdPayload->rdPublish");
}
else if (cbor_value_is_map(rdCBORPayload))
{
- char *name = NULL;
- if (CborNoError != FindStringInMap(rdCBORPayload, OC_RSRVD_DEVICE_NAME, &name))
- {
- goto cbor_error;
- }
- char *id = NULL;
- if (CborNoError != FindStringInMap(rdCBORPayload, OC_RSRVD_DEVICE_ID, &id))
- {
- goto cbor_error;
- }
- uint64_t biasFactor = 0;
- if (CborNoError != FindIntInMap(rdCBORPayload, OC_RSRVD_RD_DISCOVERY_SEL, &biasFactor))
- {
- goto cbor_error;
- }
- rdPayload->rdDiscovery = OCRDDiscoveryPayloadCreate(name, id, (uint8_t)biasFactor);
- if (!rdPayload->rdDiscovery)
- {
- goto no_memory;
- }
- OICFree(id);
- OICFree(name);
+ rdPayload->rdDiscovery = (OCRDDiscoveryPayload *)OICCalloc(1, sizeof(OCRDDiscoveryPayload));
+ VERIFY_PARAM_NON_NULL(TAG, rdPayload->rdDiscovery, "Failed allocating discoveryPayload");
+
+ cborFindResult = FindStringInMap(rdCBORPayload, OC_RSRVD_DEVICE_NAME,
+ &rdPayload->rdDiscovery->n.deviceName);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding OC_RSRVD_DEVICE_NAME.");
+ cborFindResult = FindStringInMap(rdCBORPayload, OC_RSRVD_DEVICE_ID,
+ &rdPayload->rdDiscovery->n.deviceName);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding OC_RSRVD_DEVICE_ID.");
+
+ cborFindResult = FindIntInMap(rdCBORPayload, OC_RSRVD_RD_DISCOVERY_SEL,
+ (uint64_t *)&rdPayload->rdDiscovery->sel);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding OC_RSRVD_RD_DISCOVERY_SEL.");
+
cborFindResult = cbor_value_advance(rdCBORPayload);
- if (CborNoError != cborFindResult)
- {
- goto cbor_error;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing rdCBORPayload.");
}
OIC_LOG_PAYLOAD(DEBUG, (OCPayload *) rdPayload);
*outPayload = (OCPayload *)rdPayload;
return OC_STACK_OK;
-no_memory:
- OIC_LOG(ERROR, TAG, "Failed allocating memory.");
- OCRDPayloadDestroy(rdPayload);
- return OC_STACK_NO_MEMORY;
-cbor_error:
+exit:
OCRDPayloadDestroy(rdPayload);
- return OC_STACK_ERROR;
+ return ret;
}
static CborError FindStringInMap(CborValue *map, char *tags, char **value)
{
CborValue curVal;
- size_t len;
CborError cborFindResult = cbor_value_map_find_value(map, tags, &curVal);
if (CborNoError == cborFindResult && cbor_value_is_text_string(&curVal))
{
+ size_t len = 0;
cborFindResult = cbor_value_dup_text_string(&curVal, value, &len, NULL);
- if (CborNoError != cborFindResult)
- {
- OIC_LOG_V(ERROR, TAG, "Failed finding value for tag %s .", tags);
- return cborFindResult;
- }
}
- return CborNoError;
+ return cborFindResult;
}
static CborError FindIntInMap(CborValue *map, char *tags, uint64_t *value)
if (CborNoError == cborFindResult && cbor_value_is_unsigned_integer(&curVal))
{
cborFindResult = cbor_value_get_uint64(&curVal, value);
- if (CborNoError != cborFindResult)
- {
- OIC_LOG_V(ERROR, TAG, "Failed finding value for tag %s .", tags);
- return cborFindResult;
- }
}
- return CborNoError;
+ return cborFindResult;
}
static CborError FindStringLLInMap(const CborValue *linksMap, char *tag, OCStringLL **links)
{
size_t len;
- CborError cborFindResult;
CborValue rtArray;
- cborFindResult = cbor_value_map_find_value(linksMap, tag, &rtArray);
- if (CborNoError != cborFindResult)
- {
- return CborUnknownError;
- }
+ OCStringLL* llPtr = *links;
+ CborError cborFindResult = cbor_value_map_find_value(linksMap, tag, &rtArray);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding tag");
+
CborValue rtVal;
cborFindResult = cbor_value_enter_container(&rtArray, &rtVal);
- if (CborNoError != cborFindResult)
- {
- return CborUnknownError;
- }
- OCStringLL* llPtr = *links;
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed entering container");
+
while (cbor_value_is_text_string(&rtVal))
{
if (llPtr == NULL)
{
llPtr = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
- if (!llPtr)
- {
- return CborUnknownError;
- }
+ VERIFY_PARAM_NON_NULL(TAG, llPtr, "Failed allocating OCStringLL");
*links = llPtr;
}
else if(llPtr)
llPtr = llPtr->next;
}
llPtr->next = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
- if (!llPtr->next)
- {
- return CborUnknownError;
- }
+ VERIFY_PARAM_NON_NULL(TAG, llPtr->next, "Failed allocating OCStringLL->next");
}
cborFindResult = cbor_value_dup_text_string(&rtVal, &(llPtr->value), &len, NULL);
- if (CborNoError != cborFindResult)
- {
- return CborUnknownError;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed duplicating value");
cborFindResult = cbor_value_advance(&rtVal);
- if (CborNoError != cborFindResult)
- {
- return CborUnknownError;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing OCStringLL");
}
cborFindResult = cbor_value_leave_container(&rtArray, &rtVal);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed leaving container");
+
+exit:
return cborFindResult;
}
-OCStackResult OCTagsCborToPayload(CborValue *tagsMap, OCTagsPayload **tagsPayload)
+static CborError OCTagsCborToPayload(CborValue *tagsMap, OCTagsPayload **tagsPayload)
{
+ CborError cborFindResult = CborErrorOutOfMemory;
OCTagsPayload *tags = (OCTagsPayload *)OICCalloc(1, sizeof(OCTagsPayload));
- if (!tags)
- {
- return OC_STACK_NO_MEMORY;
- }
+ VERIFY_PARAM_NON_NULL(TAG, tags, "Failed allocating tags");
+
if (cbor_value_is_map(tagsMap))
{
- if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_DEVICE_NAME, &tags->n.deviceName))
- {
- OCFreeTagsResource(tags);
- return OC_STACK_ERROR;
- }
- if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_DREL, &tags->drel))
- {
- OCFreeTagsResource(tags);
- return OC_STACK_ERROR;
- }
- if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_RTS, &tags->rts))
- {
- OCFreeTagsResource(tags);
- return OC_STACK_ERROR;
- }
- if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_BASE_URI, &tags->baseURI))
- {
- OCFreeTagsResource(tags);
- return OC_STACK_ERROR;
- }
- char *id = NULL;
- if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_DEVICE_ID, &id))
- {
- OCFreeTagsResource(tags);
- return OC_STACK_ERROR;
- }
- if (id)
- {
- OICStrcpy((char*)tags->di.id, MAX_IDENTITY_SIZE, id);
- tags->di.id_length = MAX_IDENTITY_SIZE;
- OICFree(id);
- }
- uint64_t temp;
- if (CborNoError != FindIntInMap(tagsMap, OC_RSRVD_HOSTING_PORT, &temp))
- {
- OCFreeTagsResource(tags);
- return OC_STACK_ERROR;
- }
- tags->port = (uint16_t) temp;
- if (CborNoError != FindIntInMap(tagsMap, OC_RSRVD_BITMAP, &temp))
- {
- OCFreeTagsResource(tags);
- return OC_STACK_ERROR;
- }
- tags->bitmap = (uint8_t) temp;
- if (CborNoError != FindIntInMap(tagsMap, OC_RSRVD_INS, &temp))
- {
- OCFreeTagsResource(tags);
- return OC_STACK_ERROR;
- }
- tags->ins = (uint8_t) temp;
- if (CborNoError != FindIntInMap(tagsMap, OC_RSRVD_TTL, &temp))
- {
- OCFreeTagsResource(tags);
- return OC_STACK_ERROR;
- }
- tags->ttl = (uint32_t) temp;
-
- if (CborNoError != cbor_value_advance(tagsMap))
- {
- OCFreeTagsResource(tags);
- return OC_STACK_ERROR;
- }
+ cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_DEVICE_NAME, &tags->n.deviceName);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding deviceName");
+ cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_DREL, &tags->drel);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding drel");
+ cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_RTS, &tags->rts);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding rts");
+ cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_BASE_URI, &tags->baseURI);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding baseURI");
+ cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_DEVICE_ID, (char **) &tags->di.id);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding deviceId");
+ cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_HOSTING_PORT, (uint64_t *)&tags->port);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding port");
+ cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_BITMAP, (uint64_t *)&tags->bitmap);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding bitmap");
+ cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_INS, (uint64_t *)&tags->ins);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding ins");
+ cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_TTL, (uint64_t *)&tags->ttl);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding ttl");
+ cborFindResult = cbor_value_advance(tagsMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing bitmap");
}
*tagsPayload = tags;
- return OC_STACK_OK;
+ return cborFindResult;
+
+exit:
+ OCFreeTagsResource(tags);
+ return cborFindResult;
}
-OCStackResult OCLinksCborToPayload(CborValue *linksArray, OCLinksPayload **linksPayload)
+static CborError OCLinksCborToPayload(CborValue *linksArray, OCLinksPayload **linksPayload)
{
CborValue linksMap;
+ OCLinksPayload *setLinks = NULL;
CborError cborFindResult = cbor_value_enter_container(linksArray, &linksMap);
- if (CborNoError != cborFindResult)
- {
- OIC_LOG(ERROR, TAG, "Failed enter links map");
- return OC_STACK_ERROR;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed entering links map container");
while (cbor_value_is_map(&linksMap))
{
- OCLinksPayload *setLinks = (OCLinksPayload *)OICCalloc(1, sizeof(OCLinksPayload));
- if (!setLinks)
- {
- OIC_LOG(ERROR, TAG, "Failed allocating memory.");
- OCFreeLinksResource(*linksPayload);
- return OC_STACK_NO_MEMORY;
- }
+ setLinks = (OCLinksPayload *)OICCalloc(1, sizeof(OCLinksPayload));
+ VERIFY_PARAM_NON_NULL(TAG, setLinks, "Failed allocating setLinks");
+
cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_HREF, &setLinks->href);
- if (CborNoError != cborFindResult)
- {
- OCFreeLinksResource(*linksPayload);
- OCFreeLinksResource(setLinks);
- return OC_STACK_ERROR;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding href value");
+
cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_REL, &setLinks->rel);
- if (CborNoError != cborFindResult)
- {
- OCFreeLinksResource(*linksPayload);
- OCFreeLinksResource(setLinks);
- return OC_STACK_ERROR;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding rel value");
cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_TITLE, &setLinks->title);
- if (CborNoError != cborFindResult)
- {
- OCFreeLinksResource(*linksPayload);
- OCFreeLinksResource(setLinks);
- return OC_STACK_ERROR;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding title value");
+
cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_URI, &setLinks->uri);
- if (CborNoError != cborFindResult)
- {
- OCFreeLinksResource(*linksPayload);
- OCFreeLinksResource(setLinks);
- return OC_STACK_ERROR;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding uri value");
+
cborFindResult = FindStringLLInMap(&linksMap, OC_RSRVD_RESOURCE_TYPE, &setLinks->rt);
- if (CborNoError != cborFindResult)
- {
- OCFreeLinksResource(*linksPayload);
- OCFreeLinksResource(setLinks);
- return OC_STACK_ERROR;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding rt value");
+
cborFindResult = FindStringLLInMap(&linksMap, OC_RSRVD_INTERFACE, &setLinks->itf);
- if (CborNoError != cborFindResult)
- {
- OCFreeLinksResource(*linksPayload);
- OCFreeLinksResource(setLinks);
- return OC_STACK_ERROR;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding itf value");
+
cborFindResult = FindStringLLInMap(&linksMap, OC_RSRVD_MEDIA_TYPE, &setLinks->mt);
- if (CborNoError != cborFindResult)
- {
- OCFreeLinksResource(*linksPayload);
- OCFreeLinksResource(setLinks);
- return OC_STACK_ERROR;
- }
- uint64_t temp;
- cborFindResult = FindIntInMap(&linksMap, OC_RSRVD_INS, &temp);
- if (CborNoError != cborFindResult)
- {
- OCFreeLinksResource(*linksPayload);
- OCFreeLinksResource(setLinks);
- return OC_STACK_ERROR;
- }
- setLinks->ins = (uint8_t) temp;
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding mt value");
+
+ cborFindResult = FindIntInMap(&linksMap, OC_RSRVD_INS, (uint64_t *) &setLinks->ins);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding ins value");
if (!*linksPayload)
{
temp->next = setLinks;
}
cborFindResult = cbor_value_advance(&linksMap);
- if (CborNoError != cborFindResult)
- {
- OIC_LOG(ERROR, TAG, "Failed advancing links map");
- OCFreeLinksResource(*linksPayload);
- OCFreeLinksResource(setLinks);
- return OC_STACK_ERROR;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing links map");
}
- return OC_STACK_OK;
+
+ return cborFindResult;
+
+exit:
+ OCFreeLinksResource(*linksPayload);
+ OCFreeLinksResource(setLinks);
+ return cborFindResult;
}
-static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
+static CborError AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
const char* value)
{
- return cbor_encode_text_string(map, key, keylen) |
- cbor_encode_text_string(map, value, strlen(value));
+ CborError err = cbor_encode_text_string(map, key, keylen);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting key value");
+ err = cbor_encode_text_string(map, value, strlen(value));
+exit:
+ return err;
}
-static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
+static CborError ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
const char* value)
{
- return value ? AddTextStringToMap(map, key, keylen, value) : 0;
+ return value ? AddTextStringToMap(map, key, keylen, value) : CborNoError;
}
-static int64_t ConditionalAddIntToMap(CborEncoder *map, const char *tags, const size_t size,
+static CborError ConditionalAddIntToMap(CborEncoder *map, const char *tags, const size_t size,
const uint64_t *value)
{
- return (*value) ? (cbor_encode_text_string(map, tags, size) |
- cbor_encode_uint(map, *value)): 0;
+ CborError err = CborUnknownError;
+ if (*value)
+ {
+ err = cbor_encode_text_string(map, tags, size);
+ VERIFY_CBOR_SUCCESS(TAG, err, "failed setting value");
+ err = cbor_encode_uint(map, *value);
+ }
+exit:
+ return err;
}
-static int64_t AddStringLLToMap(CborEncoder *map, char *tag, const size_t size, OCStringLL *value)
+static CborError AddStringLLToMap(CborEncoder *map, char *tag, const size_t size, OCStringLL *value)
{
CborEncoder array;
CborError cborEncoderResult;
+ OCStringLL *strType = value;
cborEncoderResult = cbor_encode_text_string(map, tag, size);
- if (CborNoError != cborEncoderResult)
- {
- return cborEncoderResult;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed encoding string tag name");
cborEncoderResult = cbor_encoder_create_array(map, &array, CborIndefiniteLength);
- if (CborNoError != cborEncoderResult)
- {
- return cborEncoderResult;
- }
- OCStringLL *strType = value;
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed creating stringLL array");
while (strType)
{
cborEncoderResult = cbor_encode_text_string(&array, strType->value, strlen(strType->value));
- if (CborNoError != cborEncoderResult)
- {
- return cborEncoderResult;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed encoding string value");
strType = strType->next;
}
cborEncoderResult = cbor_encoder_close_container(map, &array);
- if (CborNoError != cborEncoderResult)
- {
- return cborEncoderResult;
- }
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing string array");
+exit:
return cborEncoderResult;
}
OCRDPayload *OCRDPayloadCreate()
{
OCRDPayload *rdPayload = (OCRDPayload *)OICCalloc(1, sizeof(OCRDPayload));
-
- if (!rdPayload)
- {
- return NULL;
- }
-
+ VERIFY_PARAM_NON_NULL(TAG, rdPayload, "Failed allocating rdPayload");
rdPayload->base.type = PAYLOAD_TYPE_RD;
+exit:
return rdPayload;
}
OCRDDiscoveryPayload *OCRDDiscoveryPayloadCreate(const char *deviceName, const char *id, int biasFactor)
{
OCRDDiscoveryPayload *discoveryPayload = (OCRDDiscoveryPayload *)OICCalloc(1, sizeof(OCRDDiscoveryPayload));
-
- if (!discoveryPayload)
- {
- return NULL;
- }
+ VERIFY_PARAM_NON_NULL(TAG, discoveryPayload, "Failed allocating memory for discovery payload");
if (deviceName)
{
discoveryPayload->n.deviceName = OICStrdup(deviceName);
- if (!discoveryPayload->n.deviceName)
- {
- OICFree(discoveryPayload);
- return NULL;
- }
+ VERIFY_PARAM_NON_NULL(TAG, discoveryPayload->n.deviceName,
+ "Failed allocating memory for discovery device name");
}
if (id)
{
}
discoveryPayload->sel = biasFactor;
-
+ return discoveryPayload;
+exit:
+ OICFree(discoveryPayload);
+ discoveryPayload = NULL;
return discoveryPayload;
}
OCResourceCollectionPayload* OCCopyCollectionResource(OCTagsPayload *tags, OCLinksPayload *links)
{
- if (!tags || !links)
- {
- return NULL;
- }
- OCResourceCollectionPayload *pl = (OCResourceCollectionPayload *)OICCalloc(1, sizeof(OCResourceCollectionPayload));
- if(!pl)
- {
- OIC_LOG(ERROR, TAG, "Failed allocating memory for the OCResourceCollectionPayload.");
- return NULL;
- }
+ OCResourceCollectionPayload *pl = NULL;
+ VERIFY_PARAM_NON_NULL(TAG, tags, "Invalid param tags");
+ VERIFY_PARAM_NON_NULL(TAG, links, "Invalid param links");
+
+ pl = (OCResourceCollectionPayload *)OICCalloc(1, sizeof(OCResourceCollectionPayload));
+ VERIFY_PARAM_NON_NULL(TAG, pl, "Failed allocating memory for the OCResourceCollectionPayload");
+
pl->tags = tags;
pl->setLinks = links;
+exit:
return pl;
}
#include <ocpayloadcbor.h>
#include <oic_malloc.h>
#include <oic_string.h>
+#include "payload_logging.h"
namespace OC
{
payload->sid = (uint8_t*)OICMalloc(16);
payload->resources = resource;
- OCResourcePayloadAddResourceType(resource, "rt.singleitem");
- OCResourcePayloadAddInterface(resource, "if.singleitem");
+ EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem"));
+ EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem"));
+
resource->uri = OICStrdup("/uri/thing");
uint8_t* cborData;
OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
EXPECT_EQ(NULL, parsedResource->next);
-
- EXPECT_EQ(NULL, parsedResource->types->next);
EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
+ EXPECT_EQ(NULL, parsedResource->types->next);
EXPECT_EQ(NULL, parsedResource->interfaces->next);
EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
payload->resources = resource;
- OCResourcePayloadAddResourceType(resource, " rt.singleitem");
- OCResourcePayloadAddInterface(resource, " if.singleitem");
+ EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem"));
+ EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, " if.singleitem"));
resource->uri = OICStrdup("/uri/thing");
uint8_t* cborData;
OCPayloadDestroy(cparsed);
OCDiscoveryPayloadDestroy(payload);
}
+
TEST(DiscoveryRTandIF, SingleItemBackTrim)
{
OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
payload->resources = resource;
- OCResourcePayloadAddResourceType(resource, "rt.singleitem ");
- OCResourcePayloadAddInterface(resource, "if.singleitem ");
+ OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem ");
+ OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem ");
resource->uri = OICStrdup("/uri/thing");
uint8_t* cborData;
OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
payload->resources = resource;
- OCResourcePayloadAddResourceType(resource, " rt.singleitem ");
- OCResourcePayloadAddInterface(resource, " if.singleitem ");
+ OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem ");
+ OCResourcePayloadAddStringLL(&resource->interfaces, " if.singleitem ");
resource->uri = OICStrdup("/uri/thing");
uint8_t* cborData;
OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
payload->resources = resource;
- OCResourcePayloadAddResourceType(resource, "rt.firstitem");
- OCResourcePayloadAddResourceType(resource, "rt.seconditem");
- OCResourcePayloadAddInterface(resource, "if.firstitem");
- OCResourcePayloadAddInterface(resource, "if.seconditem");
+ OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem");
+ OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem");
+ OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem");
+ OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem");
resource->uri = OICStrdup("/uri/thing");
uint8_t* cborData;
OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
payload->resources = resource;
- OCResourcePayloadAddResourceType(resource, " rt.firstitem");
- OCResourcePayloadAddResourceType(resource, " rt.seconditem");
- OCResourcePayloadAddInterface(resource, " if.firstitem");
- OCResourcePayloadAddInterface(resource, " if.seconditem");
+ OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem");
+ OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem");
+ OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem");
+ OCResourcePayloadAddStringLL(&resource->interfaces, " if.seconditem");
resource->uri = OICStrdup("/uri/thing");
uint8_t* cborData;
OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
payload->resources = resource;
- OCResourcePayloadAddResourceType(resource, "rt.firstitem ");
- OCResourcePayloadAddResourceType(resource, "rt.seconditem ");
- OCResourcePayloadAddInterface(resource, "if.firstitem ");
- OCResourcePayloadAddInterface(resource, "if.seconditem ");
+ OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem ");
+ OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem ");
+ OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem ");
+ OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem ");
resource->uri = OICStrdup("/uri/thing");
uint8_t* cborData;
OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
payload->resources = resource;
- OCResourcePayloadAddResourceType(resource, " rt.firstitem ");
- OCResourcePayloadAddResourceType(resource, " rt.seconditem ");
- OCResourcePayloadAddInterface(resource, " if.firstitem ");
- OCResourcePayloadAddInterface(resource, " if.seconditem ");
+ OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem ");
+ OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem ");
+ OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem ");
+ OCResourcePayloadAddStringLL(&resource->interfaces, " if.seconditem ");
resource->uri = OICStrdup("/uri/thing");
uint8_t* cborData;
EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
EXPECT_EQ(NULL, parsedPayload->interfaces->next);
-
OICFree(cborData);
OCRepPayloadDestroy(payload);
OCPayloadDestroy(cparsed);
projects / contrib / iotivity.git / commitdiff