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