/** * Updates \a it to point to the next element after the container. The \a * recursed object needs to point to the element obtained either by advancing * the last element of the container (via cbor_value_advance(), * cbor_value_advance_fixed(), a nested cbor_value_leave_container(), or the \c * next pointer from cbor_value_copy_string() or cbor_value_dup_string()). * * \sa cbor_value_enter_container(), cbor_value_at_end() */ CborError cbor_value_leave_container(CborValue *it, const CborValue *recursed) { assert(cbor_value_is_container(it)); assert(recursed->type == CborInvalidType); it->ptr = recursed->ptr; return preparse_next_value(it); }
static CborError advance_recursive(CborValue *it, int nestingLevel) { if (is_fixed_type(it->type)) return advance_internal(it); if (!cbor_value_is_container(it)) { size_t len = SIZE_MAX; return _cbor_value_copy_string(it, NULL, &len, it); } // map or array if (nestingLevel == CBOR_PARSER_MAX_RECURSIONS) return CborErrorNestingTooDeep; CborError err; CborValue recursed; err = cbor_value_enter_container(it, &recursed); if (err) return err; while (!cbor_value_at_end(&recursed)) { err = advance_recursive(&recursed, nestingLevel + 1); if (err) return err; } return cbor_value_leave_container(it, &recursed); }
/** * Creates a CborValue iterator pointing to the first element of the container * represented by \a it and saves it in \a recursed. The \a it container object * needs to be kept and passed again to cbor_value_leave_container() in order * to continue iterating past this container. * * \sa cbor_value_is_container(), cbor_value_leave_container(), cbor_value_advance() */ CborError cbor_value_enter_container(const CborValue *it, CborValue *recursed) { CborError err; assert(cbor_value_is_container(it)); *recursed = *it; if (it->flags & CborIteratorFlag_UnknownLength) { recursed->remaining = UINT32_MAX; ++recursed->ptr; err = preparse_value(recursed); if (err != CborErrorUnexpectedBreak) return err; // actually, break was expected here // it's just an empty container ++recursed->ptr; } else { uint64_t len; err = extract_number(&recursed->ptr, recursed->parser->end, &len); assert(err == CborNoError); recursed->remaining = len; if (recursed->remaining != len || len == UINT32_MAX) { // back track the pointer to indicate where the error occurred recursed->ptr = it->ptr; return CborErrorDataTooLarge; } if (recursed->type == CborMapType) { // maps have keys and values, so we need to multiply by 2 if (recursed->remaining > UINT32_MAX / 2) { // back track the pointer to indicate where the error occurred recursed->ptr = it->ptr; return CborErrorDataTooLarge; } recursed->remaining *= 2; } if (len != 0) return preparse_value(recursed); } // the case of the empty container recursed->type = CborInvalidType; recursed->remaining = 0; return CborNoError; }
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; }
static CborError OCParseSingleRepPayload(OCRepPayload **outPayload, CborValue *objMap, bool isRoot) { CborError err = CborUnknownError; char *name = NULL; bool res; VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload"); VERIFY_PARAM_NON_NULL(TAG, objMap, "Invalid Parameter objMap"); if (cbor_value_is_map(objMap)) { if (!*outPayload) { *outPayload = OCRepPayloadCreate(); if (!*outPayload) { return CborErrorOutOfMemory; } } OCRepPayload *curPayload = *outPayload; size_t len = 0; CborValue repMap; err = cbor_value_enter_container(objMap, &repMap); VERIFY_CBOR_SUCCESS(TAG, err, "Failed entering repMap"); while (!err && cbor_value_is_valid(&repMap)) { if (cbor_value_is_text_string(&repMap)) { err = cbor_value_dup_text_string(&repMap, &name, &len, NULL); VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding tag name in the map"); err = cbor_value_advance(&repMap); VERIFY_CBOR_SUCCESS(TAG, err, "Failed advancing rootMap"); if (name && isRoot && ((0 == strcmp(OC_RSRVD_HREF, name)) || (0 == strcmp(OC_RSRVD_RESOURCE_TYPE, name)) || (0 == strcmp(OC_RSRVD_INTERFACE, name)))) { err = cbor_value_advance(&repMap); OICFree(name); continue; } } CborType type = cbor_value_get_type(&repMap); switch (type) { case CborNullType: res = OCRepPayloadSetNull(curPayload, name); break; case CborIntegerType: { int64_t intval = 0; err = cbor_value_get_int64(&repMap, &intval); VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting int value"); res = OCRepPayloadSetPropInt(curPayload, name, intval); } break; case CborDoubleType: { double doubleval = 0; err = cbor_value_get_double(&repMap, &doubleval); VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting double value"); res = OCRepPayloadSetPropDouble(curPayload, name, doubleval); } break; case CborBooleanType: { bool boolval = false; err = cbor_value_get_boolean(&repMap, &boolval); VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting boolean value"); res = OCRepPayloadSetPropBool(curPayload, name, boolval); } break; case CborTextStringType: { char *strval = NULL; err = cbor_value_dup_text_string(&repMap, &strval, &len, NULL); VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting string value"); res = OCRepPayloadSetPropStringAsOwner(curPayload, name, strval); } break; case CborByteStringType: { uint8_t* bytestrval = NULL; err = cbor_value_dup_byte_string(&repMap, &bytestrval, &len, NULL); VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting byte string value"); OCByteString tmp = {.bytes = bytestrval, .len = len}; res = OCRepPayloadSetPropByteStringAsOwner(curPayload, name, &tmp); } break; case CborMapType: { OCRepPayload *pl = NULL; err = OCParseSingleRepPayload(&pl, &repMap, false); VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting parse single rep"); res = OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl); } break; case CborArrayType: err = OCParseArray(curPayload, name, &repMap); break; default: OIC_LOG_V(ERROR, TAG, "Parsing rep property, unknown type %d", repMap.type); res = false; } if (type != CborArrayType) { err = (CborError) !res; } VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting value"); if (type != CborMapType && cbor_value_is_valid(&repMap)) { err = cbor_value_advance(&repMap); VERIFY_CBOR_SUCCESS(TAG, err, "Failed advance repMap"); } OICFree(name); name = NULL; } if (cbor_value_is_container(objMap)) { err = cbor_value_leave_container(objMap, &repMap); VERIFY_CBOR_SUCCESS(TAG, err, "Failed to leave container"); } return err; } exit: OICFree(name); OCRepPayloadDestroy(*outPayload); *outPayload = NULL; return err; }