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 CborError FindIntInMap(const CborValue *map, const char *tags, uint64_t *value) { CborValue curVal; CborError cborFindResult = cbor_value_map_find_value(map, tags, &curVal); if (CborNoError == cborFindResult && cbor_value_is_unsigned_integer(&curVal)) { cborFindResult = cbor_value_get_uint64(&curVal, value); } return cborFindResult; }
static CborError FindIntInMap(CborValue *map, char *tags, uint64_t *value) { CborValue curVal; CborError cborFindResult = cbor_value_map_find_value(map, tags, &curVal); if (CborNoError == cborFindResult && cbor_value_is_unsigned_integer(&curVal)) { cborFindResult = cbor_value_get_uint64(&curVal, value); if (CborNoError != cborFindResult) { OC_LOG_V(ERROR, TAG, "Failed finding value for tag %s .", tags); return cborFindResult; } } return CborNoError; }
static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* rootValue) { if (!outPayload) { return OC_STACK_INVALID_PARAM; } bool err = false; OCResourcePayload* resource = NULL; uint16_t resourceCount = 0; CborValue resourceMap = {}; OCDiscoveryPayload* out = OCDiscoveryPayloadCreate(); if(!out) { return OC_STACK_NO_MEMORY; } // Root value is already inside the main root array CborValue rootMap = {}; // Enter the main root map err = err || cbor_value_enter_container(rootValue, &rootMap); // Look for DI CborValue curVal = {}; err = cbor_value_map_find_value(&rootMap, OC_RSRVD_DEVICE_ID, &curVal); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor find value failed."); goto malformed_cbor; } size_t len; err = cbor_value_dup_byte_string(&curVal, &(out->sid), &len, NULL); // Look for Links which will have an array as the value err = cbor_value_map_find_value(&rootMap, OC_RSRVD_LINKS, &curVal); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor find value failed."); goto malformed_cbor; } // Enter the links array and start iterating through the array processing // each resource which shows up as a map. err = err || cbor_value_enter_container(&curVal, &resourceMap); while (cbor_value_is_map(&resourceMap)) { resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload)); if(!resource) { OC_LOG(ERROR, TAG, "Memory allocation failed"); OCDiscoveryPayloadDestroy(out); return OC_STACK_NO_MEMORY; } // Uri CborValue uriVal = {}; err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_HREF, &uriVal); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding href type failed."); goto malformed_cbor; } err = cbor_value_dup_text_string(&uriVal, &(resource->uri), &len, NULL); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding href value failed."); goto malformed_cbor; } // ResourceTypes CborValue rtVal = {}; err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_RESOURCE_TYPE, &rtVal); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding rt type failed."); goto malformed_cbor; } if (cbor_value_is_text_string(&rtVal)) { char* input = NULL; char* savePtr; err = cbor_value_dup_text_string(&rtVal, &input, &len, NULL); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding rt value failed."); goto malformed_cbor; } if (input) { char* curPtr = strtok_r(input, " ", &savePtr); while (curPtr) { char* trimmed = InPlaceStringTrim(curPtr); if (trimmed[0] !='\0') { if (!OCResourcePayloadAddResourceType(resource, trimmed)) { OICFree(resource->uri); OCFreeOCStringLL(resource->types); OICFree(resource); OCDiscoveryPayloadDestroy(out); return OC_STACK_NO_MEMORY; } } curPtr = strtok_r(NULL, " ", &savePtr); } OICFree(input); } } // Interface Types CborValue ifVal = {}; err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_INTERFACE, &ifVal); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding if type failed."); goto malformed_cbor; } if (!err && cbor_value_is_text_string(&ifVal)) { char* input = NULL; char* savePtr; err = cbor_value_dup_text_string(&ifVal, &input, &len, NULL); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding if value failed."); goto malformed_cbor; } if (input) { char* curPtr = strtok_r(input, " ", &savePtr); while (curPtr) { char* trimmed = InPlaceStringTrim(curPtr); if (trimmed[0] !='\0') { if (!OCResourcePayloadAddInterface(resource, trimmed)) { OICFree(resource->uri); OCFreeOCStringLL(resource->types); OICFree(resource); OCDiscoveryPayloadDestroy(out); return OC_STACK_NO_MEMORY; } } curPtr = strtok_r(NULL, " ", &savePtr); } OICFree(input); } } // Policy CborValue policyMap = {}; err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_POLICY, &policyMap); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding policy type failed."); goto malformed_cbor; } // Bitmap CborValue val = {}; err = cbor_value_map_find_value(&policyMap, OC_RSRVD_BITMAP, &val); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding bitmap type failed."); goto malformed_cbor; } uint64_t temp = 0; err = cbor_value_get_uint64(&val, &temp); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding bitmap value failed."); goto malformed_cbor; } resource->bitmap = (uint8_t)temp; // Secure Flag err = cbor_value_map_find_value(&policyMap, OC_RSRVD_SECURE, &val); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding secure type failed."); goto malformed_cbor; } if(cbor_value_is_valid(&val)) { err = cbor_value_get_boolean(&val, &(resource->secure)); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding secure value failed."); goto malformed_cbor; } // Port CborValue port; err = cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT, &port); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding port type failed."); goto malformed_cbor; } if(cbor_value_is_valid(&port)) { err = cbor_value_get_uint64(&port, &temp); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor finding port value failed."); goto malformed_cbor; } resource->port = (uint16_t)temp; } } err = cbor_value_advance(&resourceMap); if (CborNoError != err) { OC_LOG(ERROR, TAG, "Cbor advance value failed."); goto malformed_cbor; } ++resourceCount; OCDiscoveryPayloadAddNewResource(out, resource); } err = err || cbor_value_leave_container(rootValue, &resourceMap); *outPayload = (OCPayload*)out; return OC_STACK_OK; malformed_cbor: OICFree(resource->uri); OCFreeOCStringLL(resource->types); OCFreeOCStringLL(resource->interfaces); OICFree(resource); OCDiscoveryPayloadDestroy(out); return OC_STACK_MALFORMED_RESPONSE; cbor_error: OCDiscoveryCollectionPayloadDestroy(out); return OC_STACK_MALFORMED_RESPONSE; }
static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* arrayVal) { if (!outPayload) { return OC_STACK_INVALID_PARAM; } bool err = false; OCDiscoveryPayload* out = OCDiscoveryPayloadCreate(); if(!out) { return OC_STACK_NO_MEMORY; } size_t resourceCount = 0; while(!err && cbor_value_is_map(arrayVal)) { OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload)); if(!resource) { OC_LOG(ERROR, TAG, "Memory allocation failed"); OCDiscoveryPayloadDestroy(out); return OC_STACK_NO_MEMORY; } CborValue curVal; // Uri err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_HREF, &curVal); size_t len; err = err || cbor_value_dup_text_string(&curVal, &(resource->uri), &len, NULL); // SID err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_SERVER_INSTANCE_ID, &curVal); err = err || cbor_value_dup_byte_string(&curVal, &(resource->sid), &len, NULL); // Prop Tag { err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_PROPERTY, &curVal); // ResourceTypes CborValue rtVal; err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_RESOURCE_TYPE, &rtVal); if (!err && cbor_value_is_text_string(&rtVal)) { char* input = NULL; char* savePtr; err = err || cbor_value_dup_text_string(&rtVal, &input, &len, NULL); if (input) { char* curPtr = strtok_r(input, " ", &savePtr); while (curPtr) { char* trimmed = InPlaceStringTrim(curPtr); if (trimmed[0] !='\0') { if (!OCResourcePayloadAddResourceType(resource, trimmed)) { OICFree(resource->uri); OICFree(resource->sid); OCFreeOCStringLL(resource->types); OICFree(resource); OCDiscoveryPayloadDestroy(out); return OC_STACK_NO_MEMORY; } } curPtr = strtok_r(NULL, " ", &savePtr); } OICFree(input); } } // Interface Types CborValue ifVal; err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_INTERFACE, &ifVal); if (!err && cbor_value_is_text_string(&ifVal)) { char* input = NULL; char* savePtr; err = err || cbor_value_dup_text_string(&ifVal, &input, &len, NULL); if (input) { char* curPtr = strtok_r(input, " ", &savePtr); while (curPtr) { char* trimmed = InPlaceStringTrim(curPtr); if (trimmed[0] !='\0') { if (!OCResourcePayloadAddInterface(resource, trimmed)) { OICFree(resource->uri); OICFree(resource->sid); OCFreeOCStringLL(resource->types); OICFree(resource); OCDiscoveryPayloadDestroy(out); return OC_STACK_NO_MEMORY; } } curPtr = strtok_r(NULL, " ", &savePtr); } OICFree(input); } } // Policy { CborValue policyMap; err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_POLICY, &policyMap); // Bitmap CborValue val; err = err || cbor_value_map_find_value(&policyMap, OC_RSRVD_BITMAP, &val); uint64_t temp = 0; err = err || cbor_value_get_uint64(&val, &temp); resource->bitmap = (uint8_t)temp; // Secure Flag err = err || cbor_value_map_find_value(&policyMap, OC_RSRVD_SECURE, &val); if(cbor_value_is_valid(&val)) { err = err || cbor_value_get_boolean(&val, &(resource->secure)); // Port CborValue port; err = err || cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT, &port); if(cbor_value_is_valid(&port)) { err = err || cbor_value_get_uint64(&port, &temp); resource->port = (uint16_t)temp; } } } } err = err || cbor_value_advance(arrayVal); if(err) { OICFree(resource->uri); OICFree(resource->sid); OCFreeOCStringLL(resource->types); OCFreeOCStringLL(resource->interfaces); OICFree(resource); OCDiscoveryPayloadDestroy(out); OC_LOG_V(ERROR, TAG, "CBOR in error condition", err); return OC_STACK_MALFORMED_RESPONSE; } ++resourceCount; OCDiscoveryPayloadAddNewResource(out, resource); } if(err) { OCDiscoveryPayloadDestroy(out); return OC_STACK_MALFORMED_RESPONSE; } else { *outPayload = (OCPayload*)out; return OC_STACK_OK; } }
static OCStackResult OCParsePresencePayload(OCPayload** outPayload, CborValue* arrayVal) { if (!outPayload) { return OC_STACK_INVALID_PARAM; } bool err = false; if(cbor_value_is_map(arrayVal)) { uint64_t seqNum = 0; uint64_t maxAge = 0; OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE; char* tempStr = NULL; size_t len = 0; CborValue curVal; // Sequence Number err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_NONCE, &curVal); err = err || cbor_value_get_uint64(&curVal, &seqNum); // Max Age err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_TTL, &curVal); err = err || cbor_value_get_uint64(&curVal, &maxAge); // Trigger err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_TRIGGER, &curVal); err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL); trigger = convertTriggerStringToEnum(tempStr); OICFree(tempStr); tempStr = NULL; // Resource type name err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_RESOURCE_TYPE, &curVal); if(cbor_value_is_valid(&curVal)) { err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL); } err = err || cbor_value_advance(arrayVal); if(!err) { *outPayload = (OCPayload*)OCPresencePayloadCreate(seqNum, maxAge, trigger, tempStr); } OICFree(tempStr); if(err) { OCPayloadDestroy(*outPayload); OC_LOG(ERROR, TAG, "CBOR error Parse Presence Payload"); return OC_STACK_MALFORMED_RESPONSE; } if(!*outPayload) { return OC_STACK_NO_MEMORY; } return OC_STACK_OK; } else { OC_LOG(ERROR, TAG, "Root presence node was not a map"); return OC_STACK_MALFORMED_RESPONSE; } }
int cbor_read_array(struct CborValue *value, const struct cbor_array_t *arr) { CborError err = 0; struct CborValue elem; int off, arrcount; size_t len; void *lptr; char *tp; err = cbor_value_enter_container(value, &elem); if (err) { return err; } arrcount = 0; tp = arr->arr.strings.store; for (off = 0; off < arr->maxlen; off++) { switch (arr->element_type) { case CborAttrBooleanType: lptr = &arr->arr.booleans.store[off]; err |= cbor_value_get_boolean(&elem, lptr); break; case CborAttrIntegerType: lptr = &arr->arr.integers.store[off]; err |= cbor_value_get_int64(&elem, lptr); break; case CborAttrUnsignedIntegerType: lptr = &arr->arr.uintegers.store[off]; err |= cbor_value_get_uint64(&elem, lptr); break; #if FLOAT_SUPPORT case CborAttrFloatType: case CborAttrDoubleType: lptr = &arr->arr.reals.store[off]; err |= cbor_value_get_double(&elem, lptr); break; #endif case CborAttrTextStringType: len = arr->arr.strings.storelen - (tp - arr->arr.strings.store); err |= cbor_value_copy_text_string(&elem, tp, &len, NULL); arr->arr.strings.ptrs[off] = tp; tp += len + 1; break; case CborAttrStructObjectType: err |= cbor_internal_read_object(&elem, arr->arr.objects.subtype, arr, off); break; default: err |= CborErrorIllegalType; break; } arrcount++; if (arr->element_type != CborAttrStructObjectType) { err |= cbor_value_advance(&elem); } if (!cbor_value_is_valid(&elem)) { break; } } if (arr->count) { *arr->count = arrcount; } while (!cbor_value_at_end(&elem)) { err |= CborErrorDataTooLarge; cbor_value_advance(&elem); } err |= cbor_value_leave_container(value, &elem); return err; }
static int cbor_internal_read_object(CborValue *root_value, const struct cbor_attr_t *attrs, const struct cbor_array_t *parent, int offset) { const struct cbor_attr_t *cursor, *best_match; char attrbuf[MYNEWT_VAL(CBORATTR_MAX_SIZE) + 1]; void *lptr; CborValue cur_value; CborError err = 0; size_t len; CborType type = CborInvalidType; /* stuff fields with defaults in case they're omitted in the JSON input */ for (cursor = attrs; cursor->attribute != NULL; cursor++) { if (!cursor->nodefault) { lptr = cbor_target_address(cursor, parent, offset); if (lptr != NULL) { switch (cursor->type) { case CborAttrIntegerType: memcpy(lptr, &cursor->dflt.integer, sizeof(long long int)); break; case CborAttrUnsignedIntegerType: memcpy(lptr, &cursor->dflt.integer, sizeof(long long unsigned int)); break; case CborAttrBooleanType: memcpy(lptr, &cursor->dflt.boolean, sizeof(bool)); break; #if FLOAT_SUPPORT case CborAttrFloatType: memcpy(lptr, &cursor->dflt.fval, sizeof(float)); break; case CborAttrDoubleType: memcpy(lptr, &cursor->dflt.real, sizeof(double)); break; #endif default: break; } } } } if (cbor_value_is_map(root_value)) { err |= cbor_value_enter_container(root_value, &cur_value); } else { err |= CborErrorIllegalType; return err; } /* contains key value pairs */ while (cbor_value_is_valid(&cur_value) && !err) { /* get the attribute */ if (cbor_value_is_text_string(&cur_value)) { if (cbor_value_calculate_string_length(&cur_value, &len) == 0) { if (len > MYNEWT_VAL(CBORATTR_MAX_SIZE)) { err |= CborErrorDataTooLarge; break; } err |= cbor_value_copy_text_string(&cur_value, attrbuf, &len, NULL); } /* at least get the type of the next value so we can match the * attribute name and type for a perfect match */ err |= cbor_value_advance(&cur_value); if (cbor_value_is_valid(&cur_value)) { type = cbor_value_get_type(&cur_value); } else { err |= CborErrorIllegalType; break; } } else { attrbuf[0] = '\0'; type = cbor_value_get_type(&cur_value); } /* find this attribute in our list */ best_match = NULL; for (cursor = attrs; cursor->attribute != NULL; cursor++) { if (valid_attr_type(type, cursor->type)) { if (cursor->attribute == CBORATTR_ATTR_UNNAMED && attrbuf[0] == '\0') { best_match = cursor; } else if (strlen(cursor->attribute) == len && !memcmp(cursor->attribute, attrbuf, len)) { break; } } } if (!cursor->attribute && best_match) { cursor = best_match; } /* we found a match */ if (cursor->attribute != NULL) { lptr = cbor_target_address(cursor, parent, offset); switch (cursor->type) { case CborAttrNullType: /* nothing to do */ break; case CborAttrBooleanType: err |= cbor_value_get_boolean(&cur_value, lptr); break; case CborAttrIntegerType: err |= cbor_value_get_int64(&cur_value, lptr); break; case CborAttrUnsignedIntegerType: err |= cbor_value_get_uint64(&cur_value, lptr); break; #if FLOAT_SUPPORT case CborAttrFloatType: err |= cbor_value_get_float(&cur_value, lptr); break; case CborAttrDoubleType: err |= cbor_value_get_double(&cur_value, lptr); break; #endif case CborAttrByteStringType: { size_t len = cursor->len; err |= cbor_value_copy_byte_string(&cur_value, lptr, &len, NULL); *cursor->addr.bytestring.len = len; break; } case CborAttrTextStringType: { size_t len = cursor->len; err |= cbor_value_copy_text_string(&cur_value, lptr, &len, NULL); break; } case CborAttrArrayType: err |= cbor_read_array(&cur_value, &cursor->addr.array); continue; case CborAttrObjectType: err |= cbor_internal_read_object(&cur_value, cursor->addr.obj, NULL, 0); continue; default: err |= CborErrorIllegalType; } } cbor_value_advance(&cur_value); } if (!err) { /* that should be it for this container */ err |= cbor_value_leave_container(root_value, &cur_value); } return err; }