Diff: mbed-client/test/lwm2mtestapplication/lwm2mtest.cpp

Revision:

0:29983394c6b6

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed-client/test/lwm2mtestapplication/lwm2mtest.cpp	Thu Apr 13 04:48:11 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);
+}