joey shelton
/
LED_Demo
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Dependencies: MAX44000 PWM_Tone_Library nexpaq_mdk
Fork of
LED_Demo
by 
Maxim nexpaq
Embed:
(wiki syntax)
Show/hide line numbers
m2mnsdlinterface.cpp
00001 /* 00002 * Copyright (c) 2015 ARM Limited. All rights reserved. 00003 * SPDX-License-Identifier: Apache-2.0 00004 * Licensed under the Apache License, Version 2.0 (the License); you may 00005 * not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an AS IS BASIS, WITHOUT 00012 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 00017 // Note: this macro is needed on armcc to get the the PRI*32 macros 00018 // from inttypes.h in a C++ code. 00019 #ifndef __STDC_FORMAT_MACROS 00020 #define __STDC_FORMAT_MACROS 00021 #endif 00022 00023 // Note: this macro is needed on armcc to get the the limit macros like UINT16_MAX 00024 #ifndef __STDC_LIMIT_MACROS 00025 #define __STDC_LIMIT_MACROS 00026 #endif 00027 00028 00029 #include "include/nsdlaccesshelper.h" 00030 #include "include/m2mnsdlobserver.h" 00031 #include "include/m2mtlvdeserializer.h" 00032 #include "include/m2mtlvserializer.h" 00033 #include "include/m2mnsdlinterface.h" 00034 #include "mbed-client/m2mstring.h" 00035 #include "mbed-client/m2msecurity.h" 00036 #include "mbed-client/m2mserver.h" 00037 #include "mbed-client/m2mobject.h" 00038 #include "mbed-client/m2mobjectinstance.h" 00039 #include "mbed-client/m2mresource.h" 00040 #include "mbed-client/m2mconstants.h" 00041 #include "mbed-trace/mbed_trace.h" 00042 #include "mbed-client/m2mtimer.h" 00043 #include "source/libNsdl/src/include/sn_grs.h" 00044 00045 #include <assert.h> 00046 #include <inttypes.h> 00047 00048 #define BUFFER_SIZE 21 00049 #define TRACE_GROUP "mClt" 00050 00051 M2MNsdlInterface::M2MNsdlInterface(M2MNsdlObserver &observer) 00052 : _observer(observer), 00053 _server(NULL), 00054 _security(NULL), 00055 _nsdl_exceution_timer(new M2MTimer(*this)), 00056 _registration_timer(new M2MTimer(*this)), 00057 _endpoint(NULL), 00058 _resource(NULL), 00059 _nsdl_handle(NULL), 00060 _counter_for_nsdl(0), 00061 _bootstrap_id(0), 00062 _register_ongoing(false), 00063 _unregister_ongoing(false), 00064 _update_register_ongoing(false) 00065 { 00066 tr_debug("M2MNsdlInterface::M2MNsdlInterface()"); 00067 __nsdl_interface_list.push_back(this); 00068 _sn_nsdl_address.addr_len = 0; 00069 _sn_nsdl_address.addr_ptr = NULL; 00070 _sn_nsdl_address.port = 0; 00071 00072 // This initializes libCoap and libNsdl 00073 // Parameters are function pointers to used memory allocation 00074 // and free functions in structure and used functions for sending 00075 // and receiving purposes. 00076 _nsdl_handle = sn_nsdl_init(&(__nsdl_c_send_to_server), &(__nsdl_c_received_from_server), 00077 &(__nsdl_c_memory_alloc), &(__nsdl_c_memory_free)); 00078 00079 00080 _server = new M2MServer(); 00081 initialize(); 00082 } 00083 00084 M2MNsdlInterface::~M2MNsdlInterface() 00085 { 00086 tr_debug("M2MNsdlInterface::~M2MNsdlInterface() - IN"); 00087 if(_resource) { 00088 memory_free(_resource->resource_parameters_ptr); 00089 memory_free(_resource); 00090 } 00091 if(_endpoint) { 00092 memory_free(_endpoint->endpoint_name_ptr); 00093 memory_free(_endpoint->lifetime_ptr); 00094 memory_free(_endpoint->location_ptr); 00095 memory_free(_endpoint); 00096 } 00097 delete _nsdl_exceution_timer; 00098 delete _registration_timer; 00099 _object_list.clear(); 00100 delete _server; 00101 _security = NULL; 00102 00103 sn_nsdl_destroy(_nsdl_handle); 00104 _nsdl_handle = NULL; 00105 00106 M2MNsdlInterfaceList::const_iterator it; 00107 it = __nsdl_interface_list.begin(); 00108 int index = 0; 00109 for (; it!=__nsdl_interface_list.end(); it++) { 00110 if ((*it) == this) { 00111 __nsdl_interface_list.erase(index); 00112 break; 00113 } 00114 index++; 00115 } 00116 tr_debug("M2MNsdlInterface::~M2MNsdlInterface() - OUT"); 00117 } 00118 00119 bool M2MNsdlInterface::initialize() 00120 { 00121 tr_debug("M2MNsdlInterface::initialize()"); 00122 bool success = false; 00123 00124 //Sets the packet retransmission attempts and time interval 00125 sn_nsdl_set_retransmission_parameters(_nsdl_handle, 00126 MBED_CLIENT_RECONNECTION_COUNT, 00127 MBED_CLIENT_RECONNECTION_INTERVAL); 00128 00129 // We want to parse and handle bootstrap messages 00130 if (_nsdl_handle) { 00131 _nsdl_handle->handle_bootstrap_msg = false; 00132 } 00133 00134 // Allocate the memory for resources 00135 _resource = (sn_nsdl_resource_info_s*)memory_alloc(sizeof(sn_nsdl_resource_info_s)); 00136 if(_resource) { 00137 memset(_resource, 0, sizeof(sn_nsdl_resource_info_s)); 00138 _resource->resource_parameters_ptr = (sn_nsdl_resource_parameters_s*)memory_alloc(sizeof(sn_nsdl_resource_parameters_s)); 00139 if(_resource->resource_parameters_ptr) { 00140 memset(_resource->resource_parameters_ptr, 0, sizeof(sn_nsdl_resource_parameters_s)); 00141 } 00142 } 00143 00144 //Allocate the memory for endpoint 00145 _endpoint = (sn_nsdl_ep_parameters_s*)memory_alloc(sizeof(sn_nsdl_ep_parameters_s)); 00146 if(_endpoint) { 00147 memset(_endpoint, 0, sizeof(sn_nsdl_ep_parameters_s)); 00148 success = true; 00149 } 00150 return success; 00151 } 00152 00153 void M2MNsdlInterface::create_endpoint(const String &name, 00154 const String &type, 00155 const int32_t life_time, 00156 const String &domain, 00157 const uint8_t mode, 00158 const String &/*context_address*/) 00159 { 00160 tr_debug("M2MNsdlInterface::create_endpoint( name %s type %s lifetime %" PRId32 ", domain %s, mode %d)", 00161 name.c_str(), type.c_str(), life_time, domain.c_str(), mode); 00162 _endpoint_name = name; 00163 if(_endpoint){ 00164 memset(_endpoint, 0, sizeof(sn_nsdl_ep_parameters_s)); 00165 if(!_endpoint_name.empty()) { 00166 memory_free(_endpoint->endpoint_name_ptr); 00167 _endpoint->endpoint_name_ptr = alloc_string_copy((uint8_t*)_endpoint_name.c_str(), _endpoint_name.length()); 00168 _endpoint->endpoint_name_len = _endpoint_name.length(); 00169 } 00170 if(!type.empty()) { 00171 _endpoint->type_ptr = (uint8_t*)type.c_str(); 00172 _endpoint->type_len = type.length(); 00173 } 00174 if(!domain.empty()) { 00175 _endpoint->domain_name_ptr = (uint8_t*)domain.c_str(); 00176 _endpoint->domain_name_len = domain.length(); 00177 } 00178 _endpoint->binding_and_mode = (sn_nsdl_oma_binding_and_mode_t)mode; 00179 00180 // If lifetime is less than zero then leave the field empty 00181 if( life_time > 0) { 00182 set_endpoint_lifetime_buffer(life_time); 00183 } 00184 } 00185 } 00186 00187 void M2MNsdlInterface::set_endpoint_lifetime_buffer(int lifetime) 00188 { 00189 // max len of "-9223372036854775808" plus zero termination 00190 char buffer[20+1]; 00191 00192 uint32_t size = m2m::itoa_c(lifetime, buffer); 00193 00194 if (size <= sizeof(buffer)) { 00195 _endpoint->lifetime_ptr = alloc_string_copy((uint8_t*)buffer, size); 00196 if(_endpoint->lifetime_ptr) { 00197 _endpoint->lifetime_len = size; 00198 } else { 00199 _endpoint->lifetime_len = 0; 00200 } 00201 } 00202 } 00203 00204 00205 void M2MNsdlInterface::delete_endpoint() 00206 { 00207 tr_debug("M2MNsdlInterface::delete_endpoint()"); 00208 if(_endpoint) { 00209 free(_endpoint->lifetime_ptr); 00210 00211 memory_free(_endpoint); 00212 _endpoint = NULL; 00213 } 00214 } 00215 00216 bool M2MNsdlInterface::create_nsdl_list_structure(const M2MObjectList &object_list) 00217 { 00218 tr_debug("M2MNsdlInterface::create_nsdl_list_structure()"); 00219 bool success = false; 00220 if(!object_list.empty()) { 00221 tr_debug("M2MNsdlInterface::create_nsdl_list_structure - Object count is %d", object_list.size()); 00222 M2MObjectList::const_iterator it; 00223 it = object_list.begin(); 00224 for ( ; it != object_list.end(); it++ ) { 00225 // Create NSDL structure for all Objects inside 00226 success = create_nsdl_object_structure(*it); 00227 add_object_to_list(*it); 00228 } 00229 } 00230 return success; 00231 } 00232 00233 bool M2MNsdlInterface::delete_nsdl_resource(const String &resource_name) 00234 { 00235 tr_debug("M2MNsdlInterface::delete_nsdl_resource( %s)", resource_name.c_str()); 00236 return (sn_nsdl_delete_resource(_nsdl_handle, 00237 resource_name.length(), 00238 (uint8_t *)resource_name.c_str()) == 0) ? true : false; 00239 } 00240 00241 00242 bool M2MNsdlInterface::create_bootstrap_resource(sn_nsdl_addr_s *address, const String &bootstrap_endpoint_name) 00243 { 00244 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE 00245 tr_debug("M2MNsdlInterface::create_bootstrap_resource()"); 00246 bool success = false; 00247 sn_nsdl_bs_ep_info_t bootstrap_endpoint; 00248 tr_debug("M2MNsdlInterface::create_bootstrap_resource() - endpoint name: %s", bootstrap_endpoint_name.c_str()); 00249 if (_endpoint->endpoint_name_ptr) { 00250 memory_free(_endpoint->endpoint_name_ptr); 00251 } 00252 //_endpoint->endpoint_name_ptr = (uint8_t*)bootstrap_endpoint_name.c_str(); 00253 _endpoint->endpoint_name_ptr = alloc_string_copy((uint8_t*)bootstrap_endpoint_name.c_str(), bootstrap_endpoint_name.length()); 00254 _endpoint->endpoint_name_len = bootstrap_endpoint_name.length(); 00255 if(_bootstrap_id == 0) { 00256 _bootstrap_id = sn_nsdl_oma_bootstrap(_nsdl_handle, 00257 address, 00258 _endpoint, 00259 &bootstrap_endpoint); 00260 tr_debug("M2MNsdlInterface::create_bootstrap_resource - _bootstrap_id %d", _bootstrap_id); 00261 success = _bootstrap_id != 0; 00262 00263 } 00264 return success; 00265 #else 00266 (void)address; 00267 (void)bootstrap_endpoint_name; 00268 return false; 00269 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE 00270 } 00271 00272 bool M2MNsdlInterface::send_register_message(uint8_t* address, 00273 const uint16_t port, 00274 sn_nsdl_addr_type_e address_type) 00275 { 00276 tr_debug("M2MNsdlInterface::send_register_message()"); 00277 _nsdl_exceution_timer->stop_timer(); 00278 _nsdl_exceution_timer->start_timer(ONE_SECOND_TIMER * 1000, 00279 M2MTimerObserver::NsdlExecution, 00280 false); 00281 bool success = false; 00282 if(set_NSP_address(_nsdl_handle,address, port, address_type) == 0) { 00283 if(!_register_ongoing) { 00284 _register_ongoing = true; 00285 success = sn_nsdl_register_endpoint(_nsdl_handle,_endpoint) != 0; 00286 } 00287 } 00288 return success; 00289 } 00290 00291 bool M2MNsdlInterface::send_update_registration(const uint32_t lifetime) 00292 { 00293 if (_update_register_ongoing) { 00294 tr_debug("M2MNsdlInterface::send_update_registration - update already in progress"); 00295 return true; 00296 } 00297 tr_debug("M2MNsdlInterface::send_update_registration( lifetime %" PRIu32 ")", lifetime); 00298 bool success = false; 00299 00300 create_nsdl_list_structure(_object_list); 00301 //If Lifetime value is 0, then don't change the existing lifetime value 00302 if(lifetime != 0) { 00303 if(_endpoint->lifetime_ptr) { 00304 memory_free(_endpoint->lifetime_ptr); 00305 _endpoint->lifetime_ptr = NULL; 00306 _endpoint->lifetime_len = 0; 00307 } 00308 set_endpoint_lifetime_buffer(lifetime); 00309 00310 _registration_timer->stop_timer(); 00311 _registration_timer->start_timer(registration_time() * 1000, 00312 M2MTimerObserver::Registration, 00313 false); 00314 if(_nsdl_handle && 00315 _endpoint && _endpoint->lifetime_ptr) { 00316 tr_debug("M2MNsdlInterface::send_update_registration - new lifetime value"); 00317 _update_register_ongoing = true; 00318 success = sn_nsdl_update_registration(_nsdl_handle, 00319 _endpoint->lifetime_ptr, 00320 _endpoint->lifetime_len) != 0; 00321 } 00322 } else { 00323 if(_nsdl_handle) { 00324 tr_debug("M2MNsdlInterface::send_update_registration - regular update"); 00325 _update_register_ongoing = true; 00326 success = sn_nsdl_update_registration(_nsdl_handle, NULL, 0) != 0; 00327 } 00328 } 00329 return success; 00330 } 00331 00332 bool M2MNsdlInterface::send_unregister_message() 00333 { 00334 tr_debug("M2MNsdlInterface::send_unregister_message"); 00335 if (_unregister_ongoing) { 00336 tr_debug("M2MNsdlInterface::send_unregister_message - unregistration already in progress"); 00337 return true; 00338 } 00339 00340 bool success = false; 00341 _unregister_ongoing = true; 00342 success = sn_nsdl_unregister_endpoint(_nsdl_handle) != 0; 00343 return success; 00344 } 00345 00346 // XXX: move these to common place, no need to copy these wrappers to multiple places: 00347 void *M2MNsdlInterface::memory_alloc(uint16_t size) 00348 { 00349 if(size) 00350 return malloc(size); 00351 else 00352 return 0; 00353 } 00354 00355 void M2MNsdlInterface::memory_free(void *ptr) 00356 { 00357 if(ptr) 00358 free(ptr); 00359 } 00360 00361 uint8_t* M2MNsdlInterface::alloc_string_copy(const uint8_t* source, uint16_t size) 00362 { 00363 assert(source != NULL); 00364 00365 uint8_t* result = (uint8_t*)memory_alloc(size + 1); 00366 if (result) { 00367 memcpy(result, source, size); 00368 result[size] = '\0'; 00369 } 00370 return result; 00371 } 00372 00373 uint8_t M2MNsdlInterface::send_to_server_callback(struct nsdl_s * /*nsdl_handle*/, 00374 sn_nsdl_capab_e /*protocol*/, 00375 uint8_t *data_ptr, 00376 uint16_t data_len, 00377 sn_nsdl_addr_s *address) 00378 { 00379 tr_debug("M2MNsdlInterface::send_to_server_callback()"); 00380 _observer.coap_message_ready(data_ptr,data_len,address); 00381 return 1; 00382 } 00383 00384 uint8_t M2MNsdlInterface::received_from_server_callback(struct nsdl_s * nsdl_handle, 00385 sn_coap_hdr_s *coap_header, 00386 sn_nsdl_addr_s *address) 00387 { 00388 tr_debug("M2MNsdlInterface::received_from_server_callback - msg id:%" PRIu16, coap_header->msg_id); 00389 tr_debug("M2MNsdlInterface::received_from_server_callback - registration id:%" PRIu16, nsdl_handle->register_msg_id); 00390 tr_debug("M2MNsdlInterface::received_from_server_callback - unregistration id:%" PRIu16, nsdl_handle->unregister_msg_id); 00391 tr_debug("M2MNsdlInterface::received_from_server_callback - update registration id:%" PRIu16, nsdl_handle->update_register_msg_id); 00392 _observer.coap_data_processed(); 00393 uint8_t value = 0; 00394 if(nsdl_handle && coap_header) { 00395 bool is_bootstrap_msg = address && (nsdl_handle->oma_bs_address_len == address->addr_len) && 00396 (nsdl_handle->oma_bs_port == address->port) && 00397 !memcmp(nsdl_handle->oma_bs_address_ptr, address->addr_ptr, nsdl_handle->oma_bs_address_len); 00398 if(coap_header->msg_id == nsdl_handle->register_msg_id) { 00399 _register_ongoing = false; 00400 if(coap_header->msg_code == COAP_MSG_CODE_RESPONSE_CREATED) { 00401 tr_debug("M2MNsdlInterface::received_from_server_callback - registration callback"); 00402 _observer.client_registered(_server); 00403 // If lifetime is less than zero then leave the field empty 00404 if(coap_header->options_list_ptr) { 00405 if(coap_header->options_list_ptr->max_age_ptr) { 00406 memory_free(_endpoint->lifetime_ptr); 00407 _endpoint->lifetime_ptr = NULL; 00408 _endpoint->lifetime_len = 0; 00409 00410 uint32_t max_time = 0; 00411 for(int i=0;i < coap_header->options_list_ptr->max_age_len; i++) { 00412 max_time += (*(coap_header->options_list_ptr->max_age_ptr + i) & 0xff) << 00413 8*(coap_header->options_list_ptr->max_age_len- 1 - i); 00414 } 00415 // If lifetime is less than zero then leave the field empty 00416 if( max_time > 0) { 00417 set_endpoint_lifetime_buffer(max_time); 00418 } 00419 } 00420 if(coap_header->options_list_ptr->location_path_ptr) { 00421 00422 memory_free(_endpoint->location_ptr); 00423 00424 _endpoint->location_ptr = alloc_string_copy(coap_header->options_list_ptr->location_path_ptr, coap_header->options_list_ptr->location_path_len); 00425 if (_endpoint->location_ptr != NULL) { 00426 _endpoint->location_len = coap_header->options_list_ptr->location_path_len; 00427 } 00428 sn_nsdl_set_endpoint_location(_nsdl_handle,_endpoint->location_ptr,_endpoint->location_len); 00429 } 00430 } 00431 if(_endpoint->lifetime_ptr) { 00432 _registration_timer->stop_timer(); 00433 _registration_timer->start_timer(registration_time() * 1000, 00434 M2MTimerObserver::Registration, 00435 false); 00436 } 00437 } else { 00438 tr_error("M2MNsdlInterface::received_from_server_callback - registration error %d", coap_header->msg_code); 00439 // Try to do clean register again 00440 if(COAP_MSG_CODE_RESPONSE_BAD_REQUEST == coap_header->msg_code || 00441 COAP_MSG_CODE_RESPONSE_FORBIDDEN == coap_header->msg_code) { 00442 _observer.registration_error(M2MInterface::InvalidParameters, false); 00443 } else { 00444 _observer.registration_error(M2MInterface::NetworkError, true); 00445 } 00446 00447 } 00448 } else if(coap_header->msg_id == nsdl_handle->unregister_msg_id) { 00449 _unregister_ongoing = false; 00450 tr_debug("M2MNsdlInterface::received_from_server_callback - unregistration callback"); 00451 if(coap_header->msg_code == COAP_MSG_CODE_RESPONSE_DELETED) { 00452 _registration_timer->stop_timer(); 00453 _observer.client_unregistered(); 00454 } else { 00455 tr_error("M2MNsdlInterface::received_from_server_callback - unregistration error %d", coap_header->msg_code); 00456 M2MInterface::Error error = interface_error(coap_header); 00457 _observer.registration_error(error); 00458 } 00459 } else if(coap_header->msg_id == nsdl_handle->update_register_msg_id) { 00460 _update_register_ongoing = false; 00461 if(coap_header->msg_code == COAP_MSG_CODE_RESPONSE_CHANGED) { 00462 tr_debug("M2MNsdlInterface::received_from_server_callback - registration_updated successfully"); 00463 _observer.registration_updated(*_server); 00464 } else { 00465 tr_error("M2MNsdlInterface::received_from_server_callback - registration_updated failed %d", coap_header->msg_code); 00466 _registration_timer->stop_timer(); 00467 _register_ongoing = true; 00468 sn_nsdl_register_endpoint(_nsdl_handle,_endpoint); 00469 } 00470 } 00471 #ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE 00472 else if(coap_header->msg_id == nsdl_handle->bootstrap_msg_id) { 00473 tr_debug("M2MNsdlInterface::received_from_server_callback - bootstrap"); 00474 _bootstrap_id = 0; 00475 M2MInterface::Error error = interface_error(coap_header); 00476 if(error != M2MInterface::ErrorNone) { 00477 handle_bootstrap_error(); 00478 } 00479 } 00480 #endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE 00481 else { 00482 if(COAP_MSG_CODE_REQUEST_PUT == coap_header->msg_code) { 00483 if (is_bootstrap_msg) { 00484 handle_bootstrap_put_message(coap_header, address); 00485 } 00486 } 00487 else if(COAP_MSG_CODE_REQUEST_DELETE == coap_header->msg_code) { 00488 if (is_bootstrap_msg) { 00489 handle_bootstrap_delete(coap_header, address); 00490 } 00491 } 00492 else if(COAP_MSG_CODE_REQUEST_POST == coap_header->msg_code) { 00493 if(is_bootstrap_msg) { 00494 handle_bootstrap_finished(coap_header, address); 00495 } 00496 else if(coap_header->uri_path_ptr) { 00497 sn_coap_hdr_s *coap_response = NULL; 00498 bool execute_value_updated = false; 00499 M2MObjectInstance *obj_instance = NULL; 00500 String resource_name = coap_to_string(coap_header->uri_path_ptr, 00501 coap_header->uri_path_len); 00502 00503 String object_name; 00504 int slash_found = resource_name.find_last_of('/'); 00505 //The POST operation here is only allowed for non-existing object instances 00506 if(slash_found != -1) { 00507 object_name = resource_name.substr(0,slash_found); 00508 if( object_name.find_last_of('/') != -1){ 00509 coap_response = sn_nsdl_build_response(_nsdl_handle, 00510 coap_header, 00511 COAP_MSG_CODE_RESPONSE_NOT_FOUND); 00512 } else { 00513 int32_t instance_id = atoi(resource_name.substr(slash_found+1, 00514 resource_name.size()-object_name.size()).c_str()); 00515 M2MBase* base = find_resource(object_name); 00516 if(base && (instance_id >= 0) && (instance_id < UINT16_MAX)) { 00517 if(coap_header->payload_ptr) { 00518 M2MObject* object = static_cast<M2MObject*> (base); 00519 obj_instance = object->create_object_instance(instance_id); 00520 if(obj_instance) { 00521 obj_instance->set_operation(M2MBase::GET_PUT_POST_ALLOWED); 00522 coap_response = obj_instance->handle_post_request(_nsdl_handle, 00523 coap_header, 00524 this, 00525 execute_value_updated); 00526 } 00527 if(coap_response && coap_response->msg_code != COAP_MSG_CODE_RESPONSE_CREATED) { 00528 //Invalid request so remove created ObjectInstance 00529 object->remove_object_instance(instance_id); 00530 } else { 00531 tr_debug("M2MNsdlInterface::received_from_server_callback - Send Update registration for Create"); 00532 send_update_registration(); 00533 } 00534 } else { 00535 tr_debug("M2MNsdlInterface::received_from_server_callback - Missing Payload - Cannot create"); 00536 coap_response = sn_nsdl_build_response(_nsdl_handle, 00537 coap_header, 00538 COAP_MSG_CODE_RESPONSE_BAD_REQUEST); 00539 } 00540 } else { //if(base) 00541 tr_debug("M2MNsdlInterface::received_from_server_callback - Missing BASE - Cannot create"); 00542 coap_response = sn_nsdl_build_response(_nsdl_handle, 00543 coap_header, 00544 COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED); 00545 } 00546 } 00547 } else{ // if(slash_found != -1) 00548 tr_debug("M2MNsdlInterface::received_from_server_callback - slash_found - Cannot create"); 00549 coap_response = sn_nsdl_build_response(_nsdl_handle, 00550 coap_header, 00551 COAP_MSG_CODE_RESPONSE_NOT_FOUND); 00552 } 00553 if(coap_response) { 00554 tr_debug("M2MNsdlInterface::received_from_server_callback - send CoAP response"); 00555 (sn_nsdl_send_coap_message(_nsdl_handle, address, coap_response) == 0) ? value = 0 : value = 1; 00556 sn_nsdl_release_allocated_coap_msg_mem(_nsdl_handle, coap_response); 00557 } 00558 if (execute_value_updated) { 00559 value_updated(obj_instance, obj_instance->name()); 00560 } 00561 } 00562 } 00563 } 00564 } 00565 return value; 00566 } 00567 00568 uint8_t M2MNsdlInterface::resource_callback(struct nsdl_s */*nsdl_handle*/, 00569 sn_coap_hdr_s *received_coap_header, 00570 sn_nsdl_addr_s *address, 00571 sn_nsdl_capab_e /*nsdl_capab*/) 00572 { 00573 tr_debug("M2MNsdlInterface::resource_callback()"); 00574 _observer.coap_data_processed(); 00575 uint8_t result = 1; 00576 sn_coap_hdr_s *coap_response = NULL; 00577 sn_coap_msg_code_e msg_code = COAP_MSG_CODE_RESPONSE_CHANGED; // 4.00 00578 String resource_name = coap_to_string(received_coap_header->uri_path_ptr, 00579 received_coap_header->uri_path_len); 00580 tr_debug("M2MNsdlInterface::resource_callback() - resource_name %s", resource_name.c_str()); 00581 bool execute_value_updated = false; 00582 M2MBase* base = find_resource(resource_name); 00583 if(base) { 00584 base->set_uri_path(resource_name); 00585 if(COAP_MSG_CODE_REQUEST_GET == received_coap_header->msg_code) { 00586 coap_response = base->handle_get_request(_nsdl_handle, received_coap_header,this); 00587 } else if(COAP_MSG_CODE_REQUEST_PUT == received_coap_header->msg_code) { 00588 coap_response = base->handle_put_request(_nsdl_handle, received_coap_header, this, execute_value_updated); 00589 } else if(COAP_MSG_CODE_REQUEST_POST == received_coap_header->msg_code) { 00590 if(base->base_type() == M2MBase::ResourceInstance) { 00591 msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST; 00592 } else { 00593 coap_response = base->handle_post_request(_nsdl_handle, received_coap_header,this, execute_value_updated); 00594 } 00595 } else if(COAP_MSG_CODE_REQUEST_DELETE == received_coap_header->msg_code) { 00596 // Delete the object instance 00597 tr_debug("M2MNsdlInterface::resource_callback() - DELETE the object instance"); 00598 M2MBase::BaseType type = base->base_type(); 00599 if(M2MBase::ObjectInstance == type) { 00600 M2MBase* base_object = find_resource(base->name()); 00601 if(base_object) { 00602 M2MObject *object = static_cast<M2MObject*> (base_object); 00603 int slash_found = resource_name.find_last_of('/'); 00604 // Object instance validty checks done in upper level, no need for error handling 00605 if(slash_found != -1) { 00606 String object_name; 00607 object_name = resource_name.substr(slash_found + 1, resource_name.length()); 00608 if (object->remove_object_instance(strtoul( 00609 object_name.c_str(), 00610 NULL, 00611 10))) { 00612 msg_code = COAP_MSG_CODE_RESPONSE_DELETED; 00613 } 00614 } 00615 } 00616 } else { 00617 msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST; // 4.00 00618 } 00619 } else if(COAP_MSG_TYPE_RESET == received_coap_header->msg_type) { 00620 // Cancel ongoing observation 00621 tr_error("M2MNsdlInterface::resource_callback() - RESET message"); 00622 M2MBase::BaseType type = base->base_type(); 00623 switch (type) { 00624 case M2MBase::Object: 00625 base->remove_observation_level(M2MBase::O_Attribute); 00626 break; 00627 case M2MBase::Resource: 00628 base->remove_observation_level(M2MBase::R_Attribute); 00629 break; 00630 case M2MBase::ObjectInstance: 00631 base->remove_observation_level(M2MBase::OI_Attribute); 00632 break; 00633 default: 00634 break; 00635 } 00636 base->set_under_observation(false, this); 00637 } 00638 } else { 00639 tr_debug("M2MNsdlInterface::resource_callback() - Resource NOT FOUND"); 00640 msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST; // 4.00 00641 } 00642 if(!coap_response) { 00643 coap_response = sn_nsdl_build_response(_nsdl_handle, 00644 received_coap_header, 00645 msg_code); 00646 } 00647 00648 if(coap_response) { 00649 tr_debug("M2MNsdlInterface::resource_callback() - send CoAP response"); 00650 (sn_nsdl_send_coap_message(_nsdl_handle, address, coap_response) == 0) ? result = 0 : result = 1; 00651 if(coap_response->payload_ptr) { 00652 free(coap_response->payload_ptr); 00653 coap_response->payload_ptr = NULL; 00654 } 00655 sn_nsdl_release_allocated_coap_msg_mem(_nsdl_handle, coap_response); 00656 } 00657 if (execute_value_updated) { 00658 value_updated(base,base->uri_path()); 00659 } 00660 00661 return result; 00662 } 00663 00664 bool M2MNsdlInterface::process_received_data(uint8_t *data, 00665 uint16_t data_size, 00666 sn_nsdl_addr_s *address) 00667 { 00668 tr_debug("M2MNsdlInterface::process_received_data( data size %d)", data_size); 00669 return (0 == sn_nsdl_process_coap(_nsdl_handle, 00670 data, 00671 data_size, 00672 address)) ? true : false; 00673 } 00674 00675 void M2MNsdlInterface::stop_timers() 00676 { 00677 tr_debug("M2MNsdlInterface::stop_timers()"); 00678 if(_registration_timer) { 00679 _registration_timer->stop_timer(); 00680 } 00681 if (_nsdl_exceution_timer) { 00682 _nsdl_exceution_timer->stop_timer(); 00683 } 00684 _bootstrap_id = 0; 00685 _register_ongoing = false; 00686 _unregister_ongoing = false; 00687 _update_register_ongoing = false; 00688 } 00689 00690 void M2MNsdlInterface::timer_expired(M2MTimerObserver::Type type) 00691 { 00692 if(M2MTimerObserver::NsdlExecution == type) { 00693 sn_nsdl_exec(_nsdl_handle, _counter_for_nsdl); 00694 _counter_for_nsdl++; 00695 } else if(M2MTimerObserver::Registration == type) { 00696 tr_debug("M2MNsdlInterface::timer_expired - M2MTimerObserver::Registration - Send update registration"); 00697 send_update_registration(); 00698 } 00699 } 00700 00701 void M2MNsdlInterface::observation_to_be_sent(M2MBase *object, 00702 uint16_t obs_number, 00703 m2m::Vector<uint16_t> changed_instance_ids, 00704 bool send_object) 00705 { 00706 __mutex_claim(); 00707 tr_debug("M2MNsdlInterface::observation_to_be_sent(), %s", object->uri_path().c_str()); 00708 if(object) { 00709 M2MBase::BaseType type = object->base_type(); 00710 if(type == M2MBase::Object) { 00711 send_object_observation(static_cast<M2MObject*> (object), 00712 obs_number, 00713 changed_instance_ids, 00714 send_object); 00715 } else if(type == M2MBase::ObjectInstance) { 00716 send_object_instance_observation(static_cast<M2MObjectInstance*> (object), obs_number); 00717 } else if(type == M2MBase::Resource) { 00718 send_resource_observation(static_cast<M2MResource*> (object), obs_number); 00719 } 00720 } 00721 __mutex_release(); 00722 } 00723 00724 void M2MNsdlInterface::send_delayed_response(M2MBase *base) 00725 { 00726 __mutex_claim(); 00727 tr_debug("M2MNsdlInterface::send_delayed_response()"); 00728 M2MResource *resource = NULL; 00729 if(base) { 00730 if(M2MBase::Resource == base->base_type()) { 00731 resource = static_cast<M2MResource *> (base); 00732 } 00733 if(resource) { 00734 sn_coap_hdr_s * coap_response = static_cast<sn_coap_hdr_s *>(malloc(sizeof(sn_coap_hdr_s))); 00735 if(coap_response) { 00736 memset(coap_response,0,sizeof(sn_coap_hdr_s)); 00737 00738 coap_response->msg_type = COAP_MSG_TYPE_CONFIRMABLE; 00739 coap_response->msg_code = COAP_MSG_CODE_RESPONSE_CONTENT; 00740 resource->get_delayed_token(coap_response->token_ptr,coap_response->token_len); 00741 00742 uint32_t length = 0; 00743 resource->get_value(coap_response->payload_ptr, length); 00744 coap_response->payload_len = length; 00745 00746 sn_nsdl_send_coap_message(_nsdl_handle, _nsdl_handle->nsp_address_ptr->omalw_address_ptr, coap_response); 00747 00748 if(coap_response->payload_ptr) { 00749 free(coap_response->payload_ptr); 00750 coap_response->payload_ptr = NULL; 00751 } 00752 if(coap_response->token_ptr) { 00753 free(coap_response->token_ptr); 00754 coap_response->token_ptr = NULL; 00755 } 00756 free(coap_response); 00757 } 00758 } 00759 } 00760 __mutex_release(); 00761 } 00762 00763 void M2MNsdlInterface::resource_to_be_deleted(const String &resource_name) 00764 { 00765 __mutex_claim(); 00766 tr_debug("M2MNsdlInterface::resource_to_be_deleted(resource_name %s)", resource_name.c_str()); 00767 delete_nsdl_resource(resource_name); 00768 __mutex_release(); 00769 } 00770 00771 void M2MNsdlInterface::value_updated(M2MBase *base, 00772 const String &object_name) 00773 { 00774 tr_debug("M2MNsdlInterface::value_updated()"); 00775 if(base) { 00776 switch(base->base_type()) { 00777 case M2MBase::Object: 00778 create_nsdl_object_structure(static_cast<M2MObject*> (base)); 00779 break; 00780 case M2MBase::ObjectInstance: 00781 create_nsdl_object_instance_structure(static_cast<M2MObjectInstance*> (base)); 00782 break; 00783 case M2MBase::Resource: { 00784 M2MResource* resource = static_cast<M2MResource*> (base); 00785 create_nsdl_resource_structure(resource,object_name, 00786 resource->supports_multiple_instances()); 00787 } 00788 break; 00789 case M2MBase::ResourceInstance: { 00790 M2MResourceInstance* instance = static_cast<M2MResourceInstance*> (base); 00791 create_nsdl_resource(instance,object_name); 00792 } 00793 break; 00794 } 00795 } 00796 00797 if (base->is_value_updated_function_set()) { 00798 base->execute_value_updated(base->name()); 00799 } 00800 else { 00801 _observer.value_updated(base); 00802 } 00803 } 00804 00805 void M2MNsdlInterface::remove_object(M2MBase *object) 00806 { 00807 __mutex_claim(); 00808 tr_debug("M2MNsdlInterface::remove_object()"); 00809 M2MObject* rem_object = static_cast<M2MObject*> (object); 00810 if(rem_object && !_object_list.empty()) { 00811 M2MObjectList::const_iterator it; 00812 it = _object_list.begin(); 00813 int index = 0; 00814 for ( ; it != _object_list.end(); it++, index++ ) { 00815 if((*it) == rem_object) { 00816 _object_list.erase(index); 00817 break; 00818 } 00819 } 00820 } 00821 if(_object_list.empty()) { 00822 _object_list.clear(); 00823 } 00824 __mutex_release(); 00825 } 00826 00827 bool M2MNsdlInterface::create_nsdl_object_structure(M2MObject *object) 00828 { 00829 tr_debug("M2MNsdlInterface::create_nsdl_object_structure()"); 00830 bool success = false; 00831 if(object) { 00832 M2MObjectInstanceList instance_list = object->instances(); 00833 tr_debug("M2MNsdlInterface::create_nsdl_object_structure - Object Instance count %d", instance_list.size()); 00834 if(!instance_list.empty()) { 00835 M2MObjectInstanceList::const_iterator it; 00836 it = instance_list.begin(); 00837 for ( ; it != instance_list.end(); it++ ) { 00838 // Create NSDL structure for all object instances inside 00839 success = create_nsdl_object_instance_structure(*it); 00840 } 00841 } 00842 } 00843 if((object->operation() != M2MBase::NOT_ALLOWED)) { 00844 success = create_nsdl_resource(object,object->name(),object->register_uri()); 00845 } 00846 return success; 00847 } 00848 00849 bool M2MNsdlInterface::create_nsdl_object_instance_structure(M2MObjectInstance *object_instance) 00850 { 00851 tr_debug("M2MNsdlInterface::create_nsdl_object_instance_structure()"); 00852 bool success = false; 00853 if( object_instance) { 00854 00855 // Append object instance id to the object name. 00856 String object_name = object_instance->name(); 00857 object_name.push_back('/'); 00858 object_name.append_int(object_instance->instance_id()); 00859 00860 M2MResourceList res_list = object_instance->resources(); 00861 tr_debug("M2MNsdlInterface::create_nsdl_object_instance_structure - ResourceBase count %d", res_list.size()); 00862 if(!res_list.empty()) { 00863 M2MResourceList::const_iterator it; 00864 it = res_list.begin(); 00865 for ( ; it != res_list.end(); it++ ) { 00866 // Create NSDL structure for all resources inside 00867 success = create_nsdl_resource_structure(*it,object_name, 00868 (*it)->supports_multiple_instances()); 00869 } 00870 } 00871 if(object_instance->operation() != M2MBase::NOT_ALLOWED) { 00872 success = create_nsdl_resource(object_instance,object_name,object_instance->register_uri()); 00873 } 00874 } 00875 return success; 00876 } 00877 00878 bool M2MNsdlInterface::create_nsdl_resource_structure(M2MResource *res, 00879 const String &object_name, 00880 bool multiple_instances) 00881 { 00882 tr_debug("M2MNsdlInterface::create_nsdl_resource_structure(object_name %s)", object_name.c_str()); 00883 bool success = false; 00884 if(res) { 00885 // Append object name to the resource. 00886 // Take out the instance Id and append to the 00887 // resource name like "object/0/+ resource + / + 0" 00888 String res_name = object_name; 00889 if (strcmp(res_name.c_str(), res->uri_path().c_str()) != 0) { 00890 res_name.push_back('/'); 00891 res_name.append(res->name().c_str(),res->name().length()); 00892 } 00893 00894 // if there are multiple instances supported 00895 // then add instance Id into creating resource path 00896 // else normal /object_id/object_instance/resource_id format. 00897 if(multiple_instances) { 00898 M2MResourceInstanceList res_list = res->resource_instances(); 00899 tr_debug("M2MNsdlInterface::create_nsdl_resource_structure - ResourceInstance count %d", res_list.size()); 00900 if(!res_list.empty()) { 00901 M2MResourceInstanceList::const_iterator it; 00902 it = res_list.begin(); 00903 for ( ; it != res_list.end(); it++ ) { 00904 String inst_name = res_name; 00905 // Create NSDL structure for all resources inside 00906 inst_name.push_back('/'); 00907 inst_name.append_int((*it)->instance_id()); 00908 00909 success = create_nsdl_resource((*it),inst_name,(*it)->register_uri()); 00910 } 00911 // Register the main Resource as well along with ResourceInstances 00912 success = create_nsdl_resource(res,res_name,res->register_uri()); 00913 } 00914 } else { 00915 tr_debug("M2MNsdlInterface::create_nsdl_resource_structure - res_name %s", res_name.c_str()); 00916 success = create_nsdl_resource(res,res_name,res->register_uri()); 00917 } 00918 } 00919 return success; 00920 } 00921 00922 bool M2MNsdlInterface::create_nsdl_resource(M2MBase *base, const String &name, bool publish_uri) 00923 { 00924 __mutex_claim(); 00925 tr_debug("M2MNsdlInterface::create_nsdl_resource(name %s)", name.c_str()); 00926 bool success = false; 00927 uint8_t* buffer = 0; 00928 uint32_t length = 0; 00929 00930 // Create the NSDL Resource Pointer... 00931 if(base) { 00932 sn_nsdl_resource_info_s* resource = sn_nsdl_get_resource(_nsdl_handle, 00933 name.length(), 00934 (uint8_t*)name.c_str()); 00935 00936 if(resource) { 00937 bool changed = false; 00938 success = true; 00939 if(resource->mode == SN_GRS_STATIC) { 00940 if((M2MBase::Resource == base->base_type() || 00941 M2MBase::ResourceInstance == base->base_type()) && 00942 M2MBase::Static == base->mode()) { 00943 M2MResourceInstance *res = (M2MResourceInstance*) base; 00944 res->get_value(buffer,length); 00945 if(resource->resource) { 00946 memory_free(resource->resource); 00947 } 00948 resource->resource = buffer; 00949 resource->resourcelen = length; 00950 resource->publish_uri = publish_uri; 00951 } 00952 } 00953 // Check if the access level for the resource has changed. 00954 if(resource->access != (sn_grs_resource_acl_e)base->operation()) { 00955 changed = true; 00956 resource->access = (sn_grs_resource_acl_e)base->operation(); 00957 } 00958 if(resource->resource_parameters_ptr) { 00959 // Check if the observation parameter for the resource has changed. 00960 if(resource->resource_parameters_ptr->observable != (uint8_t)base->is_observable()) { 00961 changed = true; 00962 resource->resource_parameters_ptr->observable = (uint8_t)base->is_observable(); 00963 } 00964 } 00965 if(changed && resource->resource_parameters_ptr) { 00966 resource->resource_parameters_ptr->registered = SN_NDSL_RESOURCE_NOT_REGISTERED; 00967 } 00968 } else if(_resource) { 00969 base->set_under_observation(false,this); 00970 //TODO: implement access control 00971 // Currently complete access is given 00972 _resource->access = (sn_grs_resource_acl_e)base->operation(); 00973 00974 if((M2MBase::Resource == base->base_type() || 00975 M2MBase::ResourceInstance == base->base_type()) && 00976 M2MBase::Static == base->mode()) { 00977 M2MResourceInstance *res = (M2MResourceInstance*)base; 00978 // Static resource is updated 00979 _resource->mode = SN_GRS_STATIC; 00980 00981 res->get_value(buffer,length); 00982 _resource->resource = buffer; 00983 _resource->resourcelen = length; 00984 } 00985 00986 if(M2MBase::Dynamic == base->mode()){ 00987 // Dynamic resource is updated 00988 _resource->mode = SN_GRS_DYNAMIC; 00989 _resource->sn_grs_dyn_res_callback = __nsdl_c_callback; 00990 } 00991 00992 if( _resource->path != NULL ){ 00993 memory_free(_resource->path); 00994 _resource->path = NULL; 00995 } 00996 if(name.length() > 0 ){ 00997 _resource->path = alloc_string_copy((uint8_t*)name.c_str(), name.length()); 00998 if(_resource->path) { 00999 _resource->pathlen = name.length(); 01000 } 01001 } 01002 if(!base->resource_type().empty() && _resource->resource_parameters_ptr) { 01003 _resource->resource_parameters_ptr->resource_type_ptr = 01004 alloc_string_copy((uint8_t*)base->resource_type().c_str(), 01005 base->resource_type().length()); 01006 if(_resource->resource_parameters_ptr->resource_type_ptr) { 01007 _resource->resource_parameters_ptr->resource_type_len = 01008 base->resource_type().length(); 01009 } 01010 } 01011 if(!base->interface_description().empty() && _resource->resource_parameters_ptr) { 01012 _resource->resource_parameters_ptr->interface_description_ptr = 01013 alloc_string_copy((uint8_t*)base->interface_description().c_str(), 01014 base->interface_description().length()); 01015 if(_resource->resource_parameters_ptr->interface_description_ptr) { 01016 _resource->resource_parameters_ptr->interface_description_len = 01017 base->interface_description().length(); 01018 } 01019 } 01020 if(_resource->resource_parameters_ptr) { 01021 _resource->resource_parameters_ptr->coap_content_type = base->coap_content_type(); 01022 _resource->resource_parameters_ptr->observable = (uint8_t)base->is_observable(); 01023 } 01024 _resource->publish_uri = publish_uri; 01025 int8_t result = sn_nsdl_create_resource(_nsdl_handle,_resource); 01026 tr_debug("M2MNsdlInterface::create_nsdl_resource - Creating in NSDL-C result %d", result); 01027 01028 // Either the resource is created or it already 01029 // exists , then result is success. 01030 if (result == 0 || 01031 result == -2){ 01032 success = true; 01033 } 01034 01035 if(_resource->path) { 01036 memory_free(_resource->path); 01037 } 01038 if(_resource->resource_parameters_ptr->resource_type_ptr){ 01039 memory_free(_resource->resource_parameters_ptr->resource_type_ptr); 01040 } 01041 if(_resource->resource_parameters_ptr->interface_description_ptr){ 01042 memory_free(_resource->resource_parameters_ptr->interface_description_ptr); 01043 } 01044 if (_resource->resource) { 01045 memory_free(_resource->resource); 01046 } 01047 01048 //Clear up the filled resource to fill up new resource. 01049 clear_resource(_resource); 01050 01051 if(success) { 01052 base->set_under_observation(false,this); 01053 } 01054 } 01055 } 01056 __mutex_release(); 01057 return success; 01058 } 01059 01060 // convenience method to get the URI from its buffer field... 01061 String M2MNsdlInterface::coap_to_string(uint8_t *coap_data,int coap_data_length) 01062 { 01063 String value = ""; 01064 if (coap_data != NULL && coap_data_length > 0) { 01065 value.append_raw((char *)coap_data,coap_data_length); 01066 } 01067 return value; 01068 } 01069 01070 uint64_t M2MNsdlInterface::registration_time() 01071 { 01072 uint64_t value = 0; 01073 if(_endpoint->lifetime_ptr) { 01074 value = atol((const char*)_endpoint->lifetime_ptr); 01075 } 01076 01077 if(value >= OPTIMUM_LIFETIME) { 01078 value = value - REDUCE_LIFETIME; 01079 } else { 01080 value = REDUCTION_FACTOR * value; 01081 } 01082 tr_debug("M2MNsdlInterface::registration_time - value (in seconds) %ld", value); 01083 return value; 01084 } 01085 01086 M2MBase* M2MNsdlInterface::find_resource(const String &object_name) 01087 { 01088 M2MBase *object = NULL; 01089 if(!_object_list.empty()) { 01090 M2MObjectList::const_iterator it; 01091 it = _object_list.begin(); 01092 for ( ; it != _object_list.end(); it++ ) { 01093 if((*it)->name() == object_name) { 01094 object = (*it); 01095 tr_debug("M2MNsdlInterface::find_resource(%s) found", object_name.c_str()); 01096 break; 01097 } 01098 object = find_resource((*it),object_name); 01099 if(object != NULL) { 01100 tr_debug("M2MNsdlInterface::find_resource(%s) found", object_name.c_str()); 01101 break; 01102 } 01103 } 01104 } 01105 return object; 01106 } 01107 01108 M2MBase* M2MNsdlInterface::find_resource(const M2MObject *object, 01109 const String &object_instance) 01110 { 01111 M2MBase *instance = NULL; 01112 if(object) { 01113 M2MObjectInstanceList list = object->instances(); 01114 if(!list.empty()) { 01115 M2MObjectInstanceList::const_iterator it; 01116 it = list.begin(); 01117 for ( ; it != list.end(); it++ ) { 01118 // Append object instance id to the object name. 01119 String name = (*it)->name(); 01120 name.push_back('/'); 01121 name.append_int((*it)->instance_id()); 01122 01123 if(name == object_instance){ 01124 instance = (*it); 01125 break; 01126 } 01127 instance = find_resource((*it),object_instance); 01128 if(instance != NULL){ 01129 break; 01130 } 01131 } 01132 } 01133 } 01134 return instance; 01135 } 01136 01137 M2MBase* M2MNsdlInterface::find_resource(const M2MObjectInstance *object_instance, 01138 const String &resource_instance) 01139 { 01140 M2MBase *instance = NULL; 01141 if(object_instance) { 01142 M2MResourceList list = object_instance->resources(); 01143 if(!list.empty()) { 01144 M2MResourceList::const_iterator it; 01145 it = list.begin(); 01146 for ( ; it != list.end(); it++ ) { 01147 String name = object_instance->name(); 01148 // Append object instance id to the object name. 01149 name.push_back('/'); 01150 name.append_int(object_instance->instance_id()); 01151 01152 name.push_back('/'); 01153 name+= (*it)->name(); 01154 01155 if(name == resource_instance) { 01156 instance = *it; 01157 break; 01158 } else if((*it)->supports_multiple_instances()) { 01159 instance = find_resource((*it),name, resource_instance); 01160 if(instance != NULL){ 01161 break; 01162 } 01163 } 01164 } 01165 } 01166 } 01167 return instance; 01168 } 01169 01170 M2MBase* M2MNsdlInterface::find_resource(const M2MResource *resource, 01171 const String &object_name, 01172 const String &resource_instance) 01173 { 01174 M2MBase *res = NULL; 01175 if(resource) { 01176 if(resource->supports_multiple_instances()) { 01177 M2MResourceInstanceList list = resource->resource_instances(); 01178 if(!list.empty()) { 01179 M2MResourceInstanceList::const_iterator it; 01180 it = list.begin(); 01181 for ( ; it != list.end(); it++ ) { 01182 String name = object_name; 01183 // if there are multiple instances supported 01184 // then add instance Id into creating resource path 01185 // else normal /object_id/object_instance/resource_id format. 01186 01187 name.push_back('/'); 01188 name.append_int((*it)->instance_id()); 01189 01190 if(name == resource_instance){ 01191 res = (*it); 01192 break; 01193 } 01194 } 01195 } 01196 } 01197 } 01198 return res; 01199 } 01200 01201 bool M2MNsdlInterface::object_present(M2MObject* object) const 01202 { 01203 bool success = false; 01204 if(object && !_object_list.empty()) { 01205 M2MObjectList::const_iterator it; 01206 it = _object_list.begin(); 01207 for ( ; it != _object_list.end(); it++ ) { 01208 if((*it) == object) { 01209 success = true; 01210 break; 01211 } 01212 } 01213 } 01214 return success; 01215 } 01216 01217 bool M2MNsdlInterface::add_object_to_list(M2MObject* object) 01218 { 01219 bool success = false; 01220 if(object && !object_present(object)) { 01221 _object_list.push_back(object); 01222 success = true; 01223 } 01224 return success; 01225 } 01226 01227 void M2MNsdlInterface::clear_resource(sn_nsdl_resource_info_s *&resource) 01228 { 01229 //Clear up the filled resource to fill up new resource. 01230 if(resource && resource->resource_parameters_ptr) { 01231 sn_nsdl_resource_parameters_s *temp_resource_parameter = resource->resource_parameters_ptr; 01232 memset(resource->resource_parameters_ptr, 0, sizeof(sn_nsdl_resource_parameters_s)); 01233 memset(resource,0, sizeof(sn_nsdl_resource_info_s)); 01234 resource->resource_parameters_ptr = temp_resource_parameter; 01235 } 01236 } 01237 01238 M2MInterface::Error M2MNsdlInterface::interface_error(sn_coap_hdr_s *coap_header) 01239 { 01240 M2MInterface::Error error = M2MInterface::ErrorNone; 01241 if(coap_header) { 01242 switch(coap_header->msg_code) { 01243 case COAP_MSG_CODE_RESPONSE_BAD_REQUEST: 01244 case COAP_MSG_CODE_RESPONSE_BAD_OPTION: 01245 case COAP_MSG_CODE_RESPONSE_REQUEST_ENTITY_INCOMPLETE: 01246 case COAP_MSG_CODE_RESPONSE_PRECONDITION_FAILED: 01247 case COAP_MSG_CODE_RESPONSE_REQUEST_ENTITY_TOO_LARGE: 01248 case COAP_MSG_CODE_RESPONSE_UNSUPPORTED_CONTENT_FORMAT: 01249 error = M2MInterface::InvalidParameters; 01250 break; 01251 case COAP_MSG_CODE_RESPONSE_UNAUTHORIZED: 01252 case COAP_MSG_CODE_RESPONSE_FORBIDDEN: 01253 case COAP_MSG_CODE_RESPONSE_NOT_ACCEPTABLE: 01254 case COAP_MSG_CODE_RESPONSE_NOT_FOUND: 01255 case COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED: 01256 error = M2MInterface::NotAllowed; 01257 break; 01258 case COAP_MSG_CODE_RESPONSE_CREATED: 01259 case COAP_MSG_CODE_RESPONSE_DELETED: 01260 case COAP_MSG_CODE_RESPONSE_VALID: 01261 case COAP_MSG_CODE_RESPONSE_CHANGED: 01262 case COAP_MSG_CODE_RESPONSE_CONTENT: 01263 error = M2MInterface::ErrorNone; 01264 break; 01265 default: 01266 error = M2MInterface::UnknownError; 01267 break; 01268 } 01269 if(coap_header->coap_status == COAP_STATUS_BUILDER_MESSAGE_SENDING_FAILED) { 01270 error = M2MInterface::NetworkError; 01271 } 01272 } 01273 return error; 01274 } 01275 01276 void M2MNsdlInterface::send_object_observation(M2MObject *object, 01277 uint16_t obs_number, 01278 m2m::Vector<uint16_t> changed_instance_ids, 01279 bool send_object) 01280 { 01281 tr_debug("M2MNsdlInterface::send_object_observation"); 01282 if(object) { 01283 uint8_t *value = 0; 01284 uint32_t length = 0; 01285 uint8_t *token = 0; 01286 uint32_t token_length = 0; 01287 01288 M2MTLVSerializer serializer; 01289 // Send whole object structure 01290 if (send_object) { 01291 value = serializer.serialize(object->instances(), length); 01292 } 01293 // Send only changed object instances 01294 else { 01295 M2MObjectInstanceList list; 01296 Vector<uint16_t>::const_iterator it; 01297 it = changed_instance_ids.begin(); 01298 for (; it != changed_instance_ids.end(); it++){ 01299 M2MObjectInstance* obj_instance = object->object_instance(*it); 01300 if (obj_instance){ 01301 list.push_back(obj_instance); 01302 } 01303 } 01304 if (!list.empty()) { 01305 value = serializer.serialize(list, length); 01306 list.clear(); 01307 } 01308 } 01309 01310 object->get_observation_token(token,token_length); 01311 01312 send_notification(token, 01313 token_length, 01314 value, 01315 length, 01316 obs_number, 01317 object->max_age(), 01318 object->coap_content_type(), 01319 object->uri_path()); 01320 01321 memory_free(value); 01322 memory_free(token); 01323 } 01324 } 01325 01326 void M2MNsdlInterface::send_object_instance_observation(M2MObjectInstance *object_instance, 01327 uint16_t obs_number) 01328 { 01329 tr_debug("M2MNsdlInterface::send_object_instance_observation"); 01330 if(object_instance) { 01331 uint8_t *value = 0; 01332 uint32_t length = 0; 01333 uint8_t *token = 0; 01334 uint32_t token_length = 0; 01335 01336 M2MTLVSerializer serializer; 01337 value = serializer.serialize(object_instance->resources(), length); 01338 01339 object_instance->get_observation_token(token,token_length); 01340 01341 send_notification(token, 01342 token_length, 01343 value, 01344 length, 01345 obs_number, 01346 object_instance->max_age(), 01347 object_instance->coap_content_type(), 01348 object_instance->uri_path()); 01349 01350 memory_free(value); 01351 memory_free(token); 01352 } 01353 } 01354 01355 void M2MNsdlInterface::send_resource_observation(M2MResource *resource, 01356 uint16_t obs_number) 01357 { 01358 tr_debug("M2MNsdlInterface::send_resource_observation"); 01359 if(resource) { 01360 uint8_t *value = 0; 01361 uint32_t length = 0; 01362 uint8_t *token = 0; 01363 uint32_t token_length = 0; 01364 01365 resource->get_observation_token(token,token_length); 01366 uint8_t content_type = 0; 01367 if(M2MResourceInstance::OPAQUE == resource->resource_instance_type()) { 01368 content_type = COAP_CONTENT_OMA_OPAQUE_TYPE; 01369 } 01370 if (resource->resource_instance_count() > 0) { 01371 content_type = COAP_CONTENT_OMA_TLV_TYPE; 01372 M2MTLVSerializer serializer; 01373 value = serializer.serialize(resource, length); 01374 } else { 01375 resource->get_value(value,length); 01376 } 01377 send_notification(token, 01378 token_length, 01379 value, 01380 length, 01381 obs_number, 01382 resource->max_age(), 01383 content_type, 01384 resource->uri_path()); 01385 01386 memory_free(value); 01387 memory_free(token); 01388 } 01389 } 01390 01391 void M2MNsdlInterface::build_observation_number(uint8_t *obs_number, 01392 uint8_t *obs_len, 01393 uint16_t number) 01394 { 01395 if(number > 0xFF) { 01396 *obs_len = 2; 01397 *(obs_number) = (number >> 8) & 0x00FF; 01398 obs_number[1] = number & 0x00FF; 01399 } else { 01400 *obs_len = 1; 01401 *(obs_number) = number & 0x00FF; 01402 } 01403 } 01404 01405 void M2MNsdlInterface::send_notification(uint8_t *token, 01406 uint8_t token_length, 01407 uint8_t *value, 01408 uint32_t value_length, 01409 uint16_t observation, 01410 uint32_t max_age, 01411 uint8_t coap_content_type, 01412 const String &uri_path) 01413 01414 { 01415 tr_debug("M2MNsdlInterface::send_notification"); 01416 sn_coap_hdr_s *notification_message_ptr; 01417 01418 /* Allocate and initialize memory for header struct */ 01419 notification_message_ptr = static_cast<sn_coap_hdr_s *>(memory_alloc(sizeof(sn_coap_hdr_s))); 01420 if (notification_message_ptr) { 01421 memset(notification_message_ptr, 0, sizeof(sn_coap_hdr_s)); 01422 01423 notification_message_ptr->options_list_ptr = (sn_coap_options_list_s *)memory_alloc(sizeof(sn_coap_options_list_s)); 01424 if (notification_message_ptr->options_list_ptr) { 01425 01426 memset(notification_message_ptr->options_list_ptr , 0, sizeof(sn_coap_options_list_s)); 01427 01428 /* Fill header */ 01429 notification_message_ptr->msg_type = COAP_MSG_TYPE_CONFIRMABLE; 01430 notification_message_ptr->msg_code = COAP_MSG_CODE_RESPONSE_CONTENT; 01431 01432 /* Fill token */ 01433 notification_message_ptr->token_len = token_length; 01434 notification_message_ptr->token_ptr = token; 01435 01436 /* Fill payload */ 01437 notification_message_ptr->payload_len = value_length; 01438 notification_message_ptr->payload_ptr = value; 01439 01440 /* Fill uri path */ 01441 notification_message_ptr->uri_path_len = uri_path.size(); 01442 notification_message_ptr->uri_path_ptr = (uint8_t *)uri_path.c_str(); 01443 01444 /* Fill observe */ 01445 uint8_t observation_number[2]; 01446 uint8_t observation_number_length = 0; 01447 01448 build_observation_number(observation_number, 01449 &observation_number_length, 01450 observation); 01451 notification_message_ptr->options_list_ptr->observe_len = observation_number_length; 01452 notification_message_ptr->options_list_ptr->observe_ptr = observation_number; 01453 01454 notification_message_ptr->options_list_ptr->max_age_ptr = 01455 m2m::String::convert_integer_to_array(max_age, 01456 notification_message_ptr->options_list_ptr->max_age_len); 01457 01458 notification_message_ptr->content_type_ptr = 01459 m2m::String::convert_integer_to_array(coap_content_type, 01460 notification_message_ptr->content_type_len); 01461 01462 /* Send message */ 01463 sn_nsdl_send_coap_message(_nsdl_handle, 01464 _nsdl_handle->nsp_address_ptr->omalw_address_ptr, 01465 notification_message_ptr); 01466 01467 /* Free memory */ 01468 notification_message_ptr->uri_path_ptr = NULL; 01469 notification_message_ptr->payload_ptr = NULL; 01470 notification_message_ptr->options_list_ptr->observe_ptr = NULL; 01471 notification_message_ptr->token_ptr = NULL; 01472 if (notification_message_ptr->content_type_ptr) { 01473 free(notification_message_ptr->content_type_ptr); 01474 } 01475 notification_message_ptr->content_type_ptr = NULL; 01476 if (notification_message_ptr->options_list_ptr->max_age_ptr) { 01477 free(notification_message_ptr->options_list_ptr->max_age_ptr); 01478 } 01479 notification_message_ptr->options_list_ptr->max_age_ptr = NULL; 01480 } 01481 sn_nsdl_release_allocated_coap_msg_mem(_nsdl_handle, notification_message_ptr); 01482 } 01483 } 01484 01485 nsdl_s * M2MNsdlInterface::get_nsdl_handle() 01486 { 01487 return _nsdl_handle; 01488 } 01489 01490 void M2MNsdlInterface::handle_bootstrap_put_message(sn_coap_hdr_s *coap_header, 01491 sn_nsdl_addr_s *address) { 01492 #ifndef M2M_CLIENT_DISABLE_BOOTSTRAP_FEATURE 01493 tr_debug("M2MNsdlInterface::handle_bootstrap_message"); 01494 uint8_t response_code = COAP_MSG_CODE_RESPONSE_CHANGED; 01495 sn_coap_hdr_s *coap_response = NULL; 01496 bool success = false; 01497 bool security_object = false; 01498 uint16_t content_type = 0; 01499 01500 if (!_security) { 01501 _security = new M2MSecurity(M2MSecurity::M2MServer); 01502 } 01503 01504 String resource_name = coap_to_string(coap_header->uri_path_ptr, 01505 coap_header->uri_path_len); 01506 tr_debug("M2MNsdlInterface::handle_bootstrap_message - uri %s", resource_name.c_str()); 01507 01508 // Check incoming object 01509 if (resource_name.compare(0,1,"0") == 0) { 01510 security_object = true; 01511 if(_security) { 01512 success = true; 01513 // Not mandatory resource that's why it must be created first 01514 _security->create_resource(M2MSecurity::ShortServerID, 1); 01515 // Change operation mode 01516 M2MResourceList list = _security->object_instance()->resources(); 01517 if(!list.empty()) { 01518 M2MResourceList::const_iterator it; 01519 it = list.begin(); 01520 for ( ; it != list.end(); it++ ) { 01521 (*it)->set_operation(M2MBase::PUT_ALLOWED); 01522 } 01523 } 01524 } 01525 } 01526 else if (resource_name.compare(0,1,"1") == 0) { 01527 success = true; 01528 } 01529 01530 if (success) { 01531 // Send delayed response if token is part of the message 01532 if (coap_header->token_ptr) { 01533 tr_debug("M2MNsdlInterface::handle_bootstrap_message - send delayed response"); 01534 coap_response = sn_nsdl_build_response(_nsdl_handle, 01535 coap_header, 01536 COAP_MSG_CODE_EMPTY); 01537 if (coap_response) { 01538 coap_response->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT; 01539 sn_nsdl_send_coap_message(_nsdl_handle, address, coap_response); 01540 sn_nsdl_release_allocated_coap_msg_mem(_nsdl_handle, coap_response); 01541 } 01542 } 01543 01544 if(coap_header->content_type_ptr) { 01545 content_type = String::convert_array_to_integer(coap_header->content_type_ptr, 01546 coap_header->content_type_len); 01547 } 01548 01549 tr_debug("M2MNsdlInterface::handle_bootstrap_message - content_type %d", content_type); 01550 if (content_type != COAP_CONTENT_OMA_TLV_TYPE) { 01551 success = false; 01552 } 01553 if (success) { 01554 success = parse_bootstrap_message(coap_header, security_object); 01555 // Set operation back to default ones 01556 if (_security) { 01557 M2MResourceList list = _security->object_instance()->resources(); 01558 if(!list.empty()) { 01559 M2MResourceList::const_iterator it; 01560 it = list.begin(); 01561 for ( ; it != list.end(); it++ ) { 01562 (*it)->set_operation(M2MBase::NOT_ALLOWED); 01563 } 01564 } 01565 } 01566 } 01567 } 01568 01569 if (!success) { 01570 response_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST; 01571 handle_bootstrap_error(); 01572 } 01573 coap_response = sn_nsdl_build_response(_nsdl_handle, 01574 coap_header, 01575 response_code); 01576 if (coap_response) { 01577 sn_nsdl_send_coap_message(_nsdl_handle, address, coap_response); 01578 sn_nsdl_release_allocated_coap_msg_mem(_nsdl_handle, coap_response); 01579 } 01580 #else 01581 (void) coap_header; 01582 (void) address; 01583 #endif 01584 } 01585 01586 bool M2MNsdlInterface::parse_bootstrap_message(sn_coap_hdr_s *coap_header, bool is_security_object) 01587 { 01588 #ifndef M2M_CLIENT_DISABLE_BOOTSTRAP_FEATURE 01589 tr_debug("M2MNsdlInterface::parse_bootstrap_put_message"); 01590 M2MTLVDeserializer *deserializer = new M2MTLVDeserializer(); 01591 bool ret = false; 01592 bool is_obj_instance = false; 01593 uint16_t instance_id = 0; 01594 if (deserializer && _security) { 01595 ret = is_obj_instance = deserializer->is_object_instance(coap_header->payload_ptr); 01596 if (!is_obj_instance) { 01597 ret = deserializer->is_resource(coap_header->payload_ptr); 01598 } 01599 01600 if (ret) { 01601 M2MTLVDeserializer::Error error = M2MTLVDeserializer::None; 01602 if (is_obj_instance) { 01603 if (is_security_object) { 01604 error = deserializer->deserialise_object_instances(coap_header->payload_ptr, 01605 coap_header->payload_len, 01606 *_security, 01607 M2MTLVDeserializer::Put); 01608 } 01609 else { 01610 error = deserializer->deserialise_object_instances(coap_header->payload_ptr, 01611 coap_header->payload_len, 01612 *_server, 01613 M2MTLVDeserializer::Put); 01614 } 01615 } 01616 else { 01617 if (is_security_object) { 01618 instance_id = deserializer->instance_id(coap_header->payload_ptr); 01619 error = deserializer->deserialize_resources(coap_header->payload_ptr, 01620 coap_header->payload_len, 01621 *_security->object_instance(instance_id), 01622 M2MTLVDeserializer::Put); 01623 } 01624 else { 01625 instance_id = deserializer->instance_id(coap_header->payload_ptr); 01626 error = deserializer->deserialize_resources(coap_header->payload_ptr, 01627 coap_header->payload_len, 01628 *_server->object_instance(instance_id), 01629 M2MTLVDeserializer::Post); 01630 } 01631 } 01632 01633 if (error != M2MTLVDeserializer::None) { 01634 tr_error("M2MNsdlInterface::parse_bootstrap_put_message - error %d", error); 01635 ret = false; 01636 } 01637 } 01638 } 01639 delete deserializer; 01640 return ret; 01641 #else 01642 (void) coap_header; 01643 (void) is_security_object; 01644 return false; 01645 #endif 01646 } 01647 01648 void M2MNsdlInterface::handle_bootstrap_finished(sn_coap_hdr_s *coap_header,sn_nsdl_addr_s *address) 01649 { 01650 #ifndef M2M_CLIENT_DISABLE_BOOTSTRAP_FEATURE 01651 String object_name = coap_to_string(coap_header->uri_path_ptr, 01652 coap_header->uri_path_len); 01653 tr_debug("M2MNsdlInterface::handle_bootstrap_finished - path: %s", object_name.c_str()); 01654 sn_coap_hdr_s *coap_response = NULL; 01655 uint8_t msg_code = COAP_MSG_CODE_RESPONSE_CHANGED; 01656 01657 // Accept only '/bs' path and check that needed data is in security object 01658 if (object_name.size() != 2 || 01659 object_name.compare(0,2,BOOTSTRAP_URI) != 0 || 01660 !validate_security_object()) { 01661 msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST; 01662 } else { 01663 // Add short server id to server object 01664 _server->set_resource_value(M2MServer::ShortServerID, 01665 _security->resource_value_int(M2MSecurity::ShortServerID)); 01666 } 01667 01668 coap_response = sn_nsdl_build_response(_nsdl_handle, 01669 coap_header, 01670 msg_code); 01671 if(coap_response) { 01672 sn_nsdl_send_coap_message(_nsdl_handle, address, coap_response); 01673 sn_nsdl_release_allocated_coap_msg_mem(_nsdl_handle, coap_response); 01674 } 01675 if (COAP_MSG_CODE_RESPONSE_CHANGED == msg_code) { 01676 // Switch back to original ep name 01677 if (_endpoint->endpoint_name_ptr) { 01678 memory_free(_endpoint->endpoint_name_ptr); 01679 } 01680 _endpoint->endpoint_name_ptr = alloc_string_copy((uint8_t*)_endpoint_name.c_str(), _endpoint_name.length()); 01681 _endpoint->endpoint_name_len = _endpoint_name.length(); 01682 _observer.bootstrap_done(_security); 01683 } else { 01684 handle_bootstrap_error(); 01685 } 01686 #else 01687 (void) coap_header; 01688 (void) address; 01689 #endif 01690 } 01691 01692 void M2MNsdlInterface::handle_bootstrap_delete(sn_coap_hdr_s *coap_header,sn_nsdl_addr_s *address) 01693 { 01694 #ifndef M2M_CLIENT_DISABLE_BOOTSTRAP_FEATURE 01695 sn_coap_hdr_s *coap_response = NULL; 01696 uint8_t msg_code = COAP_MSG_CODE_RESPONSE_DELETED; 01697 String object_name = coap_to_string(coap_header->uri_path_ptr, 01698 coap_header->uri_path_len); 01699 tr_debug("M2MNsdlInterface::handle_bootstrap_delete - obj %s", object_name.c_str()); 01700 01701 // Only following paths are accepted, 0, 0/0 01702 if (object_name.size() == 2 || object_name.size() > 3) { 01703 msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST; 01704 } 01705 else if ((object_name.size() == 1 && object_name.compare(0,1,"0") != 0) || 01706 (object_name.size() == 3 && object_name.compare(0,3,"0/0") != 0)) { 01707 msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST; 01708 } 01709 01710 coap_response = sn_nsdl_build_response(_nsdl_handle, 01711 coap_header, 01712 msg_code); 01713 01714 if(coap_response) { 01715 sn_nsdl_send_coap_message(_nsdl_handle, address, coap_response); 01716 sn_nsdl_release_allocated_coap_msg_mem(_nsdl_handle, coap_response); 01717 if(_security) { 01718 _security->clear_resources(); 01719 } 01720 } else { 01721 handle_bootstrap_error(); 01722 } 01723 #else 01724 (void) coap_header; 01725 (void) address; 01726 #endif 01727 } 01728 01729 bool M2MNsdlInterface::validate_security_object() 01730 { 01731 #ifndef M2M_CLIENT_DISABLE_BOOTSTRAP_FEATURE 01732 tr_debug("M2MNsdlInterface::validate_security_object"); 01733 if (_security) { 01734 String address = _security->resource_value_string(M2MSecurity::M2MServerUri); 01735 uint32_t sec_mode = _security->resource_value_int(M2MSecurity::SecurityMode); 01736 bool is_bs_server = _security->resource_value_int(M2MSecurity::BootstrapServer); 01737 uint32_t public_key_size = _security->get_resource(M2MSecurity::PublicKey)->value_length(); 01738 uint32_t server_key_size = _security->get_resource(M2MSecurity::ServerPublicKey)->value_length(); 01739 uint32_t pkey_size = _security->get_resource(M2MSecurity::Secretkey)->value_length(); 01740 tr_debug("M2MNsdlInterface::validate_security_object - Server URI /0/0: %s", address.c_str()); 01741 tr_debug("M2MNsdlInterface::validate_security_object - is bs server /0/1: %d", is_bs_server); 01742 tr_debug("M2MNsdlInterface::validate_security_object - Security Mode /0/2: %d", sec_mode); 01743 tr_debug("M2MNsdlInterface::validate_security_object - Public key size /0/3: %d", public_key_size); 01744 tr_debug("M2MNsdlInterface::validate_security_object - Server Public key size /0/4: %d", server_key_size); 01745 tr_debug("M2MNsdlInterface::validate_security_object - Secret key size /0/5: %d", pkey_size); 01746 // Only NoSec and Certificate modes are supported 01747 if (!address.empty() && !is_bs_server) { 01748 if (M2MSecurity::Certificate == sec_mode) { 01749 if (!public_key_size || !server_key_size || !pkey_size) { 01750 return false; 01751 } else { 01752 return true; 01753 } 01754 } else if (M2MSecurity::NoSecurity == sec_mode){ 01755 return true; 01756 } else { 01757 return false; 01758 } 01759 } else { 01760 return false; 01761 } 01762 } 01763 return false; 01764 #else 01765 return false; 01766 #endif 01767 } 01768 01769 void M2MNsdlInterface::handle_bootstrap_error() 01770 { 01771 tr_debug("M2MNsdlInterface::handle_bootstrap_error()"); 01772 if (_security) { 01773 delete _security; 01774 _security = NULL; 01775 } 01776 _observer.bootstrap_error(); 01777 } 01778 01779 const String& M2MNsdlInterface::endpoint_name() const 01780 { 01781 return _endpoint_name; 01782 }
Generated on Tue Jul 12 2022 12:28:38 by
1.7.2