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 CborError OCParseSingleRepPayload(OCRepPayload **outPayload, CborValue *repParent, bool isRoot);
static OCStackResult OCParseRepPayload(OCPayload **outPayload, CborValue *arrayVal);
static OCStackResult OCParsePresencePayload(OCPayload **outPayload, CborValue *arrayVal);
-static OCStackResult OCParseSecurityPayload(OCPayload **outPayload, CborValue * rrayVal);
+static OCStackResult OCParseSecurityPayload(OCPayload **outPayload, const uint8_t *payload, size_t size);
OCStackResult OCParsePayload(OCPayload **outPayload, OCPayloadType payloadType,
const uint8_t *payload, size_t payloadSize)
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);
+ OIC_LOG_V(INFO, TAG, "CBOR Parsing size: %zu of Payload Type: %d, Payload:",
+ payloadSize, payloadType);
+ OIC_LOG_BUFFER(DEBUG, TAG, payload, payloadSize);
CborParser parser;
CborValue rootValue;
result = OCParsePresencePayload(outPayload, &rootValue);
break;
case PAYLOAD_TYPE_SECURITY:
- result = OCParseSecurityPayload(outPayload, &rootValue);
+ result = OCParseSecurityPayload(outPayload, payload, payloadSize);
break;
case PAYLOAD_TYPE_RD:
result = OCRDCborToPayload(&rootValue, outPayload);
void OCFreeOCStringLL(OCStringLL* ll);
-static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* rootValue)
+static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, const uint8_t *payload,
+ size_t size)
{
- OCStackResult ret = OC_STACK_MALFORMED_RESPONSE;
- CborError err;
- char *securityData = NULL;
-
- 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);
- VERIFY_CBOR_SUCCESS(TAG, err, "Failed entering container");
- if (cbor_value_is_text_string(&strVal))
+ if (size > 0)
{
- 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;
+ *outPayload = (OCPayload *)OCSecurityPayloadCreate(payload, size);
}
-
-exit:
- OICFree(securityData);
- return ret;
-
+ else
+ {
+ *outPayload = NULL;
+ }
+ return OC_STACK_OK;
}
static char* InPlaceStringTrim(char* str)
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))
+ if (cbor_value_is_array(&val))
{
- char *input = NULL;
- char *savePtr = NULL;
- size_t len = 0;
-
- err = cbor_value_dup_text_string(&val, &input, &len, NULL);
- VERIFY_CBOR_SUCCESS(TAG, err, "to find StringLL value");
-
- if (input)
+ CborValue txtStr;
+ err = cbor_value_enter_container(&val, &txtStr);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to enter container");
+ while (cbor_value_is_text_string(&txtStr))
{
- char *curPtr = strtok_r(input, " ", &savePtr);
- while (curPtr)
+ size_t len = 0;
+ char *input = NULL;
+ err = cbor_value_dup_text_string(&txtStr, &input, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find StringLL value.");
+ if (input)
{
- char *trimmed = InPlaceStringTrim(curPtr);
- if (trimmed[0] !='\0')
+ char *savePtr = NULL;
+ char *curPtr = strtok_r(input, " ", &savePtr);
+ while (curPtr)
{
- if (!OCResourcePayloadAddStringLL(resource, trimmed))
+ char *trimmed = InPlaceStringTrim(curPtr);
+ if (trimmed[0] !='\0')
{
- return CborErrorOutOfMemory;
+ if (!OCResourcePayloadAddStringLL(resource, trimmed))
+ {
+ return CborErrorOutOfMemory;
+ }
}
+ curPtr = strtok_r(NULL, " ", &savePtr);
}
- curPtr = strtok_r(NULL, " ", &savePtr);
+ OICFree(input);
+ }
+ if (cbor_value_is_text_string(&txtStr))
+ {
+ err = cbor_value_advance(&txtStr);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to advance string value");
}
- OICFree(input);
}
}
exit:
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;
- ret = OC_STACK_NO_MEMORY;
- out = OCDiscoveryPayloadCreate();
- VERIFY_PARAM_NON_NULL(TAG, out, "Failed error initializing discovery payload");
-
- // Enter the main root map
- 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;
- err = cbor_value_map_find_value(&rootMap, OC_RSRVD_DEVICE_ID, &curVal);
- VERIFY_CBOR_SUCCESS(TAG, err, "to find device id tag");
+ if (cbor_value_is_array(rootValue))
{
- err = cbor_value_dup_byte_string(&curVal, &(out->sid), &len, NULL);
- VERIFY_CBOR_SUCCESS(TAG, err, "to copy device id value");
- }
-
- // BaseURI - Not a mandatory field
- err = cbor_value_map_find_value(&rootMap, OC_RSRVD_BASE_URI, &curVal);
- if (cbor_value_is_valid(&curVal))
- {
- err = cbor_value_dup_text_string(&curVal, &(out->baseURI), &len, NULL);
- VERIFY_CBOR_SUCCESS(TAG, err, "to find base uri value");
- }
+ // Root value is already inside the main root array
+ CborValue rootMap;
+ ret = OC_STACK_NO_MEMORY;
+ out = OCDiscoveryPayloadCreate();
+ VERIFY_PARAM_NON_NULL(TAG, out, "Failed error initializing discovery payload");
- // Look for Links which will have an array as the value
- CborValue linkMap;
- err = cbor_value_map_find_value(&rootMap, OC_RSRVD_LINKS, &linkMap);
- VERIFY_CBOR_SUCCESS(TAG, err, "to find links tag");
+ // Enter the main root map
+ ret = OC_STACK_MALFORMED_RESPONSE;
+ err = cbor_value_enter_container(rootValue, &rootMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to enter root map container");
- // Enter the links array and start iterating through the array processing
- // each resource which shows up as a map.
- CborValue resourceMap;
- err = cbor_value_enter_container(&linkMap, &resourceMap);
- VERIFY_CBOR_SUCCESS(TAG, err, "to enter link map");
+ // Look for DI
+ CborValue curVal;
+ if (!cbor_value_is_map(&rootMap))
+ {
+ OIC_LOG(ERROR, TAG, "Malformed packet!!");
+ goto exit;
+ }
+ err = cbor_value_map_find_value(&rootMap, OC_RSRVD_DEVICE_ID, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find device id tag");
+ if (cbor_value_is_valid(&curVal))
+ {
+ if (cbor_value_is_byte_string(&curVal))
+ {
+ err = cbor_value_dup_byte_string(&curVal, (uint8_t **)&(out->sid), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to copy device id value");
+ }
+ else if (cbor_value_is_text_string(&curVal))
+ {
+ err = cbor_value_dup_text_string(&curVal, &(out->sid), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to copy device id value");
+ }
+ }
- while (cbor_value_is_map(&resourceMap))
- {
- resource = (OCResourcePayload *)OICCalloc(1, sizeof(OCResourcePayload));
- VERIFY_PARAM_NON_NULL(TAG, resource, "Failed allocating resource payload");
+ // BaseURI - Not a mandatory field
+ err = cbor_value_map_find_value(&rootMap, OC_RSRVD_BASE_URI, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find uri tag");
+ if (cbor_value_is_valid(&curVal))
+ {
+ err = cbor_value_dup_text_string(&curVal, &(out->baseURI), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find base uri value");
+ }
- // Uri
- 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");
+ // HREF - Not a mandatory field
+ err = cbor_value_map_find_value(&rootMap, OC_RSRVD_HREF, &curVal);
+ if (cbor_value_is_valid(&curVal))
+ {
+ err = cbor_value_dup_text_string(&curVal, &(out->uri), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find uri value");
+ }
- // ResourceTypes
- err = OCParseStringLL(&resourceMap, OC_RSRVD_RESOURCE_TYPE, &resource->types);
- VERIFY_CBOR_SUCCESS(TAG, err, "to find resource type tag/value");
+ // RT - Not a mandatory field
+ err = cbor_value_map_find_value(&rootMap, OC_RSRVD_RESOURCE_TYPE, &curVal);
+ if (cbor_value_is_valid(&curVal))
+ {
+ err = cbor_value_dup_text_string(&curVal, &(out->type), &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find base uri value");
+ }
- // Interface Types
- err = OCParseStringLL(&resourceMap, OC_RSRVD_INTERFACE, &resource->interfaces);
- VERIFY_CBOR_SUCCESS(TAG, err, "to find interface tag/value");
-
- // Policy
- CborValue policyMap;
- err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_POLICY, &policyMap);
- VERIFY_CBOR_SUCCESS(TAG, err, "to find policy tag");
-
- // Bitmap
- 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, &curVal);
+ // IF - Not a mandatory field
+ err = cbor_value_map_find_value(&rootMap, OC_RSRVD_INTERFACE, &curVal);
if (cbor_value_is_valid(&curVal))
{
- err = cbor_value_get_boolean(&curVal, &(resource->secure));
- VERIFY_CBOR_SUCCESS(TAG, err, "to find secure value");
+ err = OCParseStringLL(&rootMap, OC_RSRVD_INTERFACE, &out->interface);
+ }
+ if (!out->interface)
+ {
+ if (!OCResourcePayloadAddStringLL(&out->interface, OC_RSRVD_INTERFACE_LL))
+ {
+ err = CborErrorOutOfMemory;
+ }
}
- // Port
- err = cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT, &curVal);
+ // Name - Not a mandatory field
+ err = cbor_value_map_find_value(&rootMap, OC_RSRVD_DEVICE_NAME, &curVal);
if (cbor_value_is_valid(&curVal))
{
- err = cbor_value_get_int(&curVal, (int *)&resource->port);
- VERIFY_CBOR_SUCCESS(TAG, err, "to find port value");
+ err = cbor_value_dup_text_string(&curVal, &out->name, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find device name");
}
- err = cbor_value_advance(&resourceMap);
- VERIFY_CBOR_SUCCESS(TAG, err, "to advance resource map");
+ // Look for Links which will have an array as the value
+ CborValue linkMap;
+ err = cbor_value_map_find_value(&rootMap, OC_RSRVD_LINKS, &linkMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find links tag");
- OCDiscoveryPayloadAddNewResource(out, resource);
- }
+ // Enter the links array and start iterating through the array processing
+ // each resource which shows up as a map.
+ CborValue resourceMap;
+ err = cbor_value_enter_container(&linkMap, &resourceMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to enter link map");
- err = cbor_value_leave_container(rootValue, &resourceMap);
- VERIFY_CBOR_SUCCESS(TAG, err, "to advance resource map");
+ while (cbor_value_is_map(&resourceMap))
+ {
+ resource = (OCResourcePayload *)OICCalloc(1, sizeof(OCResourcePayload));
+ VERIFY_PARAM_NON_NULL(TAG, resource, "Failed allocating resource payload");
+
+ // Uri
+ 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");
+
+ // ResourceTypes
+ err = OCParseStringLL(&resourceMap, OC_RSRVD_RESOURCE_TYPE, &resource->types);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find resource type tag/value");
+
+ // Interface Types
+ err = OCParseStringLL(&resourceMap, OC_RSRVD_INTERFACE, &resource->interfaces);
+ if (CborNoError != err)
+ {
+ if (!OCResourcePayloadAddStringLL(&resource->interfaces, OC_RSRVD_INTERFACE_LL))
+ {
+ OIC_LOG(ERROR, TAG, "Failed to add string to StringLL");
+ goto exit;
+ }
+ }
+
+ // Policy
+ CborValue policyMap;
+ err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_POLICY, &policyMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find policy tag");
+
+ // Bitmap
+ 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, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find secure tag");
+ if (cbor_value_is_valid(&curVal))
+ {
+ err = cbor_value_get_boolean(&curVal, &(resource->secure));
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find secure value");
+ }
+
+ // Port
+ err = cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find port tag");
+ if (cbor_value_is_valid(&curVal))
+ {
+ err = cbor_value_get_int(&curVal, (int *)&resource->port);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find port value");
+ }
+
+#ifdef TCP_ADAPTER
+ // TCP Port
+ err = cbor_value_map_find_value(&policyMap, OC_RSRVD_TCP_PORT, &curVal);
+ if (cbor_value_is_valid(&curVal))
+ {
+ err = cbor_value_get_int(&curVal, (int *)&resource->tcpPort);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find tcp port value");
+ }
+#endif
+
+ err = cbor_value_advance(&resourceMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to advance resource map");
+
+ OCDiscoveryPayloadAddNewResource(out, resource);
+ }
+
+ err = cbor_value_leave_container(rootValue, &resourceMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to advance resource map");
+ }
+ else
+ {
+ OIC_LOG(ERROR, TAG, "Malformed packet ");
+ goto exit;
+ }
*outPayload = (OCPayload *)out;
+ OIC_LOG_PAYLOAD(DEBUG, *outPayload);
+
return OC_STACK_OK;
exit:
if (cbor_value_is_map(rootValue))
{
+ CborValue curVal;
+ // Resource Type
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_RESOURCE_TYPE, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find resource type tag");
+
+ if (cbor_value_is_valid(&curVal))
+ {
+ err = OCParseStringLL(rootValue, OC_RSRVD_RESOURCE_TYPE, &out->types);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find rt type tag/value");
+ }
+
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_INTERFACE, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find interface tag");
+ if (cbor_value_is_valid(&curVal))
+ {
+ err = OCParseStringLL(rootValue, OC_RSRVD_INTERFACE, &out->interfaces);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find interfaces tag/value");
+ }
// Device ID
size_t len = 0;
- CborValue curVal;
err = cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_ID, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find device id tag");
if (cbor_value_is_valid(&curVal))
{
- err = cbor_value_dup_byte_string(&curVal, &out->sid, &len, NULL);
- VERIFY_CBOR_SUCCESS(TAG, err, "to find device id in device payload");
+ if (cbor_value_is_byte_string(&curVal))
+ {
+ err = cbor_value_dup_byte_string(&curVal, (uint8_t **)&out->sid, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find device id in device payload");
+ }
+ else if (cbor_value_is_text_string(&curVal))
+ {
+ err = cbor_value_dup_text_string(&curVal, &out->sid, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find device id in device payload");
+ }
}
// Device Name
err = cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_NAME, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find device name tag");
if (cbor_value_is_valid(&curVal))
{
err = cbor_value_dup_text_string(&curVal, &out->deviceName, &len, NULL);
}
// Device Spec Version
err = cbor_value_map_find_value(rootValue, OC_RSRVD_SPEC_VERSION, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find spec ver tag");
if (cbor_value_is_valid(&curVal))
{
err = cbor_value_dup_text_string(&curVal, &out->specVersion, &len, NULL);
}
// Data Model Version
err = cbor_value_map_find_value(rootValue, OC_RSRVD_DATA_MODEL_VERSION, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find data model ver tag");
if (cbor_value_is_valid(&curVal))
{
err = cbor_value_dup_text_string(&curVal, &out->dataModelVersion, &len, NULL);
OCStackResult ret = OC_STACK_INVALID_PARAM;
CborError err = CborNoError;
OCPlatformInfo info = {0};
+ OCStringLL* rt = NULL;
+ OCStringLL* interfaces = NULL;
+ OCPlatformPayload* out = NULL;
VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
// Platform ID
err = cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_ID, &repVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find platform id tag");
if (cbor_value_is_valid(&repVal))
{
err = cbor_value_dup_text_string(&repVal, &(info.platformID), &len, NULL);
}
// MFG Name
err = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_NAME, &repVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find mfg name tag");
if (cbor_value_is_valid(&repVal))
{
err = cbor_value_dup_text_string(&repVal, &(info.manufacturerName), &len, NULL);
}
// MFG URL
err = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_URL, &repVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find mfg url tag");
if (cbor_value_is_valid(&repVal))
{
err = cbor_value_dup_text_string(&repVal, &(info.manufacturerUrl), &len, NULL);
}
// Model Num
err = cbor_value_map_find_value(rootValue, OC_RSRVD_MODEL_NUM, &repVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find model num tag");
if (cbor_value_is_valid(&repVal))
{
err = cbor_value_dup_text_string(&repVal, &(info.modelNumber), &len, NULL);
}
// Date of Mfg
err = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_DATE, &repVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find mfg date tag");
if (cbor_value_is_valid(&repVal))
{
err = cbor_value_dup_text_string(&repVal, &(info.dateOfManufacture), &len, NULL);
}
// Platform Version
err = cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_VERSION, &repVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find platform ver tag");
if (cbor_value_is_valid(&repVal))
{
err = cbor_value_dup_text_string(&repVal, &(info.platformVersion), &len, NULL);
}
// OS Version
err = cbor_value_map_find_value(rootValue, OC_RSRVD_OS_VERSION, &repVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find os ver tag");
if (cbor_value_is_valid(&repVal))
{
err = cbor_value_dup_text_string(&repVal, &(info.operatingSystemVersion), &len, NULL);
}
// Hardware Version
err = cbor_value_map_find_value(rootValue, OC_RSRVD_HARDWARE_VERSION, &repVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find hw ver tag");
if(cbor_value_is_valid(&repVal))
{
err = cbor_value_dup_text_string(&repVal, &(info.hardwareVersion), &len, NULL);
}
// Firmware Version
err = cbor_value_map_find_value(rootValue, OC_RSRVD_FIRMWARE_VERSION, &repVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find fw ver tag");
if(cbor_value_is_valid(&repVal))
{
err = cbor_value_dup_text_string(&repVal, &(info.firmwareVersion), &len, NULL);
}
// Support URL
err = cbor_value_map_find_value(rootValue, OC_RSRVD_SUPPORT_URL, &repVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find support url tag");
if(cbor_value_is_valid(&repVal))
{
err = cbor_value_dup_text_string(&repVal, &(info.supportUrl), &len, NULL);
}
// System Time
err = cbor_value_map_find_value(rootValue, OC_RSRVD_SYSTEM_TIME, &repVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find sys time tag");
if(cbor_value_is_valid(&repVal))
{
err = cbor_value_dup_text_string(&repVal, &(info.systemTime), &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find systemTume in the platform payload");
}
+ // Resource type
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_RESOURCE_TYPE, &repVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find resource type tag");
+
+ if(cbor_value_is_valid(&repVal))
+ {
+ err = OCParseStringLL(rootValue, OC_RSRVD_RESOURCE_TYPE, &rt);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find resource type in the platform payload");
+ }
+
+ // Interface Types
+ err = cbor_value_map_find_value(rootValue, OC_RSRVD_INTERFACE, &repVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find interface tag");
+
+ if(cbor_value_is_valid(&repVal))
+ {
+ err = OCParseStringLL(rootValue, OC_RSRVD_INTERFACE, &interfaces);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find interfaces tag/value");
+ }
+
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;
+ out = (OCPlatformPayload *)OCPlatformPayloadCreateAsOwner(&info);
+ out->rt = rt;
+ out->interfaces = interfaces;
+ *outPayload = (OCPayload *)out;
+ OIC_LOG_PAYLOAD(DEBUG, *outPayload);
+ return OC_STACK_OK;
}
exit:
case CborIntegerType:
return OCREP_PROP_INT;
case CborDoubleType:
+ case CborFloatType:
return OCREP_PROP_DOUBLE;
case CborBooleanType:
return OCREP_PROP_BOOL;
case OCREP_PROP_DOUBLE:
if (dimensions[1] == 0)
{
- err = cbor_value_get_double(&insideArray, &(((double*)targetArray)[i]));
+ double *d = &(((double*)targetArray)[i]);
+ if (cbor_value_get_type(&insideArray) == CborDoubleType)
+ {
+ err = cbor_value_get_double(&insideArray, d);
+ }
+ else
+ {
+ /* must be float */
+ float f;
+ err = cbor_value_get_float(&insideArray, &f);
+ if (!err)
+ *d = f;
+ }
}
else
{
case OCREP_PROP_OBJECT:
if (dimensions[1] == 0)
{
- err = OCParseSingleRepPayload(&tempPl, &insideArray);
+ err = OCParseSingleRepPayload(&tempPl, &insideArray, false);
((OCRepPayload**)targetArray)[i] = tempPl;
tempPl = NULL;
noAdvance = true;
static CborError OCParseArray(OCRepPayload *out, const char *name, CborValue *container)
{
void *arr = NULL;
- OCRepPayloadPropType type;
- size_t dimensions[MAX_REP_ARRAY_DEPTH];
- size_t dimTotal;
- size_t allocSize;
+
+ OCRepPayloadPropType type = OCREP_PROP_NULL;
+ size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0 };
+
+ size_t dimTotal = 0;
+ size_t allocSize = 0;
bool res = true;
CborError err = OCParseArrayFindDimensionsAndType(container, dimensions, &type);
VERIFY_CBOR_SUCCESS(TAG, err, "Array details weren't clear");
return err;
}
-static CborError OCParseSingleRepPayload(OCRepPayload **outPayload, CborValue *objMap)
+static CborError OCParseSingleRepPayload(OCRepPayload **outPayload, CborValue *objMap, bool isRoot)
{
CborError err = CborUnknownError;
char *name = NULL;
- bool res;
+ bool res = false;
VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
VERIFY_PARAM_NON_NULL(TAG, objMap, "Invalid Parameter objMap");
err = cbor_value_advance(&repMap);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed advancing rootMap");
if (name &&
+ isRoot &&
((0 == strcmp(OC_RSRVD_HREF, name)) ||
(0 == strcmp(OC_RSRVD_RESOURCE_TYPE, name)) ||
(0 == strcmp(OC_RSRVD_INTERFACE, name))))
case CborMapType:
{
OCRepPayload *pl = NULL;
- err = OCParseSingleRepPayload(&pl, &repMap);
+ err = OCParseSingleRepPayload(&pl, &repMap, false);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting parse single rep");
res = OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl);
}
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))
{
err = cbor_value_enter_container(root, &rootMap);
+ VERIFY_CBOR_SUCCESS(TAG, err, "Failed entering repMap");
}
while (cbor_value_is_valid(&rootMap))
{
CborValue curVal;
ret = OC_STACK_MALFORMED_RESPONSE;
+ // temporary fix to check for malformed cbor payload
+ if (!cbor_value_is_map(&rootMap) && !cbor_value_is_array(&rootMap)){
+ goto exit;
+ }
+
if (cbor_value_is_map(&rootMap))
{
err = cbor_value_map_find_value(&rootMap, OC_RSRVD_HREF, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find href tag");
if (cbor_value_is_valid(&curVal))
{
size_t len = 0;
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find uri");
}
}
+
// Resource types
if (cbor_value_is_map(&rootMap))
{
if (cbor_value_is_map(&rootMap))
{
- err = OCParseSingleRepPayload(&temp, &rootMap);
+ err = OCParseSingleRepPayload(&temp, &rootMap, true);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to parse single rep payload");
}
+
if(rootPayload == NULL)
{
rootPayload = temp;
// Resource type name
err = cbor_value_map_find_value(rootValue, OC_RSRVD_RESOURCE_TYPE, &curVal);
+ VERIFY_CBOR_SUCCESS(TAG, err, "to find res type tag");
if (cbor_value_is_valid(&curVal))
{
size_t len = 0;