static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* rootValue) { OCStackResult ret = OC_STACK_MALFORMED_RESPONSE; CborError err; char *securityData = NULL; VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid parameter"); VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid cbor"); CborValue strVal; err = cbor_value_enter_container(rootValue, &strVal); VERIFY_CBOR_SUCCESS(TAG, err, "Failed entering container"); if (cbor_value_is_text_string(&strVal)) { size_t len = 0; err = cbor_value_dup_text_string(&strVal, &securityData, &len, NULL); VERIFY_CBOR_SUCCESS(TAG, err, "Failed reading security data"); *outPayload = (OCPayload *)OCSecurityPayloadCreate(securityData); VERIFY_PARAM_NON_NULL(TAG, *outPayload, "Invalid cbor"); ret = OC_STACK_OK; } exit: OICFree(securityData); return ret; }
static CborError OCTagsCborToPayload(CborValue *tagsMap, OCTagsPayload **tagsPayload) { CborError cborFindResult = CborErrorOutOfMemory; OCTagsPayload *tags = (OCTagsPayload *)OICCalloc(1, sizeof(OCTagsPayload)); VERIFY_PARAM_NON_NULL(TAG, tags, "Failed allocating tags"); cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_DEVICE_NAME, &tags->n.deviceName); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding deviceName"); { char *deviceId = NULL; cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_DEVICE_ID, &deviceId); if (deviceId) { memcpy(tags->di.id, deviceId, strlen(deviceId)); OICFree(deviceId); } VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding deviceId"); } cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_DEVICE_TTL, &tags->ttl); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding ttl"); *tagsPayload = tags; return cborFindResult; exit: OCFreeTagsResource(tags); return cborFindResult; }
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 CborError OCTagsCborToPayload(CborValue *tagsMap, OCTagsPayload **tagsPayload) { CborError cborFindResult = CborErrorOutOfMemory; OCTagsPayload *tags = (OCTagsPayload *)OICCalloc(1, sizeof(OCTagsPayload)); VERIFY_PARAM_NON_NULL(TAG, tags, "Failed allocating tags"); if (cbor_value_is_map(tagsMap)) { cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_DEVICE_NAME, &tags->n.deviceName); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding deviceName"); cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_DREL, &tags->drel); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding drel"); cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_RTS, &tags->rts); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding rts"); cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_BASE_URI, &tags->baseURI); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding baseURI"); char *deviceId = NULL; cborFindResult = FindStringInMap(tagsMap, OC_RSRVD_DEVICE_ID, &deviceId); if (deviceId) { memcpy(tags->di.id, deviceId, strlen(deviceId)); OICFree(deviceId); } VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding deviceId"); { uint64_t value = 0; cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_HOSTING_PORT, &value); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding port"); tags->port = value; value = 0; cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_BITMAP, &value); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding bitmap"); tags->bitmap = value; value = 0; cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_INS, &value); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding ins"); tags->ins = value; value = 0; cborFindResult = FindIntInMap(tagsMap, OC_RSRVD_TTL, &value); tags->ttl = value; } VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding ttl"); cborFindResult = cbor_value_advance(tagsMap); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed advancing bitmap"); } *tagsPayload = tags; return cborFindResult; exit: OCFreeTagsResource(tags); return cborFindResult; }
static int64_t OCConvertRepMap(CborEncoder *map, const OCRepPayload *payload) { int64_t err = CborNoError; CborEncoder repMap; err |= cbor_encoder_create_map(map, &repMap, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep map"); err |= OCConvertSingleRepPayload(&repMap, payload); VERIFY_CBOR_SUCCESS(TAG, err, "Failed converting single rep payload"); err |= cbor_encoder_close_container(map, &repMap); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep map"); exit: return err; }
static int64_t OCConvertArray(CborEncoder *parent, const OCRepPayloadValueArray *valArray) { int64_t err = CborNoError; CborEncoder array; err |= cbor_encoder_create_array(parent, &array, valArray->dimensions[0]); VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array"); for (size_t i = 0; i < valArray->dimensions[0]; ++i) { if (0 != valArray->dimensions[1]) { CborEncoder array2; err |= cbor_encoder_create_array(&array, &array2, valArray->dimensions[1]); VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array2"); for (size_t j = 0; j < valArray->dimensions[1]; ++j) { if (0 != valArray->dimensions[2]) { CborEncoder array3; err |= cbor_encoder_create_array(&array2, &array3, valArray->dimensions[2]); VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array3"); for(size_t k = 0; k < valArray->dimensions[2]; ++k) { err |= OCConvertArrayItem(&array3, valArray, j * valArray->dimensions[2] + i * valArray->dimensions[2] * valArray->dimensions[1] + k); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array3 value"); } err |= cbor_encoder_close_container(&array2, &array3); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array3"); } else { err |= OCConvertArrayItem(&array2, valArray, i * valArray->dimensions[1] + j); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array2 value"); } } err |= cbor_encoder_close_container(&array, &array2); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array2"); } else { err |= OCConvertArrayItem(&array, valArray, i); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array value"); } } err |= cbor_encoder_close_container(parent, &array); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array"); exit: return err; }
static int64_t OCTagsPayloadToCbor(OCTagsPayload *tags, CborEncoder *setMap) { int64_t cborEncoderResult = CborNoError; cborEncoderResult |= ConditionalAddTextStringToMap(setMap, OC_RSRVD_DEVICE_NAME, tags->n.deviceName); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_NAME in tags map"); cborEncoderResult |= ConditionalAddTextStringToMap(setMap, OC_RSRVD_DEVICE_ID, (char *)tags->di.id); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_ID in tags map"); cborEncoderResult |= ConditionalAddIntToMap(setMap, OC_RSRVD_DEVICE_TTL, &tags->ttl); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_TTL in tags map"); exit: return cborEncoderResult; }
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; }
static int64_t OCConvertSingleRepPayload(CborEncoder *repMap, const OCRepPayload *payload) { int64_t err = CborNoError; OCRepPayloadValue *value = payload->values; while (value) { err |= cbor_encode_text_string(repMap, value->name, strlen(value->name)); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tag name"); switch (value->type) { case OCREP_PROP_NULL: err |= cbor_encode_null(repMap); break; case OCREP_PROP_INT: err |= cbor_encode_int(repMap, value->i); break; case OCREP_PROP_DOUBLE: err |= cbor_encode_double(repMap, value->d); break; case OCREP_PROP_BOOL: err |= cbor_encode_boolean(repMap, value->b); break; case OCREP_PROP_STRING: err |= cbor_encode_text_string(repMap, value->str, strlen(value->str)); break; case OCREP_PROP_BYTE_STRING: err |= cbor_encode_byte_string(repMap, value->ocByteStr.bytes, value->ocByteStr.len); break; case OCREP_PROP_OBJECT: err |= OCConvertRepMap(repMap, value->obj); break; case OCREP_PROP_ARRAY: err |= OCConvertArray(repMap, &value->arr); break; default: OIC_LOG_V(ERROR, TAG, "Invalid Prop type: %d", value->type); break; } VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding single rep value"); value = value->next; } exit: return err; }
static int64_t AddTextStringToMap(CborEncoder* map, const char* key, const char* value) { int64_t err = cbor_encode_text_string(map, key, strlen(key)); VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting key value"); err |= cbor_encode_text_string(map, value, strlen(value)); exit: return err; }
static int64_t OCConvertDevicePayload(OCDevicePayload *payload, uint8_t *outPayload, size_t *size) { if (!payload) { return CborUnknownError; } int64_t err = CborNoError; CborEncoder encoder; cbor_encoder_init(&encoder, outPayload, *size, 0); CborEncoder repMap; err |= cbor_encoder_create_map(&encoder, &repMap, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating device map"); // Resource Type if (payload->types) { OIC_LOG(INFO, TAG, "Payload has types"); err |= OCStringLLJoin(&repMap, OC_RSRVD_RESOURCE_TYPE, payload->types); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type tag/value."); } if (payload->interfaces) { OIC_LOG(INFO, TAG, "Payload has interface"); err |= OCStringLLJoin(&repMap, OC_RSRVD_INTERFACE, payload->interfaces); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding interface type tag/value."); } // Device ID err |= AddTextStringToMap(&repMap, OC_RSRVD_DEVICE_ID, sizeof(OC_RSRVD_DEVICE_ID) - 1 , payload->sid); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding device id"); // Device Name err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_DEVICE_NAME, sizeof(OC_RSRVD_DEVICE_NAME) - 1, payload->deviceName); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding device name"); // Device Spec Version err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SPEC_VERSION, sizeof(OC_RSRVD_SPEC_VERSION) - 1, payload->specVersion); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding data spec version"); // Device data Model Version err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_DATA_MODEL_VERSION, sizeof(OC_RSRVD_DATA_MODEL_VERSION) - 1, payload->dataModelVersion); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding data model version"); err |= cbor_encoder_close_container(&encoder, &repMap); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing device map"); exit: return checkError(err, &encoder, outPayload, size); }
static int64_t AddStringLLToMap(CborEncoder *map, const char *tag, const OCStringLL *strType) { CborEncoder array; int64_t cborEncoderResult = CborNoError; cborEncoderResult |= cbor_encode_text_string(map, tag, strlen(tag)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed encoding string tag name"); cborEncoderResult |= cbor_encoder_create_array(map, &array, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed creating stringLL array"); while (strType) { cborEncoderResult |= cbor_encode_text_string(&array, strType->value, strlen(strType->value)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed encoding string value"); strType = strType->next; } cborEncoderResult |= cbor_encoder_close_container(map, &array); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing string array"); exit: return cborEncoderResult; }
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 int64_t ConditionalAddIntToMap(CborEncoder *map, const char *tags, const uint64_t *value) { int64_t err = CborNoError; if (*value) { err |= cbor_encode_text_string(map, tags, strlen(tags)); VERIFY_CBOR_SUCCESS(TAG, err, "failed setting value"); err |= cbor_encode_uint(map, *value); } exit: return err; }
static int64_t OCConvertPresencePayload(OCPresencePayload *payload, uint8_t *outPayload, size_t *size) { int64_t err = CborNoError; CborEncoder encoder; cbor_encoder_init(&encoder, outPayload, *size, 0); CborEncoder map; err |= cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating presence map"); // Sequence Number err |= cbor_encode_text_string(&map, OC_RSRVD_NONCE, sizeof(OC_RSRVD_NONCE) - 1); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding nonce tag to presence map"); err |= cbor_encode_uint(&map, payload->sequenceNumber); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding nonce value to presence map"); // Max Age err |= cbor_encode_text_string(&map, OC_RSRVD_TTL, sizeof(OC_RSRVD_TTL) - 1); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding ttl tag to presence map"); err |= cbor_encode_uint(&map, payload->maxAge); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding ttl value to presence map"); // Trigger err |= cbor_encode_text_string(&map, OC_RSRVD_TRIGGER, sizeof(OC_RSRVD_TRIGGER) - 1); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding trigger tag to presence map"); err |= cbor_encode_simple_value(&map, payload->trigger); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding trigger value to presence map"); // Resource type name if (payload->trigger != OC_PRESENCE_TRIGGER_DELETE) { err |= ConditionalAddTextStringToMap(&map, OC_RSRVD_RESOURCE_TYPE, sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, payload->resourceType); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type to presence map"); } // Close Map err |= cbor_encoder_close_container(&encoder, &map); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing presence map"); exit: return checkError(err, &encoder, outPayload, size); }
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 int64_t OCConvertRepPayload(OCRepPayload *payload, uint8_t *outPayload, size_t *size) { CborEncoder encoder; int64_t err = CborNoError; cbor_encoder_init(&encoder, outPayload, *size, 0); size_t arrayCount = 0; for (OCRepPayload *temp = payload; temp; temp = temp->next) { arrayCount++; } CborEncoder rootArray; if (arrayCount > 1) { err |= cbor_encoder_create_array(&encoder, &rootArray, arrayCount); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep root map"); } while (payload != NULL && (err == CborNoError)) { CborEncoder rootMap; err |= cbor_encoder_create_map(((arrayCount == 1)? &encoder: &rootArray), &rootMap, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating root map"); // Only in case of collection href is included. if (arrayCount > 1 && payload->uri && strlen(payload->uri) > 0) { OIC_LOG(INFO, TAG, "Payload has uri"); err |= cbor_encode_text_string(&rootMap, OC_RSRVD_HREF, strlen(OC_RSRVD_HREF)); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep href tag"); err |= cbor_encode_text_string(&rootMap, payload->uri, strlen(payload->uri)); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep href value"); } if (payload->types) { OIC_LOG(INFO, TAG, "Payload has types"); err |= OCStringLLJoin(&rootMap, OC_RSRVD_RESOURCE_TYPE, payload->types); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type."); } if (payload->interfaces) { OIC_LOG(INFO, TAG, "Payload has interfaces"); err |= OCStringLLJoin(&rootMap, OC_RSRVD_INTERFACE, payload->interfaces); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform interface type."); } err |= OCConvertSingleRepPayload(&rootMap, payload); VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting rep payload"); // Close main array err |= cbor_encoder_close_container(((arrayCount == 1) ? &encoder: &rootArray), &rootMap); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root map"); payload = payload->next; } if (arrayCount > 1) { err |= cbor_encoder_close_container(&encoder, &rootArray); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root array"); } exit: return checkError(err, &encoder, outPayload, size); }
/** * 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; }
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 int64_t OCConvertPlatformPayload(OCPlatformPayload *payload, uint8_t *outPayload, size_t *size) { int64_t err = CborNoError; CborEncoder encoder; cbor_encoder_init(&encoder, outPayload, *size, 0); CborEncoder repMap; err |= cbor_encoder_create_map(&encoder, &repMap, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating platform map"); // Platform ID err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_ID, sizeof(OC_RSRVD_PLATFORM_ID) - 1, payload->info.platformID); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform id"); // MFG Name err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_NAME, sizeof(OC_RSRVD_MFG_NAME) - 1, payload->info.manufacturerName); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding mfg name"); // MFG Url err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_URL, sizeof(OC_RSRVD_MFG_URL) - 1, payload->info.manufacturerUrl); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding mfg url"); // Model Num err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MODEL_NUM, sizeof(OC_RSRVD_MODEL_NUM) -1, payload->info.modelNumber); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding model num"); // Date of Mfg err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_DATE, sizeof(OC_RSRVD_MFG_DATE) - 1, payload->info.dateOfManufacture); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding mfg date"); // Platform Version err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_VERSION, sizeof(OC_RSRVD_PLATFORM_VERSION) - 1, payload->info.platformVersion); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform version"); // OS Version err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_OS_VERSION, sizeof(OC_RSRVD_OS_VERSION) - 1, payload->info.operatingSystemVersion); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding OS version"); // Hardware Version err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_HARDWARE_VERSION, sizeof(OC_RSRVD_HARDWARE_VERSION) - 1, payload->info.hardwareVersion); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding HW version"); // Firmware Version err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_FIRMWARE_VERSION, sizeof(OC_RSRVD_FIRMWARE_VERSION) - 1, payload->info.firmwareVersion); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding firmware version"); // Support URL err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SUPPORT_URL, sizeof(OC_RSRVD_SUPPORT_URL) - 1, payload->info.supportUrl); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding support url"); // System Time err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SYSTEM_TIME, sizeof(OC_RSRVD_SYSTEM_TIME) - 1, payload->info.systemTime); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding system time"); // Resource type if (payload->rt) { err |= OCStringLLJoin(&repMap, OC_RSRVD_RESOURCE_TYPE, payload->rt); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type."); } // Resource interfaces if (payload->interfaces) { err |= OCStringLLJoin(&repMap, OC_RSRVD_INTERFACE, payload->interfaces); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform interface type."); } // Close Map err |= cbor_encoder_close_container(&encoder, &repMap); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep map"); exit: return checkError(err, &encoder, outPayload, size); }
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; }
static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload *payload, uint8_t *outPayload, size_t *size) { CborEncoder encoder; int64_t err = CborNoError; cbor_encoder_init(&encoder, outPayload, *size, 0); if (payload->resources) { /* The format for the payload is "modelled" as JSON. [ // rootArray { // rootMap "di" : UUID, // device ID "rt": "oic.wk.res" "n":"MyDevice" "if":"oic.if.ll oic.if.baseline" "di": "0685B960-736F-46F7-BEC0-9E6CBD61ADC1", links :[ // linksArray contains maps of resources { href, rt, if, policy // Resource 1 }, { href, rt, if, policy // Resource 2 }, . . . ] } ] */ // Open the main root array CborEncoder rootArray; size_t resourceCount = OCDiscoveryPayloadGetResourceCount(payload); err |= cbor_encoder_create_array(&encoder, &rootArray, 1); VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating discovery root array"); // Open the root map in the root array CborEncoder rootMap; err |= cbor_encoder_create_map(&rootArray, &rootMap, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating discovery map"); // Insert Name err |= ConditionalAddTextStringToMap(&rootMap, OC_RSRVD_DEVICE_NAME, sizeof(OC_RSRVD_DEVICE_NAME) - 1, payload->name); VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting name"); // Insert Device ID into the root map err |= AddTextStringToMap(&rootMap, OC_RSRVD_DEVICE_ID, sizeof(OC_RSRVD_DEVICE_ID) - 1, payload->sid); VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting device id"); // Insert Resource Type err |= ConditionalAddTextStringToMap(&rootMap, OC_RSRVD_RESOURCE_TYPE, sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, payload->type); VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting RT"); // Insert interfaces if (payload->interface) { err |= OCStringLLJoin(&rootMap, OC_RSRVD_INTERFACE, payload->interface); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding interface types tag/value"); } // Insert baseURI if present err |= ConditionalAddTextStringToMap(&rootMap, OC_RSRVD_BASE_URI, sizeof(OC_RSRVD_BASE_URI) - 1, payload->baseURI); VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting baseURI"); // Insert Links into the root map. CborEncoder linkArray; err |= cbor_encode_text_string(&rootMap, OC_RSRVD_LINKS, sizeof(OC_RSRVD_LINKS) - 1); VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting links array tag"); err |= cbor_encoder_create_array(&rootMap, &linkArray, resourceCount); VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting links array"); for(size_t i = 0; i < resourceCount; ++i) { CborEncoder linkMap; OCResourcePayload *resource = OCDiscoveryPayloadGetResource(payload, i); VERIFY_PARAM_NON_NULL(TAG, resource, "Failed retrieving resource"); // resource map inside the links array. err |= cbor_encoder_create_map(&linkArray, &linkMap, LINKS_MAP_LEN); VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating links map"); // Below are insertions of the resource properties into the map. // Uri err |= AddTextStringToMap(&linkMap, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1, resource->uri); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding uri to links map"); // Resource Type if (resource->types) { err |= OCStringLLJoin(&linkMap, OC_RSRVD_RESOURCE_TYPE, resource->types); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resourceType tag/value to links map"); } // Interface Types if (resource->interfaces) { err |= OCStringLLJoin(&linkMap, OC_RSRVD_INTERFACE, resource->interfaces); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding interfaces tag/value to links map"); } // Policy CborEncoder policyMap; err |= cbor_encode_text_string(&linkMap, OC_RSRVD_POLICY, sizeof(OC_RSRVD_POLICY) - 1); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding policy tag to links map"); err |= cbor_encoder_create_map(&linkMap, &policyMap, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding policy map to links map"); // Bitmap err |= cbor_encode_text_string(&policyMap, OC_RSRVD_BITMAP, sizeof(OC_RSRVD_BITMAP) - 1); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding bitmap tag to policy map"); err |= cbor_encode_uint(&policyMap, resource->bitmap); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding bitmap value to policy map"); if (resource->secure) { err |= cbor_encode_text_string(&policyMap, OC_RSRVD_SECURE, sizeof(OC_RSRVD_SECURE) - 1); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure tag to policy map"); err |= cbor_encode_boolean(&policyMap, OC_RESOURCE_SECURE); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure value to policy map"); } if ((resource->secure && resource->port != 0) || payload->baseURI) { err |= cbor_encode_text_string(&policyMap, OC_RSRVD_HOSTING_PORT, sizeof(OC_RSRVD_HOSTING_PORT) - 1); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure port tag"); err |= cbor_encode_uint(&policyMap, resource->port); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure port value"); } #ifdef TCP_ADAPTER err |= cbor_encode_text_string(&policyMap, OC_RSRVD_TCP_PORT, sizeof(OC_RSRVD_TCP_PORT) - 1); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tcp port tag"); err |= cbor_encode_uint(&policyMap, resource->tcpPort); VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tcp port value"); #endif err |= cbor_encoder_close_container(&linkMap, &policyMap); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing policy map"); // Finsihed encoding a resource, close the map. err |= cbor_encoder_close_container(&linkArray, &linkMap); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing link map"); } // Close links array inside the root map. err |= cbor_encoder_close_container(&rootMap, &linkArray); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing link array"); // close root map inside the root array. err |= cbor_encoder_close_container(&rootArray, &rootMap); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root map"); // Close the final root array. err |= cbor_encoder_close_container(&encoder, &rootArray); VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root array"); } exit: return checkError(err, &encoder, outPayload, size); }
static int64_t OCTagsPayloadToCbor(OCTagsPayload *tags, CborEncoder *setMap) { CborEncoder tagsMap; int64_t cborEncoderResult = CborNoError; cborEncoderResult |= cbor_encoder_create_map(setMap, &tagsMap, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create tags map"); cborEncoderResult |= ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DEVICE_NAME, tags->n.deviceName); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_NAME in tags map"); cborEncoderResult |= ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DEVICE_ID, (char *)tags->di.id); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_ID in tags map"); cborEncoderResult |= ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_RTS, tags->rts); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_RTS in tags map"); cborEncoderResult |= ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DREL, tags->drel); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DREL in tags map"); cborEncoderResult |= ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_BASE_URI, tags->baseURI); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_BASE_URI in tags map"); { uint64_t value = tags->bitmap; cborEncoderResult |= ConditionalAddIntToMap(&tagsMap, OC_RSRVD_BITMAP, &value); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_BITMAP in tags map"); value = tags->port; cborEncoderResult |= ConditionalAddIntToMap(&tagsMap, OC_RSRVD_HOSTING_PORT, &value); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_HOSTING_PORT in tags map"); value = tags->ins; cborEncoderResult |= ConditionalAddIntToMap(&tagsMap, OC_RSRVD_INS, &value); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_INS in tags map"); value = tags->ttl; cborEncoderResult |= ConditionalAddIntToMap(&tagsMap, OC_RSRVD_TTL, &value); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_TTL in tags map"); } cborEncoderResult |= cbor_encoder_close_container(setMap, &tagsMap); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to close container"); exit: return cborEncoderResult; }
static int64_t OCLinksPayloadToCbor(OCLinksPayload *rtPtr, CborEncoder *setMap) { CborEncoder linksArray; int64_t cborEncoderResult = CborNoError; cborEncoderResult |= cbor_encoder_create_array(setMap, &linksArray, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create Links array"); while (rtPtr) { CborEncoder linksMap; cborEncoderResult |= cbor_encoder_create_map(&linksArray, &linksMap, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create Links map"); cborEncoderResult |= ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_HREF, rtPtr->href); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_HREF in Links map"); cborEncoderResult|= ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_REL, rtPtr->rel); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_REL in Links map"); cborEncoderResult |= ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_TITLE, rtPtr->title); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_TITLE in Links map"); cborEncoderResult |= ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_URI, rtPtr->uri); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_URI in Links map"); cborEncoderResult |= AddStringLLToMap(&linksMap, OC_RSRVD_RESOURCE_TYPE, rtPtr->rt); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_RT in Links map"); cborEncoderResult |= AddStringLLToMap(&linksMap, OC_RSRVD_INTERFACE, rtPtr->itf); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_ITF in Links map"); cborEncoderResult |= AddStringLLToMap(&linksMap, OC_RSRVD_MEDIA_TYPE, rtPtr->mt); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_MT in Links map"); { uint64_t value = rtPtr->ins; cborEncoderResult |= ConditionalAddIntToMap(&linksMap, OC_RSRVD_INS, &value); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_INS in Links map"); } cborEncoderResult |= cbor_encoder_close_container(&linksArray, &linksMap); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing Links map"); rtPtr = rtPtr->next; } cborEncoderResult |= cbor_encoder_close_container(setMap, &linksArray); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing links array"); exit: return cborEncoderResult; }
int64_t OCRDPayloadToCbor(const OCRDPayload *rdPayload, uint8_t *outPayload, size_t *size) { int64_t cborEncoderResult = CborErrorIO; int flags = 0; CborEncoder encoder; VERIFY_PARAM_NON_NULL(TAG, rdPayload, "Invalid input parameter rdPayload"); VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid input parameter outPayload"); VERIFY_PARAM_NON_NULL(TAG, size, "Invalid input parameter size"); cbor_encoder_init(&encoder, outPayload, *size, flags); if (rdPayload->rdDiscovery) { CborEncoder map; cborEncoderResult |= cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create discovery map"); cborEncoderResult |= ConditionalAddTextStringToMap(&map, OC_RSRVD_DEVICE_NAME, rdPayload->rdDiscovery->n.deviceName); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_NAME in map"); cborEncoderResult |= ConditionalAddTextStringToMap(&map, OC_RSRVD_DEVICE_ID, (char *)rdPayload->rdDiscovery->di.id); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_DEVICE_ID in map"); { uint64_t value = rdPayload->rdDiscovery->sel; cborEncoderResult |= ConditionalAddIntToMap(&map, OC_RSRVD_RD_DISCOVERY_SEL, &value); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add RD_DISCOVERY_SEL in map"); } cborEncoderResult |= cbor_encoder_close_container(&encoder, &map); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing discovery map"); } else if (rdPayload->rdPublish) { CborEncoder colArray; cborEncoderResult |= cbor_encoder_create_array(&encoder, &colArray, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create collection array"); OCResourceCollectionPayload *rdPublish = rdPayload->rdPublish; while (rdPublish) { cborEncoderResult |= OCTagsPayloadToCbor(rdPublish->tags, &colArray); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed adding tags payload"); cborEncoderResult |= OCLinksPayloadToCbor(rdPublish->setLinks, &colArray); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed adding setLinks payload"); rdPublish = rdPublish->next; } cborEncoderResult |= cbor_encoder_close_container(&encoder, &colArray); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing collection array"); } else { CborEncoder map; cborEncoderResult |= cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed entering discovery map"); cborEncoderResult |= cbor_encoder_close_container(&encoder, &map); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing discovery map"); } if (cborEncoderResult == CborErrorOutOfMemory) { *size += encoder.ptr - encoder.end; } else { *size = encoder.ptr - outPayload; } return cborEncoderResult; exit: OICFree(outPayload); return cborEncoderResult; }
static CborError OCLinksCborToPayload(CborValue *linksArray, OCLinksPayload **linksPayload) { CborValue linksMap; OCLinksPayload *setLinks = NULL; CborError 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 = FindStringInMap(&linksMap, OC_RSRVD_TITLE, &setLinks->title); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding title value"); cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_URI, &setLinks->uri); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding uri 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"); cborFindResult = FindStringLLInMap(&linksMap, OC_RSRVD_MEDIA_TYPE, &setLinks->mt); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding mt value"); { uint64_t value = 0; cborFindResult = FindIntInMap(&linksMap, OC_RSRVD_INS, &value); VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed finding ins value"); setLinks->ins = 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 PstatToCBORPayload(const OicSecPstat_t *pstat, uint8_t **payload, size_t *size) { if (NULL == pstat || NULL == payload || NULL != *payload || NULL == size) { return OC_STACK_INVALID_PARAM; } size_t cborLen = *size; if (0 == cborLen) { cborLen = CBOR_SIZE; } *payload = NULL; *size = 0; OCStackResult ret = OC_STACK_ERROR; CborEncoder encoder; CborEncoder pstatMap; char* strUuid = NULL; int64_t cborEncoderResult = CborNoError; uint8_t *outPayload = (uint8_t *)OICCalloc(1, cborLen); VERIFY_NON_NULL(TAG, outPayload, ERROR); cbor_encoder_init(&encoder, outPayload, cborLen, 0); cborEncoderResult = cbor_encoder_create_map(&encoder, &pstatMap, PSTAT_MAP_SIZE); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Pstat Map."); cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_ISOP_NAME, strlen(OIC_JSON_ISOP_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ISOP Name Tag."); cborEncoderResult = cbor_encode_boolean(&pstatMap, pstat->isOp); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ISOP Name Value."); cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_DEVICE_ID_NAME, strlen(OIC_JSON_DEVICE_ID_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Device Id Tag."); ret = ConvertUuidToStr(&pstat->deviceID, &strUuid); VERIFY_SUCCESS(TAG, OC_STACK_OK == ret , ERROR); cborEncoderResult = cbor_encode_text_string(&pstatMap, strUuid, strlen(strUuid)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Device Id Value."); OICFree(strUuid); strUuid = NULL; cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_CM_NAME, strlen(OIC_JSON_CM_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CM Name Tag."); cborEncoderResult = cbor_encode_int(&pstatMap, pstat->cm); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CM Name Value."); cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_TM_NAME, strlen(OIC_JSON_TM_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding TM Name Tag."); cborEncoderResult = cbor_encode_int(&pstatMap, pstat->tm); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding TM Name Value."); cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_OM_NAME, strlen(OIC_JSON_OM_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding OM Name Tag."); cborEncoderResult = cbor_encode_int(&pstatMap, pstat->om); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding OM Name Value."); cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_SM_NAME, strlen(OIC_JSON_SM_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SM Name Tag."); cborEncoderResult = cbor_encode_int(&pstatMap, pstat->sm[0]); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SM Name Value."); cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_ROWNERID_NAME, strlen(OIC_JSON_ROWNERID_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ROwner Id Tag."); ret = ConvertUuidToStr(&pstat->rownerID, &strUuid); VERIFY_SUCCESS(TAG, OC_STACK_OK == ret , ERROR); cborEncoderResult = cbor_encode_text_string(&pstatMap, strUuid, strlen(strUuid)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ROwner Id Value."); OICFree(strUuid); strUuid = NULL; cborEncoderResult = cbor_encoder_close_container(&encoder, &pstatMap); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Closing PSTAT Map."); if (CborNoError == cborEncoderResult) { *size = encoder.ptr - outPayload; *payload = outPayload; ret = OC_STACK_OK; } exit: if ((CborErrorOutOfMemory == cborEncoderResult) && (cborLen < CBOR_MAX_SIZE)) { // reallocate and try again! OICFree(outPayload); // Since the allocated initial memory failed, double the memory. cborLen += encoder.ptr - encoder.end; cborEncoderResult = CborNoError; ret = PstatToCBORPayload(pstat, payload, &cborLen); if (OC_STACK_OK == ret) { *size = cborLen; } } if ((CborNoError != cborEncoderResult) || (OC_STACK_OK != ret)) { OICFree(outPayload); outPayload = NULL; *payload = NULL; *size = 0; ret = OC_STACK_ERROR; } return ret; }
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 void ConvertJsonToCBOR(const char *jsonFileName, const char *cborFileName) { char *jsonStr = NULL; FILE *fp = NULL; FILE *fp1 = 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; cJSON *jsonRoot = NULL; OCStackResult ret = OC_STACK_ERROR; size_t size = GetJSONFileSize(jsonFileName); if (0 == size) { OIC_LOG (ERROR, TAG, "Failed converting to JSON"); return; } jsonStr = (char *)OICMalloc(size + 1); VERIFY_NON_NULL(TAG, jsonStr, FATAL); fp = fopen(jsonFileName, "r"); if (fp) { size_t bytesRead = fread(jsonStr, 1, size, fp); jsonStr[bytesRead] = '\0'; OIC_LOG_V(DEBUG, TAG, "Read %zu bytes", bytesRead); fclose(fp); fp = NULL; } else { OIC_LOG (ERROR, TAG, "Unable to open JSON file!!"); goto exit; } jsonRoot = cJSON_Parse(jsonStr); cJSON *value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_ACL_NAME); //printf("ACL json : \n%s\n", cJSON_PrintUnformatted(value)); size_t aclCborSize = 0; if (NULL != value) { OicSecAcl_t *acl = JSONToAclBin(jsonStr); VERIFY_NON_NULL(TAG, acl, FATAL); ret = AclToCBORPayload(acl, &aclCbor, &aclCborSize); if(OC_STACK_OK != ret) { OIC_LOG (ERROR, TAG, "Failed converting Acl to Cbor Payload"); DeleteACLList(acl); goto exit; } printf("ACL Cbor Size: %zd\n", aclCborSize); DeleteACLList(acl); } value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_PSTAT_NAME); size_t pstatCborSize = 0; if (NULL != value) { OicSecPstat_t *pstat = JSONToPstatBin(jsonStr); VERIFY_NON_NULL(TAG, pstat, FATAL); ret = PstatToCBORPayload(pstat, &pstatCbor, &pstatCborSize); if(OC_STACK_OK != ret) { OIC_LOG (ERROR, TAG, "Failed converting Pstat to Cbor Payload"); DeletePstatBinData(pstat); goto exit; } printf("PSTAT Cbor Size: %zd\n", pstatCborSize); DeletePstatBinData(pstat); } value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_DOXM_NAME); size_t doxmCborSize = 0; if (NULL != value) { OicSecDoxm_t *doxm = JSONToDoxmBin(jsonStr); VERIFY_NON_NULL(TAG, doxm, FATAL); ret = DoxmToCBORPayload(doxm, &doxmCbor, &doxmCborSize); if(OC_STACK_OK != ret) { OIC_LOG (ERROR, TAG, "Failed converting Doxm to Cbor Payload"); DeleteDoxmBinData(doxm); goto exit; } printf("DOXM Cbor Size: %zd\n", doxmCborSize); DeleteDoxmBinData(doxm); } value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_AMACL_NAME); size_t amaclCborSize = 0; if (NULL != value) { OicSecAmacl_t *amacl = JSONToAmaclBin(jsonStr); VERIFY_NON_NULL(TAG, amacl, FATAL); ret = AmaclToCBORPayload(amacl, &amaclCbor, &amaclCborSize); if(OC_STACK_OK != ret) { OIC_LOG (ERROR, TAG, "Failed converting Amacl to Cbor Payload"); DeleteAmaclList(amacl); goto exit; } printf("AMACL Cbor Size: %zd\n", amaclCborSize); DeleteAmaclList(amacl); } value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_SVC_NAME); size_t svcCborSize = 0; if (NULL != value) { OicSecSvc_t *svc = JSONToSvcBin(jsonStr); VERIFY_NON_NULL(TAG, svc, FATAL); ret = SVCToCBORPayload(svc, &svcCbor, &svcCborSize); if(OC_STACK_OK != ret) { OIC_LOG (ERROR, TAG, "Failed converting Svc to Cbor Payload"); DeleteSVCList(svc); goto exit; } printf("SVC Cbor Size: %zd\n", svcCborSize); DeleteSVCList(svc); } value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_CRED_NAME); //printf("CRED json : \n%s\n", cJSON_PrintUnformatted(value)); size_t credCborSize = 0; int secureFlag = 0; if (NULL != value) { OicSecCred_t *cred = JSONToCredBin(jsonStr); VERIFY_NON_NULL(TAG, cred, FATAL); ret = CredToCBORPayload(cred, &credCbor, &credCborSize, secureFlag); if(OC_STACK_OK != ret) { OIC_LOG (ERROR, TAG, "Failed converting Cred to Cbor Payload"); DeleteCredList(cred); goto exit; } printf("CRED Cbor Size: %zd\n", credCborSize); DeleteCredList(cred); } CborEncoder encoder; size_t cborSize = aclCborSize + pstatCborSize + doxmCborSize + svcCborSize + credCborSize + amaclCborSize; printf("Total Cbor Size : %zd\n", cborSize); cborSize += 255; // buffer margin for adding map and byte string uint8_t *outPayload = (uint8_t *)OICCalloc(1, cborSize); VERIFY_NON_NULL(TAG, outPayload, ERROR); cbor_encoder_init(&encoder, outPayload, cborSize, 0); CborEncoder map; CborError cborEncoderResult = cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Creating Main Map."); if (aclCborSize > 0) { cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_ACL_NAME, strlen(OIC_JSON_ACL_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ACL Name."); cborEncoderResult = cbor_encode_byte_string(&map, aclCbor, aclCborSize); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ACL Value."); } if (pstatCborSize > 0) { cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_PSTAT_NAME, strlen(OIC_JSON_PSTAT_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PSTAT Name."); cborEncoderResult = cbor_encode_byte_string(&map, pstatCbor, pstatCborSize); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PSTAT Value."); } if (doxmCborSize > 0) { cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_DOXM_NAME, strlen(OIC_JSON_DOXM_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding DOXM Name."); cborEncoderResult = cbor_encode_byte_string(&map, doxmCbor, doxmCborSize); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding DOXM Value."); } if (amaclCborSize > 0) { cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_AMACL_NAME, strlen(OIC_JSON_AMACL_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding AMACL Name."); cborEncoderResult = cbor_encode_byte_string(&map, amaclCbor, amaclCborSize); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding AMACL Value."); } if (svcCborSize > 0) { cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_SVC_NAME, strlen(OIC_JSON_SVC_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SVC Name."); cborEncoderResult = cbor_encode_byte_string(&map, svcCbor, svcCborSize); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SVC Value."); } if (credCborSize > 0) { cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_CRED_NAME, strlen(OIC_JSON_CRED_NAME)); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CRED Name."); cborEncoderResult = cbor_encode_byte_string(&map, credCbor, credCborSize); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CRED Value."); } cborEncoderResult = cbor_encoder_close_container(&encoder, &map); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Container."); size_t s = encoder.ptr - outPayload; OIC_LOG_V(DEBUG, TAG, "Payload size %zu", s); fp1 = fopen(cborFileName, "w"); if (fp1) { size_t bytesWritten = fwrite(outPayload, 1, s, fp1); if (bytesWritten == s) { OIC_LOG_V(DEBUG, TAG, "Written %zu bytes", bytesWritten); } else { OIC_LOG_V(ERROR, TAG, "Failed writing %zu bytes", s); } fclose(fp1); fp1 = NULL; } exit: cJSON_Delete(jsonRoot); OICFree(aclCbor); OICFree(doxmCbor); OICFree(pstatCbor); OICFree(amaclCbor); OICFree(svcCbor); OICFree(credCbor); OICFree(jsonStr); return ; }
static int64_t OCLinksPayloadToCbor(OCLinksPayload *links, CborEncoder *setMap) { CborEncoder linksArray; int64_t cborEncoderResult = CborNoError; cborEncoderResult |= cbor_encode_text_string(setMap, OC_RSRVD_LINKS, sizeof(OC_RSRVD_LINKS) - 1); cborEncoderResult |= cbor_encoder_create_array(setMap, &linksArray, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create Links array"); while (links) { CborEncoder linksMap; cborEncoderResult |= cbor_encoder_create_map(&linksArray, &linksMap, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to create links map"); cborEncoderResult |= ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_HREF, links->href); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_HREF in links map"); cborEncoderResult |= ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_REL, links->rel); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_REL in links map"); cborEncoderResult |= AddStringLLToMap(&linksMap, OC_RSRVD_RESOURCE_TYPE, links->rt); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_RT in links map"); cborEncoderResult |= AddStringLLToMap(&linksMap, OC_RSRVD_INTERFACE, links->itf); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_ITF in links map"); // Policy CborEncoder policyMap; cborEncoderResult |= cbor_encode_text_string(&linksMap, OC_RSRVD_POLICY, sizeof(OC_RSRVD_POLICY) - 1); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed adding policy tag to links map"); cborEncoderResult |= cbor_encoder_create_map(&linksMap, &policyMap, CborIndefiniteLength); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed adding policy map to links map"); // Bitmap cborEncoderResult |= cbor_encode_text_string(&policyMap, OC_RSRVD_BITMAP, sizeof(OC_RSRVD_BITMAP) - 1); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed adding bitmap tag to policy map"); cborEncoderResult |= cbor_encode_uint(&policyMap, links->p); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed adding bitmap value to policy map"); cborEncoderResult |= cbor_encoder_close_container(&linksMap, &policyMap); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing policy map"); cborEncoderResult |= ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_TITLE, links->title); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_TITLE in links map"); cborEncoderResult |= ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_URI, links->anchor); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_URI in links map"); cborEncoderResult |= ConditionalAddIntToMap(&linksMap, OC_RSRVD_INS, (uint64_t *) &links->ins); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_INS in links map"); cborEncoderResult |= ConditionalAddIntToMap(&linksMap, OC_RSRVD_TTL, &links->ttl); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_TTL in links map"); cborEncoderResult |= AddStringLLToMap(&linksMap, OC_RSRVD_MEDIA_TYPE, links->type); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to add OC_RSRVD_MT in links map"); // Finsihed encoding a resource, close the map. cborEncoderResult |= cbor_encoder_close_container(&linksArray, &linksMap); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing links map"); links = links->next; } cborEncoderResult |= cbor_encoder_close_container(setMap, &linksArray); VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed closing links array"); exit: return cborEncoderResult; }