m2mfirmware.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 #include "mbed-client/m2mfirmware.h"
00018 #include "mbed-client/m2mconstants.h"
00019 #include "mbed-client/m2mobject.h"
00020 #include "mbed-client/m2mobjectinstance.h"
00021 #include "mbed-client/m2mresource.h"
00022 #include "include/nsdlaccesshelper.h"
00023 
00024 #define BUFFER_SIZE 21
00025 #define TRACE_GROUP "mClt"
00026 
00027 M2MFirmware* M2MFirmware::_instance = NULL;
00028 
00029 M2MFirmware* M2MFirmware::get_instance()
00030 {
00031     if(_instance == NULL) {
00032         _instance = new M2MFirmware();
00033     }
00034     return _instance;
00035 }
00036 
00037 void M2MFirmware::delete_instance()
00038 {
00039     delete _instance;
00040     _instance = NULL;
00041 }
00042 
00043 M2MFirmware::M2MFirmware()
00044 : M2MObject(M2M_FIRMWARE_ID, stringdup(M2M_FIRMWARE_ID))
00045 {
00046     M2MBase::set_register_uri(false);
00047     M2MBase::set_operation(M2MBase::GET_PUT_ALLOWED);
00048     _firmware_instance = M2MObject::create_object_instance();
00049     if(_firmware_instance) {
00050         _firmware_instance->set_operation(M2MBase::GET_PUT_ALLOWED);
00051         create_mandatory_resources();
00052     }
00053 }
00054 
00055 M2MFirmware::~M2MFirmware()
00056 {
00057 }
00058 
00059 // Conditionally put the static part of parameter struct into flash.
00060 // Unfortunately this can't be done yet by default as there is old API which
00061 // may be used to modify the values in sn_nsdl_static_resource_parameters_s.
00062 #ifdef MEMORY_OPTIMIZED_API
00063 #define STATIC_PARAM_TYPE const
00064 #else
00065 #define STATIC_PARAM_TYPE
00066 #endif
00067 
00068 #define PACKAGE_PATH FIRMWARE_PATH_PREFIX FIRMWARE_PACKAGE
00069 
00070 #ifdef RESOURCE_ATTRIBUTES_LIST
00071 sn_nsdl_attribute_item_s default_attributes[2] = {
00072         {ATTR_RESOURCE_TYPE, OMA_RESOURCE_TYPE},
00073         {ATTR_END, 0}
00074 };
00075 #endif
00076 
00077 STATIC_PARAM_TYPE
00078 static sn_nsdl_static_resource_parameters_s firmware_package_params_static = {
00079 #ifndef RESOURCE_ATTRIBUTES_LIST
00080 #ifndef DISABLE_RESOURCE_TYPE
00081     (char*)OMA_RESOURCE_TYPE,      // resource_type_ptr
00082 #endif
00083 #ifndef DISABLE_INTERFACE_DESCRIPTION
00084     (char*)"",                     // interface_description_ptr
00085 #endif
00086 #else
00087     default_attributes,
00088 #endif
00089     (char*)PACKAGE_PATH,    // path
00090 //    (uint8_t*)"",           // resource
00091 //    0,                      // resourcelen
00092     false,                  // external_memory_block
00093     SN_GRS_DYNAMIC,         // mode
00094     false                   // free_on_delete
00095 };
00096 
00097 #define PACKAGE_URI_PATH FIRMWARE_PATH_PREFIX FIRMWARE_PACKAGE_URI
00098 
00099 STATIC_PARAM_TYPE
00100 static sn_nsdl_static_resource_parameters_s firmware_package_uri_params_static = {
00101 #ifndef RESOURCE_ATTRIBUTES_LIST
00102 #ifndef DISABLE_RESOURCE_TYPE
00103     (char*)OMA_RESOURCE_TYPE,      // resource_type_ptr
00104 #endif
00105 #ifndef DISABLE_INTERFACE_DESCRIPTION
00106     (char*)"",                     // interface_description_ptr
00107 #endif
00108 #else
00109     default_attributes,
00110 #endif
00111     (char*)PACKAGE_URI_PATH, // path
00112 //    (uint8_t*)"",           // resource
00113 //    0,                      // resourcelen
00114     false,                  // external_memory_block
00115     SN_GRS_DYNAMIC,         // mode
00116     false                   // free_on_delete
00117 };
00118 
00119 #define UPDATE_PATH FIRMWARE_PATH_PREFIX FIRMWARE_UPDATE
00120 
00121 STATIC_PARAM_TYPE
00122 static sn_nsdl_static_resource_parameters_s firmware_update_params_static = {
00123 #ifndef RESOURCE_ATTRIBUTES_LIST
00124 #ifndef DISABLE_RESOURCE_TYPE
00125     (char*)OMA_RESOURCE_TYPE,      // resource_type_ptr
00126 #endif
00127 #ifndef DISABLE_INTERFACE_DESCRIPTION
00128     (char*)"",                     // interface_description_ptr
00129 #endif
00130 #else
00131     default_attributes,
00132 #endif
00133     (char*)UPDATE_PATH,     // path
00134 //    (uint8_t*)"",           // resource
00135 //    0,                      // resourcelen
00136     false,                  // external_memory_block
00137     SN_GRS_DYNAMIC,         // mode
00138     false                   // free_on_delete
00139 };
00140 
00141 #define STATE_URI_PATH FIRMWARE_PATH_PREFIX FIRMWARE_STATE
00142 
00143 STATIC_PARAM_TYPE
00144 static sn_nsdl_static_resource_parameters_s firmware_state_params_static = {
00145 #ifndef RESOURCE_ATTRIBUTES_LIST
00146 #ifndef DISABLE_RESOURCE_TYPE
00147     (char*)OMA_RESOURCE_TYPE,      // resource_type_ptr
00148 #endif
00149 #ifndef DISABLE_INTERFACE_DESCRIPTION
00150     (char*)"",                     // interface_description_ptr
00151 #endif
00152 #else
00153     default_attributes,
00154 #endif
00155     (char*)STATE_URI_PATH,   // path
00156     false,                  // external_memory_block
00157     SN_GRS_DYNAMIC,         // mode
00158     false                   // free_on_delete
00159 };
00160 
00161 #define UPDATE_RESULT_PATH FIRMWARE_PATH_PREFIX FIRMWARE_UPDATE_RESULT
00162 
00163 STATIC_PARAM_TYPE
00164 static sn_nsdl_static_resource_parameters_s firmware_update_result_params_static = {
00165 #ifndef RESOURCE_ATTRIBUTES_LIST
00166 #ifndef DISABLE_RESOURCE_TYPE
00167     (char*)OMA_RESOURCE_TYPE,      // resource_type_ptr
00168 #endif
00169 #ifndef DISABLE_INTERFACE_DESCRIPTION
00170     (char*)"",                     // interface_description_ptr
00171 #endif
00172 #else
00173     default_attributes,
00174 #endif
00175     (char*)UPDATE_RESULT_PATH, // path
00176     false,                  // external_memory_block
00177     SN_GRS_DYNAMIC,         // mode
00178     false                   // free_on_delete
00179 };
00180 
00181 static sn_nsdl_dynamic_resource_parameters_s firmware_package_params_dynamic = {
00182     __nsdl_c_callback,
00183     &firmware_package_params_static,
00184     NULL,
00185     {NULL, NULL},                     // link
00186     0,
00187     COAP_CONTENT_OMA_PLAIN_TEXT_TYPE, // coap_content_type
00188     0, // msg_id
00189     M2MBase::PUT_ALLOWED,   // access
00190     0,                      // registered
00191     false,                  // publish_uri
00192     false,                  // free_on_delete
00193     true,                   // observable
00194     false,                  // auto-observable
00195     NOTIFICATION_STATUS_INIT
00196 };
00197 
00198 static sn_nsdl_dynamic_resource_parameters_s firmware_package_uri_params_dynamic = {
00199     __nsdl_c_callback,
00200     &firmware_package_uri_params_static,
00201     NULL,
00202     {NULL, NULL},                     // link
00203     0,
00204     COAP_CONTENT_OMA_PLAIN_TEXT_TYPE, // coap_content_type
00205     0, // msg_id
00206     M2MBase::PUT_ALLOWED,   // access
00207     0,                      // registered
00208     false,                  // publish_uri
00209     false,                  // free_on_delete
00210     true,                   // observable
00211     false,                  // auto-observable
00212     NOTIFICATION_STATUS_INIT
00213 };
00214 
00215 static sn_nsdl_dynamic_resource_parameters_s firmware_update_params_dynamic = {
00216     __nsdl_c_callback,
00217     &firmware_update_params_static,
00218     NULL,
00219     {NULL, NULL},                     // link
00220     0,
00221     COAP_CONTENT_OMA_PLAIN_TEXT_TYPE, // coap_content_type
00222     0, // msg_id
00223     M2MBase::NOT_ALLOWED,   // access
00224     0,                      // registered
00225     false,                  // publish_uri
00226     false,                  // free_on_delete
00227     true,                   // observable
00228     false,                  // auto-observable
00229     NOTIFICATION_STATUS_INIT
00230 };
00231 
00232 static sn_nsdl_dynamic_resource_parameters_s firmware_state_params_dynamic = {
00233     __nsdl_c_callback,
00234     &firmware_state_params_static,
00235     NULL,                   // resource
00236     {NULL, NULL},           // link
00237     0,                      // resourcelen
00238     COAP_CONTENT_OMA_PLAIN_TEXT_TYPE, // coap_content_type
00239     0, // msg_id
00240     M2MBase::GET_ALLOWED,   // access
00241     0,                      // registered
00242     false,                  // publish_uri
00243     false,                  // free_on_delete
00244     true,                   // observable
00245     false,                  // auto-observable
00246     NOTIFICATION_STATUS_INIT
00247 };
00248 
00249 static sn_nsdl_dynamic_resource_parameters_s firmware_update_result_params_dynamic = {
00250     __nsdl_c_callback,
00251     &firmware_update_result_params_static,
00252     NULL,                   // resource
00253     {NULL, NULL},           // link
00254     0,                      // resourcelen
00255     COAP_CONTENT_OMA_PLAIN_TEXT_TYPE, // coap_content_type
00256     0, // msg_id
00257     M2MBase::GET_ALLOWED,   // access
00258     0,                      // registered
00259     false,                  // publish_uri
00260     false,                  // free_on_delete
00261     true,                   // observable
00262     false,                  // auto-observable
00263     NOTIFICATION_STATUS_INIT
00264 };
00265 
00266 const static M2MBase::lwm2m_parameters firmware_package_params = {
00267     0, // max_age
00268     (char*)FIRMWARE_PACKAGE,
00269     &firmware_package_params_dynamic,
00270     M2MBase::Resource, // base_type
00271     M2MBase::OPAQUE,
00272     false,
00273     false, // free_on_delete
00274     false  // identifier_int_type
00275 };
00276 
00277 const static M2MBase::lwm2m_parameters firmware_package_uri_params = {
00278     0, // max_age
00279     (char*)FIRMWARE_PACKAGE_URI,
00280     &firmware_package_uri_params_dynamic,
00281     M2MBase::Resource, // base_type
00282     M2MBase::STRING,
00283     false,
00284     false, // free_on_delete
00285     false  // identifier_int_type
00286 };
00287 
00288 const static M2MBase::lwm2m_parameters firmware_update_params = {
00289     0, // max_age
00290     (char*)FIRMWARE_UPDATE,
00291     &firmware_update_params_dynamic,
00292     M2MBase::Resource, // base_type
00293     M2MBase::OPAQUE,
00294     false,
00295     false, // free_on_delete
00296     false  // identifier_int_type
00297 };
00298 
00299 const static M2MBase::lwm2m_parameters firmware_state_params = {
00300     0, // max_age
00301     (char*)FIRMWARE_STATE,
00302     &firmware_state_params_dynamic,
00303     M2MBase::Resource, // base_type
00304     M2MBase::INTEGER,
00305     false,
00306     false, // free_on_delete
00307     false  // identifier_int_type
00308 };
00309 
00310 const static M2MBase::lwm2m_parameters firmware_update_result_params = {
00311     0, // max_age
00312     (char*)FIRMWARE_UPDATE_RESULT,
00313     &firmware_update_result_params_dynamic,
00314     M2MBase::Resource, // base_type
00315     M2MBase::INTEGER,
00316     false,
00317     false, // free_on_delete
00318     false  // identifier_int_type
00319 };
00320 
00321 void M2MFirmware::create_mandatory_resources()
00322 {
00323     _firmware_instance->set_coap_content_type(COAP_CONTENT_OMA_TLV_TYPE);
00324 
00325     M2MResource* res;
00326 
00327     // todo:
00328     // perhaps we should have a API for batch creation of objects by using a array
00329     // of lwm2m_parameters.
00330     res = _firmware_instance->create_dynamic_resource(&firmware_package_params,
00331                                                         M2MResourceInstance::OPAQUE,
00332                                                         false);
00333 
00334     res = _firmware_instance->create_dynamic_resource(&firmware_package_uri_params,
00335                                                     M2MResourceInstance::STRING,
00336                                                     false);
00337 
00338     res = _firmware_instance->create_dynamic_resource(&firmware_update_params,
00339                                                     M2MResourceInstance::OPAQUE,
00340                                                     false);
00341 
00342     res = _firmware_instance->create_dynamic_resource(&firmware_state_params,
00343                                                     M2MResourceInstance::INTEGER,
00344                                                     true);
00345 
00346     // XXX: some of the tests expect to have some value available here
00347     if (res) {
00348         res->set_value(0);
00349     }
00350 
00351     res = _firmware_instance->create_dynamic_resource(&firmware_update_result_params,
00352                                                     M2MResourceInstance::INTEGER,
00353                                                     true);
00354 
00355     // XXX: some of the tests expect to have some value available here
00356     if (res) {
00357         res->set_value(0);
00358     }
00359 }
00360 
00361 M2MResource* M2MFirmware::create_resource(FirmwareResource resource, const String &value)
00362 {
00363     M2MResource* res = NULL;
00364     const char* firmware_id_ptr = "";
00365     M2MBase::Operation operation = M2MBase::GET_ALLOWED;
00366     if(!is_resource_present(resource)) {
00367         switch(resource) {
00368             case PackageName:
00369                 firmware_id_ptr = FIRMWARE_PACKAGE_NAME;
00370                 break;
00371             case PackageVersion:
00372                 firmware_id_ptr = FIRMWARE_PACKAGE_VERSION;
00373                 break;
00374             default:
00375                 break;
00376         }
00377     }
00378     String firmware_id(firmware_id_ptr);
00379 
00380     if(!firmware_id.empty() && value.size() < 256) {
00381         if(_firmware_instance) {
00382             res = _firmware_instance->create_dynamic_resource(firmware_id,
00383                                                             OMA_RESOURCE_TYPE,
00384                                                             M2MResourceInstance::STRING,
00385                                                             false);
00386 
00387             if(res) {
00388                 res->set_register_uri(false);
00389                 res->set_operation(operation);
00390                 if(value.empty()) {
00391                     res->clear_value();
00392                 } else {
00393                     res->set_value((const uint8_t*)value.c_str(),
00394                                    (uint32_t)value.length());
00395                 }
00396             }
00397         }
00398     }
00399     return res;
00400 }
00401 
00402 M2MResource* M2MFirmware::create_resource(FirmwareResource resource, int64_t value)
00403 {
00404     M2MResource* res = NULL;
00405     const char* firmware_id_ptr = "";
00406     M2MBase::Operation operation = M2MBase::GET_ALLOWED;
00407     if(!is_resource_present(resource)) {
00408         switch(resource) {
00409         case UpdateSupportedObjects:
00410             if(check_value_range(resource, value)) {
00411                 firmware_id_ptr = FIRMWARE_UPDATE_SUPPORTED_OBJECTS;
00412                 operation = M2MBase::GET_PUT_ALLOWED;
00413             }
00414             break;
00415         default:
00416             break;
00417         }
00418     }
00419 
00420     const String firmware_id(firmware_id_ptr);
00421 
00422     if(!firmware_id.empty()) {
00423         if(_firmware_instance) {
00424             res = _firmware_instance->create_dynamic_resource(firmware_id,
00425                                                             OMA_RESOURCE_TYPE,
00426                                                             M2MResourceInstance::INTEGER,
00427                                                             false);
00428 
00429             if(res) {
00430                 res->set_register_uri(false);
00431 
00432                 res->set_operation(operation);
00433                 res->set_value(value);
00434             }
00435         }
00436     }
00437     return res;
00438 }
00439 
00440 bool M2MFirmware::set_resource_value(FirmwareResource resource,
00441                                    const String &value)
00442 {
00443     bool success = false;
00444     M2MResource* res = get_resource(resource);
00445     if(res) {
00446         if(M2MFirmware::PackageUri == resource  ||
00447            M2MFirmware::PackageName == resource ||
00448            M2MFirmware::PackageVersion == resource) {
00449             if (value.size() < 256) {
00450                 if(value.empty()) {
00451                     res->clear_value();
00452                     success = true;
00453                 } else {
00454                     success = res->set_value((const uint8_t*)value.c_str(),(uint32_t)value.length());
00455                 }
00456             }
00457         }
00458     }
00459     return success;
00460 }
00461 
00462 bool M2MFirmware::set_resource_value(FirmwareResource resource,
00463                                        int64_t value)
00464 {
00465     bool success = false;
00466     M2MResource* res = get_resource(resource);
00467     if(res) {
00468         if(M2MFirmware::State == resource          ||
00469            M2MFirmware::UpdateSupportedObjects == resource ||
00470            M2MFirmware::UpdateResult == resource) {
00471             // If it is any of the above resource
00472             // set the value of the resource.
00473             if (check_value_range(resource, value)) {
00474 
00475                 success = res->set_value(value);
00476             }
00477         }
00478     }
00479     return success;
00480 }
00481 
00482 bool M2MFirmware::set_resource_value(FirmwareResource resource,
00483                                      const uint8_t *value,
00484                                      const uint32_t length)
00485 {
00486     bool success = false;
00487     M2MResource* res = get_resource(resource);
00488     if(res) {
00489         if(M2MFirmware::Package == resource) {
00490             success = res->set_value(value,length);
00491         }
00492     }
00493     return success;
00494 }
00495 
00496 bool M2MFirmware::is_resource_present(FirmwareResource resource) const
00497 {
00498     bool success = false;
00499     M2MResource* res = get_resource(resource);
00500     if(res) {
00501         success = true;
00502     }
00503     return success;
00504 }
00505 
00506 const char* M2MFirmware::resource_name(FirmwareResource resource)
00507 {
00508     const char* res_name = "";
00509     switch(resource) {
00510         case Package:
00511             res_name = FIRMWARE_PACKAGE;
00512             break;
00513         case PackageUri:
00514             res_name = FIRMWARE_PACKAGE_URI;
00515             break;
00516         case Update:
00517             res_name = FIRMWARE_UPDATE;
00518             break;
00519         case State:
00520             res_name = FIRMWARE_STATE;
00521             break;
00522         case UpdateSupportedObjects:
00523             res_name = FIRMWARE_UPDATE_SUPPORTED_OBJECTS;
00524             break;
00525         case UpdateResult:
00526             res_name = FIRMWARE_UPDATE_RESULT;
00527             break;
00528         case PackageName:
00529             res_name = FIRMWARE_PACKAGE_NAME;
00530             break;
00531         case PackageVersion:
00532             res_name = FIRMWARE_PACKAGE_VERSION;
00533             break;
00534     }
00535     return res_name;
00536 }
00537 
00538 uint16_t M2MFirmware::per_resource_count(FirmwareResource res) const
00539 {
00540     uint16_t count = 0;
00541     if(_firmware_instance) {
00542         count = _firmware_instance->resource_count(resource_name(res));
00543     }
00544     return count;
00545 }
00546 
00547 uint16_t M2MFirmware::total_resource_count() const
00548 {
00549     uint16_t count = 0;
00550     if(_firmware_instance) {
00551         count = _firmware_instance->resources().size();
00552     }
00553     return count;
00554 }
00555 
00556 uint32_t M2MFirmware::resource_value_buffer(FirmwareResource resource,
00557                                uint8_t *&data) const
00558 {
00559     uint32_t size = 0;
00560     M2MResource* res = get_resource(resource);
00561     if(res) {
00562         if(M2MFirmware::Package == resource) {
00563             res->get_value(data,size);
00564         }
00565     }
00566     return size;
00567 }
00568 
00569 M2MResource* M2MFirmware::get_resource(FirmwareResource res) const
00570 {
00571     M2MResource* res_object = NULL;
00572     if(_firmware_instance) {
00573         const char* res_name_ptr = "";
00574         switch(res) {
00575             case Package:
00576                 res_name_ptr = FIRMWARE_PACKAGE;
00577                 break;
00578             case PackageUri:
00579                 res_name_ptr = FIRMWARE_PACKAGE_URI;
00580                 break;
00581             case Update:
00582                 res_name_ptr = FIRMWARE_UPDATE;
00583                 break;
00584             case State:
00585                 res_name_ptr = FIRMWARE_STATE;
00586                 break;
00587             case UpdateSupportedObjects:
00588                 res_name_ptr = FIRMWARE_UPDATE_SUPPORTED_OBJECTS;
00589                 break;
00590             case UpdateResult:
00591                 res_name_ptr = FIRMWARE_UPDATE_RESULT;
00592                 break;
00593             case PackageName:
00594                 res_name_ptr = FIRMWARE_PACKAGE_NAME;
00595                 break;
00596             case PackageVersion:
00597                 res_name_ptr = FIRMWARE_PACKAGE_VERSION;
00598                 break;
00599         }
00600 
00601         res_object = _firmware_instance->resource(res_name_ptr);
00602     }
00603     return res_object;
00604 }
00605 
00606 bool M2MFirmware::delete_resource(FirmwareResource resource)
00607 {
00608     bool success = false;
00609     if(M2MFirmware::UpdateSupportedObjects == resource ||
00610        M2MFirmware::PackageName == resource            ||
00611        M2MFirmware::PackageVersion == resource) {
00612         if(_firmware_instance) {
00613             success = _firmware_instance->remove_resource(resource_name(resource));
00614         }
00615     }
00616     return success;
00617 }
00618 
00619 int64_t M2MFirmware::resource_value_int(FirmwareResource resource) const
00620 {
00621     int64_t value = -1;
00622     M2MResource* res = get_resource(resource);
00623     if(res) {
00624         if(M2MFirmware::State == resource          ||
00625            M2MFirmware::UpdateSupportedObjects == resource         ||
00626            M2MFirmware::UpdateResult == resource) {
00627 
00628             value = res->get_value_int();
00629         }
00630     }
00631     return value;
00632 }
00633 
00634 String M2MFirmware::resource_value_string(FirmwareResource resource) const
00635 {
00636     String value = "";
00637     M2MResource* res = get_resource(resource);
00638     if(res) {
00639         if(M2MFirmware::PackageUri == resource          ||
00640            M2MFirmware::PackageName == resource           ||
00641            M2MFirmware::PackageVersion == resource) {
00642 
00643             value = res->get_value_string();
00644         }
00645     }
00646     return value;
00647 }
00648 
00649 bool M2MFirmware::check_value_range(FirmwareResource resource, int64_t value) const
00650 {
00651     bool success = false;
00652     switch (resource) {
00653         case UpdateSupportedObjects:
00654             if(value == 0 || value == 1) {
00655                 success = true;
00656             }
00657             break;
00658         case State:
00659             if (value >= 0 && value <= 3) {
00660                 success = true;
00661                 M2MResource* updateRes = get_resource(M2MFirmware::Update);
00662                 if (updateRes){
00663                     if (value == M2MFirmware::Downloaded) {
00664                         updateRes->set_operation(M2MBase::POST_ALLOWED);
00665                     }
00666                     else {
00667                         updateRes->set_operation(M2MBase::NOT_ALLOWED);
00668                     }
00669                 }
00670             }
00671             break;
00672         case UpdateResult:
00673             if (value >= 0 && value <= 7) {
00674                 success = true;
00675             }
00676             break;
00677     default:
00678         break;
00679     }
00680     return success;
00681 }
00682 
00683 bool M2MFirmware::set_update_execute_callback(execute_callback callback)
00684 {
00685     M2MResource* m2mresource;
00686 
00687     m2mresource = get_resource(Update);
00688 
00689     if(m2mresource) {
00690         m2mresource->set_execute_function(callback);
00691         return true;
00692     }
00693 
00694     return false;
00695 }
00696 
00697 bool M2MFirmware::set_resource_value_update_callback(FirmwareResource resource,
00698                                         value_updated_callback callback)
00699 {
00700     M2MResource* m2mresource;
00701 
00702     m2mresource = get_resource(resource);
00703 
00704     if(m2mresource) {
00705         m2mresource->set_value_updated_function(callback);
00706         return true;
00707     }
00708 
00709     return false;
00710 }
00711 
00712 bool M2MFirmware::set_resource_notification_sent_callback(FirmwareResource resource,
00713                                              notification_sent_callback_2 callback)
00714 {
00715     M2MResource* m2mresource;
00716 
00717     m2mresource = get_resource(resource);
00718 
00719     if(m2mresource) {
00720         m2mresource->set_notification_sent_callback(callback);
00721         return true;
00722     }
00723 
00724     return false;
00725 }
00726 
00727 bool M2MFirmware::set_resource_notification_sent_callback(FirmwareResource resource,
00728                                              notification_delivery_status_cb callback)
00729 {
00730     M2MResource* m2mresource;
00731 
00732     m2mresource = get_resource(resource);
00733 
00734     if(m2mresource) {
00735         m2mresource->set_notification_delivery_status_cb(callback, 0);
00736         return true;
00737     }
00738 
00739     return false;
00740 }
00741 
00742 #ifndef DISABLE_BLOCK_MESSAGE
00743 bool M2MFirmware::set_package_block_message_callback(incoming_block_message_callback callback)
00744 {
00745     M2MResource* m2mresource;
00746 
00747     m2mresource = get_resource(Package);
00748 
00749     if(m2mresource) {
00750         m2mresource->set_incoming_block_message_callback(callback);
00751         return true;
00752     }
00753 
00754     return false;
00755 }
00756 #endif // DISABLE_BLOCK_MESSAGE