Example
Dependencies: FXAS21002 FXOS8700Q
Diff: simple-mbed-cloud-client/mbed-cloud-client/mbed-client/source/m2mobject.cpp
- Revision:
- 0:11cc2b7889af
diff -r 000000000000 -r 11cc2b7889af simple-mbed-cloud-client/mbed-cloud-client/mbed-client/source/m2mobject.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/simple-mbed-cloud-client/mbed-cloud-client/mbed-client/source/m2mobject.cpp Tue Nov 19 09:49:38 2019 +0000 @@ -0,0 +1,529 @@ +/* + * Copyright (c) 2015 ARM Limited. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// Note: this macro is needed on armcc to get the the PRI*32 macros +// from inttypes.h in a C++ code. +#ifndef __STDC_FORMAT_MACROS +#define __STDC_FORMAT_MACROS +#endif +#include <inttypes.h> + +#include "mbed-client/m2mobject.h" +#include "mbed-client/m2mendpoint.h" +#include "mbed-client/m2mconstants.h" +#include "include/m2mtlvserializer.h" +#include "include/m2mtlvdeserializer.h" +#include "include/m2mreporthandler.h" +#include "mbed-trace/mbed_trace.h" +#include "mbed-client/m2mstringbuffer.h" +#include "include/m2mcallbackstorage.h" + +#include <stdlib.h> + +#define BUFFER_SIZE 10 +#define TRACE_GROUP "mClt" + +M2MObject::M2MObject(const String &object_name, char *path, bool external_blockwise_store) +: M2MBase(object_name, + M2MBase::Dynamic, +#ifndef DISABLE_RESOURCE_TYPE + "", +#endif + path, + external_blockwise_store, + false), + _observation_handler(NULL) +#ifdef MBED_CLOUD_CLIENT_EDGE_EXTENSION + ,_endpoint(NULL) +#endif +{ + M2MBase::set_base_type(M2MBase::Object); + M2MBase::set_operation(M2MBase::GET_ALLOWED); + if(M2MBase::name_id() != -1) { + M2MBase::set_coap_content_type(COAP_CONTENT_OMA_TLV_TYPE_OLD); + } +} + +M2MObject::M2MObject(const M2MBase::lwm2m_parameters_s* static_res) +: M2MBase(static_res), + _observation_handler(NULL) +#ifdef MBED_CLOUD_CLIENT_EDGE_EXTENSION + ,_endpoint(NULL) +#endif +{ + M2MBase::set_operation(M2MBase::GET_ALLOWED); + if(M2MBase::name_id() != -1) { + M2MBase::set_coap_content_type(COAP_CONTENT_OMA_TLV_TYPE_OLD); + } +} + +M2MObject::~M2MObject() +{ + if(!_instance_list.empty()) { + + M2MObjectInstanceList::const_iterator it; + it = _instance_list.begin(); + M2MObjectInstance* obj = NULL; + uint16_t index = 0; + for (; it!=_instance_list.end(); it++, index++ ) { + //Free allocated memory for object instances. + obj = *it; + delete obj; + } + + _instance_list.clear(); + } + + free_resources(); +} + +M2MObjectInstance* M2MObject::create_object_instance(uint16_t instance_id) +{ + tr_debug("M2MObject::create_object_instance - id: %d", instance_id); + M2MObjectInstance *instance = NULL; + if(!object_instance(instance_id)) { + char* path = create_path(*this, instance_id); + if (path) { + // Note: the object instance's name contains actually object's name. + instance = new M2MObjectInstance(*this, "", path); + if(instance) { + instance->add_observation_level(observation_level()); + instance->set_instance_id(instance_id); + if(M2MBase::name_id() != -1) { + instance->set_coap_content_type(COAP_CONTENT_OMA_TLV_TYPE_OLD); + } + _instance_list.push_back(instance); + set_changed(); + } + } + } + return instance; +} + + +M2MObjectInstance* M2MObject::create_object_instance(const lwm2m_parameters_s* s) +{ + tr_debug("M2MObject::create_object_instance - id: %d", s->identifier.instance_id); + M2MObjectInstance *instance = NULL; + if(!object_instance(s->identifier.instance_id)) { + + instance = new M2MObjectInstance(*this, s); + if(instance) { + instance->add_observation_level(observation_level()); + //instance->set_instance_id(instance_id); + //if(M2MBase::name_id() != -1) { + // instance->set_coap_content_type(COAP_CONTENT_OMA_TLV_TYPE_OLD); + //} + _instance_list.push_back(instance); + set_changed(); + } + } + return instance; +} + +bool M2MObject::remove_object_instance(uint16_t inst_id) +{ + tr_debug("M2MObject::remove_object_instance(inst_id %d)", inst_id); + bool success = false; + if(!_instance_list.empty()) { + M2MObjectInstance* obj = NULL; + M2MObjectInstanceList::const_iterator it; + it = _instance_list.begin(); + int pos = 0; + for ( ; it != _instance_list.end(); it++, pos++ ) { + if((*it)->instance_id() == inst_id) { + // Instance found and deleted. + obj = *it; + + _instance_list.erase(pos); + delete obj; + success = true; + set_changed(); + break; + } + } + } + return success; +} + +M2MObjectInstance* M2MObject::object_instance(uint16_t inst_id) const +{ + tr_debug("M2MObject::object_instance(inst_id %d)", inst_id); + M2MObjectInstance *obj = NULL; + if(!_instance_list.empty()) { + M2MObjectInstanceList::const_iterator it; + it = _instance_list.begin(); + for ( ; it != _instance_list.end(); it++ ) { + if((*it)->instance_id() == inst_id) { + // Instance found. + obj = *it; + break; + } + } + } + return obj; +} + +const M2MObjectInstanceList& M2MObject::instances() const +{ + return _instance_list; +} + +uint16_t M2MObject::instance_count() const +{ + return (uint16_t)_instance_list.size(); +} + +M2MObservationHandler* M2MObject::observation_handler() const +{ + // XXX: need to check the flag too + return _observation_handler; +} + +void M2MObject::set_observation_handler(M2MObservationHandler *handler) +{ + tr_debug("M2MObject::set_observation_handler - handler: 0x%p", (void*)handler); + _observation_handler = handler; +} + +void M2MObject::add_observation_level(M2MBase::Observation observation_level) +{ + M2MBase::add_observation_level(observation_level); + if(!_instance_list.empty()) { + M2MObjectInstanceList::const_iterator it; + it = _instance_list.begin(); + for ( ; it != _instance_list.end(); it++ ) { + (*it)->add_observation_level(observation_level); + } + } +} + +void M2MObject::remove_observation_level(M2MBase::Observation observation_level) +{ + M2MBase::remove_observation_level(observation_level); + if(!_instance_list.empty()) { + M2MObjectInstanceList::const_iterator it; + it = _instance_list.begin(); + for ( ; it != _instance_list.end(); it++ ) { + (*it)->remove_observation_level(observation_level); + } + } +} + +sn_coap_hdr_s* M2MObject::handle_get_request(nsdl_s *nsdl, + sn_coap_hdr_s *received_coap_header, + M2MObservationHandler *observation_handler) +{ + tr_info("M2MObject::handle_get_request()"); + sn_coap_msg_code_e msg_code = COAP_MSG_CODE_RESPONSE_CONTENT; + sn_coap_hdr_s * coap_response = sn_nsdl_build_response(nsdl, + received_coap_header, + msg_code); + uint8_t *data = NULL; + uint32_t data_length = 0; + if(received_coap_header) { + // process the GET if we have registered a callback for it + if ((operation() & M2MBase::GET_ALLOWED) != 0) { + if(coap_response) { + bool content_type_present = false; + bool is_content_type_supported = true; + + if (received_coap_header->options_list_ptr && + received_coap_header->options_list_ptr->accept != COAP_CT_NONE) { + content_type_present = true; + coap_response->content_format = received_coap_header->options_list_ptr->accept; + + } + + // Check if preferred content type is supported + if (content_type_present) { + if (coap_response->content_format != COAP_CONTENT_OMA_TLV_TYPE_OLD && + coap_response->content_format != COAP_CONTENT_OMA_TLV_TYPE) { + is_content_type_supported = false; + } + } + + if (is_content_type_supported) { + if(!content_type_present && + (M2MBase::coap_content_type() == COAP_CONTENT_OMA_TLV_TYPE || + M2MBase::coap_content_type() == COAP_CONTENT_OMA_TLV_TYPE_OLD)) { + coap_response->content_format = sn_coap_content_format_e(M2MBase::coap_content_type()); + } + + // fill in the CoAP response payload + if(COAP_CONTENT_OMA_TLV_TYPE == coap_response->content_format || + COAP_CONTENT_OMA_TLV_TYPE_OLD == coap_response->content_format) { + set_coap_content_type(coap_response->content_format); + data = M2MTLVSerializer::serialize(_instance_list, data_length); + } + + coap_response->payload_len = data_length; + coap_response->payload_ptr = data; + if(data){ + coap_response->options_list_ptr = sn_nsdl_alloc_options_list(nsdl, coap_response); + if(coap_response->options_list_ptr){ + coap_response->options_list_ptr->max_age = max_age(); + } + if(received_coap_header->options_list_ptr) { + if(received_coap_header->options_list_ptr->observe != -1) { + handle_observation(nsdl, *received_coap_header, *coap_response, observation_handler, msg_code); + } + } + } else { + msg_code = COAP_MSG_CODE_RESPONSE_UNSUPPORTED_CONTENT_FORMAT; // Content format not supported + } + } else { + tr_error("M2MObject::handle_get_request() - Content-Type %d not supported", coap_response->content_format); + msg_code = COAP_MSG_CODE_RESPONSE_NOT_ACCEPTABLE; + } + } + }else { + tr_error("M2MResource::handle_get_request - Return COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED"); + // Operation is not allowed. + msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED; + } + } else { + msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED; + } + if(coap_response) { + coap_response->msg_code = msg_code; + } + return coap_response; +} + +sn_coap_hdr_s* M2MObject::handle_put_request(nsdl_s *nsdl, + sn_coap_hdr_s *received_coap_header, + M2MObservationHandler */*observation_handler*/, + bool &/*execute_value_updated*/) +{ + tr_info("M2MObject::handle_put_request()"); + sn_coap_msg_code_e msg_code = COAP_MSG_CODE_RESPONSE_CHANGED; // 2.04 + sn_coap_hdr_s *coap_response = sn_nsdl_build_response(nsdl, + received_coap_header, + msg_code); + if(received_coap_header) { + if(received_coap_header->content_format != COAP_CT_NONE) { + set_coap_content_type(received_coap_header->content_format); + } + if(received_coap_header->options_list_ptr && + received_coap_header->options_list_ptr->uri_query_ptr) { + char *query = (char*)alloc_string_copy(received_coap_header->options_list_ptr->uri_query_ptr, + received_coap_header->options_list_ptr->uri_query_len); + + if (query){ + tr_info("M2MObject::handle_put_request() - query %s", query); + // if anything was updated, re-initialize the stored notification attributes + if (!handle_observation_attribute(query)){ + tr_debug("M2MObject::handle_put_request() - Invalid query"); + msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST; // 4.00 + } + free(query); + } + } else { + tr_error("M2MObject::handle_put_request() - COAP_MSG_CODE_RESPONSE_BAD_REQUEST - Empty URI_QUERY"); + msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST; + } + } else { + msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED; + } + if(coap_response) { + coap_response->msg_code = msg_code; + } + return coap_response; +} + + +sn_coap_hdr_s* M2MObject::handle_post_request(nsdl_s *nsdl, + sn_coap_hdr_s *received_coap_header, + M2MObservationHandler *observation_handler, + bool &execute_value_updated, + sn_nsdl_addr_s *) +{ + tr_info("M2MObject::handle_post_request()"); + sn_coap_msg_code_e msg_code = COAP_MSG_CODE_RESPONSE_CHANGED; // 2.04 + // process the POST if we have registered a callback for it + sn_coap_hdr_s *coap_response = sn_nsdl_build_response(nsdl, + received_coap_header, + msg_code); + + if (received_coap_header) { + if ((operation() & M2MBase::POST_ALLOWED) != 0) { + if (received_coap_header->content_format != COAP_CT_NONE) { + set_coap_content_type(received_coap_header->content_format); + } + if(received_coap_header->payload_ptr) { + tr_debug("M2MObject::handle_post_request() - Update Object with new values"); + uint16_t coap_content_type = 0; + bool content_type_present = false; + if(received_coap_header->content_format != COAP_CT_NONE) { + content_type_present = true; + if(coap_response) { + coap_content_type = received_coap_header->content_format; + } + } // if(received_coap_header->content_format) + if(!content_type_present && + (M2MBase::coap_content_type() == COAP_CONTENT_OMA_TLV_TYPE || + M2MBase::coap_content_type() == COAP_CONTENT_OMA_TLV_TYPE_OLD)) { + coap_content_type = M2MBase::coap_content_type(); + } + + tr_debug("M2MObject::handle_post_request() - Request Content-type: %d", coap_content_type); + + if(COAP_CONTENT_OMA_TLV_TYPE == coap_content_type || + COAP_CONTENT_OMA_TLV_TYPE_OLD == coap_content_type) { + set_coap_content_type(coap_content_type); + uint32_t instance_id = 0; + // Check next free instance id + for(instance_id = 0; instance_id <= MAX_UNINT_16_COUNT; instance_id++) { + if(NULL == object_instance(instance_id)) { + break; + } + if(instance_id == MAX_UNINT_16_COUNT) { + msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED; + break; + } + } + if(COAP_MSG_CODE_RESPONSE_CHANGED == msg_code) { + bool is_obj_instance = false; + bool obj_instance_exists = false; + is_obj_instance = M2MTLVDeserializer::is_object_instance(received_coap_header->payload_ptr); + if (is_obj_instance) { + instance_id = M2MTLVDeserializer::instance_id(received_coap_header->payload_ptr); + tr_debug("M2MObject::handle_post_request() - instance id in TLV: %" PRIu32, instance_id); + // Check if instance id already exists + if (object_instance(instance_id)){ + obj_instance_exists = true; + } + } + if (!obj_instance_exists && coap_response) { + M2MObjectInstance *obj_instance = create_object_instance(instance_id); + if (obj_instance) { + obj_instance->set_operation(M2MBase::GET_PUT_ALLOWED); + } + + M2MTLVDeserializer::Error error = M2MTLVDeserializer::None; + if(is_obj_instance) { + tr_debug("M2MObject::handle_post_request() - TLV data contains ObjectInstance"); + error = M2MTLVDeserializer::deserialise_object_instances(received_coap_header->payload_ptr, + received_coap_header->payload_len, + *this, + M2MTLVDeserializer::Post); + } else if(obj_instance && + (M2MTLVDeserializer::is_resource(received_coap_header->payload_ptr) || + M2MTLVDeserializer::is_multiple_resource(received_coap_header->payload_ptr))) { + tr_debug("M2MObject::handle_post_request() - TLV data contains Resources"); + error = M2MTLVDeserializer::deserialize_resources(received_coap_header->payload_ptr, + received_coap_header->payload_len, + *obj_instance, + M2MTLVDeserializer::Post); + } else { + error = M2MTLVDeserializer::NotValid; + } + switch(error) { + case M2MTLVDeserializer::None: + if(observation_handler) { + execute_value_updated = true; + } + coap_response->options_list_ptr = sn_nsdl_alloc_options_list(nsdl, coap_response); + + if (coap_response->options_list_ptr) { + + StringBuffer<MAX_OBJECT_PATH_NAME> obj_name; + + if (obj_name.ensure_space(M2MBase::resource_name_length() + (1 + 5 + 1))) { + obj_name.append(M2MBase::name()); + obj_name.append('/'); + obj_name.append_int(instance_id); + + coap_response->options_list_ptr->location_path_len = obj_name.get_size(); + coap_response->options_list_ptr->location_path_ptr = + alloc_copy((uint8_t*)obj_name.c_str(), obj_name.get_size()); + // todo: else return error + } + } + // todo: else return error + msg_code = COAP_MSG_CODE_RESPONSE_CREATED; + break; + case M2MTLVDeserializer::NotAllowed: + msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED; + break; + case M2MTLVDeserializer::NotValid: + msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST; + break; + case M2MTLVDeserializer::NotFound: + msg_code = COAP_MSG_CODE_RESPONSE_NOT_FOUND; + break; + case M2MTLVDeserializer::OutOfMemory: + msg_code = COAP_MSG_CODE_RESPONSE_REQUEST_ENTITY_TOO_LARGE; + break; + } + + } else { + tr_error("M2MObject::handle_post_request() - COAP_MSG_CODE_RESPONSE_BAD_REQUEST"); + msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST; + } + } + } else { + msg_code =COAP_MSG_CODE_RESPONSE_UNSUPPORTED_CONTENT_FORMAT; + } // if(COAP_CONTENT_OMA_TLV_TYPE == coap_content_type) + } else { + tr_error("M2MObject::handle_post_request - COAP_MSG_CODE_RESPONSE_BAD_REQUEST - Missing Payload"); + msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST; // + } + } else { // if ((object->operation() & SN_GRS_POST_ALLOWED) != 0) + tr_error("M2MObject::handle_post_request - COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED"); + msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED; // 4.05 + } + } else { //if(received_coap_header) + tr_error("M2MObject::handle_post_request - COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED"); + msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED; // 4.05 + } + + if(coap_response) { + coap_response->msg_code = msg_code; + } + return coap_response; +} + +void M2MObject::notification_update(uint16_t obj_instance_id) +{ + tr_debug("M2MObject::notification_update - id: %d", obj_instance_id); + M2MReportHandler *report_handler = M2MBase::report_handler(); + if(report_handler && is_under_observation()) { + report_handler->set_notification_trigger(obj_instance_id); + } +} + +#ifdef MBED_CLOUD_CLIENT_EDGE_EXTENSION +void M2MObject::set_endpoint(M2MEndpoint *endpoint) +{ + _endpoint = endpoint; +} + +M2MEndpoint* M2MObject::get_endpoint() const +{ + return _endpoint; +} +#endif + +M2MBase *M2MObject::get_parent() const +{ +#ifdef MBED_CLOUD_CLIENT_EDGE_EXTENSION + return (M2MBase *) get_endpoint(); +#else + return NULL; +#endif +}