Ram Gandikota
A metronome using the FRDM K64F board
Diff: mbed-client/test/lwm2mtestapplication/lwm2mtest.cpp
- Revision:
- 0:a7a43371b306
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed-client/test/lwm2mtestapplication/lwm2mtest.cpp Sun May 14 18:40:18 2017 +0000
@@ -0,0 +1,859 @@
+/*
+ * 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.
+ */
+#include "lwm2mtest.h"
+#include "ns_types.h"
+#include "ns_cmdline.h"
+
+M2MLWClient::M2MLWClient()
+: _security(NULL),
+ _interface(NULL),
+ _device(NULL),
+ _bootstrapped(false),
+ _error(false),
+ _registered(false),
+ _unregistered(false),
+ _registration_updated(false)
+{
+}
+
+M2MLWClient::~M2MLWClient()
+{
+ if(_interface) {
+ delete _interface;
+ }
+ if(_security) {
+ delete _security;
+ }
+ if( _register_security){
+ delete _register_security;
+ }
+}
+
+
+bool M2MLWClient::create_interface(int32_t param_count,
+ const char *endpoint,
+ const char *resource_type,
+ const int32_t lifetime,
+ const uint16_t listen_port,
+ const char *domain,
+ const uint8_t binding_mode,
+ const uint8_t network_interface)
+{
+ if(_interface) {
+ delete _interface;
+ _interface = NULL;
+ }
+ String ep;
+ String rt;
+ String dmn;
+ if(endpoint) {
+ ep += endpoint;
+ }
+ if(resource_type) {
+ rt += resource_type;
+ }
+ if(domain) {
+ dmn += domain;
+ }
+
+ // Binding mode cannot be higher than 0x07 since it is an enum, check M2MInterface::BindingMode
+ if(binding_mode > 0x07) {
+ return false;
+ }
+
+ switch (param_count) {
+ case 0:
+ _interface = M2MInterfaceFactory::create_interface(*this, ep, rt);
+ break;
+ case 1:
+ _interface = M2MInterfaceFactory::create_interface(*this, ep, rt, lifetime);
+ break;
+ case 2:
+ _interface = M2MInterfaceFactory::create_interface(*this, ep, rt, lifetime, listen_port);
+ break;
+ case 3:
+ _interface = M2MInterfaceFactory::create_interface(*this, ep, rt, lifetime, listen_port, dmn);
+ break;
+ case 4:
+ _interface = M2MInterfaceFactory::create_interface(*this, ep, rt, lifetime, listen_port, dmn, (M2MInterface::BindingMode)binding_mode);
+ break;
+ case 5:
+ _interface = M2MInterfaceFactory::create_interface(*this, ep, rt, lifetime, listen_port, dmn, (M2MInterface::BindingMode)binding_mode, (M2MInterface::NetworkStack)network_interface);
+ break;
+ }
+ return (_interface == NULL) ? false : true;
+}
+
+bool M2MLWClient::create_bootstrap_object(const char *coap_bootstrap_address)
+{
+ bool success = false;
+ String address;
+ if(coap_bootstrap_address) {
+ address += coap_bootstrap_address;
+ }
+ if(_security) {
+ delete _security;
+ }
+ _security = M2MInterfaceFactory::create_security(M2MSecurity::Bootstrap);
+ if(_security) {
+ if(_security->set_resource_value(M2MSecurity::M2MServerUri, address) &&
+ _security->set_resource_value(M2MSecurity::SecurityMode, M2MSecurity::NoSecurity)) {
+ success = true;
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_register_object(const char *coap_register_address, bool useSecureConn)
+{
+ bool success = false;
+ String address;
+ if(coap_register_address) {
+ address += coap_register_address;
+ }
+ if(_register_security) {
+ delete _register_security;
+ }
+ _register_security = M2MInterfaceFactory::create_security(M2MSecurity::M2MServer);
+ if(_register_security) {
+ if( !useSecureConn ){
+ if(_register_security->set_resource_value(M2MSecurity::M2MServerUri, address) &&
+ _register_security->set_resource_value(M2MSecurity::SecurityMode, M2MSecurity::NoSecurity)) {
+ success = true;
+ }
+ }else{
+ if(_register_security->set_resource_value(M2MSecurity::M2MServerUri, address) &&
+ _register_security->set_resource_value(M2MSecurity::SecurityMode, M2MSecurity::Certificate) &&
+ _register_security->set_resource_value(M2MSecurity::ServerPublicKey,server_cert,server_cert_len) &&
+ _register_security->set_resource_value(M2MSecurity::PublicKey,cert,cert_len) &&
+ _register_security->set_resource_value(M2MSecurity::Secretkey,key,key_len) ){
+ success = true;
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::test_bootstrap()
+{
+ bool success = false;
+ if(_interface) {
+ _interface->bootstrap(_security);
+ success = true;
+ }
+ return success;
+}
+
+bool M2MLWClient::create_device_object(M2MDevice::DeviceResource resource,
+ const char *value)
+{
+ bool success = false;
+ String value_string;
+ if(value) {
+ value_string += value;
+ }
+ if(!_device) {
+ _device = M2MInterfaceFactory::create_device();
+ }
+ if(_device) {
+
+ if(_device->create_resource(resource,value_string)){
+ success = true;
+ } else {
+ success = _device->set_resource_value(resource,value);
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_device_object()
+{
+ bool success = false;
+ if(!_device) {
+ _device = M2MInterfaceFactory::create_device();
+ success = true;
+ }
+ return success;
+}
+
+bool M2MLWClient::create_device_object(M2MDevice::DeviceResource resource,
+ int64_t value)
+{
+ bool success = false;
+ if(!_device) {
+ _device = M2MInterfaceFactory::create_device();
+ }
+ if(_device) {
+ if(_device->create_resource(resource,value)) {
+ success = true;
+ } else {
+ success = _device->set_resource_value(resource, value);
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_device_object(M2MDevice::DeviceResource resource,
+ int64_t value,
+ uint16_t instance_id)
+{
+ bool success = false;
+ if(!_device) {
+ _device = M2MInterfaceFactory::create_device();
+ }
+ if(_device) {
+ if(_device->create_resource_instance(resource,value,instance_id)) {
+ success = true;
+ } else {
+ success = _device->set_resource_value(resource,
+ value,
+ instance_id);
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_firmware_object(M2MFirmware::FirmwareResource resource,
+ const char *value)
+{
+ bool success = false;
+ String value_string;
+ if(value) {
+ value_string += value;
+ }
+ if(!_firmware) {
+ _firmware = M2MInterfaceFactory::create_firmware();
+ }
+ if(_firmware) {
+ if(_firmware->create_resource(resource,value_string)){
+ success = true;
+ } else {
+ success = _firmware->set_resource_value(resource,value);
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_firmware_object()
+{
+ bool success = false;
+ if(!_firmware) {
+ _firmware = M2MInterfaceFactory::create_firmware();
+ success = true;
+ }
+ return success;
+}
+
+bool M2MLWClient::create_firmware_object(M2MFirmware::FirmwareResource resource,
+ int64_t value)
+{
+ bool success = false;
+ if(!_firmware) {
+ _firmware = M2MInterfaceFactory::create_firmware();
+ }
+ if(_firmware) {
+ if(_firmware->create_resource(resource,value)) {
+ success = true;
+ } else {
+ success = _firmware->set_resource_value(resource, value);
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_firmware_object(M2MFirmware::FirmwareResource resource,
+ const uint8_t *value,
+ const uint32_t length)
+{
+ bool success = false;
+ if(!_firmware) {
+ _firmware = M2MInterfaceFactory::create_firmware();
+ }
+ if(_firmware) {
+ success = _firmware->set_resource_value(resource, value, length);
+ }
+ return success;
+}
+
+void M2MLWClient::set_fw_execute_function()
+{
+ if(_firmware) {
+ M2MObjectInstance *inst = _firmware->object_instance(0);
+ if(inst) {
+ M2MResource *res = inst->resource("2");
+ if (res) {
+ res->set_execute_function(execute_callback(
+ this,
+ &M2MLWClient::fw_execute_function));
+ }
+ }
+ }
+}
+
+bool M2MLWClient::create_object(const char *name,
+ bool new_instance,
+ uint8_t object_operation,
+ uint8_t object_instance_operation,
+ uint16_t object_instance_id,
+ bool object_observable,
+ bool object_instance_observable)
+{
+ bool success = false;
+ M2MObjectInstance *inst = NULL;
+ if(!_object) {
+ _object = M2MInterfaceFactory::create_object(name);
+ if(_object) {
+ _object->set_operation(int_to_operation(object_operation));
+ _object->set_observable(object_observable);
+ inst = _object->create_object_instance(object_instance_id);
+ if(inst) {
+ success = true;
+ inst->set_operation(int_to_operation(object_instance_operation));
+ inst->set_observable(object_instance_observable);
+ }
+ }
+ } else {
+ if(new_instance) {
+ inst = _object->create_object_instance(object_instance_id);
+ if(inst) {
+ success = true;
+ inst->set_operation(int_to_operation(object_instance_operation));
+ inst->set_observable(object_instance_observable);
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_static_resource_string(const char *name,
+ const char *value,
+ bool multiple_instance,
+ uint16_t object_instance)
+{
+ bool success = false;
+ String name_string;
+ if(name) {
+ name_string += name;
+ }
+ String value_string;
+ if(value) {
+ value_string += value;
+ }
+ if(_object) {
+ M2MObjectInstance *inst = _object->object_instance(object_instance);
+ if(inst) {
+ if(inst->create_static_resource(name,"resource",
+ M2MResourceInstance::STRING,
+ (const uint8_t*)value_string.c_str(),
+ value_string.size()) != NULL) {
+ success = true;
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_static_resource_int(const char *name,
+ int64_t value,
+ bool multiple_instance,
+ uint16_t object_instance)
+{
+ bool success = false;
+ String name_string;
+ String value_string;
+
+ if(name) {
+ name_string += name;
+ }
+
+ char value_buffer[20];
+ sprintf(value_buffer,"%ld",value);
+ value_string += value_buffer;
+
+ if(_object) {
+ M2MObjectInstance *inst = _object->object_instance(object_instance);
+ if(inst) {
+ if(inst->create_static_resource(name,"resource",
+ M2MResourceInstance::INTEGER,
+ (const uint8_t*)value_string.c_str(),
+ value_string.size()) != NULL) {
+ success = true;
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_dynamic_resource_string(const char *name,
+ bool observable,
+ bool multiple_instance,
+ uint16_t object_instance,
+ uint8_t resource_operation)
+{
+ bool success = false;
+ String name_string;
+ if(name) {
+ name_string += name;
+ }
+ if(_object) {
+ M2MObjectInstance *inst = _object->object_instance(object_instance);
+ if(inst) {
+ M2MResource *res = inst->create_dynamic_resource(name,"resource",
+ M2MResourceInstance::STRING,
+ observable, multiple_instance);
+ if(res) {
+ success = true;
+ res->set_operation(int_to_operation(resource_operation));
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_dynamic_resource_int(const char *name,
+ bool observable,
+ bool multiple_instance,
+ uint16_t object_instance,
+ uint8_t resource_operation)
+{
+ bool success = false;
+ String name_string;
+ if(name) {
+ name_string += name;
+ }
+ if(_object) {
+ M2MObjectInstance *inst = _object->object_instance(object_instance);
+ if(inst) {
+ M2MResource *res = inst->create_dynamic_resource(name,"resource",
+ M2MResourceInstance::INTEGER,
+ observable, multiple_instance);
+ if(res) {
+ success = true;
+ res->set_operation(int_to_operation(resource_operation));
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::set_resource_value(const char *name,
+ int32_t value,
+ uint16_t object_instance)
+{
+ bool success = false;
+ String name_string;
+ String value_string;
+ if(name) {
+ name_string += name;
+ }
+
+ char value_buffer[20];
+ sprintf(value_buffer,"%d",value);
+ value_string += value_buffer;
+
+ if(_object && name_string.length() > 0) {
+ M2MObjectInstance *inst = _object->object_instance(object_instance);
+ if(inst) {
+ M2MResource *res = inst->resource(name_string);
+ if (res) {
+ if (res->set_value((const uint8_t*)value_string.c_str(), value_string.size())) {
+ success = true;
+ }
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::set_resource_value(const char *name,
+ const char *value,
+ uint16_t object_instance)
+{
+ bool success = false;
+ String name_string;
+ String value_string;
+ if(name) {
+ name_string += name;
+ }
+ if(value) {
+ value_string += value;
+ }
+
+ if(_object && name_string.length() > 0) {
+ M2MObjectInstance *inst = _object->object_instance(object_instance);
+ if(inst) {
+ M2MResource *res = inst->resource(name_string);
+ if (res) {
+ if (res->set_value((const uint8_t*)value_string.c_str(), value_string.size())) {
+ success = true;
+ }
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_static_resource_instance_string(const char *name,
+ const char *value,
+ bool multiple_instance,
+ uint16_t object_instance,
+ uint16_t resource_instance)
+{
+ bool success = false;
+ String name_string;
+ if(name) {
+ name_string += name;
+ }
+ String value_string;
+ if(value) {
+ value_string += value;
+ }
+ if(_object) {
+ M2MObjectInstance *inst = _object->object_instance(object_instance);
+ if(inst) {
+ if(inst->create_static_resource_instance(name,"resource",
+ M2MResourceInstance::STRING,
+ (const uint8_t*)value_string.c_str(),
+ value_string.size(),
+ resource_instance) != NULL) {
+ success = true;
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_static_resource_instance_int(const char *name,
+ int32_t value,
+ bool multiple_instance,
+ uint16_t object_instance,
+ uint16_t resource_instance)
+{
+ bool success = false;
+ String name_string;
+ String value_string;
+
+ if(name) {
+ name_string += name;
+ }
+
+ char value_buffer[20];
+ sprintf(value_buffer,"%ld",value);
+ value_string += value_buffer;
+
+ if(_object) {
+ M2MObjectInstance *inst = _object->object_instance(object_instance);
+ if(inst) {
+ if(inst->create_static_resource_instance(name,"resource",
+ M2MResourceInstance::INTEGER,
+ (const uint8_t*)value_string.c_str(),
+ value_string.size(),
+ resource_instance) != NULL) {
+ success = true;
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_dynamic_resource_instance_int(const char *name,
+ bool observable,
+ bool multiple_instance,
+ uint16_t object_instance,
+ uint16_t resource_instance,
+ uint8_t resource_instance_operation)
+{
+ bool success = false;
+ String name_string;
+ if(name) {
+ name_string += name;
+ }
+ if(_object) {
+ M2MObjectInstance *inst = _object->object_instance(object_instance);
+ if(inst) {
+ M2MResourceInstance *res = inst->create_dynamic_resource_instance(name,"resource",
+ M2MResourceInstance::INTEGER,
+ observable,
+ resource_instance);
+ if( res) {
+ success = true;
+ res->set_operation(int_to_operation(resource_instance_operation));
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::create_dynamic_resource_instance_string(const char *name,
+ bool observable,
+ bool multiple_instance,
+ uint16_t object_instance,
+ uint16_t resource_instance,
+ uint8_t resource_instance_operation)
+{
+ bool success = false;
+ String name_string;
+ if(name) {
+ name_string += name;
+ }
+ if(_object) {
+ M2MObjectInstance *inst = _object->object_instance(object_instance);
+ if(inst) {
+ M2MResourceInstance *res = inst->create_dynamic_resource_instance(name,"resource",
+ M2MResourceInstance::STRING,
+ observable,
+ resource_instance);
+ if( res) {
+ success = true;
+ res->set_operation(int_to_operation(resource_instance_operation));
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::set_resource_instance_value(const char *name,
+ int32_t value,
+ uint16_t object_instance,
+ uint16_t resource_instance)
+{
+ bool success = false;
+ String name_string;
+ String value_string;
+ if(name) {
+ name_string += name;
+ }
+
+ char value_buffer[20];
+ sprintf(value_buffer,"%d",value);
+ value_string += value_buffer;
+
+ if(_object && name_string.length() > 0) {
+ M2MObjectInstance *inst = _object->object_instance(object_instance);
+ if(inst) {
+ M2MResource *res = inst->resource(name_string);
+ if (res) {
+ M2MResourceInstance *res_inst = res->resource_instance(resource_instance);
+ if(res_inst) {
+ if (res_inst->set_value((const uint8_t*)value_string.c_str(), value_string.size())) {
+ success = true;
+ }
+ }
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::set_resource_instance_value(const char *name,
+ const char *value,
+ uint16_t object_instance,
+ uint16_t resource_instance)
+{
+ bool success = false;
+ String name_string;
+ String value_string;
+ if(name) {
+ name_string += name;
+ }
+ if(value) {
+ value_string += value;
+ }
+
+ if(_object && name_string.length() > 0) {
+ M2MObjectInstance *inst = _object->object_instance(object_instance);
+ if(inst) {
+ M2MResource *res = inst->resource(name_string);
+ if (res) {
+ M2MResourceInstance *res_inst = res->resource_instance(resource_instance);
+ if(res_inst) {
+ if (res_inst->set_value((const uint8_t*)value_string.c_str(), value_string.size())) {
+ success = true;
+ }
+ }
+ }
+ }
+ }
+ return success;
+}
+
+bool M2MLWClient::test_register()
+{
+ bool success = false;
+ M2MObjectList object_list;
+ if(_device) {
+ object_list.push_back(_device);
+ }
+ if(_firmware) {
+ object_list.push_back(_firmware);
+ }
+ if(_object) {
+ object_list.push_back(_object);
+ }
+ if(_interface) {
+ _interface->register_object(_register_security,object_list);
+ success = true;
+ }
+ return success;
+}
+
+bool M2MLWClient::test_update_register(const uint32_t lifetime)
+{
+ bool success = false;
+ if(_interface && _register_security) {
+ success = true;
+ _interface->update_registration(_register_security,lifetime);
+ }
+ return success;
+}
+
+bool M2MLWClient::test_unregister()
+{
+ bool success = false;
+ if(_interface) {
+ success = true;
+ _interface->unregister_object(_register_security);
+ }
+ return success;
+}
+
+void M2MLWClient::bootstrap_done(M2MSecurity *server_object)
+{
+ if(server_object) {
+ _register_security = server_object;
+ _bootstrapped = true;
+ cmd_printf("\nBootstrapped\n");
+ cmd_ready( CMDLINE_RETCODE_SUCCESS );
+ }
+}
+
+void M2MLWClient::object_registered(M2MSecurity *security_object, const M2MServer &server_object)
+{
+ _registered = true;
+ cmd_printf("\nRegistered\n");
+ cmd_ready( CMDLINE_RETCODE_SUCCESS );
+}
+
+void M2MLWClient::object_unregistered(M2MSecurity *server_object)
+{
+ _unregistered = true;
+ if(_device) {
+ M2MDevice::delete_instance();
+ _device = NULL;
+ }
+ if(_object) {
+ delete _object;
+ _object = NULL;
+ }
+ if(_security) {
+ delete _security;
+ _security = NULL;
+ }
+ if(_register_security) {
+ delete _register_security;
+ _register_security = NULL;
+ }
+ cmd_printf("\nUnregistered\n");
+ cmd_ready( CMDLINE_RETCODE_SUCCESS );
+}
+
+void M2MLWClient::registration_updated(M2MSecurity *security_object,
+ const M2MServer &server_object)
+{
+ _registration_updated = true;
+ cmd_printf("\nregistration updated\n");
+ cmd_ready( CMDLINE_RETCODE_SUCCESS );
+}
+
+void M2MLWClient::error(M2MInterface::Error error)
+{
+ _error = true;
+ cmd_printf("\nError occured Error Code : %d\n", (int8_t)error);
+ cmd_ready( CMDLINE_RETCODE_SUCCESS );
+}
+
+void M2MLWClient::value_updated(M2MBase *base, M2MBase::BaseType type)
+{
+ cmd_printf("\nValue updated of Object name %s and Type \n",
+ base->name().c_str(), type);
+}
+
+M2MBase::Operation M2MLWClient::int_to_operation(uint8_t operation)
+{
+ M2MBase::Operation op = M2MBase::NOT_ALLOWED;
+ switch(operation) {
+ case 0:
+ op = M2MBase::NOT_ALLOWED;
+ break;
+ case 1:
+ op = M2MBase::GET_ALLOWED;
+ break;
+ case 2:
+ op = M2MBase::PUT_ALLOWED;
+ break;
+ case 3:
+ op = M2MBase::GET_PUT_ALLOWED;
+ break;
+ case 4:
+ op = M2MBase::POST_ALLOWED;
+ break;
+ case 5:
+ op = M2MBase::GET_POST_ALLOWED;
+ break;
+ case 6:
+ op = M2MBase::PUT_POST_ALLOWED;
+ break;
+ case 7:
+ op = M2MBase::GET_PUT_POST_ALLOWED;
+ break;
+ case 8:
+ op = M2MBase::DELETE_ALLOWED;
+ break;
+ default:
+ break;
+ }
+ return op;
+}
+
+void M2MLWClient::fw_execute_function(void *argument)
+{
+ if(argument) {
+ char* arguments = (char*)argument;
+ cmd_printf("Received %s!!\n", arguments);
+ }
+ cmd_printf("Firmware update executed\n");
+}
+
+void M2MLWClient::firmware_resource_int(int resource)
+{
+ cmd_printf("Firmware resource value int\n");
+ cmd_printf("%ld\n", _firmware->resource_value_int(static_cast<M2MFirmware::FirmwareResource>(resource)));
+}
+
+void M2MLWClient::firmware_resource_string(int resource)
+{
+ cmd_printf("Firmware resource value string\n");
+ cmd_printf("%s\n", _firmware->resource_value_string(static_cast<M2MFirmware::FirmwareResource>(resource)).c_str());
+}
+
+void M2MLWClient::firmware_resource_buffer()
+{
+ cmd_printf("Firmware resource value buffer\n");
+ uint8_t *value = 0;
+ uint32_t valueSize = _firmware->resource_value_buffer(M2MFirmware::Package, value);
+ cmd_printf("%s\n", value);
+ free(value);
+}