static bool OCParseSingleRepPayload(OCRepPayload** outPayload, CborValue *objMap) { if (!outPayload) { return false; } bool err = false; if (cbor_value_is_map(objMap)) { if (!*outPayload) { *outPayload = OCRepPayloadCreate(); if(!*outPayload) { return CborErrorOutOfMemory; } } OCRepPayload* curPayload = *outPayload; size_t len; CborValue repMap; err = err || cbor_value_enter_container(objMap, &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); CborType type = cbor_value_get_type(&repMap); switch(type) { case CborNullType: err = !OCRepPayloadSetNull(curPayload, name); break; case CborIntegerType: { int64_t intval = 0; err = err || cbor_value_get_int64(&repMap, &intval); if (!err) { err = !OCRepPayloadSetPropInt(curPayload, name, intval); } } break; case CborDoubleType: { double doubleval = 0; err = err || cbor_value_get_double(&repMap, &doubleval); if (!err) { err = !OCRepPayloadSetPropDouble(curPayload, name, doubleval); } } break; case CborBooleanType: { bool boolval = false; err = err || cbor_value_get_boolean(&repMap, &boolval); if (!err) { err = !OCRepPayloadSetPropBool(curPayload, name, boolval); } } break; case CborTextStringType: { char* strval = NULL; err = err || cbor_value_dup_text_string(&repMap, &strval, &len, NULL); if (!err) { err = !OCRepPayloadSetPropStringAsOwner(curPayload, name, strval); } } break; case CborByteStringType: { uint8_t* bytestrval = NULL; err = err || cbor_value_dup_byte_string(&repMap, &bytestrval, &len, NULL); if (!err) { OCByteString tmp = {.bytes = bytestrval, .len = len}; err = !OCRepPayloadSetPropByteStringAsOwner(curPayload, name, &tmp); } } break; case CborMapType: { OCRepPayload *pl = NULL; 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; } if (type != CborMapType && cbor_value_is_valid(&repMap)) { err = err || cbor_value_advance(&repMap); } OICFree(name); } err = err || cbor_value_leave_container(objMap, &repMap); if(err) { OCRepPayloadDestroy(*outPayload); *outPayload = NULL; } }
static bool OCParseArray(OCRepPayload* out, const char* name, CborValue* container) { OCRepPayloadPropType type; size_t dimensions[MAX_REP_ARRAY_DEPTH]; bool err = OCParseArrayFindDimensionsAndType(container, dimensions, &type); if (err) { OC_LOG(ERROR, TAG, "Array details weren't clear"); return err; } if (type == OCREP_PROP_NULL) { err = err || OCRepPayloadSetNull(out, name); err = err || cbor_value_advance(container); return err; } size_t dimTotal = calcDimTotal(dimensions); size_t allocSize = getAllocSize(type); void* arr = OICCalloc(dimTotal, allocSize); if (!arr) { OC_LOG(ERROR, TAG, "Array Parse allocation failed"); return true; } err = err || OCParseArrayFillArray(container, dimensions, type, arr); switch (type) { case OCREP_PROP_INT: if (err || !OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t*)arr, dimensions)) { OICFree(arr); err = true; } break; case OCREP_PROP_DOUBLE: if (err || !OCRepPayloadSetDoubleArrayAsOwner(out, name, (double*)arr, dimensions)) { OICFree(arr); err = true; } break; case OCREP_PROP_BOOL: if (err || !OCRepPayloadSetBoolArrayAsOwner(out, name, (bool*)arr, dimensions)) { OICFree(arr); err = true; } break; case OCREP_PROP_STRING: if (err || !OCRepPayloadSetStringArrayAsOwner(out, name, (char**)arr, dimensions)) { for(size_t i = 0; i < dimTotal; ++i) { OICFree(((char**)arr)[i]); } OICFree(arr); err = true; } break; case OCREP_PROP_OBJECT: if (err || !OCRepPayloadSetPropObjectArrayAsOwner(out, name, (OCRepPayload**)arr, dimensions)) { for(size_t i = 0; i < dimTotal; ++i) { OCRepPayloadDestroy(((OCRepPayload**)arr)[i]); } OICFree(arr); err = true; } break; default: OC_LOG(ERROR, TAG, "Invalid Array type in Parse Array"); err = true; break; } return err; }
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 int _icd_state_value_from_gvariant(OCRepPayload *repr, GVariantIter *iter) { int ret; char *key; GVariant *var; const char *str_value; OCRepPayload *repr_value; struct icd_state_list_s value_list = {0}; while (g_variant_iter_loop(iter, "{sv}", &key, &var)) { if (g_variant_is_of_type(var, G_VARIANT_TYPE_BOOLEAN)) { OCRepPayloadSetPropBool(repr, key, g_variant_get_boolean(var)); } else if (g_variant_is_of_type(var, G_VARIANT_TYPE_INT32)) { OCRepPayloadSetPropInt(repr, key, g_variant_get_int32(var)); } else if (g_variant_is_of_type(var, G_VARIANT_TYPE_DOUBLE)) { OCRepPayloadSetPropDouble(repr, key, g_variant_get_double(var)); } else if (g_variant_is_of_type(var, G_VARIANT_TYPE_STRING)) { str_value = g_variant_get_string(var, NULL); if (NULL == str_value) { ERR("g_variant_get_string() Fail"); _icd_payload_state_list_destroy(&value_list); return IOTCON_ERROR_OUT_OF_MEMORY; } if (IC_STR_EQUAL == strcmp(IC_STR_NULL, str_value)) OCRepPayloadSetNull(repr, key); else OCRepPayloadSetPropString(repr, key, str_value); } else if (g_variant_is_of_type(var, G_VARIANT_TYPE("ay"))) { OCByteString byte_value; byte_value.bytes = (uint8_t*)g_variant_get_data(var); byte_value.len = g_variant_get_size(var); OCRepPayloadSetPropByteString(repr, key, byte_value); } else if (g_variant_is_of_type(var, G_VARIANT_TYPE("a{sv}"))) { GVariantIter state_iter; repr_value = OCRepPayloadCreate(); g_variant_iter_init(&state_iter, var); ret = _icd_state_value_from_gvariant(repr_value, &state_iter); if (IOTCON_ERROR_NONE != ret) { ERR("_icd_state_value_from_gvariant() Fail(%d)", ret); _icd_payload_state_list_destroy(&value_list); OCRepPayloadDestroy(repr_value); return ret; } OCRepPayloadSetPropObjectAsOwner(repr, key, repr_value); } else if (g_variant_is_of_type(var, G_VARIANT_TYPE_ARRAY)) { memset(&value_list, 0, sizeof(struct icd_state_list_s)); ret = _icd_state_list_from_gvariant(var, &value_list, 0); if (IOTCON_ERROR_NONE != ret) { ERR("_icd_state_list_from_gvariant() Fail(%d)", ret); _icd_payload_state_list_destroy(&value_list); return ret; } ret = _icd_state_array_from_list(repr, &value_list, key); if (IOTCON_ERROR_NONE != ret) { ERR("_icd_state_array_from_list() Fail(%d)", ret); _icd_payload_state_list_destroy(&value_list); return ret; } } else { ERR("Invalid type(%s)", g_variant_get_type_string(var)); return IOTCON_ERROR_INVALID_TYPE; } } return IOTCON_ERROR_NONE; }
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; }
static CborError OCParseArrayFillArray(const CborValue *parent, size_t dimensions[MAX_REP_ARRAY_DEPTH], OCRepPayloadPropType type, void *targetArray) { CborValue insideArray; size_t i = 0; char *tempStr = NULL; OCByteString ocByteStr = { .bytes = NULL, .len = 0}; size_t tempLen = 0; OCRepPayload *tempPl = NULL; size_t newdim[MAX_REP_ARRAY_DEPTH]; newdim[0] = dimensions[1]; newdim[1] = dimensions[2]; newdim[2] = 0; CborError err = cbor_value_enter_container(parent, &insideArray); VERIFY_CBOR_SUCCESS(TAG, err, "Failed to enter container"); while (!err && i < dimensions[0] && cbor_value_is_valid(&insideArray)) { bool noAdvance = false; if (cbor_value_get_type(&insideArray) != CborNullType) { switch (type) { case OCREP_PROP_INT: if (dimensions[1] == 0) { err = cbor_value_get_int64(&insideArray, &(((int64_t*)targetArray)[i])); } else { err = OCParseArrayFillArray(&insideArray, newdim, type, &(((int64_t*)targetArray)[arrayStep(dimensions, i)])); } break; case OCREP_PROP_DOUBLE: if (dimensions[1] == 0) { err = cbor_value_get_double(&insideArray, &(((double*)targetArray)[i])); } else { err = OCParseArrayFillArray(&insideArray, newdim, type, &(((double*)targetArray)[arrayStep(dimensions, i)])); } break; case OCREP_PROP_BOOL: if (dimensions[1] == 0) { err = cbor_value_get_boolean(&insideArray, &(((bool*)targetArray)[i])); } else { err = OCParseArrayFillArray(&insideArray, newdim, type, &(((bool*)targetArray)[arrayStep(dimensions, i)])); } break; case OCREP_PROP_STRING: if (dimensions[1] == 0) { err = cbor_value_dup_text_string(&insideArray, &tempStr, &tempLen, NULL); ((char**)targetArray)[i] = tempStr; tempStr = NULL; } else { err = OCParseArrayFillArray(&insideArray, newdim, type, &(((char**)targetArray)[arrayStep(dimensions, i)])); } break; case OCREP_PROP_BYTE_STRING: if (dimensions[1] == 0) { err = cbor_value_dup_byte_string(&insideArray, &(ocByteStr.bytes), &(ocByteStr.len), NULL); ((OCByteString*)targetArray)[i] = ocByteStr; } else { err = OCParseArrayFillArray(&insideArray, newdim, type, &(((OCByteString*)targetArray)[arrayStep(dimensions, i)])); } break; case OCREP_PROP_OBJECT: if (dimensions[1] == 0) { err = OCParseSingleRepPayload(&tempPl, &insideArray, false); ((OCRepPayload**)targetArray)[i] = tempPl; tempPl = NULL; noAdvance = true; } else { err = OCParseArrayFillArray(&insideArray, newdim, type, &(((OCRepPayload**)targetArray)[arrayStep(dimensions, i)])); } break; default: OIC_LOG(ERROR, TAG, "Invalid Array type in Parse Array"); err = CborErrorUnknownType; break; } VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting repPayload"); } ++i; if (!noAdvance && cbor_value_is_valid(&insideArray)) { err = cbor_value_advance(&insideArray); VERIFY_CBOR_SUCCESS(TAG, err, "Failed advnce insideArray"); } } exit: return err; } 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; bool res = true; CborError err = OCParseArrayFindDimensionsAndType(container, dimensions, &type); VERIFY_CBOR_SUCCESS(TAG, err, "Array details weren't clear"); if (type == OCREP_PROP_NULL) { res = OCRepPayloadSetNull(out, name); err = (CborError) !res; VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting value"); err = cbor_value_advance(container); VERIFY_CBOR_SUCCESS(TAG, err, "Failed advancing container"); return err; } dimTotal = calcDimTotal(dimensions); allocSize = getAllocSize(type); arr = OICCalloc(dimTotal, allocSize); VERIFY_PARAM_NON_NULL(TAG, arr, "Array Parse allocation failed"); res = OCParseArrayFillArray(container, dimensions, type, arr); VERIFY_CBOR_SUCCESS(TAG, err, "Failed parse array"); switch (type) { case OCREP_PROP_INT: res = OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t *)arr, dimensions); break; case OCREP_PROP_DOUBLE: res = OCRepPayloadSetDoubleArrayAsOwner(out, name, (double *)arr, dimensions); break; case OCREP_PROP_BOOL: res = OCRepPayloadSetBoolArrayAsOwner(out, name, (bool *)arr, dimensions); break; case OCREP_PROP_STRING: res = OCRepPayloadSetStringArrayAsOwner(out, name, (char **)arr, dimensions); break; case OCREP_PROP_BYTE_STRING: res = OCRepPayloadSetByteStringArrayAsOwner(out, name, (OCByteString *)arr, dimensions); break; case OCREP_PROP_OBJECT: res = OCRepPayloadSetPropObjectArrayAsOwner(out, name, (OCRepPayload**)arr, dimensions); break; default: OIC_LOG(ERROR, TAG, "Invalid Array type in Parse Array"); break; } err = (CborError) !res; VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting array parameter"); return CborNoError; exit: if (type == OCREP_PROP_STRING) { for(size_t i = 0; i < dimTotal; ++i) { OICFree(((char**)arr)[i]); } } if (type == OCREP_PROP_BYTE_STRING) { for(size_t i = 0; i < dimTotal; ++i) { OICFree(((OCByteString*)arr)[i].bytes); } } if (type == OCREP_PROP_OBJECT) { for(size_t i = 0; i < dimTotal; ++i) { OCRepPayloadDestroy(((OCRepPayload**)arr)[i]); } } OICFree(arr); return err; }