static OCStackResult OCParseDevicePayload(OCPayload **outPayload, CborValue *rootValue) { 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"); *outPayload = 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; if (cbor_value_is_map(rootValue)) { // Device ID 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 = 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 = cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_NAME, &curVal); if (cbor_value_is_valid(&curVal)) { 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 = cbor_value_map_find_value(rootValue, OC_RSRVD_SPEC_VERSION, &curVal); if (cbor_value_is_valid(&curVal)) { 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 = cbor_value_map_find_value(rootValue, OC_RSRVD_DATA_MODEL_VERSION, &curVal); if (cbor_value_is_valid(&curVal)) { 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; } exit: OCDevicePayloadDestroy(out); return ret; }
static OCStackResult OCParsePresencePayload(OCPayload **outPayload, CborValue *rootValue) { OCStackResult ret = OC_STACK_INVALID_PARAM; OCPresencePayload *payload = NULL; VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload"); *outPayload = NULL; 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 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 = 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 = 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 = cbor_value_map_find_value(rootValue, OC_RSRVD_RESOURCE_TYPE, &curVal); if (cbor_value_is_valid(&curVal)) { 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 = cbor_value_advance(rootValue); VERIFY_CBOR_SUCCESS(TAG, err, "Failed advancing root value"); *outPayload = (OCPayload *)payload; return OC_STACK_OK; } exit: OIC_LOG(ERROR, TAG, "CBOR error Parse Presence Payload"); OCPresencePayloadDestroy(payload); return ret; }
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 CborError FindIntInMap(const CborValue *map, const char *tags, uint64_t *value) { CborValue curVal; CborError cborFindResult = cbor_value_map_find_value(map, tags, &curVal); if (CborNoError == cborFindResult && cbor_value_is_unsigned_integer(&curVal)) { cborFindResult = cbor_value_get_uint64(&curVal, value); } 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; } CborValue rtVal; cborFindResult = cbor_value_enter_container(&rtArray, &rtVal); if (CborNoError != cborFindResult) { return CborUnknownError; } OCStringLL* llPtr = *links; while (cbor_value_is_text_string(&rtVal)) { if (llPtr == NULL) { llPtr = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL)); if (!llPtr) { return CborUnknownError; } *links = llPtr; } else if(llPtr) { while (llPtr->next) { llPtr = llPtr->next; } llPtr->next = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL)); if (!llPtr->next) { return CborUnknownError; } } cborFindResult = cbor_value_dup_text_string(&rtVal, &(llPtr->value), &len, NULL); if (CborNoError != cborFindResult) { return CborUnknownError; } cborFindResult = cbor_value_advance(&rtVal); if (CborNoError != cborFindResult) { return CborUnknownError; } } cborFindResult = cbor_value_leave_container(&rtArray, &rtVal); return cborFindResult; }
static bool _cbor_map_get_str_value(const CborValue *map, const char *key, struct sol_str_slice *slice) { CborValue value; if (cbor_value_map_find_value(map, key, &value) != CborNoError) return false; return cbor_value_dup_text_string(&value, (char **)&slice->data, &slice->len, NULL) == CborNoError; }
static CborError FindStringInMap(const CborValue *map, const char *tags, char **value) { CborValue curVal; 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); } return cborFindResult; }
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); }
static CborError FindIntInMap(CborValue *map, char *tags, uint64_t *value) { CborValue curVal; CborError cborFindResult = cbor_value_map_find_value(map, tags, &curVal); if (CborNoError == cborFindResult && cbor_value_is_unsigned_integer(&curVal)) { cborFindResult = cbor_value_get_uint64(&curVal, value); if (CborNoError != cborFindResult) { OC_LOG_V(ERROR, TAG, "Failed finding value for tag %s .", tags); return cborFindResult; } } return CborNoError; }
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)) { cborFindResult = cbor_value_dup_text_string(&curVal, value, &len, NULL); if (CborNoError != cborFindResult) { OC_LOG_V(ERROR, TAG, "Failed finding value for tag %s .", tags); return cborFindResult; } } return CborNoError; }
static CborError FindStringLLInMap(const CborValue *linksMap, const char *tag, OCStringLL **links) { size_t len; CborValue rtArray; 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); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed entering container"); while (cbor_value_is_text_string(&rtVal)) { if (llPtr == NULL) { llPtr = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL)); VERIFY_PARAM_NON_NULL(TAG, llPtr, "Failed allocating OCStringLL"); *links = llPtr; } else if (llPtr) { while (llPtr->next) { llPtr = llPtr->next; } llPtr->next = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL)); llPtr = llPtr->next; VERIFY_PARAM_NON_NULL(TAG, llPtr, "Failed allocating OCStringLL->next"); } cborFindResult = cbor_value_dup_text_string(&rtVal, &(llPtr->value), &len, NULL); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed duplicating value"); cborFindResult = cbor_value_advance(&rtVal); 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; }
static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* arrayVal) { if (!outPayload) { return OC_STACK_INVALID_PARAM; } bool err = false; char * securityData = NULL; if(cbor_value_is_map(arrayVal)) { CborValue curVal; err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_REPRESENTATION, &curVal); if(cbor_value_is_valid(&curVal)) { size_t len; err = err || cbor_value_dup_text_string(&curVal, &securityData, &len, NULL); } } else { OC_LOG(ERROR, TAG, "Cbor main value not a map"); return OC_STACK_MALFORMED_RESPONSE; } err = err || cbor_value_advance(arrayVal); if(err) { OC_LOG(ERROR, TAG, "Cbor in error condition"); OICFree(securityData); return OC_STACK_MALFORMED_RESPONSE; } *outPayload = (OCPayload*)OCSecurityPayloadCreate(securityData); OICFree(securityData); return OC_STACK_OK; }
static CborError OCParseStringLL(CborValue *map, char *type, OCStringLL **resource) { 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)) { 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) { 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 OCParsePlatformPayload(OCPayload** outPayload, CborValue* rootValue) { if (!outPayload) { return OC_STACK_INVALID_PARAM; } bool err = false; 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); } // 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); } // MFG URL err = 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); } // Model Num err = 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); } // Date of Mfg err = 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); } // Platform Version err = 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); } // OS Version err = 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); } // Hardware Version err = 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); } // Firmware Version err = 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); } // Support URL err = 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); } // System Time err = 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 = 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); OC_LOG(ERROR, TAG, "CBOR error In ParsePlatformPayload"); return OC_STACK_MALFORMED_RESPONSE; } *outPayload = (OCPayload*)OCPlatformPayloadCreateAsOwner(&info); if(!*outPayload) { return OC_STACK_NO_MEMORY; } return OC_STACK_OK; } else { OC_LOG(ERROR, TAG, "Root device node was not a map"); return OC_STACK_MALFORMED_RESPONSE; } }
static OCStackResult OCParseDevicePayload(OCPayload** outPayload, CborValue* rootValue) { if (!outPayload) { return OC_STACK_INVALID_PARAM; } bool err = false; if(cbor_value_is_map(rootValue)) { uint8_t* sid = NULL; char* dname = NULL; char* specVer = NULL; char* dmVer = NULL; CborValue repVal; // Device ID err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_ID, &repVal); size_t len; if(cbor_value_is_valid(&repVal)) { err = err || cbor_value_dup_byte_string(&repVal, &sid, &len, NULL); } // Device Name err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_NAME, &repVal); if(cbor_value_is_valid(&repVal)) { err = err || cbor_value_dup_text_string(&repVal, &dname, &len, NULL); } // Device Spec Version err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_SPEC_VERSION, &repVal); if(cbor_value_is_valid(&repVal)) { err = err || cbor_value_dup_text_string(&repVal, &specVer, &len, NULL); } // 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); OC_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) { return OC_STACK_NO_MEMORY; } return OC_STACK_OK; } else { OC_LOG(ERROR, TAG, "Root device node was not a map"); return OC_STACK_MALFORMED_RESPONSE; } }
static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* rootValue) { if (!outPayload) { return OC_STACK_INVALID_PARAM; } bool err = false; OCResourcePayload* resource = NULL; uint16_t resourceCount = 0; CborValue resourceMap = {}; OCDiscoveryPayload* out = OCDiscoveryPayloadCreate(); if(!out) { return OC_STACK_NO_MEMORY; } // Root value is already inside the main root array CborValue rootMap = {}; // Enter the main root map err = err || cbor_value_enter_container(rootValue, &rootMap); // Look for DI CborValue curVal = {}; err = cbor_value_map_find_value(&rootMap, OC_RSRVD_DEVICE_ID, &curVal); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor find value failed."); goto malformed_cbor; } size_t len; err = cbor_value_dup_byte_string(&curVal, &(out->sid), &len, NULL); // 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) { OC_LOG(ERROR, TAG, "Cbor find value failed."); goto malformed_cbor; } // 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); while (cbor_value_is_map(&resourceMap)) { resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload)); if(!resource) { OC_LOG(ERROR, TAG, "Memory allocation failed"); OCDiscoveryPayloadDestroy(out); return OC_STACK_NO_MEMORY; } // Uri CborValue uriVal = {}; err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_HREF, &uriVal); if (CborNoError != err) { OC_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) { OC_LOG(ERROR, TAG, "Cbor finding href value failed."); goto malformed_cbor; } // ResourceTypes CborValue rtVal = {}; err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_RESOURCE_TYPE, &rtVal); if (CborNoError != err) { OC_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) { OC_LOG(ERROR, TAG, "Cbor finding rt value failed."); goto malformed_cbor; } if (input) { char* curPtr = strtok_r(input, " ", &savePtr); 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); } } // Interface Types CborValue ifVal = {}; err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_INTERFACE, &ifVal); if (CborNoError != err) { OC_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) { OC_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); } } // Policy CborValue policyMap = {}; err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_POLICY, &policyMap); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding policy type failed."); goto malformed_cbor; } // Bitmap CborValue val = {}; err = cbor_value_map_find_value(&policyMap, OC_RSRVD_BITMAP, &val); if (CborNoError != err) { OC_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) { OC_LOG(ERROR, TAG, "Cbor finding bitmap value failed."); goto malformed_cbor; } resource->bitmap = (uint8_t)temp; // Secure Flag err = cbor_value_map_find_value(&policyMap, OC_RSRVD_SECURE, &val); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding secure type failed."); goto malformed_cbor; } if(cbor_value_is_valid(&val)) { err = cbor_value_get_boolean(&val, &(resource->secure)); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding secure value failed."); goto malformed_cbor; } // Port CborValue port; err = cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT, &port); if (CborNoError != err) { OC_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) { OC_LOG(ERROR, TAG, "Cbor finding port value failed."); goto malformed_cbor; } resource->port = (uint16_t)temp; } } err = cbor_value_advance(&resourceMap); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor advance value failed."); goto malformed_cbor; } ++resourceCount; OCDiscoveryPayloadAddNewResource(out, resource); } err = err || cbor_value_leave_container(rootValue, &resourceMap); *outPayload = (OCPayload*)out; return OC_STACK_OK; malformed_cbor: OICFree(resource->uri); OCFreeOCStringLL(resource->types); OCFreeOCStringLL(resource->interfaces); OICFree(resource); OCDiscoveryPayloadDestroy(out); return OC_STACK_MALFORMED_RESPONSE; cbor_error: OCDiscoveryCollectionPayloadDestroy(out); return OC_STACK_MALFORMED_RESPONSE; }
static CborError OCLinksCborToPayload(CborValue *links, OCLinksPayload **linksPayload) { OCLinksPayload *setLinks = NULL; CborValue linksMap; CborValue linksArray; CborError cborFindResult = CborErrorOutOfMemory; cborFindResult = cbor_value_map_find_value(links, OC_RSRVD_LINKS, &linksArray); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding links array"); cborFindResult = cbor_value_enter_container(&linksArray, &linksMap); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed entering links map container"); while (cbor_value_is_map(&linksMap)) { setLinks = (OCLinksPayload *)OICCalloc(1, sizeof(OCLinksPayload)); VERIFY_PARAM_NON_NULL(TAG, setLinks, "Failed allocating setLinks"); cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_HREF, &setLinks->href); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding href value"); cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_REL, &setLinks->rel); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding rel value"); cborFindResult = FindStringLLInMap(&linksMap, OC_RSRVD_RESOURCE_TYPE, &setLinks->rt); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding rt value"); cborFindResult = FindStringLLInMap(&linksMap, OC_RSRVD_INTERFACE, &setLinks->itf); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding itf value"); // Policy CborValue policyMap; cborFindResult = cbor_value_map_find_value(&linksMap, OC_RSRVD_POLICY, &policyMap); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "to find policy tag"); // Bitmap cborFindResult = FindIntInMap(&policyMap, OC_RSRVD_BITMAP, (uint64_t *) &setLinks->p); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding bitmap value"); cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_TITLE, &setLinks->title); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding title value"); cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_URI, &setLinks->anchor); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding uri value"); cborFindResult = FindIntInMap(&linksMap, OC_RSRVD_INS, (uint64_t *) &setLinks->ins); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding ins value"); cborFindResult = FindIntInMap(&linksMap, OC_RSRVD_TTL, &setLinks->ttl); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding ttl"); cborFindResult = FindStringLLInMap(&linksMap, OC_RSRVD_MEDIA_TYPE, &setLinks->type); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding mt value"); if (!*linksPayload) { *linksPayload = setLinks; } else { OCLinksPayload *temp = *linksPayload; while (temp->next) { temp = temp->next; } temp->next = setLinks; } cborFindResult = cbor_value_advance(&linksMap); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing links map"); } return cborFindResult; exit: OCFreeLinksResource(*linksPayload); OCFreeLinksResource(setLinks); return cborFindResult; }
OCStackResult CBORPayloadToPstat(const uint8_t *cborPayload, const size_t size, OicSecPstat_t **secPstat) { if (NULL == cborPayload || NULL == secPstat || NULL != *secPstat || 0 == size) { return OC_STACK_INVALID_PARAM; } OCStackResult ret = OC_STACK_ERROR; *secPstat = NULL; CborValue pstatCbor; CborParser parser; CborError cborFindResult = CborNoError; char *strUuid = NULL; size_t len = 0; cbor_parser_init(cborPayload, size, 0, &parser, &pstatCbor); CborValue pstatMap = { .parser = NULL }; OicSecPstat_t *pstat = NULL; cborFindResult = cbor_value_enter_container(&pstatCbor, &pstatMap); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding PSTAT Map."); pstat = (OicSecPstat_t *)OICCalloc(1, sizeof(OicSecPstat_t)); VERIFY_NON_NULL(TAG, pstat, ERROR); cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_ISOP_NAME, &pstatMap); if (CborNoError == cborFindResult && cbor_value_is_boolean(&pstatMap)) { cborFindResult = cbor_value_get_boolean(&pstatMap, &pstat->isOp); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding isOp Value."); } cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_DEVICE_ID_NAME, &pstatMap); if (CborNoError == cborFindResult && cbor_value_is_text_string(&pstatMap)) { cborFindResult = cbor_value_dup_text_string(&pstatMap, &strUuid , &len, NULL); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Device Id Value."); ret = ConvertStrToUuid(strUuid , &pstat->deviceID); VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR); OICFree(strUuid ); strUuid = NULL; } cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_CM_NAME, &pstatMap); if (CborNoError == cborFindResult && cbor_value_is_integer(&pstatMap)) { cborFindResult = cbor_value_get_int(&pstatMap, (int *) &pstat->cm); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding CM."); } cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_TM_NAME, &pstatMap); if (CborNoError == cborFindResult && cbor_value_is_integer(&pstatMap)) { cborFindResult = cbor_value_get_int(&pstatMap, (int *) &pstat->tm); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding TM."); } cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_OM_NAME, &pstatMap); if (CborNoError == cborFindResult && cbor_value_is_integer(&pstatMap)) { cborFindResult = cbor_value_get_int(&pstatMap, (int *) &pstat->om); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding OM."); } cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_SM_NAME, &pstatMap); if (CborNoError == cborFindResult && cbor_value_is_integer(&pstatMap)) { pstat->smLen = 1; pstat->sm = (OicSecDpom_t*)OICCalloc(pstat->smLen, sizeof(OicSecDpom_t)); cborFindResult = cbor_value_get_int(&pstatMap, (int *) &pstat->sm[0]); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding SM."); } cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_ROWNERID_NAME, &pstatMap); if (CborNoError == cborFindResult && cbor_value_is_text_string(&pstatMap)) { cborFindResult = cbor_value_dup_text_string(&pstatMap, &strUuid , &len, NULL); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding ROwner Id Value."); ret = ConvertStrToUuid(strUuid , &pstat->rownerID); VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR); OICFree(strUuid ); strUuid = NULL; } *secPstat = pstat; ret = OC_STACK_OK; exit: if (CborNoError != cborFindResult) { OIC_LOG(ERROR, TAG, "CBORPayloadToPstat failed"); DeletePstatBinData(pstat); pstat = NULL; *secPstat = NULL; ret = OC_STACK_ERROR; } return ret; }
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 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; 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"); { 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"); } // 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 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"); 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); 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 (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); 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_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"); *outPayload = (OCPayload *)out; return OC_STACK_OK; exit: OCDiscoveryResourceDestroy(resource); OCDiscoveryPayloadDestroy(out); return ret; }
static OCStackResult OCParsePlatformPayload(OCPayload **outPayload, CborValue *rootValue) { OCStackResult ret = OC_STACK_INVALID_PARAM; CborError err = CborNoError; OCPlatformInfo info = {0}; VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload"); if (cbor_value_is_map(rootValue)) { CborValue repVal; 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 = 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 = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_URL, &repVal); if (cbor_value_is_valid(&repVal)) { 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 = cbor_value_map_find_value(rootValue, OC_RSRVD_MODEL_NUM, &repVal); if (cbor_value_is_valid(&repVal)) { 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 = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_DATE, &repVal); if (cbor_value_is_valid(&repVal)) { 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 = cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_VERSION, &repVal); if (cbor_value_is_valid(&repVal)) { 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 = cbor_value_map_find_value(rootValue, OC_RSRVD_OS_VERSION, &repVal); if (cbor_value_is_valid(&repVal)) { 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 = cbor_value_map_find_value(rootValue, OC_RSRVD_HARDWARE_VERSION, &repVal); if(cbor_value_is_valid(&repVal)) { 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 = cbor_value_map_find_value(rootValue, OC_RSRVD_FIRMWARE_VERSION, &repVal); if(cbor_value_is_valid(&repVal)) { 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 = cbor_value_map_find_value(rootValue, OC_RSRVD_SUPPORT_URL, &repVal); if(cbor_value_is_valid(&repVal)) { 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 = cbor_value_map_find_value(rootValue, OC_RSRVD_SYSTEM_TIME, &repVal); 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"); } 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; } exit: OCPlatformInfoDestroy(&info); OIC_LOG(ERROR, TAG, "CBOR error In ParsePlatformPayload"); return ret; }
/** * Gets the Secure Virtual Database from the Persistent Storage * * @param rsrcName - pointer of character string for the SVR name (e.g. "acl") * @param data - pointer of the returned Secure Virtual Resource(s) * @param size - pointer of the returned size of Secure Virtual Resource(s) * * @return OCStackResult - result of getting Secure Virtual Resource(s) */ OCStackResult GetSecureVirtualDatabaseFromPS(const char *rsrcName, uint8_t **data, size_t *size) { OIC_LOG(DEBUG, TAG, "GetSecureVirtualDatabaseFromPS IN"); if (!data || *data || !size) { return OC_STACK_INVALID_PARAM; } FILE *fp = NULL; uint8_t *fsData = NULL; size_t fileSize = 0; OCStackResult ret = OC_STACK_ERROR; OCPersistentStorage *ps = SRMGetPersistentStorageHandler(); VERIFY_NON_NULL(TAG, ps, ERROR); fileSize = GetSVRDatabaseSize(ps); OIC_LOG_V(DEBUG, TAG, "File Read Size: %zu", fileSize); if (fileSize) { fsData = (uint8_t *) OICCalloc(1, fileSize); VERIFY_NON_NULL(TAG, fsData, ERROR); fp = ps->open(SVR_DB_DAT_FILE_NAME, "rb"); VERIFY_NON_NULL(TAG, fp, ERROR); if (ps->read(fsData, 1, fileSize, fp) == fileSize) { if (rsrcName) { CborParser parser; // will be initialized in |cbor_parser_init| CborValue cbor; // will be initialized in |cbor_parser_init| cbor_parser_init(fsData, fileSize, 0, &parser, &cbor); CborValue cborValue = {0}; CborError cborFindResult = cbor_value_map_find_value(&cbor, rsrcName, &cborValue); if (CborNoError == cborFindResult && cbor_value_is_byte_string(&cborValue)) { cborFindResult = cbor_value_dup_byte_string(&cborValue, data, size, NULL); VERIFY_SUCCESS(TAG, CborNoError==cborFindResult, ERROR); ret = OC_STACK_OK; } // in case of |else (...)|, svr_data not found } // return everything in case rsrcName is NULL else { *size = fileSize; *data = (uint8_t *) OICCalloc(1, fileSize); VERIFY_NON_NULL(TAG, *data, ERROR); memcpy(*data, fsData, fileSize); ret = OC_STACK_OK; } } } OIC_LOG(DEBUG, TAG, "GetSecureVirtualDatabaseFromPS OUT"); exit: if (fp) { ps->close(fp); } OICFree(fsData); return ret; }
/** * Updates the Secure Virtual Resource(s) into the Persistent Storage. * This function stores cbor-payload of each resource by appending resource name, * and empty payload implies deleting the value * * @param rsrcName - pointer of character string for the SVR name (e.g. "acl") * @param psPayload - pointer of the updated Secure Virtual Resource(s) * @param psSize - the updated size of Secure Virtual Resource(s) * * @return OCStackResult - result of updating Secure Virtual Resource(s) */ OCStackResult UpdateSecureResourceInPS(const char *rsrcName, const uint8_t *psPayload, size_t psSize) { OIC_LOG(DEBUG, TAG, "UpdateSecureResourceInPS IN"); if (!rsrcName) { return OC_STACK_INVALID_PARAM; } size_t dbSize = 0; size_t outSize = 0; uint8_t *dbData = NULL; uint8_t *outPayload = NULL; uint8_t *aclCbor = NULL; uint8_t *pstatCbor = NULL; uint8_t *doxmCbor = NULL; uint8_t *amaclCbor = NULL; uint8_t *svcCbor = NULL; uint8_t *credCbor = NULL; uint8_t *pconfCbor = NULL; int64_t cborEncoderResult = CborNoError; OCStackResult ret = GetSecureVirtualDatabaseFromPS(NULL, &dbData, &dbSize); if (dbData && dbSize) { size_t aclCborLen = 0; size_t pstatCborLen = 0; size_t doxmCborLen = 0; size_t amaclCborLen = 0; size_t svcCborLen = 0; size_t credCborLen = 0; size_t pconfCborLen = 0; // Gets each secure virtual resource from persistent storage // this local scoping intended, for destroying large cbor instances after use { CborParser parser; // will be initialized in |cbor_parser_init| CborValue cbor; // will be initialized in |cbor_parser_init| cbor_parser_init(dbData, dbSize, 0, &parser, &cbor); CborValue curVal = {0}; CborError cborFindResult = CborNoError; cborFindResult = cbor_value_map_find_value(&cbor, OIC_JSON_ACL_NAME, &curVal); if (CborNoError == cborFindResult && cbor_value_is_byte_string(&curVal)) { cborFindResult = cbor_value_dup_byte_string(&curVal, &aclCbor, &aclCborLen, NULL); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding ACL Name Value."); } cborFindResult = cbor_value_map_find_value(&cbor, OIC_JSON_PSTAT_NAME, &curVal); if (CborNoError == cborFindResult && cbor_value_is_byte_string(&curVal)) { cborFindResult = cbor_value_dup_byte_string(&curVal, &pstatCbor, &pstatCborLen, NULL); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding PSTAT Name Value."); } cborFindResult = cbor_value_map_find_value(&cbor, OIC_JSON_DOXM_NAME, &curVal); if (CborNoError == cborFindResult && cbor_value_is_byte_string(&curVal)) { cborFindResult = cbor_value_dup_byte_string(&curVal, &doxmCbor, &doxmCborLen, NULL); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding DOXM Name Value."); } cborFindResult = cbor_value_map_find_value(&cbor, OIC_JSON_AMACL_NAME, &curVal); if (CborNoError == cborFindResult && cbor_value_is_byte_string(&curVal)) { cborFindResult = cbor_value_dup_byte_string(&curVal, &amaclCbor, &amaclCborLen, NULL); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding AMACL Name Value."); } cborFindResult = cbor_value_map_find_value(&cbor, OIC_JSON_SVC_NAME, &curVal); if (CborNoError == cborFindResult && cbor_value_is_byte_string(&curVal)) { cborFindResult = cbor_value_dup_byte_string(&curVal, &svcCbor, &svcCborLen, NULL); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding SVC Name Value."); } cborFindResult = cbor_value_map_find_value(&cbor, OIC_JSON_CRED_NAME, &curVal); if (CborNoError == cborFindResult && cbor_value_is_byte_string(&curVal)) { cborFindResult = cbor_value_dup_byte_string(&curVal, &credCbor, &credCborLen, NULL); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding CRED Name Value."); } cborFindResult = cbor_value_map_find_value(&cbor, OIC_JSON_PCONF_NAME, &curVal); if (CborNoError == cborFindResult && cbor_value_is_byte_string(&curVal)) { cborFindResult = cbor_value_dup_byte_string(&curVal, &pconfCbor, &pconfCborLen, NULL); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding PCONF Name Value."); } } // Updates the added |psPayload| with the existing secure virtual resource(s) // this local scoping intended, for destroying large cbor instances after use { size_t size = aclCborLen + pstatCborLen + doxmCborLen + amaclCborLen + svcCborLen + credCborLen + pconfCborLen + psSize + 255; // This added '255' is arbitrary value that is added to cover the name of the resource, map addition and ending outPayload = (uint8_t *) OICCalloc(1, size); VERIFY_NON_NULL(TAG, outPayload, ERROR); CborEncoder encoder; // will be initialized in |cbor_parser_init| cbor_encoder_init(&encoder, outPayload, size, 0); CborEncoder secRsrc; // will be initialized in |cbor_encoder_create_map| cborEncoderResult |= cbor_encoder_create_map(&encoder, &secRsrc, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PS Map."); if (psPayload && psSize) { cborEncoderResult |= cbor_encode_text_string(&secRsrc, rsrcName, strlen(rsrcName)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Value Tag"); cborEncoderResult |= cbor_encode_byte_string(&secRsrc, psPayload, psSize); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Value."); } if (strcmp(OIC_JSON_ACL_NAME, rsrcName) && aclCborLen) { cborEncoderResult |= cbor_encode_text_string(&secRsrc, OIC_JSON_ACL_NAME, strlen(OIC_JSON_ACL_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ACL Name."); cborEncoderResult |= cbor_encode_byte_string(&secRsrc, aclCbor, aclCborLen); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ACL Value."); } if (strcmp(OIC_JSON_PSTAT_NAME, rsrcName) && pstatCborLen) { cborEncoderResult |= cbor_encode_text_string(&secRsrc, OIC_JSON_PSTAT_NAME, strlen(OIC_JSON_PSTAT_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PSTAT Name."); cborEncoderResult |= cbor_encode_byte_string(&secRsrc, pstatCbor, pstatCborLen); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PSTAT Value."); } if (strcmp(OIC_JSON_DOXM_NAME, rsrcName) && doxmCborLen) { cborEncoderResult |= cbor_encode_text_string(&secRsrc, OIC_JSON_DOXM_NAME, strlen(OIC_JSON_DOXM_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Doxm Name."); cborEncoderResult |= cbor_encode_byte_string(&secRsrc, doxmCbor, doxmCborLen); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Doxm Value."); } if (strcmp(OIC_JSON_AMACL_NAME, rsrcName) && amaclCborLen) { cborEncoderResult |= cbor_encode_text_string(&secRsrc, OIC_JSON_AMACL_NAME, strlen(OIC_JSON_AMACL_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Amacl Name."); cborEncoderResult |= cbor_encode_byte_string(&secRsrc, amaclCbor, amaclCborLen); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Amacl Value."); } if (strcmp(OIC_JSON_SVC_NAME, rsrcName) && svcCborLen) { cborEncoderResult |= cbor_encode_text_string(&secRsrc, OIC_JSON_SVC_NAME, strlen(OIC_JSON_SVC_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SVC Name."); cborEncoderResult |= cbor_encode_byte_string(&secRsrc, svcCbor, svcCborLen); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SVC Value."); } if (strcmp(OIC_JSON_CRED_NAME, rsrcName) && credCborLen) { cborEncoderResult |= cbor_encode_text_string(&secRsrc, OIC_JSON_CRED_NAME, strlen(OIC_JSON_CRED_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Cred Name."); cborEncoderResult |= cbor_encode_byte_string(&secRsrc, credCbor, credCborLen); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Cred Value."); } if (strcmp(OIC_JSON_PCONF_NAME, rsrcName) && pconfCborLen) { cborEncoderResult |= cbor_encode_text_string(&secRsrc, OIC_JSON_PCONF_NAME, strlen(OIC_JSON_PCONF_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Pconf Name."); cborEncoderResult |= cbor_encode_byte_string(&secRsrc, pconfCbor, pconfCborLen); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Pconf Value."); } cborEncoderResult |= cbor_encoder_close_container(&encoder, &secRsrc); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Array."); outSize = encoder.ptr - outPayload; } } else if (psPayload && psSize) { size_t size = psSize + 255; // This added '255' is arbitrary value that is added to cover the name of the resource, map addition and ending outPayload = (uint8_t *) OICCalloc(1, size); VERIFY_NON_NULL(TAG, outPayload, ERROR); CborEncoder encoder; // will be initialized in |cbor_parser_init| cbor_encoder_init(&encoder, outPayload, size, 0); CborEncoder secRsrc; // will be initialized in |cbor_encoder_create_map| cborEncoderResult |= cbor_encoder_create_map(&encoder, &secRsrc, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PS Map."); cborEncoderResult |= cbor_encode_text_string(&secRsrc, rsrcName, strlen(rsrcName)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Value Tag"); cborEncoderResult |= cbor_encode_byte_string(&secRsrc, psPayload, psSize); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Value."); cborEncoderResult |= cbor_encoder_close_container(&encoder, &secRsrc); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Array."); outSize = encoder.ptr - outPayload; } if (outPayload && outSize) { OIC_LOG_V(DEBUG, TAG, "Writting in the file: %zu", outSize); OCPersistentStorage* ps = SRMGetPersistentStorageHandler(); if (ps) { FILE *fp = ps->open(SVR_DB_DAT_FILE_NAME, "wb"); if (fp) { size_t numberItems = ps->write(outPayload, 1, outSize, fp); if (outSize == numberItems) { OIC_LOG_V(DEBUG, TAG, "Written %zu bytes into SVR database file", outSize); ret = OC_STACK_OK; } else { OIC_LOG_V(ERROR, TAG, "Failed writing %zu in the database", numberItems); } ps->close(fp); } else { OIC_LOG(ERROR, TAG, "File open failed."); } } } OIC_LOG(DEBUG, TAG, "UpdateSecureResourceInPS OUT"); exit: OICFree(dbData); OICFree(outPayload); OICFree(aclCbor); OICFree(pstatCbor); OICFree(doxmCbor); OICFree(amaclCbor); OICFree(svcCbor); OICFree(credCbor); OICFree(pconfCbor); return ret; }
static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* arrayVal) { if (!outPayload) { return OC_STACK_INVALID_PARAM; } bool err = false; OCDiscoveryPayload* out = OCDiscoveryPayloadCreate(); if(!out) { return OC_STACK_NO_MEMORY; } size_t resourceCount = 0; while(!err && cbor_value_is_map(arrayVal)) { OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload)); if(!resource) { OC_LOG(ERROR, TAG, "Memory allocation failed"); OCDiscoveryPayloadDestroy(out); return OC_STACK_NO_MEMORY; } CborValue curVal; // Uri err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_HREF, &curVal); size_t len; err = err || cbor_value_dup_text_string(&curVal, &(resource->uri), &len, NULL); // SID err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_SERVER_INSTANCE_ID, &curVal); err = err || cbor_value_dup_byte_string(&curVal, &(resource->sid), &len, NULL); // Prop Tag { err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_PROPERTY, &curVal); // ResourceTypes CborValue rtVal; err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_RESOURCE_TYPE, &rtVal); if (!err && cbor_value_is_text_string(&rtVal)) { char* input = NULL; char* savePtr; err = err || cbor_value_dup_text_string(&rtVal, &input, &len, NULL); if (input) { char* curPtr = strtok_r(input, " ", &savePtr); while (curPtr) { char* trimmed = InPlaceStringTrim(curPtr); if (trimmed[0] !='\0') { if (!OCResourcePayloadAddResourceType(resource, trimmed)) { OICFree(resource->uri); OICFree(resource->sid); OCFreeOCStringLL(resource->types); OICFree(resource); OCDiscoveryPayloadDestroy(out); return OC_STACK_NO_MEMORY; } } curPtr = strtok_r(NULL, " ", &savePtr); } OICFree(input); } } // Interface Types CborValue ifVal; err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_INTERFACE, &ifVal); if (!err && cbor_value_is_text_string(&ifVal)) { char* input = NULL; char* savePtr; err = err || cbor_value_dup_text_string(&ifVal, &input, &len, NULL); 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); OICFree(resource->sid); OCFreeOCStringLL(resource->types); OICFree(resource); OCDiscoveryPayloadDestroy(out); return OC_STACK_NO_MEMORY; } } curPtr = strtok_r(NULL, " ", &savePtr); } OICFree(input); } } // Policy { CborValue policyMap; err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_POLICY, &policyMap); // Bitmap CborValue val; err = err || cbor_value_map_find_value(&policyMap, OC_RSRVD_BITMAP, &val); uint64_t temp = 0; err = err || cbor_value_get_uint64(&val, &temp); resource->bitmap = (uint8_t)temp; // Secure Flag err = err || cbor_value_map_find_value(&policyMap, OC_RSRVD_SECURE, &val); if(cbor_value_is_valid(&val)) { err = err || cbor_value_get_boolean(&val, &(resource->secure)); // Port CborValue port; err = err || cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT, &port); if(cbor_value_is_valid(&port)) { err = err || cbor_value_get_uint64(&port, &temp); resource->port = (uint16_t)temp; } } } } err = err || cbor_value_advance(arrayVal); if(err) { OICFree(resource->uri); OICFree(resource->sid); OCFreeOCStringLL(resource->types); OCFreeOCStringLL(resource->interfaces); OICFree(resource); OCDiscoveryPayloadDestroy(out); OC_LOG_V(ERROR, TAG, "CBOR in error condition", err); return OC_STACK_MALFORMED_RESPONSE; } ++resourceCount; OCDiscoveryPayloadAddNewResource(out, resource); } if(err) { OCDiscoveryPayloadDestroy(out); return OC_STACK_MALFORMED_RESPONSE; } else { *outPayload = (OCPayload*)out; return OC_STACK_OK; } }
static bool OCParseSingleRepPayload(OCRepPayload** outPayload, CborValue* repParent) { if (!outPayload) { return false; } *outPayload = OCRepPayloadCreate(); OCRepPayload* curPayload = *outPayload; bool err = false; if(!*outPayload) { return CborErrorOutOfMemory; } size_t len; CborValue curVal; err = err || cbor_value_map_find_value(repParent, OC_RSRVD_HREF, &curVal); if(cbor_value_is_valid(&curVal)) { err = err || cbor_value_dup_text_string(&curVal, &curPayload->uri, &len, NULL); } err = err || cbor_value_map_find_value(repParent, OC_RSRVD_PROPERTY, &curVal); if(cbor_value_is_valid(&curVal)) { CborValue insidePropValue = {0}; err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_RESOURCE_TYPE, &insidePropValue); if(cbor_value_is_text_string(&insidePropValue)) { char* allRt = NULL; err = err || cbor_value_dup_text_string(&insidePropValue, &allRt, &len, NULL); char* savePtr; if (allRt) { char* curPtr = strtok_r(allRt, " ", &savePtr); while (curPtr) { char* trimmed = InPlaceStringTrim(curPtr); if (trimmed[0] != '\0') { OCRepPayloadAddResourceType(curPayload, curPtr); } curPtr = strtok_r(NULL, " ", &savePtr); } } OICFree(allRt); } err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_INTERFACE, &insidePropValue); if(cbor_value_is_text_string(&insidePropValue)) { char* allIf = NULL; err = err || cbor_value_dup_text_string(&insidePropValue, &allIf, &len, NULL); char* savePtr; if (allIf) { char* curPtr = strtok_r(allIf, " ", &savePtr); while (curPtr) { char* trimmed = InPlaceStringTrim(curPtr); if (trimmed[0] != '\0') { OCRepPayloadAddInterface(curPayload, curPtr); } curPtr = strtok_r(NULL, " ", &savePtr); } } OICFree(allIf); } } err = err || cbor_value_map_find_value(repParent, OC_RSRVD_REPRESENTATION, &curVal); if(cbor_value_is_map(&curVal)) { CborValue repMap; err = err || cbor_value_enter_container(&curVal, &repMap); while(!err && cbor_value_is_valid(&repMap)) { char* name; err = err || cbor_value_dup_text_string(&repMap, &name, &len, NULL); err = err || cbor_value_advance(&repMap); int64_t intval = 0; bool boolval = false; char* strval = NULL; double doubleval = 0; OCRepPayload* pl; switch(cbor_value_get_type(&repMap)) { case CborNullType: err = !OCRepPayloadSetNull(curPayload, name); break; case CborIntegerType: err = err || cbor_value_get_int64(&repMap, &intval); if (!err) { err = !OCRepPayloadSetPropInt(curPayload, name, intval); } break; case CborDoubleType: err = err || cbor_value_get_double(&repMap, &doubleval); if (!err) { err = !OCRepPayloadSetPropDouble(curPayload, name, doubleval); } break; case CborBooleanType: err = err || cbor_value_get_boolean(&repMap, &boolval); if (!err) { err = !OCRepPayloadSetPropBool(curPayload, name, boolval); } break; case CborTextStringType: err = err || cbor_value_dup_text_string(&repMap, &strval, &len, NULL); if (!err) { err = !OCRepPayloadSetPropStringAsOwner(curPayload, name, strval); } break; case CborMapType: err = err || OCParseSingleRepPayload(&pl, &repMap); if (!err) { err = !OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl); } break; case CborArrayType: err = err || OCParseArray(curPayload, name, &repMap); break; default: OC_LOG_V(ERROR, TAG, "Parsing rep property, unknown type %d", repMap.type); err = true; } err = err || cbor_value_advance(&repMap); OICFree(name); } err = err || cbor_value_leave_container(&curVal, &repMap); } if(err) { OCRepPayloadDestroy(*outPayload); *outPayload = NULL; } return err; }
static OCStackResult OCParsePresencePayload(OCPayload** outPayload, CborValue* arrayVal) { if (!outPayload) { return OC_STACK_INVALID_PARAM; } bool err = false; if(cbor_value_is_map(arrayVal)) { uint64_t seqNum = 0; uint64_t maxAge = 0; OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE; char* tempStr = NULL; size_t len = 0; CborValue curVal; // Sequence Number err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_NONCE, &curVal); err = err || cbor_value_get_uint64(&curVal, &seqNum); // Max Age err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_TTL, &curVal); err = err || cbor_value_get_uint64(&curVal, &maxAge); // Trigger err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_TRIGGER, &curVal); err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL); trigger = convertTriggerStringToEnum(tempStr); OICFree(tempStr); tempStr = NULL; // Resource type name err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_RESOURCE_TYPE, &curVal); if(cbor_value_is_valid(&curVal)) { err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL); } err = err || cbor_value_advance(arrayVal); if(!err) { *outPayload = (OCPayload*)OCPresencePayloadCreate(seqNum, maxAge, trigger, tempStr); } OICFree(tempStr); if(err) { OCPayloadDestroy(*outPayload); OC_LOG(ERROR, TAG, "CBOR error Parse Presence Payload"); return OC_STACK_MALFORMED_RESPONSE; } if(!*outPayload) { return OC_STACK_NO_MEMORY; } return OC_STACK_OK; } else { OC_LOG(ERROR, TAG, "Root presence node was not a map"); return OC_STACK_MALFORMED_RESPONSE; } }
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; }