CborError
sol_oic_decode_cbor_repr(struct sol_coap_packet *pkt, struct sol_vector *reprs)
{
CborParser parser;
CborError err;
CborValue root, array, repr;
uint8_t *payload;
uint16_t size;
int payload_type;
if (sol_coap_packet_get_payload(pkt, &payload, &size) < 0)
return CborErrorUnknownLength;
err = cbor_parser_init(payload, size, 0, &parser, &root);
if (err != CborNoError)
return err;
if (!cbor_value_is_array(&root))
return CborErrorIllegalType;
err |= cbor_value_enter_container(&root, &array);
err |= cbor_value_get_int(&array, &payload_type);
err |= cbor_value_advance_fixed(&array);
if (err != CborNoError)
return err;
if (payload_type != SOL_OIC_PAYLOAD_REPRESENTATION)
return CborErrorIllegalType;
if (cbor_value_map_find_value(&array, SOL_OIC_KEY_REPRESENTATION, &repr) != CborNoError)
return CborErrorIllegalType;
/* We're done with this CborParser, no need to close the container. */
return sol_oic_decode_cbor_repr_map(&repr, reprs);
}
static bool
_cbor_map_get_array(const CborValue *map, const char *key,
struct sol_vector *vector)
{
CborValue value;
if (cbor_value_map_find_value(map, key, &value) != CborNoError)
return false;
if (!cbor_value_is_array(&value))
return false;
return _cbor_array_to_vector(&value, vector);
}
uint16_t
oc_parse_rep(const uint8_t *in_payload, uint16_t payload_size,
oc_rep_t **out_rep)
{
CborParser parser;
CborValue root_value, cur_value, map;
CborError err = CborNoError;
struct cbor_buf_reader br;
cbor_buf_reader_init(&br, in_payload, payload_size);
err |= cbor_parser_init(&br.r, 0, &parser, &root_value);
if (cbor_value_is_map(&root_value)) {
err |= cbor_value_enter_container(&root_value, &cur_value);
*out_rep = 0;
oc_rep_t **cur = out_rep;
while (cbor_value_is_valid(&cur_value)) {
oc_parse_rep_value(&cur_value, cur, &err);
err |= cbor_value_advance(&cur_value);
cur = &(*cur)->next;
}
} else if (cbor_value_is_array(&root_value)) {
err |= cbor_value_enter_container(&root_value, &map);
err |= cbor_value_enter_container(&map, &cur_value);
*out_rep = 0;
oc_rep_t **cur = out_rep;
while (cbor_value_is_valid(&cur_value)) {
*cur = _alloc_rep();
(*cur)->type = OBJECT;
oc_parse_rep_value(&cur_value, &(*cur)->value_object, &err);
err |= cbor_value_advance(&cur_value);
(*cur)->next = 0;
cur = &(*cur)->next;
}
}
return (uint16_t)err;
}
OCStackResult OCRDCborToPayload(const CborValue *cborPayload, OCPayload **outPayload)
{
CborValue *rdCBORPayload = (CborValue *)cborPayload;
CborError cborFindResult;
OCRDPayload *rdPayload = OCRDPayloadCreate();
if (!rdPayload)
{
goto no_memory;
}
if (cbor_value_is_array(rdCBORPayload))
{
OCLinksPayload *linksPayload = NULL;
OCTagsPayload *tagsPayload = NULL;
while (cbor_value_is_container(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;
}
OCTagsLog(DEBUG, tagsPayload);
if (OC_STACK_OK != OCLinksCborToPayload(&tags, &linksPayload))
{
OCFreeLinksResource(linksPayload);
OCFreeTagsResource(tagsPayload);
goto cbor_error;
}
OCLinksLog(DEBUG, linksPayload);
// Move from tags payload to links array.
if (CborNoError != cbor_value_advance(rdCBORPayload))
{
OC_LOG(DEBUG, TAG, "Failed advancing from tags payload to links.");
OCFreeLinksResource(linksPayload);
OCFreeTagsResource(tagsPayload);
goto cbor_error;
}
}
rdPayload->rdPublish = OCCopyCollectionResource(tagsPayload, linksPayload);
if (!rdPayload->rdPublish)
{
goto cbor_error;
}
}
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);
cborFindResult = cbor_value_advance(rdCBORPayload);
if (CborNoError != cborFindResult)
{
goto cbor_error;
}
}
OC_LOG_PAYLOAD(DEBUG, (OCPayload *) rdPayload);
*outPayload = (OCPayload *)rdPayload;
return OC_STACK_OK;
no_memory:
OC_LOG(ERROR, TAG, "Failed allocating memory.");
OCRDPayloadDestroy(rdPayload);
return OC_STACK_NO_MEMORY;
cbor_error:
OCRDPayloadDestroy(rdPayload);
return OC_STACK_ERROR;
}
OCStackResult OCRDCborToPayload(const CborValue *cborPayload, OCPayload **outPayload)
{
CborValue *rdCBORPayload = (CborValue *)cborPayload;
OCStackResult ret = OC_STACK_NO_MEMORY;
CborError cborFindResult;
OCRDPayload *rdPayload = OCRDPayloadCreate();
VERIFY_PARAM_NON_NULL(TAG, rdPayload, "Failed allocating rdPayload");
ret = OC_STACK_MALFORMED_RESPONSE;
if (cbor_value_is_array(rdCBORPayload))
{
OCLinksPayload *linksPayload = NULL;
OCTagsPayload *tagsPayload = NULL;
while (cbor_value_is_container(rdCBORPayload))
{
// enter tags map
CborValue tags;
cborFindResult = cbor_value_enter_container(rdCBORPayload, &tags);
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);
cborFindResult = OCLinksCborToPayload(&tags, &linksPayload);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed parsing links payload.");
OCLinksLog(DEBUG, linksPayload);
// Move from tags payload to links array.
cborFindResult = cbor_value_advance(rdCBORPayload);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing rdCborPayload.");
}
rdPayload->rdPublish = OCCopyCollectionResource(tagsPayload, linksPayload);
VERIFY_PARAM_NON_NULL(TAG, rdPayload->rdPublish, "Failed allocating rdPayload->rdPublish");
}
else if (cbor_value_is_map(rdCBORPayload))
{
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.");
char *deviceId = NULL;
cborFindResult = FindStringInMap(rdCBORPayload, OC_RSRVD_DEVICE_ID, &deviceId);
if (deviceId)
{
memcpy(rdPayload->rdDiscovery->di.id, deviceId, strlen(deviceId));
OICFree(deviceId);
}
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding OC_RSRVD_DEVICE_ID.");
{
uint64_t value = 0;
cborFindResult = FindIntInMap(rdCBORPayload, OC_RSRVD_RD_DISCOVERY_SEL, &value);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding OC_RSRVD_RD_DISCOVERY_SEL.");
rdPayload->rdDiscovery->sel = value;
}
cborFindResult = cbor_value_advance(rdCBORPayload);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing rdCBORPayload.");
}
OIC_LOG_PAYLOAD(DEBUG, (OCPayload *) rdPayload);
*outPayload = (OCPayload *)rdPayload;
return OC_STACK_OK;
exit:
OCRDPayloadDestroy(rdPayload);
return ret;
}
OCStackResult OCParsePayload(OCPayload** outPayload, OCPayloadType payloadType,
const uint8_t* payload, size_t payloadSize)
{
CborParser parser;
CborValue rootValue;
bool err = false;
OC_LOG_V(INFO, TAG, "CBOR Parsing size: %d", payloadSize, payload);
if((err = cbor_parser_init(payload, payloadSize, 0, &parser, &rootValue)) != false)
{
OC_LOG_V(ERROR, TAG, "CBOR Parser init failed: %d", err);
return OC_STACK_ERROR;
}
if(!cbor_value_is_array(&rootValue))
{
OC_LOG_V(ERROR, TAG, "CBOR payload root object is not an array :%x", rootValue.type);
return OC_STACK_MALFORMED_RESPONSE;
}
CborValue arrayValue;
// enter the array
err = err || cbor_value_enter_container(&rootValue, &arrayValue);
if(err || arrayValue.type != CborMapType)
{
OC_LOG_V(ERROR, TAG, "CBOR payload parse failed :%d", err);
return OC_STACK_MALFORMED_RESPONSE;
}
OCStackResult result = OC_STACK_ERROR;
switch(payloadType)
{
case PAYLOAD_TYPE_DISCOVERY:
result = OCParseDiscoveryPayload(outPayload, &arrayValue);
break;
case PAYLOAD_TYPE_DEVICE:
result = OCParseDevicePayload(outPayload, &arrayValue);
break;
case PAYLOAD_TYPE_PLATFORM:
result = OCParsePlatformPayload(outPayload, &arrayValue);
break;
case PAYLOAD_TYPE_REPRESENTATION:
result = OCParseRepPayload(outPayload, &arrayValue);
break;
case PAYLOAD_TYPE_PRESENCE:
result = OCParsePresencePayload(outPayload, &arrayValue);
break;
case PAYLOAD_TYPE_SECURITY:
result = OCParseSecurityPayload(outPayload, &arrayValue);
break;
default:
OC_LOG_V(ERROR, TAG, "ParsePayload Type default: %d", payloadType);
result = OC_STACK_ERROR;
break;
}
if(result == OC_STACK_OK)
{
err = err || cbor_value_leave_container(&rootValue, &arrayValue);
if(err != CborNoError)
{
return OC_STACK_MALFORMED_RESPONSE;
}
}
else
{
OC_LOG_V(INFO, TAG, "Finished parse payload, result is %d", result);
}
return result;
}
static bool
_parse_server_info_payload(struct sol_oic_server_information *info,
uint8_t *payload, uint16_t payload_len)
{
CborParser parser;
CborError err;
CborValue root, array, value, map;
int payload_type;
err = cbor_parser_init(payload, payload_len, 0, &parser, &root);
if (err != CborNoError)
return false;
if (!cbor_value_is_array(&root))
return false;
err |= cbor_value_enter_container(&root, &array);
err |= cbor_value_get_int(&array, &payload_type);
err |= cbor_value_advance_fixed(&array);
if (err != CborNoError)
return false;
if (payload_type != SOL_OIC_PAYLOAD_PLATFORM)
return false;
if (!cbor_value_is_map(&array))
return false;
/* href is intentionally ignored */
err |= cbor_value_map_find_value(&map, SOL_OIC_KEY_REPRESENTATION, &value);
if (!cbor_value_is_map(&value))
return false;
if (err != CborNoError)
return false;
if (!_cbor_map_get_str_value(&value, SOL_OIC_KEY_PLATFORM_ID, &info->platform_id))
return false;
if (!_cbor_map_get_str_value(&value, SOL_OIC_KEY_MANUF_NAME, &info->manufacturer_name))
return false;
if (!_cbor_map_get_str_value(&value, SOL_OIC_KEY_MANUF_URL, &info->manufacturer_url))
return false;
if (!_cbor_map_get_str_value(&value, SOL_OIC_KEY_MODEL_NUM, &info->model_number))
return false;
if (!_cbor_map_get_str_value(&value, SOL_OIC_KEY_MANUF_DATE, &info->manufacture_date))
return false;
if (!_cbor_map_get_str_value(&value, SOL_OIC_KEY_PLATFORM_VER, &info->platform_version))
return false;
if (!_cbor_map_get_str_value(&value, SOL_OIC_KEY_OS_VER, &info->os_version))
return false;
if (!_cbor_map_get_str_value(&value, SOL_OIC_KEY_HW_VER, &info->hardware_version))
return false;
if (!_cbor_map_get_str_value(&value, SOL_OIC_KEY_FIRMWARE_VER, &info->firmware_version))
return false;
if (!_cbor_map_get_str_value(&value, SOL_OIC_KEY_SUPPORT_URL, &info->support_url))
return false;
if (!_cbor_map_get_str_value(&value, SOL_OIC_KEY_SYSTEM_TIME, &info->system_time))
return false;
return err == CborNoError;
}
static OCStackResult OCParseRepPayload(OCPayload **outPayload, CborValue *root)
{
OCStackResult ret = OC_STACK_INVALID_PARAM;
CborError err;
OCRepPayload *temp = NULL;
OCRepPayload *rootPayload = NULL;
OCRepPayload *curPayload = NULL;
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))
{
err = cbor_value_enter_container(root, &rootMap);
}
while (cbor_value_is_valid(&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 = cbor_value_map_find_value(&rootMap, OC_RSRVD_HREF, &curVal);
if (cbor_value_is_valid(&curVal))
{
size_t len = 0;
err = cbor_value_dup_text_string(&curVal, &temp->uri, &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find uri");
}
}
// Resource types
if (cbor_value_is_map(&rootMap))
{
if (CborNoError == cbor_value_map_find_value(&rootMap, OC_RSRVD_RESOURCE_TYPE, &curVal))
{
err = OCParseStringLL(&rootMap, OC_RSRVD_RESOURCE_TYPE, &temp->types);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find rt type tag/value");
}
}
// Interface Types
if (cbor_value_is_map(&rootMap))
{
if (CborNoError == cbor_value_map_find_value(&rootMap, OC_RSRVD_INTERFACE, &curVal))
{
err = OCParseStringLL(&rootMap, OC_RSRVD_INTERFACE, &temp->interfaces);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find interfaces tag/value");
}
}
if (cbor_value_is_map(&rootMap))
{
err = OCParseSingleRepPayload(&temp, &rootMap, true);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to parse single rep payload");
}
if(rootPayload == NULL)
{
rootPayload = temp;
curPayload = temp;
}
else
{
curPayload->next = temp;
curPayload = curPayload->next;
}
if (cbor_value_is_array(&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;
}
