Toyomasa Watarai / Mbed OS Mbed-example-WS-W27

Dependencies:   MMA7660 LM75B

simple-mbed-cloud-client/mbed-cloud-client/mbed-client/source/m2minterfaceimpl.cpp@0:119624335925, 2018-06-30 (annotated)

Committer:
MACRUM
Date:
Sat Jun 30 01:40:30 2018 +0000
Revision:
0:119624335925
Initial commit

Who changed what in which revision?

UserRevisionLine numberNew contents of line
MACRUM 0:119624335925 1 /*
MACRUM 0:119624335925 2 * Copyright (c) 2015 ARM Limited. All rights reserved.
MACRUM 0:119624335925 3 * SPDX-License-Identifier: Apache-2.0
MACRUM 0:119624335925 4 * Licensed under the Apache License, Version 2.0 (the License); you may
MACRUM 0:119624335925 5 * not use this file except in compliance with the License.
MACRUM 0:119624335925 6 * You may obtain a copy of the License at
MACRUM 0:119624335925 7 *
MACRUM 0:119624335925 8 * http://www.apache.org/licenses/LICENSE-2.0
MACRUM 0:119624335925 9 *
MACRUM 0:119624335925 10 * Unless required by applicable law or agreed to in writing, software
MACRUM 0:119624335925 11 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
MACRUM 0:119624335925 12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
MACRUM 0:119624335925 13 * See the License for the specific language governing permissions and
MACRUM 0:119624335925 14 * limitations under the License.
MACRUM 0:119624335925 15 */
MACRUM 0:119624335925 16
MACRUM 0:119624335925 17 // Needed for PRIu64 on FreeRTOS
MACRUM 0:119624335925 18 #include <stdio.h>
MACRUM 0:119624335925 19 // Note: this macro is needed on armcc to get the the PRI*32 macros
MACRUM 0:119624335925 20 // from inttypes.h in a C++ code.
MACRUM 0:119624335925 21 #ifndef __STDC_FORMAT_MACROS
MACRUM 0:119624335925 22 #define __STDC_FORMAT_MACROS
MACRUM 0:119624335925 23 #endif
MACRUM 0:119624335925 24 #include <inttypes.h>
MACRUM 0:119624335925 25
MACRUM 0:119624335925 26 #include <assert.h>
MACRUM 0:119624335925 27 #include <stdlib.h>
MACRUM 0:119624335925 28 #include <stdio.h>
MACRUM 0:119624335925 29 #include <time.h>
MACRUM 0:119624335925 30 #include "include/m2minterfaceimpl.h"
MACRUM 0:119624335925 31 #include "include/eventdata.h"
MACRUM 0:119624335925 32 #include "mbed-client/m2minterfaceobserver.h"
MACRUM 0:119624335925 33 #include "mbed-client/m2mconnectionhandler.h"
MACRUM 0:119624335925 34 #include "mbed-client/m2mconnectionsecurity.h"
MACRUM 0:119624335925 35 #include "include/m2mnsdlinterface.h"
MACRUM 0:119624335925 36 #include "mbed-client/m2msecurity.h"
MACRUM 0:119624335925 37 #include "mbed-client/m2mtimer.h"
MACRUM 0:119624335925 38 #include "mbed-trace/mbed_trace.h"
MACRUM 0:119624335925 39 #include "randLIB.h"
MACRUM 0:119624335925 40
MACRUM 0:119624335925 41 #include <stdlib.h>
MACRUM 0:119624335925 42
MACRUM 0:119624335925 43 #define TRACE_GROUP "mClt"
MACRUM 0:119624335925 44
MACRUM 0:119624335925 45 #define RESOLVE_SEC_MODE(mode) ((mode == M2MInterface::TCP || mode == M2MInterface::TCP_QUEUE) ? M2MConnectionSecurity::TLS : M2MConnectionSecurity::DTLS)
MACRUM 0:119624335925 46
MACRUM 0:119624335925 47 M2MInterfaceImpl::M2MInterfaceImpl(M2MInterfaceObserver& observer,
MACRUM 0:119624335925 48 const String &ep_name,
MACRUM 0:119624335925 49 const String &ep_type,
MACRUM 0:119624335925 50 const int32_t l_time,
MACRUM 0:119624335925 51 const uint16_t listen_port,
MACRUM 0:119624335925 52 const String &dmn,
MACRUM 0:119624335925 53 M2MInterface::BindingMode mode,
MACRUM 0:119624335925 54 M2MInterface::NetworkStack stack,
MACRUM 0:119624335925 55 const String &con_addr)
MACRUM 0:119624335925 56 : _event_data(NULL),
MACRUM 0:119624335925 57 _registration_flow_timer(NULL),
MACRUM 0:119624335925 58 _server_port(0),
MACRUM 0:119624335925 59 _listen_port(listen_port),
MACRUM 0:119624335925 60 _life_time(l_time),
MACRUM 0:119624335925 61 _register_server(NULL),
MACRUM 0:119624335925 62 _queue_sleep_timer(*this),
MACRUM 0:119624335925 63 _retry_timer(*this),
MACRUM 0:119624335925 64 _callback_handler(NULL),
MACRUM 0:119624335925 65 _max_states( STATE_MAX_STATES ),
MACRUM 0:119624335925 66 _event_ignored(false),
MACRUM 0:119624335925 67 _event_generated(false),
MACRUM 0:119624335925 68 _reconnecting(false),
MACRUM 0:119624335925 69 _retry_timer_expired(false),
MACRUM 0:119624335925 70 _bootstrapped(true), // True as default to get it working with connector only configuration
MACRUM 0:119624335925 71 _queue_mode_timer_ongoing(false),
MACRUM 0:119624335925 72 _current_state(0),
MACRUM 0:119624335925 73 _binding_mode(mode),
MACRUM 0:119624335925 74 _reconnection_state(M2MInterfaceImpl::None),
MACRUM 0:119624335925 75 _observer(observer),
MACRUM 0:119624335925 76 _security_connection( new M2MConnectionSecurity( RESOLVE_SEC_MODE(mode) )),
MACRUM 0:119624335925 77 _connection_handler(*this, _security_connection, mode, stack),
MACRUM 0:119624335925 78 _nsdl_interface(*this, _connection_handler),
MACRUM 0:119624335925 79 _security(NULL)
MACRUM 0:119624335925 80 {
MACRUM 0:119624335925 81 tr_debug("M2MInterfaceImpl::M2MInterfaceImpl() -IN");
MACRUM 0:119624335925 82 //TODO:Increase the range from 1 to 100 seconds
MACRUM 0:119624335925 83 randLIB_seed_random();
MACRUM 0:119624335925 84 // Range is from 2 to 10
MACRUM 0:119624335925 85 _initial_reconnection_time = randLIB_get_random_in_range(2, 10);
MACRUM 0:119624335925 86
MACRUM 0:119624335925 87 tr_info("M2MInterfaceImpl::M2MInterfaceImpl() initial random time %d\n", _initial_reconnection_time);
MACRUM 0:119624335925 88 _reconnection_time = _initial_reconnection_time;
MACRUM 0:119624335925 89
MACRUM 0:119624335925 90 #ifndef DISABLE_ERROR_DESCRIPTION
MACRUM 0:119624335925 91 memset(_error_description, 0, sizeof(_error_description));
MACRUM 0:119624335925 92 #endif
MACRUM 0:119624335925 93
MACRUM 0:119624335925 94 _nsdl_interface.create_endpoint(ep_name,
MACRUM 0:119624335925 95 ep_type,
MACRUM 0:119624335925 96 _life_time,
MACRUM 0:119624335925 97 dmn,
MACRUM 0:119624335925 98 (uint8_t)_binding_mode,
MACRUM 0:119624335925 99 con_addr);
MACRUM 0:119624335925 100
MACRUM 0:119624335925 101 //Here we must use TCP still
MACRUM 0:119624335925 102 _connection_handler.bind_connection(_listen_port);
MACRUM 0:119624335925 103
MACRUM 0:119624335925 104 // We need this timer only in case of TCP
MACRUM 0:119624335925 105 if (_binding_mode == M2MInterface::TCP ||
MACRUM 0:119624335925 106 _binding_mode == M2MInterface::TCP_QUEUE ) {
MACRUM 0:119624335925 107 _registration_flow_timer = new M2MTimer(*this);
MACRUM 0:119624335925 108 }
MACRUM 0:119624335925 109 tr_debug("M2MInterfaceImpl::M2MInterfaceImpl() -OUT");
MACRUM 0:119624335925 110 }
MACRUM 0:119624335925 111
MACRUM 0:119624335925 112
MACRUM 0:119624335925 113 M2MInterfaceImpl::~M2MInterfaceImpl()
MACRUM 0:119624335925 114 {
MACRUM 0:119624335925 115 tr_debug("M2MInterfaceImpl::~M2MInterfaceImpl() - IN");
MACRUM 0:119624335925 116 delete _registration_flow_timer;
MACRUM 0:119624335925 117 _security_connection = NULL;
MACRUM 0:119624335925 118 tr_debug("M2MInterfaceImpl::~M2MInterfaceImpl() - OUT");
MACRUM 0:119624335925 119 }
MACRUM 0:119624335925 120
MACRUM 0:119624335925 121 void M2MInterfaceImpl::bootstrap(M2MSecurity *security)
MACRUM 0:119624335925 122 {
MACRUM 0:119624335925 123 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 124 tr_debug("M2MInterfaceImpl::bootstrap(M2MSecurity *security) - IN");
MACRUM 0:119624335925 125 _retry_timer.stop_timer();
MACRUM 0:119624335925 126 _security = NULL;
MACRUM 0:119624335925 127 if(!security) {
MACRUM 0:119624335925 128 set_error_description(ERROR_REASON_1);
MACRUM 0:119624335925 129 _observer.error(M2MInterface::InvalidParameters);
MACRUM 0:119624335925 130 return;
MACRUM 0:119624335925 131 }
MACRUM 0:119624335925 132 // Transition to a new state based upon
MACRUM 0:119624335925 133 // the current state of the state machine
MACRUM 0:119624335925 134 M2MSecurityData data;
MACRUM 0:119624335925 135 data._object = security;
MACRUM 0:119624335925 136 BEGIN_TRANSITION_MAP // - Current State -
MACRUM 0:119624335925 137 TRANSITION_MAP_ENTRY (STATE_BOOTSTRAP) // state_idle
MACRUM 0:119624335925 138 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap
MACRUM 0:119624335925 139 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state__bootstrap_address_resolved
MACRUM 0:119624335925 140 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap_resource_created
MACRUM 0:119624335925 141 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap_wait
MACRUM 0:119624335925 142 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap_error_wait
MACRUM 0:119624335925 143 TRANSITION_MAP_ENTRY (STATE_BOOTSTRAP) // state_bootstrapped
MACRUM 0:119624335925 144 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_register
MACRUM 0:119624335925 145 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_register_address_resolved
MACRUM 0:119624335925 146 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_registered
MACRUM 0:119624335925 147 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_update_registration
MACRUM 0:119624335925 148 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_unregister
MACRUM 0:119624335925 149 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_unregistered
MACRUM 0:119624335925 150 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_sending_coap_data
MACRUM 0:119624335925 151 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_coap_data_sent
MACRUM 0:119624335925 152 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_coap_data_received
MACRUM 0:119624335925 153 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_processing_coap_data
MACRUM 0:119624335925 154 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_coap_data_processed
MACRUM 0:119624335925 155 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_waiting
MACRUM 0:119624335925 156 END_TRANSITION_MAP(&data)
MACRUM 0:119624335925 157 if(_event_ignored) {
MACRUM 0:119624335925 158 _event_ignored = false;
MACRUM 0:119624335925 159 set_error_description(ERROR_REASON_2);
MACRUM 0:119624335925 160 _observer.error(M2MInterface::NotAllowed);
MACRUM 0:119624335925 161 }
MACRUM 0:119624335925 162 tr_debug("M2MInterfaceImpl::bootstrap(M2MSecurity *security) - OUT");
MACRUM 0:119624335925 163 #else
MACRUM 0:119624335925 164 set_error_description(ERROR_REASON_3);
MACRUM 0:119624335925 165 _observer.error(M2MInterface::NotAllowed);
MACRUM 0:119624335925 166 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 167 }
MACRUM 0:119624335925 168
MACRUM 0:119624335925 169 void M2MInterfaceImpl::cancel_bootstrap()
MACRUM 0:119624335925 170 {
MACRUM 0:119624335925 171 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 172 //TODO: Do we need this ?
MACRUM 0:119624335925 173 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 174 }
MACRUM 0:119624335925 175
MACRUM 0:119624335925 176 void M2MInterfaceImpl::register_object(M2MSecurity *security, const M2MObjectList &object_list)
MACRUM 0:119624335925 177 {
MACRUM 0:119624335925 178 tr_debug("M2MInterfaceImpl::register_object - IN");
MACRUM 0:119624335925 179 if(!security) {
MACRUM 0:119624335925 180 set_error_description(ERROR_REASON_4);
MACRUM 0:119624335925 181 _observer.error(M2MInterface::InvalidParameters);
MACRUM 0:119624335925 182 return;
MACRUM 0:119624335925 183 }
MACRUM 0:119624335925 184 // Transition to a new state based upon
MACRUM 0:119624335925 185 // the current state of the state machine
MACRUM 0:119624335925 186 //TODO: manage register object in a list.
MACRUM 0:119624335925 187 _connection_handler.claim_mutex();
MACRUM 0:119624335925 188 _register_server = security;
MACRUM 0:119624335925 189 M2MRegisterData data;
MACRUM 0:119624335925 190 data._object = security;
MACRUM 0:119624335925 191 data._object_list = object_list;
MACRUM 0:119624335925 192 BEGIN_TRANSITION_MAP // - Current State -
MACRUM 0:119624335925 193 TRANSITION_MAP_ENTRY (STATE_REGISTER) // state_idle
MACRUM 0:119624335925 194 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap
MACRUM 0:119624335925 195 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state__bootstrap_address_resolved
MACRUM 0:119624335925 196 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap_resource_created
MACRUM 0:119624335925 197 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap_wait
MACRUM 0:119624335925 198 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap_error_wait
MACRUM 0:119624335925 199 TRANSITION_MAP_ENTRY (STATE_REGISTER) // state_bootstrapped
MACRUM 0:119624335925 200 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_register
MACRUM 0:119624335925 201 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_register_address_resolved
MACRUM 0:119624335925 202 TRANSITION_MAP_ENTRY (STATE_REGISTER) // state_registered
MACRUM 0:119624335925 203 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_update_registration
MACRUM 0:119624335925 204 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_unregister
MACRUM 0:119624335925 205 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_unregistered
MACRUM 0:119624335925 206 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_sending_coap_data
MACRUM 0:119624335925 207 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_coap_data_sent
MACRUM 0:119624335925 208 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_coap_data_received
MACRUM 0:119624335925 209 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_processing_coap_data
MACRUM 0:119624335925 210 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_coap_data_processed
MACRUM 0:119624335925 211 TRANSITION_MAP_ENTRY (STATE_REGISTER) // state_waiting
MACRUM 0:119624335925 212 END_TRANSITION_MAP(&data)
MACRUM 0:119624335925 213 if(_event_ignored) {
MACRUM 0:119624335925 214 _event_ignored = false;
MACRUM 0:119624335925 215 set_error_description(ERROR_REASON_5);
MACRUM 0:119624335925 216 _observer.error(M2MInterface::NotAllowed);
MACRUM 0:119624335925 217 }
MACRUM 0:119624335925 218 _connection_handler.release_mutex();
MACRUM 0:119624335925 219 tr_debug("M2MInterfaceImpl::register_object - OUT");
MACRUM 0:119624335925 220 }
MACRUM 0:119624335925 221
MACRUM 0:119624335925 222 void M2MInterfaceImpl::update_registration(M2MSecurity *security_object, const uint32_t lifetime)
MACRUM 0:119624335925 223 {
MACRUM 0:119624335925 224 tr_debug("M2MInterfaceImpl::update_registration()");
MACRUM 0:119624335925 225 _connection_handler.claim_mutex();
MACRUM 0:119624335925 226 M2MUpdateRegisterData data;
MACRUM 0:119624335925 227 data._object = security_object;
MACRUM 0:119624335925 228 data._lifetime = lifetime;
MACRUM 0:119624335925 229 start_register_update(&data);
MACRUM 0:119624335925 230 _connection_handler.release_mutex();
MACRUM 0:119624335925 231 }
MACRUM 0:119624335925 232
MACRUM 0:119624335925 233 void M2MInterfaceImpl::update_registration(M2MSecurity *security_object,
MACRUM 0:119624335925 234 const M2MObjectList &object_list,
MACRUM 0:119624335925 235 const uint32_t lifetime)
MACRUM 0:119624335925 236 {
MACRUM 0:119624335925 237 tr_debug("M2MInterfaceImpl::update_registration - with object list");
MACRUM 0:119624335925 238 _connection_handler.claim_mutex();
MACRUM 0:119624335925 239 M2MUpdateRegisterData data;
MACRUM 0:119624335925 240 data._object = security_object;
MACRUM 0:119624335925 241 data._lifetime = lifetime;
MACRUM 0:119624335925 242 data._object_list = object_list;
MACRUM 0:119624335925 243 start_register_update(&data);
MACRUM 0:119624335925 244 _connection_handler.release_mutex();
MACRUM 0:119624335925 245 }
MACRUM 0:119624335925 246
MACRUM 0:119624335925 247 void M2MInterfaceImpl::unregister_object(M2MSecurity* /*security*/)
MACRUM 0:119624335925 248 {
MACRUM 0:119624335925 249 tr_debug("M2MInterfaceImpl::unregister_object - current state %d", _current_state);
MACRUM 0:119624335925 250 _connection_handler.claim_mutex();
MACRUM 0:119624335925 251 // Transition to a new state based upon
MACRUM 0:119624335925 252 // the current state of the state machine
MACRUM 0:119624335925 253 BEGIN_TRANSITION_MAP // - Current State -
MACRUM 0:119624335925 254 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_idle
MACRUM 0:119624335925 255 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap
MACRUM 0:119624335925 256 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state__bootstrap_address_resolved
MACRUM 0:119624335925 257 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap_resource_created
MACRUM 0:119624335925 258 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap_wait
MACRUM 0:119624335925 259 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap_error_wait
MACRUM 0:119624335925 260 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrapped
MACRUM 0:119624335925 261 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_register
MACRUM 0:119624335925 262 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_register_address_resolved
MACRUM 0:119624335925 263 TRANSITION_MAP_ENTRY (STATE_UNREGISTER) // state_registered
MACRUM 0:119624335925 264 TRANSITION_MAP_ENTRY (STATE_UNREGISTER) // state_update_registration
MACRUM 0:119624335925 265 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_unregister
MACRUM 0:119624335925 266 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_unregistered
MACRUM 0:119624335925 267 TRANSITION_MAP_ENTRY (STATE_UNREGISTER) // state_sending_coap_data
MACRUM 0:119624335925 268 TRANSITION_MAP_ENTRY (STATE_UNREGISTER) // state_coap_data_sent
MACRUM 0:119624335925 269 TRANSITION_MAP_ENTRY (STATE_UNREGISTER) // state_coap_data_received
MACRUM 0:119624335925 270 TRANSITION_MAP_ENTRY (STATE_UNREGISTER) // state_processing_coap_data
MACRUM 0:119624335925 271 TRANSITION_MAP_ENTRY (STATE_UNREGISTER) // state_coap_data_processed
MACRUM 0:119624335925 272 TRANSITION_MAP_ENTRY (STATE_UNREGISTER) // state_waiting
MACRUM 0:119624335925 273 END_TRANSITION_MAP(NULL)
MACRUM 0:119624335925 274 if(_event_ignored) {
MACRUM 0:119624335925 275 _event_ignored = false;
MACRUM 0:119624335925 276 set_error_description(ERROR_REASON_6);
MACRUM 0:119624335925 277 _observer.error(M2MInterface::NotAllowed);
MACRUM 0:119624335925 278 }
MACRUM 0:119624335925 279 _connection_handler.release_mutex();
MACRUM 0:119624335925 280 tr_debug("M2MInterfaceImpl::unregister_object - OUT");
MACRUM 0:119624335925 281 }
MACRUM 0:119624335925 282
MACRUM 0:119624335925 283 void M2MInterfaceImpl::set_queue_sleep_handler(callback_handler handler)
MACRUM 0:119624335925 284 {
MACRUM 0:119624335925 285 _callback_handler = handler;
MACRUM 0:119624335925 286 }
MACRUM 0:119624335925 287
MACRUM 0:119624335925 288 void M2MInterfaceImpl::set_random_number_callback(random_number_cb callback)
MACRUM 0:119624335925 289 {
MACRUM 0:119624335925 290 if(_security_connection) {
MACRUM 0:119624335925 291 _security_connection->set_random_number_callback(callback);
MACRUM 0:119624335925 292 }
MACRUM 0:119624335925 293 }
MACRUM 0:119624335925 294
MACRUM 0:119624335925 295 void M2MInterfaceImpl::set_entropy_callback(entropy_cb callback)
MACRUM 0:119624335925 296 {
MACRUM 0:119624335925 297 if(_security_connection) {
MACRUM 0:119624335925 298 _security_connection->set_entropy_callback(callback);
MACRUM 0:119624335925 299 }
MACRUM 0:119624335925 300 }
MACRUM 0:119624335925 301
MACRUM 0:119624335925 302 void M2MInterfaceImpl::set_platform_network_handler(void *handler)
MACRUM 0:119624335925 303 {
MACRUM 0:119624335925 304 _connection_handler.set_platform_network_handler(handler);
MACRUM 0:119624335925 305 }
MACRUM 0:119624335925 306
MACRUM 0:119624335925 307 void M2MInterfaceImpl::coap_message_ready(uint8_t *data_ptr,
MACRUM 0:119624335925 308 uint16_t data_len,
MACRUM 0:119624335925 309 sn_nsdl_addr_s *address_ptr)
MACRUM 0:119624335925 310 {
MACRUM 0:119624335925 311 tr_debug("M2MInterfaceImpl::coap_message_ready");
MACRUM 0:119624335925 312 if (_current_state != STATE_IDLE) {
MACRUM 0:119624335925 313 internal_event(STATE_SENDING_COAP_DATA);
MACRUM 0:119624335925 314 if(!_connection_handler.send_data(data_ptr,data_len,address_ptr)) {
MACRUM 0:119624335925 315 internal_event( STATE_IDLE);
MACRUM 0:119624335925 316 tr_error("M2MInterfaceImpl::coap_message_ready() - M2MInterface::NetworkError");
MACRUM 0:119624335925 317 if (!_reconnecting) {
MACRUM 0:119624335925 318 _queue_mode_timer_ongoing = false;
MACRUM 0:119624335925 319 socket_error(M2MConnectionHandler::SOCKET_SEND_ERROR, true);
MACRUM 0:119624335925 320 } else {
MACRUM 0:119624335925 321 socket_error(M2MConnectionHandler::SOCKET_ABORT);
MACRUM 0:119624335925 322 }
MACRUM 0:119624335925 323 }
MACRUM 0:119624335925 324 }
MACRUM 0:119624335925 325 }
MACRUM 0:119624335925 326
MACRUM 0:119624335925 327 void M2MInterfaceImpl::client_registered(M2MServer *server_object)
MACRUM 0:119624335925 328 {
MACRUM 0:119624335925 329 tr_info("M2MInterfaceImpl::client_registered");
MACRUM 0:119624335925 330 internal_event(STATE_REGISTERED);
MACRUM 0:119624335925 331 //Inform client is registered.
MACRUM 0:119624335925 332 //TODO: manage register object in a list.
MACRUM 0:119624335925 333 _observer.object_registered(_register_server,*server_object);
MACRUM 0:119624335925 334 }
MACRUM 0:119624335925 335
MACRUM 0:119624335925 336 void M2MInterfaceImpl::registration_updated(const M2MServer &server_object)
MACRUM 0:119624335925 337 {
MACRUM 0:119624335925 338 tr_info("M2MInterfaceImpl::registration_updated");
MACRUM 0:119624335925 339 internal_event(STATE_REGISTERED);
MACRUM 0:119624335925 340 _observer.registration_updated(_register_server,server_object);
MACRUM 0:119624335925 341 }
MACRUM 0:119624335925 342
MACRUM 0:119624335925 343 void M2MInterfaceImpl::registration_error(uint8_t error_code, bool retry)
MACRUM 0:119624335925 344 {
MACRUM 0:119624335925 345 tr_error("M2MInterfaceImpl::registration_error code [%d]", error_code);
MACRUM 0:119624335925 346 // Try to register again
MACRUM 0:119624335925 347 if (retry) {
MACRUM 0:119624335925 348 _queue_mode_timer_ongoing = false;
MACRUM 0:119624335925 349 if (error_code == M2MInterface::UnregistrationFailed) {
MACRUM 0:119624335925 350 _reconnection_state = M2MInterfaceImpl::Unregistration;
MACRUM 0:119624335925 351 }
MACRUM 0:119624335925 352 socket_error(M2MConnectionHandler::SOCKET_SEND_ERROR);
MACRUM 0:119624335925 353 } else {
MACRUM 0:119624335925 354 _security = NULL;
MACRUM 0:119624335925 355 internal_event(STATE_IDLE);
MACRUM 0:119624335925 356 if (error_code == M2MInterface::UnregistrationFailed) {
MACRUM 0:119624335925 357 set_error_description(ERROR_REASON_24);
MACRUM 0:119624335925 358 } else {
MACRUM 0:119624335925 359 set_error_description(ERROR_REASON_8);
MACRUM 0:119624335925 360 }
MACRUM 0:119624335925 361 _observer.error((M2MInterface::Error)error_code);
MACRUM 0:119624335925 362 }
MACRUM 0:119624335925 363 }
MACRUM 0:119624335925 364
MACRUM 0:119624335925 365 void M2MInterfaceImpl::client_unregistered()
MACRUM 0:119624335925 366 {
MACRUM 0:119624335925 367 tr_info("M2MInterfaceImpl::client_unregistered()");
MACRUM 0:119624335925 368 internal_event(STATE_UNREGISTERED);
MACRUM 0:119624335925 369 //TODO: manage register object in a list.
MACRUM 0:119624335925 370 _observer.object_unregistered(_register_server);
MACRUM 0:119624335925 371 }
MACRUM 0:119624335925 372
MACRUM 0:119624335925 373 void M2MInterfaceImpl::bootstrap_done()
MACRUM 0:119624335925 374 {
MACRUM 0:119624335925 375 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 376 tr_info("M2MInterfaceImpl::bootstrap_done");
MACRUM 0:119624335925 377 _reconnection_time = _initial_reconnection_time;
MACRUM 0:119624335925 378 _reconnecting = false;
MACRUM 0:119624335925 379 _reconnection_state = M2MInterfaceImpl::None;
MACRUM 0:119624335925 380 _bootstrapped = true;
MACRUM 0:119624335925 381 if (_registration_flow_timer) {
MACRUM 0:119624335925 382 _registration_flow_timer->stop_timer();
MACRUM 0:119624335925 383 }
MACRUM 0:119624335925 384 internal_event(STATE_BOOTSTRAPPED);
MACRUM 0:119624335925 385 _observer.bootstrap_done(_nsdl_interface.get_security_object());
MACRUM 0:119624335925 386 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 387 }
MACRUM 0:119624335925 388
MACRUM 0:119624335925 389 void M2MInterfaceImpl::bootstrap_wait()
MACRUM 0:119624335925 390 {
MACRUM 0:119624335925 391 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 392 tr_info("M2MInterfaceImpl::bootstrap_wait");
MACRUM 0:119624335925 393 internal_event(STATE_BOOTSTRAP_WAIT);
MACRUM 0:119624335925 394 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 395 }
MACRUM 0:119624335925 396
MACRUM 0:119624335925 397 void M2MInterfaceImpl::bootstrap_error_wait(const char *reason)
MACRUM 0:119624335925 398 {
MACRUM 0:119624335925 399 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 400 tr_error("M2MInterfaceImpl::bootstrap_error_wait");
MACRUM 0:119624335925 401 set_error_description(reason);
MACRUM 0:119624335925 402 internal_event(STATE_BOOTSTRAP_ERROR_WAIT);
MACRUM 0:119624335925 403 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 404 }
MACRUM 0:119624335925 405
MACRUM 0:119624335925 406 void M2MInterfaceImpl::bootstrap_error(const char *reason)
MACRUM 0:119624335925 407 {
MACRUM 0:119624335925 408 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 409 tr_error("M2MInterfaceImpl::bootstrap_error(%s)", reason);
MACRUM 0:119624335925 410 _bootstrapped = false;
MACRUM 0:119624335925 411 if (_registration_flow_timer) {
MACRUM 0:119624335925 412 _registration_flow_timer->stop_timer();
MACRUM 0:119624335925 413 }
MACRUM 0:119624335925 414
MACRUM 0:119624335925 415 _reconnection_state = M2MInterfaceImpl::None;
MACRUM 0:119624335925 416
MACRUM 0:119624335925 417 set_error_description(reason);
MACRUM 0:119624335925 418
MACRUM 0:119624335925 419 _observer.error(M2MInterface::BootstrapFailed);
MACRUM 0:119624335925 420
MACRUM 0:119624335925 421 internal_event(STATE_IDLE);
MACRUM 0:119624335925 422 _reconnecting = true;
MACRUM 0:119624335925 423 _connection_handler.stop_listening();
MACRUM 0:119624335925 424
MACRUM 0:119624335925 425 _retry_timer_expired = false;
MACRUM 0:119624335925 426 _retry_timer.start_timer(_reconnection_time * 1000,
MACRUM 0:119624335925 427 M2MTimerObserver::RetryTimer);
MACRUM 0:119624335925 428 tr_info("M2MInterfaceImpl::bootstrap_error - reconnecting in %" PRIu64 "(s)", _reconnection_time);
MACRUM 0:119624335925 429 _reconnection_time = _reconnection_time * RECONNECT_INCREMENT_FACTOR;
MACRUM 0:119624335925 430 if(_reconnection_time >= MAX_RECONNECT_TIMEOUT) {
MACRUM 0:119624335925 431 _reconnection_time = MAX_RECONNECT_TIMEOUT;
MACRUM 0:119624335925 432 }
MACRUM 0:119624335925 433 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 434 }
MACRUM 0:119624335925 435
MACRUM 0:119624335925 436 void M2MInterfaceImpl::coap_data_processed()
MACRUM 0:119624335925 437 {
MACRUM 0:119624335925 438 tr_debug("M2MInterfaceImpl::coap_data_processed()");
MACRUM 0:119624335925 439 internal_event(STATE_COAP_DATA_PROCESSED);
MACRUM 0:119624335925 440 }
MACRUM 0:119624335925 441
MACRUM 0:119624335925 442 void M2MInterfaceImpl::value_updated(M2MBase *base)
MACRUM 0:119624335925 443 {
MACRUM 0:119624335925 444 tr_debug("M2MInterfaceImpl::value_updated");
MACRUM 0:119624335925 445 if(base) {
MACRUM 0:119624335925 446 M2MBase::BaseType type = base->base_type();
MACRUM 0:119624335925 447 _observer.value_updated(base, type);
MACRUM 0:119624335925 448 }
MACRUM 0:119624335925 449 }
MACRUM 0:119624335925 450
MACRUM 0:119624335925 451 void M2MInterfaceImpl::data_available(uint8_t* data,
MACRUM 0:119624335925 452 uint16_t data_size,
MACRUM 0:119624335925 453 const M2MConnectionObserver::SocketAddress &address)
MACRUM 0:119624335925 454 {
MACRUM 0:119624335925 455 tr_debug("M2MInterfaceImpl::data_available");
MACRUM 0:119624335925 456 ReceivedData event;
MACRUM 0:119624335925 457 event._data = data;
MACRUM 0:119624335925 458 event._size = data_size;
MACRUM 0:119624335925 459 event._address = &address;
MACRUM 0:119624335925 460 internal_event(STATE_COAP_DATA_RECEIVED, &event);
MACRUM 0:119624335925 461 }
MACRUM 0:119624335925 462
MACRUM 0:119624335925 463 void M2MInterfaceImpl::socket_error(uint8_t error_code, bool retry)
MACRUM 0:119624335925 464 {
MACRUM 0:119624335925 465 // Bootstrap completed once PEER CLOSE notify received from the server.
MACRUM 0:119624335925 466 if (_current_state == STATE_BOOTSTRAP_WAIT &&
MACRUM 0:119624335925 467 error_code == M2MConnectionHandler::SSL_PEER_CLOSED) {
MACRUM 0:119624335925 468 _security = NULL;
MACRUM 0:119624335925 469 bootstrap_done();
MACRUM 0:119624335925 470 return;
MACRUM 0:119624335925 471 }
MACRUM 0:119624335925 472
MACRUM 0:119624335925 473 tr_error("M2MInterfaceImpl::socket_error: (%d), retry (%d), reconnecting (%d), reconnection_state (%d)",
MACRUM 0:119624335925 474 error_code, retry, _reconnecting, (int)_reconnection_state);
MACRUM 0:119624335925 475
MACRUM 0:119624335925 476 // Ignore errors while client is sleeping
MACRUM 0:119624335925 477 if(queue_mode()) {
MACRUM 0:119624335925 478 if(_callback_handler && _queue_mode_timer_ongoing) {
MACRUM 0:119624335925 479 tr_info("M2MInterfaceImpl::socket_error - Queue Mode - don't try to reconnect while in QueueMode");
MACRUM 0:119624335925 480 return;
MACRUM 0:119624335925 481 }
MACRUM 0:119624335925 482 }
MACRUM 0:119624335925 483 _queue_sleep_timer.stop_timer();
MACRUM 0:119624335925 484
MACRUM 0:119624335925 485 if (_registration_flow_timer) {
MACRUM 0:119624335925 486 _registration_flow_timer->stop_timer();
MACRUM 0:119624335925 487 }
MACRUM 0:119624335925 488
MACRUM 0:119624335925 489 _queue_sleep_timer.stop_timer();
MACRUM 0:119624335925 490
MACRUM 0:119624335925 491 // Don't change flag state if unregistration has failed.
MACRUM 0:119624335925 492 // This info is needed for continuing unregistration process after client is registered again.
MACRUM 0:119624335925 493 if (_reconnection_state != M2MInterfaceImpl::Unregistration && _reconnection_state != M2MInterfaceImpl::FullRegistration) {
MACRUM 0:119624335925 494 _reconnection_state = M2MInterfaceImpl::WithUpdate;
MACRUM 0:119624335925 495 }
MACRUM 0:119624335925 496
MACRUM 0:119624335925 497 const char *error_code_des;
MACRUM 0:119624335925 498 M2MInterface::Error error = M2MInterface::ErrorNone;
MACRUM 0:119624335925 499 switch (error_code) {
MACRUM 0:119624335925 500 case M2MConnectionHandler::SSL_CONNECTION_ERROR:
MACRUM 0:119624335925 501 error = M2MInterface::SecureConnectionFailed;
MACRUM 0:119624335925 502 error_code_des = ERROR_SECURE_CONNECTION;
MACRUM 0:119624335925 503 break;
MACRUM 0:119624335925 504 case M2MConnectionHandler::DNS_RESOLVING_ERROR:
MACRUM 0:119624335925 505 error = M2MInterface::DnsResolvingFailed;
MACRUM 0:119624335925 506 error_code_des = ERROR_DNS;
MACRUM 0:119624335925 507 break;
MACRUM 0:119624335925 508 case M2MConnectionHandler::SOCKET_READ_ERROR:
MACRUM 0:119624335925 509 error = M2MInterface::NetworkError;
MACRUM 0:119624335925 510 error_code_des = ERROR_NETWORK;
MACRUM 0:119624335925 511 break;
MACRUM 0:119624335925 512 case M2MConnectionHandler::SOCKET_SEND_ERROR:
MACRUM 0:119624335925 513 error = M2MInterface::NetworkError;
MACRUM 0:119624335925 514 error_code_des = ERROR_NETWORK;
MACRUM 0:119624335925 515 break;
MACRUM 0:119624335925 516 case M2MConnectionHandler::SSL_HANDSHAKE_ERROR:
MACRUM 0:119624335925 517 error = M2MInterface::SecureConnectionFailed;
MACRUM 0:119624335925 518 error_code_des = ERROR_SECURE_CONNECTION;
MACRUM 0:119624335925 519 break;
MACRUM 0:119624335925 520 case M2MConnectionHandler::SOCKET_ABORT:
MACRUM 0:119624335925 521 error = M2MInterface::NetworkError;
MACRUM 0:119624335925 522 error_code_des = ERROR_NETWORK;
MACRUM 0:119624335925 523 break;
MACRUM 0:119624335925 524 default:
MACRUM 0:119624335925 525 error_code_des = ERROR_NO;
MACRUM 0:119624335925 526 break;
MACRUM 0:119624335925 527 }
MACRUM 0:119624335925 528
MACRUM 0:119624335925 529 internal_event(STATE_IDLE);
MACRUM 0:119624335925 530 // Try to do reconnecting
MACRUM 0:119624335925 531 if (retry) {
MACRUM 0:119624335925 532 _reconnecting = true;
MACRUM 0:119624335925 533 _connection_handler.stop_listening();
MACRUM 0:119624335925 534 _retry_timer_expired = false;
MACRUM 0:119624335925 535 _retry_timer.start_timer(_reconnection_time * 1000,
MACRUM 0:119624335925 536 M2MTimerObserver::RetryTimer);
MACRUM 0:119624335925 537 tr_info("M2MInterfaceImpl::socket_error - reconnecting in %" PRIu64 "(s)", _reconnection_time);
MACRUM 0:119624335925 538 _reconnection_time = _reconnection_time * RECONNECT_INCREMENT_FACTOR;
MACRUM 0:119624335925 539 if(_reconnection_time >= MAX_RECONNECT_TIMEOUT) {
MACRUM 0:119624335925 540 _reconnection_time = MAX_RECONNECT_TIMEOUT;
MACRUM 0:119624335925 541 }
MACRUM 0:119624335925 542 #ifndef DISABLE_ERROR_DESCRIPTION
MACRUM 0:119624335925 543 snprintf(_error_description, sizeof(_error_description), ERROR_REASON_9, error_code_des);
MACRUM 0:119624335925 544 #endif
MACRUM 0:119624335925 545 }
MACRUM 0:119624335925 546 // Inform application
MACRUM 0:119624335925 547 if (!retry && M2MInterface::ErrorNone != error) {
MACRUM 0:119624335925 548 tr_info("M2MInterfaceImpl::socket_error - send error to application");
MACRUM 0:119624335925 549 _connection_handler.stop_listening();
MACRUM 0:119624335925 550 _retry_timer.stop_timer();
MACRUM 0:119624335925 551 _security = NULL;
MACRUM 0:119624335925 552 _reconnecting = false;
MACRUM 0:119624335925 553 _reconnection_time = _initial_reconnection_time;
MACRUM 0:119624335925 554 _reconnection_state = M2MInterfaceImpl::None;
MACRUM 0:119624335925 555 #ifndef DISABLE_ERROR_DESCRIPTION
MACRUM 0:119624335925 556 snprintf(_error_description, sizeof(_error_description), ERROR_REASON_10, error_code_des);
MACRUM 0:119624335925 557 #endif
MACRUM 0:119624335925 558 }
MACRUM 0:119624335925 559 if(M2MInterface::ErrorNone != error) {
MACRUM 0:119624335925 560 _observer.error(error);
MACRUM 0:119624335925 561 }
MACRUM 0:119624335925 562 }
MACRUM 0:119624335925 563
MACRUM 0:119624335925 564 void M2MInterfaceImpl::address_ready(const M2MConnectionObserver::SocketAddress &address,
MACRUM 0:119624335925 565 M2MConnectionObserver::ServerType server_type,
MACRUM 0:119624335925 566 const uint16_t server_port)
MACRUM 0:119624335925 567 {
MACRUM 0:119624335925 568 tr_debug("M2MInterfaceImpl::address_ready");
MACRUM 0:119624335925 569 ResolvedAddressData data;
MACRUM 0:119624335925 570 data._address = &address;
MACRUM 0:119624335925 571 data._port = server_port;
MACRUM 0:119624335925 572 if( M2MConnectionObserver::Bootstrap == server_type) {
MACRUM 0:119624335925 573 tr_info("M2MInterfaceImpl::address_ready() Server Type Bootstrap");
MACRUM 0:119624335925 574 internal_event(STATE_BOOTSTRAP_ADDRESS_RESOLVED, &data);
MACRUM 0:119624335925 575 } else {
MACRUM 0:119624335925 576 tr_info("M2MInterfaceImpl::address_ready() Server Type LWM2M");
MACRUM 0:119624335925 577 internal_event(STATE_REGISTER_ADDRESS_RESOLVED, &data);
MACRUM 0:119624335925 578 }
MACRUM 0:119624335925 579 }
MACRUM 0:119624335925 580
MACRUM 0:119624335925 581 void M2MInterfaceImpl::data_sent()
MACRUM 0:119624335925 582 {
MACRUM 0:119624335925 583 tr_debug("M2MInterfaceImpl::data_sent()");
MACRUM 0:119624335925 584 if(queue_mode()) {
MACRUM 0:119624335925 585 if(_callback_handler && (_nsdl_interface.get_unregister_ongoing() == false)) {
MACRUM 0:119624335925 586 _queue_sleep_timer.stop_timer();
MACRUM 0:119624335925 587 // Multiply by two to get enough time for coap retransmissions.
MACRUM 0:119624335925 588 _queue_sleep_timer.start_timer(MBED_CLIENT_RECONNECTION_COUNT*MBED_CLIENT_RECONNECTION_INTERVAL*1000*2,
MACRUM 0:119624335925 589 M2MTimerObserver::QueueSleep);
MACRUM 0:119624335925 590 }
MACRUM 0:119624335925 591 }
MACRUM 0:119624335925 592
MACRUM 0:119624335925 593 if (_current_state == STATE_BOOTSTRAP_ERROR_WAIT) {
MACRUM 0:119624335925 594 // bootstrap_error to be called only after we have sent the last ACK.
MACRUM 0:119624335925 595 // Otherwise client will goto reconnection mode before ACK has sent.
MACRUM 0:119624335925 596 bootstrap_error(_error_description);
MACRUM 0:119624335925 597 } else if (_current_state != STATE_BOOTSTRAP_WAIT) {
MACRUM 0:119624335925 598 internal_event(STATE_COAP_DATA_SENT);
MACRUM 0:119624335925 599 }
MACRUM 0:119624335925 600 }
MACRUM 0:119624335925 601
MACRUM 0:119624335925 602 void M2MInterfaceImpl::timer_expired(M2MTimerObserver::Type type)
MACRUM 0:119624335925 603 {
MACRUM 0:119624335925 604 if(M2MTimerObserver::QueueSleep == type) {
MACRUM 0:119624335925 605 tr_debug("M2MInterfaceImpl::timer_expired() - sleep");
MACRUM 0:119624335925 606 M2MTimer &timer = _nsdl_interface.get_nsdl_execution_timer();
MACRUM 0:119624335925 607 timer.stop_timer();
MACRUM 0:119624335925 608 _queue_mode_timer_ongoing = true;
MACRUM 0:119624335925 609 if(_callback_handler) {
MACRUM 0:119624335925 610 _callback_handler();
MACRUM 0:119624335925 611 }
MACRUM 0:119624335925 612 }
MACRUM 0:119624335925 613 else if (M2MTimerObserver::RetryTimer == type) {
MACRUM 0:119624335925 614 tr_debug("M2MInterfaceImpl::timer_expired() - retry");
MACRUM 0:119624335925 615 _retry_timer_expired = true;
MACRUM 0:119624335925 616 if (_bootstrapped) {
MACRUM 0:119624335925 617 internal_event(STATE_REGISTER);
MACRUM 0:119624335925 618 } else {
MACRUM 0:119624335925 619 internal_event(STATE_BOOTSTRAP);
MACRUM 0:119624335925 620 }
MACRUM 0:119624335925 621 }
MACRUM 0:119624335925 622 else if (M2MTimerObserver::BootstrapFlowTimer == type) {
MACRUM 0:119624335925 623 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 624 tr_debug("M2MInterfaceImpl::timer_expired() - bootstrap");
MACRUM 0:119624335925 625 _bootstrapped = false;
MACRUM 0:119624335925 626 if (_registration_flow_timer) {
MACRUM 0:119624335925 627 _registration_flow_timer->stop_timer();
MACRUM 0:119624335925 628 }
MACRUM 0:119624335925 629 bootstrap_error(ERROR_REASON_23);
MACRUM 0:119624335925 630 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 631 }
MACRUM 0:119624335925 632 else if (M2MTimerObserver::RegistrationFlowTimer == type) {
MACRUM 0:119624335925 633 tr_debug("M2MInterfaceImpl::timer_expired() - register");
MACRUM 0:119624335925 634 registration_error(M2MInterface::Timeout, true);
MACRUM 0:119624335925 635 }
MACRUM 0:119624335925 636 }
MACRUM 0:119624335925 637
MACRUM 0:119624335925 638 // state machine sits here.
MACRUM 0:119624335925 639 void M2MInterfaceImpl::state_idle(EventData* /*data*/)
MACRUM 0:119624335925 640 {
MACRUM 0:119624335925 641 tr_debug("M2MInterfaceImpl::state_idle");
MACRUM 0:119624335925 642 _nsdl_interface.stop_timers();
MACRUM 0:119624335925 643 _queue_sleep_timer.stop_timer();
MACRUM 0:119624335925 644 }
MACRUM 0:119624335925 645
MACRUM 0:119624335925 646 void M2MInterfaceImpl::state_bootstrap(EventData *data)
MACRUM 0:119624335925 647 {
MACRUM 0:119624335925 648 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 649 tr_debug("M2MInterfaceImpl::state_bootstrap");
MACRUM 0:119624335925 650 // Start with bootstrapping preparation
MACRUM 0:119624335925 651 _bootstrapped = false;
MACRUM 0:119624335925 652 M2MSecurityData *event = static_cast<M2MSecurityData *> (data);
MACRUM 0:119624335925 653 if(!_security) {
MACRUM 0:119624335925 654 M2MInterface::Error error = M2MInterface::InvalidParameters;
MACRUM 0:119624335925 655 if (event) {
MACRUM 0:119624335925 656 _security = event->_object;
MACRUM 0:119624335925 657 if(_security) {
MACRUM 0:119624335925 658 int32_t bs_id = _security->get_security_instance_id(M2MSecurity::Bootstrap);
MACRUM 0:119624335925 659 tr_info("M2MInterfaceImpl::state_bootstrap - bs_id = %d", bs_id);
MACRUM 0:119624335925 660 if(bs_id >= 0) {
MACRUM 0:119624335925 661 String server_address = _security->resource_value_string(M2MSecurity::M2MServerUri, bs_id);
MACRUM 0:119624335925 662 _nsdl_interface.set_server_address(server_address.c_str());
MACRUM 0:119624335925 663 tr_info("M2MInterfaceImpl::state_bootstrap - server_address %s", server_address.c_str());
MACRUM 0:119624335925 664 String coap;
MACRUM 0:119624335925 665 if(server_address.compare(0,sizeof(COAP)-1,COAP) == 0) {
MACRUM 0:119624335925 666 coap = COAP;
MACRUM 0:119624335925 667 }
MACRUM 0:119624335925 668 else if(server_address.compare(0,sizeof(COAPS)-1,COAPS) == 0) {
MACRUM 0:119624335925 669 _security->resource_value_int(M2MSecurity::SecurityMode, bs_id) != M2MSecurity::NoSecurity ? coap = COAPS: coap = "";
MACRUM 0:119624335925 670 }
MACRUM 0:119624335925 671 if(!coap.empty()) {
MACRUM 0:119624335925 672 server_address = server_address.substr(coap.size(),
MACRUM 0:119624335925 673 server_address.size()-coap.size());
MACRUM 0:119624335925 674
MACRUM 0:119624335925 675 process_address(server_address, _server_ip_address, _server_port);
MACRUM 0:119624335925 676
MACRUM 0:119624335925 677 tr_info("M2MInterfaceImpl::state_bootstrap - IP address %s, Port %d", _server_ip_address.c_str(), _server_port);
MACRUM 0:119624335925 678 // If bind and resolving server address succeed then proceed else
MACRUM 0:119624335925 679 // return error to the application and go to Idle state.
MACRUM 0:119624335925 680 if(!_server_ip_address.empty()) {
MACRUM 0:119624335925 681 error = M2MInterface::ErrorNone;
MACRUM 0:119624335925 682 if (_registration_flow_timer) {
MACRUM 0:119624335925 683 _registration_flow_timer->stop_timer();
MACRUM 0:119624335925 684 _registration_flow_timer->start_timer(MBED_CLIENT_RECONNECTION_COUNT * MBED_CLIENT_RECONNECTION_INTERVAL * 8 * 1000,
MACRUM 0:119624335925 685 M2MTimerObserver::BootstrapFlowTimer);
MACRUM 0:119624335925 686 }
MACRUM 0:119624335925 687 _connection_handler.resolve_server_address(_server_ip_address,
MACRUM 0:119624335925 688 _server_port,
MACRUM 0:119624335925 689 M2MConnectionObserver::Bootstrap,
MACRUM 0:119624335925 690 _security);
MACRUM 0:119624335925 691 }
MACRUM 0:119624335925 692 }
MACRUM 0:119624335925 693 }
MACRUM 0:119624335925 694 }
MACRUM 0:119624335925 695 }
MACRUM 0:119624335925 696 if (error != M2MInterface::ErrorNone) {
MACRUM 0:119624335925 697 tr_error("M2MInterfaceImpl::state_bootstrap - set error as M2MInterface::InvalidParameters");
MACRUM 0:119624335925 698 internal_event(STATE_IDLE);
MACRUM 0:119624335925 699 set_error_description(ERROR_REASON_11);
MACRUM 0:119624335925 700 _observer.error(error);
MACRUM 0:119624335925 701 }
MACRUM 0:119624335925 702 } else {
MACRUM 0:119624335925 703 _listen_port = 0;
MACRUM 0:119624335925 704 _connection_handler.bind_connection(_listen_port);
MACRUM 0:119624335925 705 if (_registration_flow_timer) {
MACRUM 0:119624335925 706 _registration_flow_timer->stop_timer();
MACRUM 0:119624335925 707 _registration_flow_timer->start_timer(MBED_CLIENT_RECONNECTION_COUNT * MBED_CLIENT_RECONNECTION_INTERVAL * 8 * 1000,
MACRUM 0:119624335925 708 M2MTimerObserver::BootstrapFlowTimer);
MACRUM 0:119624335925 709 }
MACRUM 0:119624335925 710 tr_info("M2MInterfaceImpl::state_bootstrap (reconnect) - IP address %s, Port %d", _server_ip_address.c_str(), _server_port);
MACRUM 0:119624335925 711 _connection_handler.resolve_server_address(_server_ip_address,
MACRUM 0:119624335925 712 _server_port,
MACRUM 0:119624335925 713 M2MConnectionObserver::Bootstrap,
MACRUM 0:119624335925 714 _security);
MACRUM 0:119624335925 715 }
MACRUM 0:119624335925 716 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 717 }
MACRUM 0:119624335925 718
MACRUM 0:119624335925 719 void M2MInterfaceImpl::state_bootstrap_address_resolved( EventData *data)
MACRUM 0:119624335925 720 {
MACRUM 0:119624335925 721 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 722 tr_debug("M2MInterfaceImpl::state_bootstrap_address_resolved");
MACRUM 0:119624335925 723 if (data) {
MACRUM 0:119624335925 724 ResolvedAddressData *event = static_cast<ResolvedAddressData *> (data);
MACRUM 0:119624335925 725 sn_nsdl_addr_s address;
MACRUM 0:119624335925 726
MACRUM 0:119624335925 727 M2MInterface::NetworkStack stack = event->_address->_stack;
MACRUM 0:119624335925 728
MACRUM 0:119624335925 729 if(M2MInterface::LwIP_IPv4 == stack) {
MACRUM 0:119624335925 730 tr_info("M2MInterfaceImpl::state_bootstrap_address_resolved : IPv4 address");
MACRUM 0:119624335925 731 address.type = SN_NSDL_ADDRESS_TYPE_IPV4;
MACRUM 0:119624335925 732 } else if((M2MInterface::LwIP_IPv6 == stack) ||
MACRUM 0:119624335925 733 (M2MInterface::Nanostack_IPv6 == stack)) {
MACRUM 0:119624335925 734 tr_info("M2MInterfaceImpl::state_bootstrap_address_resolved : IPv6 address");
MACRUM 0:119624335925 735 address.type = SN_NSDL_ADDRESS_TYPE_IPV6;
MACRUM 0:119624335925 736 }
MACRUM 0:119624335925 737 address.port = event->_port;
MACRUM 0:119624335925 738 address.addr_ptr = (uint8_t*)event->_address->_address;
MACRUM 0:119624335925 739 address.addr_len = event->_address->_length;
MACRUM 0:119624335925 740 _connection_handler.start_listening_for_data();
MACRUM 0:119624335925 741
MACRUM 0:119624335925 742 if(_nsdl_interface.create_bootstrap_resource(&address)) {
MACRUM 0:119624335925 743 internal_event(STATE_BOOTSTRAP_RESOURCE_CREATED);
MACRUM 0:119624335925 744 } else{
MACRUM 0:119624335925 745 // If resource creation fails then inform error to application
MACRUM 0:119624335925 746 tr_error("M2MInterfaceImpl::state_bootstrap_address_resolved : M2MInterface::InvalidParameters");
MACRUM 0:119624335925 747 internal_event(STATE_IDLE);
MACRUM 0:119624335925 748 set_error_description(ERROR_REASON_12);
MACRUM 0:119624335925 749 _observer.error(M2MInterface::InvalidParameters);
MACRUM 0:119624335925 750 }
MACRUM 0:119624335925 751 }
MACRUM 0:119624335925 752 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 753 }
MACRUM 0:119624335925 754
MACRUM 0:119624335925 755 void M2MInterfaceImpl::state_bootstrap_resource_created( EventData */*data*/)
MACRUM 0:119624335925 756 {
MACRUM 0:119624335925 757 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 758 tr_debug("M2MInterfaceImpl::state_bootstrap_resource_created");
MACRUM 0:119624335925 759 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 760 }
MACRUM 0:119624335925 761
MACRUM 0:119624335925 762 void M2MInterfaceImpl::state_bootstrapped( EventData */*data*/)
MACRUM 0:119624335925 763 {
MACRUM 0:119624335925 764 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 765 tr_debug("M2MInterfaceImpl::state_bootstrapped");
MACRUM 0:119624335925 766 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 767 }
MACRUM 0:119624335925 768
MACRUM 0:119624335925 769 void M2MInterfaceImpl::state_register(EventData *data)
MACRUM 0:119624335925 770 {
MACRUM 0:119624335925 771 tr_debug("M2MInterfaceImpl::state_register");
MACRUM 0:119624335925 772 M2MRegisterData *event = static_cast<M2MRegisterData *> (data);
MACRUM 0:119624335925 773 if (!_security) {
MACRUM 0:119624335925 774 M2MInterface::Error error = M2MInterface::InvalidParameters;
MACRUM 0:119624335925 775 // Start with registration preparation
MACRUM 0:119624335925 776 if(event) {
MACRUM 0:119624335925 777 _security = event->_object;
MACRUM 0:119624335925 778 if(_security) {
MACRUM 0:119624335925 779 int32_t m2m_id = _security->get_security_instance_id(M2MSecurity::M2MServer);
MACRUM 0:119624335925 780 if(m2m_id >= 0) {
MACRUM 0:119624335925 781 if(_nsdl_interface.create_nsdl_list_structure(event->_object_list)) {
MACRUM 0:119624335925 782 // If the nsdl resource structure is created successfully
MACRUM 0:119624335925 783 String server_address = _security->resource_value_string(M2MSecurity::M2MServerUri, m2m_id);
MACRUM 0:119624335925 784 _nsdl_interface.set_server_address(server_address.c_str());
MACRUM 0:119624335925 785 tr_info("M2MInterfaceImpl::state_register - server_address %s", server_address.c_str());
MACRUM 0:119624335925 786 String coap;
MACRUM 0:119624335925 787 if(server_address.compare(0,sizeof(COAP)-1,COAP) == 0) {
MACRUM 0:119624335925 788 coap = COAP;
MACRUM 0:119624335925 789 }
MACRUM 0:119624335925 790 else if(server_address.compare(0,sizeof(COAPS)-1,COAPS) == 0) {
MACRUM 0:119624335925 791 _security->resource_value_int(M2MSecurity::SecurityMode, m2m_id) != M2MSecurity::NoSecurity ? coap = COAPS: coap = "";
MACRUM 0:119624335925 792 }
MACRUM 0:119624335925 793 if(!coap.empty()) {
MACRUM 0:119624335925 794 server_address = server_address.substr(coap.size(),
MACRUM 0:119624335925 795 server_address.size() - coap.size());
MACRUM 0:119624335925 796 process_address(server_address, _server_ip_address, _server_port);
MACRUM 0:119624335925 797
MACRUM 0:119624335925 798 tr_info("M2MInterfaceImpl::state_register - IP address %s, Port %d", _server_ip_address.c_str(), _server_port);
MACRUM 0:119624335925 799 if(!_server_ip_address.empty()) {
MACRUM 0:119624335925 800 // Connection related errors are coming through callback
MACRUM 0:119624335925 801 if (_registration_flow_timer) {
MACRUM 0:119624335925 802 _registration_flow_timer->stop_timer();
MACRUM 0:119624335925 803 _registration_flow_timer->start_timer(MBED_CLIENT_RECONNECTION_COUNT * MBED_CLIENT_RECONNECTION_INTERVAL * 8 * 1000,
MACRUM 0:119624335925 804 M2MTimerObserver::RegistrationFlowTimer);
MACRUM 0:119624335925 805 }
MACRUM 0:119624335925 806 _reconnection_state = M2MInterfaceImpl::FullRegistration;
MACRUM 0:119624335925 807 error = M2MInterface::ErrorNone;
MACRUM 0:119624335925 808 _connection_handler.resolve_server_address(_server_ip_address,_server_port,
MACRUM 0:119624335925 809 M2MConnectionObserver::LWM2MServer,
MACRUM 0:119624335925 810 _security);
MACRUM 0:119624335925 811 }
MACRUM 0:119624335925 812 }
MACRUM 0:119624335925 813 } else {
MACRUM 0:119624335925 814 tr_error("M2MInterfaceImpl::state_register - fail to create nsdl list structure!");
MACRUM 0:119624335925 815 }
MACRUM 0:119624335925 816 }
MACRUM 0:119624335925 817 }
MACRUM 0:119624335925 818 }
MACRUM 0:119624335925 819 if (error != M2MInterface::ErrorNone) {
MACRUM 0:119624335925 820 tr_error("M2MInterfaceImpl::state_register - set error as M2MInterface::InvalidParameters");
MACRUM 0:119624335925 821 internal_event(STATE_IDLE);
MACRUM 0:119624335925 822 set_error_description(ERROR_REASON_13);
MACRUM 0:119624335925 823 _observer.error(error);
MACRUM 0:119624335925 824 }
MACRUM 0:119624335925 825 } else {
MACRUM 0:119624335925 826 _listen_port = 0;
MACRUM 0:119624335925 827 if (event) {
MACRUM 0:119624335925 828 _nsdl_interface.create_nsdl_list_structure(event->_object_list);
MACRUM 0:119624335925 829 }
MACRUM 0:119624335925 830 _connection_handler.bind_connection(_listen_port);
MACRUM 0:119624335925 831 if (_registration_flow_timer) {
MACRUM 0:119624335925 832 _registration_flow_timer->stop_timer();
MACRUM 0:119624335925 833 _registration_flow_timer->start_timer(MBED_CLIENT_RECONNECTION_COUNT * MBED_CLIENT_RECONNECTION_INTERVAL * 8 * 1000,
MACRUM 0:119624335925 834 M2MTimerObserver::RegistrationFlowTimer);
MACRUM 0:119624335925 835 }
MACRUM 0:119624335925 836 _reconnection_state = M2MInterfaceImpl::FullRegistration;
MACRUM 0:119624335925 837 tr_info("M2MInterfaceImpl::state_register (reconnect) - IP address %s, Port %d", _server_ip_address.c_str(), _server_port);
MACRUM 0:119624335925 838 _connection_handler.resolve_server_address(_server_ip_address,_server_port,
MACRUM 0:119624335925 839 M2MConnectionObserver::LWM2MServer,
MACRUM 0:119624335925 840 _security);
MACRUM 0:119624335925 841 }
MACRUM 0:119624335925 842 }
MACRUM 0:119624335925 843
MACRUM 0:119624335925 844 void M2MInterfaceImpl::process_address(const String& server_address, String& ip_address, uint16_t& port) {
MACRUM 0:119624335925 845
MACRUM 0:119624335925 846 int colonFound = server_address.find_last_of(':'); //10
MACRUM 0:119624335925 847 if(colonFound != -1) {
MACRUM 0:119624335925 848 ip_address = server_address.substr(0,colonFound);
MACRUM 0:119624335925 849 port = atoi(server_address.substr(colonFound+1,
MACRUM 0:119624335925 850 server_address.size()-ip_address.size()).c_str());
MACRUM 0:119624335925 851 colonFound = ip_address.find_last_of(']');
MACRUM 0:119624335925 852 if(ip_address.compare(0,1,"[") == 0) {
MACRUM 0:119624335925 853 if(colonFound == -1) {
MACRUM 0:119624335925 854 ip_address.clear();
MACRUM 0:119624335925 855 } else {
MACRUM 0:119624335925 856 ip_address = ip_address.substr(1,colonFound-1);
MACRUM 0:119624335925 857 }
MACRUM 0:119624335925 858 } else if(colonFound != -1) {
MACRUM 0:119624335925 859 ip_address.clear();
MACRUM 0:119624335925 860 }
MACRUM 0:119624335925 861 }
MACRUM 0:119624335925 862 }
MACRUM 0:119624335925 863
MACRUM 0:119624335925 864 void M2MInterfaceImpl::state_register_address_resolved( EventData *data)
MACRUM 0:119624335925 865 {
MACRUM 0:119624335925 866 tr_debug("M2MInterfaceImpl::state_register_address_resolved");
MACRUM 0:119624335925 867 if(data) {
MACRUM 0:119624335925 868 ResolvedAddressData *event = static_cast<ResolvedAddressData *> (data);
MACRUM 0:119624335925 869
MACRUM 0:119624335925 870 sn_nsdl_addr_type_e address_type = SN_NSDL_ADDRESS_TYPE_IPV6;
MACRUM 0:119624335925 871
MACRUM 0:119624335925 872 M2MInterface::NetworkStack stack = event->_address->_stack;
MACRUM 0:119624335925 873
MACRUM 0:119624335925 874 if(M2MInterface::LwIP_IPv4 == stack) {
MACRUM 0:119624335925 875 tr_info("M2MInterfaceImpl::state_register_address_resolved : IPv4 address");
MACRUM 0:119624335925 876 address_type = SN_NSDL_ADDRESS_TYPE_IPV4;
MACRUM 0:119624335925 877 } else if((M2MInterface::LwIP_IPv6 == stack) ||
MACRUM 0:119624335925 878 (M2MInterface::Nanostack_IPv6 == stack)) {
MACRUM 0:119624335925 879 tr_info("M2MInterfaceImpl::state_register_address_resolved : IPv6 address");
MACRUM 0:119624335925 880 address_type = SN_NSDL_ADDRESS_TYPE_IPV6;
MACRUM 0:119624335925 881 }
MACRUM 0:119624335925 882 _connection_handler.start_listening_for_data();
MACRUM 0:119624335925 883 _nsdl_interface.set_server_address((uint8_t*)event->_address->_address,event->_address->_length,
MACRUM 0:119624335925 884 event->_port, address_type);
MACRUM 0:119624335925 885 switch (_reconnection_state) {
MACRUM 0:119624335925 886 case M2MInterfaceImpl::None:
MACRUM 0:119624335925 887 case M2MInterfaceImpl::FullRegistration:
MACRUM 0:119624335925 888 if(!_nsdl_interface.send_register_message()) {
MACRUM 0:119624335925 889 // If resource creation fails then inform error to application
MACRUM 0:119624335925 890 tr_error("M2MInterfaceImpl::state_register_address_resolved : M2MInterface::MemoryFail");
MACRUM 0:119624335925 891 internal_event(STATE_IDLE);
MACRUM 0:119624335925 892 set_error_description(ERROR_REASON_25);
MACRUM 0:119624335925 893 _observer.error(M2MInterface::MemoryFail);
MACRUM 0:119624335925 894 }
MACRUM 0:119624335925 895 break;
MACRUM 0:119624335925 896 case M2MInterfaceImpl::Unregistration:
MACRUM 0:119624335925 897 case M2MInterfaceImpl::WithUpdate:
MACRUM 0:119624335925 898 // Start registration update in case it is reconnection logic because of network issue.
MACRUM 0:119624335925 899 internal_event(STATE_UPDATE_REGISTRATION);
MACRUM 0:119624335925 900 break;
MACRUM 0:119624335925 901 }
MACRUM 0:119624335925 902 }
MACRUM 0:119624335925 903 }
MACRUM 0:119624335925 904
MACRUM 0:119624335925 905 void M2MInterfaceImpl::state_registered( EventData */*data*/)
MACRUM 0:119624335925 906 {
MACRUM 0:119624335925 907 tr_info("M2MInterfaceImpl::state_registered");
MACRUM 0:119624335925 908 if (_registration_flow_timer) {
MACRUM 0:119624335925 909 _registration_flow_timer->stop_timer();
MACRUM 0:119624335925 910 }
MACRUM 0:119624335925 911 _reconnection_time = _initial_reconnection_time;
MACRUM 0:119624335925 912 _reconnecting = false;
MACRUM 0:119624335925 913
MACRUM 0:119624335925 914 // Continue with the unregistration process if it has failed due to connection lost
MACRUM 0:119624335925 915 if (_reconnection_state == M2MInterfaceImpl::Unregistration) {
MACRUM 0:119624335925 916 internal_event(STATE_UNREGISTER);
MACRUM 0:119624335925 917 }
MACRUM 0:119624335925 918
MACRUM 0:119624335925 919 _reconnection_state = M2MInterfaceImpl::None;
MACRUM 0:119624335925 920 }
MACRUM 0:119624335925 921
MACRUM 0:119624335925 922 void M2MInterfaceImpl::state_update_registration(EventData *data)
MACRUM 0:119624335925 923 {
MACRUM 0:119624335925 924 tr_debug("M2MInterfaceImpl::state_update_registration");
MACRUM 0:119624335925 925 uint32_t lifetime = 0;
MACRUM 0:119624335925 926 bool clear_queue = false;
MACRUM 0:119624335925 927 // Set to false to allow reconnection to work.
MACRUM 0:119624335925 928 _queue_mode_timer_ongoing = false;
MACRUM 0:119624335925 929
MACRUM 0:119624335925 930 if(data) {
MACRUM 0:119624335925 931 M2MUpdateRegisterData *event = static_cast<M2MUpdateRegisterData *> (data);
MACRUM 0:119624335925 932 // Create new resources if any
MACRUM 0:119624335925 933 if (!event->_object_list.empty()) {
MACRUM 0:119624335925 934 _nsdl_interface.create_nsdl_list_structure(event->_object_list);
MACRUM 0:119624335925 935 }
MACRUM 0:119624335925 936 lifetime = event->_lifetime;
MACRUM 0:119624335925 937 } else {
MACRUM 0:119624335925 938 clear_queue = true;
MACRUM 0:119624335925 939 }
MACRUM 0:119624335925 940
MACRUM 0:119624335925 941 bool success = _nsdl_interface.send_update_registration(lifetime, clear_queue);
MACRUM 0:119624335925 942 if(!success) {
MACRUM 0:119624335925 943 if(_reconnection_state == M2MInterfaceImpl::WithUpdate) {
MACRUM 0:119624335925 944 if (_reconnection_state != M2MInterfaceImpl::Unregistration) {
MACRUM 0:119624335925 945 _reconnection_state = M2MInterfaceImpl::FullRegistration;
MACRUM 0:119624335925 946 if(!_nsdl_interface.send_register_message()) {
MACRUM 0:119624335925 947 tr_error("M2MInterfaceImpl::state_update_registration : M2MInterface::MemoryFail");
MACRUM 0:119624335925 948 internal_event(STATE_IDLE);
MACRUM 0:119624335925 949 set_error_description(ERROR_REASON_25);
MACRUM 0:119624335925 950 _observer.error(M2MInterface::MemoryFail);
MACRUM 0:119624335925 951 }
MACRUM 0:119624335925 952 }
MACRUM 0:119624335925 953 }
MACRUM 0:119624335925 954 }
MACRUM 0:119624335925 955 }
MACRUM 0:119624335925 956
MACRUM 0:119624335925 957 void M2MInterfaceImpl::state_unregister(EventData */*data*/)
MACRUM 0:119624335925 958 {
MACRUM 0:119624335925 959 tr_debug("M2MInterfaceImpl::state_unregister");
MACRUM 0:119624335925 960 internal_event(STATE_SENDING_COAP_DATA);
MACRUM 0:119624335925 961 if(!_nsdl_interface.send_unregister_message()) {
MACRUM 0:119624335925 962 tr_error("M2MInterfaceImpl::state_unregister : M2MInterface::NotRegistered");
MACRUM 0:119624335925 963 internal_event(STATE_IDLE);
MACRUM 0:119624335925 964 set_error_description(ERROR_REASON_16);
MACRUM 0:119624335925 965 _observer.error(M2MInterface::NotRegistered);
MACRUM 0:119624335925 966 }
MACRUM 0:119624335925 967 }
MACRUM 0:119624335925 968
MACRUM 0:119624335925 969 void M2MInterfaceImpl::state_unregistered( EventData */*data*/)
MACRUM 0:119624335925 970 {
MACRUM 0:119624335925 971 tr_info("M2MInterfaceImpl::state_unregistered");
MACRUM 0:119624335925 972 _reconnection_time = _initial_reconnection_time;
MACRUM 0:119624335925 973 _connection_handler.stop_listening();
MACRUM 0:119624335925 974 internal_event(STATE_IDLE);
MACRUM 0:119624335925 975 }
MACRUM 0:119624335925 976
MACRUM 0:119624335925 977 void M2MInterfaceImpl::state_sending_coap_data( EventData */*data*/)
MACRUM 0:119624335925 978 {
MACRUM 0:119624335925 979 tr_debug("M2MInterfaceImpl::state_sending_coap_data");
MACRUM 0:119624335925 980 _nsdl_interface.start_nsdl_execution_timer();
MACRUM 0:119624335925 981 internal_event(STATE_WAITING);
MACRUM 0:119624335925 982 }
MACRUM 0:119624335925 983
MACRUM 0:119624335925 984 void M2MInterfaceImpl::state_coap_data_sent( EventData */*data*/)
MACRUM 0:119624335925 985 {
MACRUM 0:119624335925 986 tr_debug("M2MInterfaceImpl::state_coap_data_sent");
MACRUM 0:119624335925 987 internal_event(STATE_WAITING);
MACRUM 0:119624335925 988 }
MACRUM 0:119624335925 989
MACRUM 0:119624335925 990 void M2MInterfaceImpl::state_coap_data_received( EventData *data)
MACRUM 0:119624335925 991 {
MACRUM 0:119624335925 992 tr_debug("M2MInterfaceImpl::state_coap_data_received");
MACRUM 0:119624335925 993 if(data) {
MACRUM 0:119624335925 994 ReceivedData *event = static_cast<ReceivedData*> (data);
MACRUM 0:119624335925 995 sn_nsdl_addr_s address;
MACRUM 0:119624335925 996
MACRUM 0:119624335925 997 M2MInterface::NetworkStack stack = event->_address->_stack;
MACRUM 0:119624335925 998
MACRUM 0:119624335925 999 if(M2MInterface::LwIP_IPv4 == stack) {
MACRUM 0:119624335925 1000 address.type = SN_NSDL_ADDRESS_TYPE_IPV4;
MACRUM 0:119624335925 1001 address.addr_len = 4;
MACRUM 0:119624335925 1002 } else if((M2MInterface::LwIP_IPv6 == stack) ||
MACRUM 0:119624335925 1003 (M2MInterface::Nanostack_IPv6 == stack)) {
MACRUM 0:119624335925 1004 address.type = SN_NSDL_ADDRESS_TYPE_IPV6;
MACRUM 0:119624335925 1005 address.addr_len = 16;
MACRUM 0:119624335925 1006 }
MACRUM 0:119624335925 1007 address.port = event->_address->_port;
MACRUM 0:119624335925 1008 address.addr_ptr = (uint8_t*)event->_address->_address;
MACRUM 0:119624335925 1009 address.addr_len = event->_address->_length;
MACRUM 0:119624335925 1010
MACRUM 0:119624335925 1011 // Process received data
MACRUM 0:119624335925 1012 internal_event(STATE_PROCESSING_COAP_DATA);
MACRUM 0:119624335925 1013 if(!_nsdl_interface.process_received_data(event->_data,
MACRUM 0:119624335925 1014 event->_size,
MACRUM 0:119624335925 1015 &address)) {
MACRUM 0:119624335925 1016 tr_error("M2MInterfaceImpl::state_coap_data_received : M2MInterface::ResponseParseFailed");
MACRUM 0:119624335925 1017 set_error_description(ERROR_REASON_17);
MACRUM 0:119624335925 1018 _observer.error(M2MInterface::ResponseParseFailed);
MACRUM 0:119624335925 1019 }
MACRUM 0:119624335925 1020 }
MACRUM 0:119624335925 1021 }
MACRUM 0:119624335925 1022
MACRUM 0:119624335925 1023 void M2MInterfaceImpl::state_processing_coap_data( EventData */*data*/)
MACRUM 0:119624335925 1024 {
MACRUM 0:119624335925 1025 tr_debug("M2MInterfaceImpl::state_processing_coap_data");
MACRUM 0:119624335925 1026 internal_event(STATE_WAITING);
MACRUM 0:119624335925 1027 }
MACRUM 0:119624335925 1028
MACRUM 0:119624335925 1029 void M2MInterfaceImpl::state_coap_data_processed( EventData */*data*/)
MACRUM 0:119624335925 1030 {
MACRUM 0:119624335925 1031 tr_debug("M2MInterfaceImpl::state_coap_data_processed");
MACRUM 0:119624335925 1032 internal_event(STATE_WAITING);
MACRUM 0:119624335925 1033 }
MACRUM 0:119624335925 1034
MACRUM 0:119624335925 1035 void M2MInterfaceImpl::state_waiting( EventData */*data*/)
MACRUM 0:119624335925 1036 {
MACRUM 0:119624335925 1037 tr_debug("M2MInterfaceImpl::state_waiting");
MACRUM 0:119624335925 1038 }
MACRUM 0:119624335925 1039
MACRUM 0:119624335925 1040 // generates an external event. called once per external event
MACRUM 0:119624335925 1041 // to start the state machine executing
MACRUM 0:119624335925 1042 void M2MInterfaceImpl::external_event(uint8_t new_state,
MACRUM 0:119624335925 1043 EventData* p_data)
MACRUM 0:119624335925 1044 {
MACRUM 0:119624335925 1045 tr_debug("M2MInterfaceImpl::external_event : new state %d", new_state);
MACRUM 0:119624335925 1046 // if we are supposed to ignore this event
MACRUM 0:119624335925 1047 if (new_state == EVENT_IGNORED) {
MACRUM 0:119624335925 1048 tr_debug("M2MInterfaceImpl::external_event : new state is EVENT_IGNORED");
MACRUM 0:119624335925 1049 _event_ignored = true;
MACRUM 0:119624335925 1050 }
MACRUM 0:119624335925 1051 else {
MACRUM 0:119624335925 1052 tr_debug("M2MInterfaceImpl::external_event : handle new state");
MACRUM 0:119624335925 1053 // generate the event and execute the state engine
MACRUM 0:119624335925 1054 internal_event(new_state, p_data);
MACRUM 0:119624335925 1055 }
MACRUM 0:119624335925 1056 }
MACRUM 0:119624335925 1057
MACRUM 0:119624335925 1058 // generates an internal event. called from within a state
MACRUM 0:119624335925 1059 // function to transition to a new state
MACRUM 0:119624335925 1060 void M2MInterfaceImpl::internal_event(uint8_t new_state,
MACRUM 0:119624335925 1061 EventData* p_data)
MACRUM 0:119624335925 1062 {
MACRUM 0:119624335925 1063 tr_debug("M2MInterfaceImpl::internal_event : new state %d", new_state);
MACRUM 0:119624335925 1064 _event_data = p_data;
MACRUM 0:119624335925 1065 _event_generated = true;
MACRUM 0:119624335925 1066 _current_state = new_state;
MACRUM 0:119624335925 1067 state_engine();
MACRUM 0:119624335925 1068 }
MACRUM 0:119624335925 1069
MACRUM 0:119624335925 1070 // the state engine executes the state machine states
MACRUM 0:119624335925 1071 void M2MInterfaceImpl::state_engine (void)
MACRUM 0:119624335925 1072 {
MACRUM 0:119624335925 1073 tr_debug("M2MInterfaceImpl::state_engine");
MACRUM 0:119624335925 1074 EventData* p_data_temp = NULL;
MACRUM 0:119624335925 1075
MACRUM 0:119624335925 1076 // while events are being generated keep executing states
MACRUM 0:119624335925 1077 while (_event_generated) {
MACRUM 0:119624335925 1078 p_data_temp = _event_data; // copy of event data pointer
MACRUM 0:119624335925 1079 _event_data = NULL; // event data used up, reset ptr
MACRUM 0:119624335925 1080 _event_generated = false; // event used up, reset flag
MACRUM 0:119624335925 1081
MACRUM 0:119624335925 1082 assert(_current_state < _max_states);
MACRUM 0:119624335925 1083
MACRUM 0:119624335925 1084 state_function( _current_state, p_data_temp );
MACRUM 0:119624335925 1085 }
MACRUM 0:119624335925 1086 }
MACRUM 0:119624335925 1087
MACRUM 0:119624335925 1088 void M2MInterfaceImpl::state_function( uint8_t current_state, EventData* data )
MACRUM 0:119624335925 1089 {
MACRUM 0:119624335925 1090 switch( current_state ) {
MACRUM 0:119624335925 1091 case STATE_IDLE:
MACRUM 0:119624335925 1092 M2MInterfaceImpl::state_idle(data);
MACRUM 0:119624335925 1093 break;
MACRUM 0:119624335925 1094 case STATE_BOOTSTRAP:
MACRUM 0:119624335925 1095 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 1096 M2MInterfaceImpl::state_bootstrap(data);
MACRUM 0:119624335925 1097 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 1098 break;
MACRUM 0:119624335925 1099 case STATE_BOOTSTRAP_ADDRESS_RESOLVED:
MACRUM 0:119624335925 1100 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 1101 M2MInterfaceImpl::state_bootstrap_address_resolved(data);
MACRUM 0:119624335925 1102 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 1103 break;
MACRUM 0:119624335925 1104 case STATE_BOOTSTRAP_RESOURCE_CREATED:
MACRUM 0:119624335925 1105 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 1106 M2MInterfaceImpl::state_bootstrap_resource_created(data);
MACRUM 0:119624335925 1107 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 1108 break;
MACRUM 0:119624335925 1109 case STATE_BOOTSTRAP_WAIT:
MACRUM 0:119624335925 1110 case STATE_BOOTSTRAP_ERROR_WAIT:
MACRUM 0:119624335925 1111 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 1112 // Do nothing, we're just waiting for data_sent callback
MACRUM 0:119624335925 1113 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 1114 break;
MACRUM 0:119624335925 1115 case STATE_BOOTSTRAPPED:
MACRUM 0:119624335925 1116 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 1117 M2MInterfaceImpl::state_bootstrapped(data);
MACRUM 0:119624335925 1118 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE
MACRUM 0:119624335925 1119 break;
MACRUM 0:119624335925 1120 case STATE_REGISTER:
MACRUM 0:119624335925 1121 M2MInterfaceImpl::state_register(data);
MACRUM 0:119624335925 1122 break;
MACRUM 0:119624335925 1123 case STATE_REGISTER_ADDRESS_RESOLVED:
MACRUM 0:119624335925 1124 M2MInterfaceImpl::state_register_address_resolved(data);
MACRUM 0:119624335925 1125 break;
MACRUM 0:119624335925 1126 case STATE_REGISTERED:
MACRUM 0:119624335925 1127 M2MInterfaceImpl::state_registered(data);
MACRUM 0:119624335925 1128 break;
MACRUM 0:119624335925 1129 case STATE_UPDATE_REGISTRATION:
MACRUM 0:119624335925 1130 M2MInterfaceImpl::state_update_registration(data);
MACRUM 0:119624335925 1131 break;
MACRUM 0:119624335925 1132 case STATE_UNREGISTER:
MACRUM 0:119624335925 1133 M2MInterfaceImpl::state_unregister(data);
MACRUM 0:119624335925 1134 break;
MACRUM 0:119624335925 1135 case STATE_UNREGISTERED:
MACRUM 0:119624335925 1136 M2MInterfaceImpl::state_unregistered(data);
MACRUM 0:119624335925 1137 break;
MACRUM 0:119624335925 1138 case STATE_SENDING_COAP_DATA:
MACRUM 0:119624335925 1139 M2MInterfaceImpl::state_sending_coap_data(data);
MACRUM 0:119624335925 1140 break;
MACRUM 0:119624335925 1141 case STATE_COAP_DATA_SENT:
MACRUM 0:119624335925 1142 M2MInterfaceImpl::state_coap_data_sent(data);
MACRUM 0:119624335925 1143 break;
MACRUM 0:119624335925 1144 case STATE_COAP_DATA_RECEIVED:
MACRUM 0:119624335925 1145 M2MInterfaceImpl::state_coap_data_received(data);
MACRUM 0:119624335925 1146 break;
MACRUM 0:119624335925 1147 case STATE_PROCESSING_COAP_DATA:
MACRUM 0:119624335925 1148 M2MInterfaceImpl::state_processing_coap_data(data);
MACRUM 0:119624335925 1149 break;
MACRUM 0:119624335925 1150 case STATE_COAP_DATA_PROCESSED:
MACRUM 0:119624335925 1151 M2MInterfaceImpl::state_coap_data_processed(data);
MACRUM 0:119624335925 1152 break;
MACRUM 0:119624335925 1153 case STATE_WAITING:
MACRUM 0:119624335925 1154 M2MInterfaceImpl::state_waiting(data);
MACRUM 0:119624335925 1155 break;
MACRUM 0:119624335925 1156 }
MACRUM 0:119624335925 1157 }
MACRUM 0:119624335925 1158
MACRUM 0:119624335925 1159 void M2MInterfaceImpl::start_register_update(M2MUpdateRegisterData *data) {
MACRUM 0:119624335925 1160 tr_debug("M2MInterfaceImpl::start_register_update()");
MACRUM 0:119624335925 1161 if(!data || (data->_lifetime != 0 && (data->_lifetime < MINIMUM_REGISTRATION_TIME))) {
MACRUM 0:119624335925 1162 set_error_description(ERROR_REASON_18);
MACRUM 0:119624335925 1163 _observer.error(M2MInterface::InvalidParameters);
MACRUM 0:119624335925 1164 }
MACRUM 0:119624335925 1165
MACRUM 0:119624335925 1166 if (_reconnecting) {
MACRUM 0:119624335925 1167 //If client is in reconnection mode, ignore this call, state machine will reconnect on its own.
MACRUM 0:119624335925 1168 return;
MACRUM 0:119624335925 1169 }
MACRUM 0:119624335925 1170
MACRUM 0:119624335925 1171 _reconnection_state = M2MInterfaceImpl::WithUpdate;
MACRUM 0:119624335925 1172 BEGIN_TRANSITION_MAP // - Current State -
MACRUM 0:119624335925 1173 TRANSITION_MAP_ENTRY (STATE_REGISTER) // state_idle
MACRUM 0:119624335925 1174 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap
MACRUM 0:119624335925 1175 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state__bootstrap_address_resolved
MACRUM 0:119624335925 1176 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap_resource_created
MACRUM 0:119624335925 1177 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap_wait
MACRUM 0:119624335925 1178 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrap_error_wait
MACRUM 0:119624335925 1179 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_bootstrapped
MACRUM 0:119624335925 1180 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_register
MACRUM 0:119624335925 1181 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_register_address_resolved
MACRUM 0:119624335925 1182 TRANSITION_MAP_ENTRY (STATE_UPDATE_REGISTRATION) // state_registered
MACRUM 0:119624335925 1183 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_update_registration
MACRUM 0:119624335925 1184 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_unregister
MACRUM 0:119624335925 1185 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_unregistered
MACRUM 0:119624335925 1186 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_sending_coap_data
MACRUM 0:119624335925 1187 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_coap_data_sent
MACRUM 0:119624335925 1188 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_coap_data_received
MACRUM 0:119624335925 1189 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_processing_coap_data
MACRUM 0:119624335925 1190 TRANSITION_MAP_ENTRY (EVENT_IGNORED) // state_coap_data_processed
MACRUM 0:119624335925 1191 TRANSITION_MAP_ENTRY (STATE_UPDATE_REGISTRATION) // state_waiting
MACRUM 0:119624335925 1192 END_TRANSITION_MAP(data)
MACRUM 0:119624335925 1193 if(_event_ignored) {
MACRUM 0:119624335925 1194 _event_ignored = false;
MACRUM 0:119624335925 1195 if (!_reconnecting) {
MACRUM 0:119624335925 1196 set_error_description(ERROR_REASON_19);
MACRUM 0:119624335925 1197 _observer.error(M2MInterface::NotAllowed);
MACRUM 0:119624335925 1198 }
MACRUM 0:119624335925 1199 }
MACRUM 0:119624335925 1200 }
MACRUM 0:119624335925 1201
MACRUM 0:119624335925 1202 void M2MInterfaceImpl::update_endpoint(String &name) {
MACRUM 0:119624335925 1203 _nsdl_interface.update_endpoint(name);
MACRUM 0:119624335925 1204 }
MACRUM 0:119624335925 1205
MACRUM 0:119624335925 1206 void M2MInterfaceImpl::update_domain(String &domain)
MACRUM 0:119624335925 1207 {
MACRUM 0:119624335925 1208 _nsdl_interface.update_domain(domain);
MACRUM 0:119624335925 1209 }
MACRUM 0:119624335925 1210
MACRUM 0:119624335925 1211 const String M2MInterfaceImpl::internal_endpoint_name() const
MACRUM 0:119624335925 1212 {
MACRUM 0:119624335925 1213 return _nsdl_interface.internal_endpoint_name();
MACRUM 0:119624335925 1214 }
MACRUM 0:119624335925 1215
MACRUM 0:119624335925 1216 const char *M2MInterfaceImpl::error_description() const
MACRUM 0:119624335925 1217 {
MACRUM 0:119624335925 1218 #ifndef DISABLE_ERROR_DESCRIPTION
MACRUM 0:119624335925 1219 return _error_description;
MACRUM 0:119624335925 1220 #else
MACRUM 0:119624335925 1221 return "";
MACRUM 0:119624335925 1222 #endif
MACRUM 0:119624335925 1223 }
MACRUM 0:119624335925 1224
MACRUM 0:119624335925 1225 void M2MInterfaceImpl::set_error_description(const char *description)
MACRUM 0:119624335925 1226 {
MACRUM 0:119624335925 1227 #ifndef DISABLE_ERROR_DESCRIPTION
MACRUM 0:119624335925 1228 if (strncmp(_error_description, description, sizeof(_error_description)) != 0) {
MACRUM 0:119624335925 1229 strncpy(_error_description, description, MAX_ALLOWED_ERROR_STRING_LENGTH - 1);
MACRUM 0:119624335925 1230 }
MACRUM 0:119624335925 1231 #endif
MACRUM 0:119624335925 1232 }
MACRUM 0:119624335925 1233
MACRUM 0:119624335925 1234 bool M2MInterfaceImpl::queue_mode() const
MACRUM 0:119624335925 1235 {
MACRUM 0:119624335925 1236 return (_binding_mode == M2MInterface::UDP_QUEUE ||
MACRUM 0:119624335925 1237 _binding_mode == M2MInterface::TCP_QUEUE ||
MACRUM 0:119624335925 1238 _binding_mode == M2MInterface::SMS_QUEUE ||
MACRUM 0:119624335925 1239 _binding_mode == M2MInterface::UDP_SMS_QUEUE);
MACRUM 0:119624335925 1240 }
MACRUM 0:119624335925 1241
MACRUM 0:119624335925 1242 void M2MInterfaceImpl::get_data_request(const char *uri,
MACRUM 0:119624335925 1243 const size_t offset,
MACRUM 0:119624335925 1244 const bool async,
MACRUM 0:119624335925 1245 get_data_cb data_cb,
MACRUM 0:119624335925 1246 get_data_error_cb error_cb,
MACRUM 0:119624335925 1247 void *context)
MACRUM 0:119624335925 1248 {
MACRUM 0:119624335925 1249 get_data_req_error_e error = FAILED_TO_SEND_MSG;
MACRUM 0:119624335925 1250 if(_current_state != STATE_IDLE && uri) {
MACRUM 0:119624335925 1251 if (!_nsdl_interface.send_get_data_request(uri, offset, async, data_cb, error_cb, context)) {
MACRUM 0:119624335925 1252 error_cb(error, context);
MACRUM 0:119624335925 1253 }
MACRUM 0:119624335925 1254 }
MACRUM 0:119624335925 1255 else {
MACRUM 0:119624335925 1256 error_cb(error, context);
MACRUM 0:119624335925 1257 }
MACRUM 0:119624335925 1258 }
MACRUM 0:119624335925 1259