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 #include <cstdio>
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 
00023 #define BUFFER_SIZE 21
00024 #define TRACE_GROUP "mClt"
00025 
00026 M2MFirmware* M2MFirmware::_instance = NULL;
00027 
00028 M2MFirmware* M2MFirmware::get_instance()
00029 {
00030     if(_instance == NULL) {
00031         _instance = new M2MFirmware();
00032     }
00033     return _instance;
00034 }
00035 
00036 void M2MFirmware::delete_instance()
00037 {
00038     delete _instance;
00039     _instance = NULL;
00040 }
00041 
00042 M2MFirmware::M2MFirmware()
00043 : M2MObject(M2M_FIRMWARE_ID)
00044 {
00045     M2MBase::set_register_uri(false);
00046     M2MBase::set_operation(M2MBase::GET_PUT_ALLOWED);
00047     _firmware_instance = M2MObject::create_object_instance();
00048     if(_firmware_instance) {
00049         _firmware_instance->set_operation(M2MBase::GET_PUT_ALLOWED);
00050         create_mandatory_resources();
00051     }
00052 }
00053 
00054 M2MFirmware::~M2MFirmware()
00055 {
00056 }
00057 
00058 void M2MFirmware::create_mandatory_resources()
00059 {
00060     _firmware_instance->set_coap_content_type(COAP_CONTENT_OMA_TLV_TYPE);
00061     M2MResource* res = _firmware_instance->create_dynamic_resource(FIRMWARE_PACKAGE,
00062                                                                  OMA_RESOURCE_TYPE,
00063                                                                  M2MResourceInstance::OPAQUE,
00064                                                                  false);
00065     if(res) {
00066         res->set_operation(M2MBase::PUT_ALLOWED);
00067         res->set_register_uri(false);
00068     }
00069 
00070     res = _firmware_instance->create_dynamic_resource(FIRMWARE_PACKAGE_URI,
00071                                                     OMA_RESOURCE_TYPE,
00072                                                     M2MResourceInstance::STRING,
00073                                                     false);
00074     if(res) {
00075         res->set_operation(M2MBase::PUT_ALLOWED);
00076         res->set_register_uri(false);
00077     }
00078 
00079     res = _firmware_instance->create_dynamic_resource(FIRMWARE_UPDATE,
00080                                                     OMA_RESOURCE_TYPE,
00081                                                     M2MResourceInstance::OPAQUE,
00082                                                     false);
00083     if(res) {
00084         res->set_operation(M2MBase::NOT_ALLOWED);
00085         res->set_register_uri(false);
00086     }
00087 
00088     res = _firmware_instance->create_dynamic_resource(FIRMWARE_STATE,
00089                                                     OMA_RESOURCE_TYPE,
00090                                                     M2MResourceInstance::INTEGER,
00091                                                     true);
00092     set_zero_value(res);
00093     if(res) {        
00094         res->set_operation(M2MBase::GET_ALLOWED);
00095         res->set_register_uri(false);
00096     }
00097     res = _firmware_instance->create_dynamic_resource(FIRMWARE_UPDATE_RESULT,
00098                                                     OMA_RESOURCE_TYPE,
00099                                                     M2MResourceInstance::INTEGER,
00100                                                     true);
00101     set_zero_value(res);
00102     if(res) {
00103         res->set_operation(M2MBase::GET_ALLOWED);
00104         res->set_register_uri(false);
00105     }
00106 }
00107 
00108 M2MResource* M2MFirmware::create_resource(FirmwareResource resource, const String &value)
00109 {
00110     M2MResource* res = NULL;
00111     const char* firmware_id_ptr = "";
00112     M2MBase::Operation operation = M2MBase::GET_ALLOWED;
00113     if(!is_resource_present(resource)) {
00114         switch(resource) {
00115             case PackageName:
00116                 firmware_id_ptr = FIRMWARE_PACKAGE_NAME;
00117                 break;
00118             case PackageVersion:
00119                 firmware_id_ptr = FIRMWARE_PACKAGE_VERSION;
00120                 break;
00121             default:
00122                 break;
00123         }
00124     }
00125     String firmware_id(firmware_id_ptr);
00126 
00127     if(!firmware_id.empty() && value.size() < 256) {
00128         if(_firmware_instance) {
00129             res = _firmware_instance->create_dynamic_resource(firmware_id,
00130                                                             OMA_RESOURCE_TYPE,
00131                                                             M2MResourceInstance::STRING,
00132                                                             false);
00133 
00134             if(res) {
00135                 res->set_register_uri(false);
00136                 res->set_operation(operation);
00137                 if(value.empty()) {
00138                     res->clear_value();
00139                 } else {
00140                     res->set_value((const uint8_t*)value.c_str(),
00141                                    (uint32_t)value.length());
00142                 }
00143             }
00144         }
00145     }
00146     return res;
00147 }
00148 
00149 M2MResource* M2MFirmware::create_resource(FirmwareResource resource, int64_t value)
00150 {
00151     M2MResource* res = NULL;
00152     const char* firmware_id_ptr = "";
00153     M2MBase::Operation operation = M2MBase::GET_ALLOWED;
00154     if(!is_resource_present(resource)) {
00155         switch(resource) {
00156         case UpdateSupportedObjects:
00157             if(check_value_range(resource, value)) {
00158                 firmware_id_ptr = FIRMWARE_UPDATE_SUPPORTED_OBJECTS;
00159                 operation = M2MBase::GET_PUT_ALLOWED;
00160             }
00161             break;
00162         default:
00163             break;
00164         }
00165     }
00166 
00167     const String firmware_id(firmware_id_ptr);
00168     
00169     if(!firmware_id.empty()) {
00170         if(_firmware_instance) {
00171             res = _firmware_instance->create_dynamic_resource(firmware_id,
00172                                                             OMA_RESOURCE_TYPE,
00173                                                             M2MResourceInstance::INTEGER,
00174                                                             false);
00175 
00176             if(res) {
00177                 res->set_register_uri(false);
00178 
00179                 res->set_operation(operation);
00180                 res->set_value(value);
00181             }
00182         }
00183     }
00184     return res;
00185 }
00186 
00187 bool M2MFirmware::set_resource_value(FirmwareResource resource,
00188                                    const String &value)
00189 {
00190     bool success = false;
00191     M2MResource* res = get_resource(resource);
00192     if(res) {
00193         if(M2MFirmware::PackageUri == resource  ||
00194            M2MFirmware::PackageName == resource ||
00195            M2MFirmware::PackageVersion == resource) {
00196             if (value.size() < 256) {
00197                 if(value.empty()) {
00198                     res->clear_value();
00199                     success = true;
00200                 } else {
00201                     success = res->set_value((const uint8_t*)value.c_str(),(uint32_t)value.length());
00202                 }
00203             }
00204         }
00205     }
00206     return success;
00207 }
00208 
00209 bool M2MFirmware::set_resource_value(FirmwareResource resource,
00210                                        int64_t value)
00211 {
00212     bool success = false;
00213     M2MResource* res = get_resource(resource);
00214     if(res) {
00215         if(M2MFirmware::State == resource          ||
00216            M2MFirmware::UpdateSupportedObjects == resource ||
00217            M2MFirmware::UpdateResult == resource) {
00218             // If it is any of the above resource
00219             // set the value of the resource.
00220             if (check_value_range(resource, value)) {
00221                 
00222                 success = res->set_value(value);
00223             }
00224         }
00225     }
00226     return success;
00227 }
00228 
00229 bool M2MFirmware::set_resource_value(FirmwareResource resource,
00230                                      const uint8_t *value,
00231                                      const uint32_t length)
00232 {
00233     bool success = false;
00234     M2MResource* res = get_resource(resource);
00235     if(res) {
00236         if(M2MFirmware::Package == resource) {
00237             success = res->set_value(value,length);
00238         }
00239     }
00240     return success;
00241 }
00242 
00243 bool M2MFirmware::is_resource_present(FirmwareResource resource) const
00244 {
00245     bool success = false;
00246     M2MResource* res = get_resource(resource);
00247     if(res) {
00248         success = true;
00249     }
00250     return success;
00251 }
00252 
00253 const String M2MFirmware::resource_name(FirmwareResource resource)
00254 {
00255     const char* res_name = "";
00256     switch(resource) {
00257         case Package:
00258             res_name = FIRMWARE_PACKAGE;
00259             break;
00260         case PackageUri:
00261             res_name = FIRMWARE_PACKAGE_URI;
00262             break;
00263         case Update:
00264             res_name = FIRMWARE_UPDATE;
00265             break;
00266         case State:
00267             res_name = FIRMWARE_STATE;
00268             break;
00269         case UpdateSupportedObjects:
00270             res_name = FIRMWARE_UPDATE_SUPPORTED_OBJECTS;
00271             break;
00272         case UpdateResult:
00273             res_name = FIRMWARE_UPDATE_RESULT;
00274             break;
00275         case PackageName:
00276             res_name = FIRMWARE_PACKAGE_NAME;
00277             break;
00278         case PackageVersion:
00279             res_name = FIRMWARE_PACKAGE_VERSION;
00280             break;
00281     }
00282     return String(res_name);
00283 }
00284 
00285 uint16_t M2MFirmware::per_resource_count(FirmwareResource res) const
00286 {
00287     uint16_t count = 0;
00288     if(_firmware_instance) {
00289         count = _firmware_instance->resource_count(resource_name(res));
00290     }
00291     return count;
00292 }
00293 
00294 uint16_t M2MFirmware::total_resource_count() const
00295 {
00296     uint16_t count = 0;
00297     if(_firmware_instance) {
00298         count = _firmware_instance->resources().size();
00299     }
00300     return count;
00301 }
00302 
00303 uint32_t M2MFirmware::resource_value_buffer(FirmwareResource resource,
00304                                uint8_t *&data) const
00305 {
00306     uint32_t size = 0;
00307     M2MResource* res = get_resource(resource);
00308     if(res) {
00309         if(M2MFirmware::Package == resource) {
00310             res->get_value(data,size);
00311         }
00312     }
00313     return size;
00314 }
00315 
00316 M2MResource* M2MFirmware::get_resource(FirmwareResource res) const
00317 {
00318     M2MResource* res_object = NULL;
00319     if(_firmware_instance) {
00320         const char* res_name_ptr = "";
00321         switch(res) {
00322             case Package:
00323                 res_name_ptr = FIRMWARE_PACKAGE;
00324                 break;
00325             case PackageUri:
00326                 res_name_ptr = FIRMWARE_PACKAGE_URI;
00327                 break;
00328             case Update:
00329                 res_name_ptr = FIRMWARE_UPDATE;
00330                 break;
00331             case State:
00332                 res_name_ptr = FIRMWARE_STATE;
00333                 break;
00334             case UpdateSupportedObjects:
00335                 res_name_ptr = FIRMWARE_UPDATE_SUPPORTED_OBJECTS;
00336                 break;
00337             case UpdateResult:
00338                 res_name_ptr = FIRMWARE_UPDATE_RESULT;
00339                 break;
00340             case PackageName:
00341                 res_name_ptr = FIRMWARE_PACKAGE_NAME;
00342                 break;
00343             case PackageVersion:
00344                 res_name_ptr = FIRMWARE_PACKAGE_VERSION;
00345                 break;
00346         }
00347         const String res_name(res_name_ptr);
00348         
00349         res_object = _firmware_instance->resource(res_name);
00350     }
00351     return res_object;
00352 }
00353 
00354 bool M2MFirmware::delete_resource(FirmwareResource resource)
00355 {
00356     bool success = false;
00357     if(M2MFirmware::UpdateSupportedObjects == resource ||
00358        M2MFirmware::PackageName == resource            ||
00359        M2MFirmware::PackageVersion == resource) {
00360         if(_firmware_instance) {
00361             success = _firmware_instance->remove_resource(resource_name(resource));
00362         }
00363     }
00364     return success;
00365 }
00366 
00367 int64_t M2MFirmware::resource_value_int(FirmwareResource resource) const
00368 {
00369     int64_t value = -1;
00370     M2MResource* res = get_resource(resource);
00371     if(res) {
00372         if(M2MFirmware::State == resource          ||
00373            M2MFirmware::UpdateSupportedObjects == resource         ||
00374            M2MFirmware::UpdateResult == resource) {
00375 
00376             value = res->get_value_int();
00377         }
00378     }
00379     return value;
00380 }
00381 
00382 String M2MFirmware::resource_value_string(FirmwareResource resource) const
00383 {
00384     String value = "";
00385     M2MResource* res = get_resource(resource);
00386     if(res) {
00387         if(M2MFirmware::PackageUri == resource          ||
00388            M2MFirmware::PackageName == resource           ||
00389            M2MFirmware::PackageVersion == resource) {
00390 
00391             value = res->get_value_string();
00392         }
00393     }
00394     return value;
00395 }
00396 
00397 bool M2MFirmware::check_value_range(FirmwareResource resource, int64_t value) const
00398 {
00399     bool success = false;
00400     switch (resource) {
00401         case UpdateSupportedObjects:
00402             if(value == 0 || value == 1) {
00403                 success = true;
00404             }
00405             break;
00406         case State:
00407             if (value >= 0 && value <= 3) {
00408                 success = true;
00409                 M2MResource* updateRes = get_resource(M2MFirmware::Update);
00410                 if (updateRes){
00411                     if (value == M2MFirmware::Downloaded) {
00412                         updateRes->set_operation(M2MBase::POST_ALLOWED);
00413                     }
00414                     else {
00415                         updateRes->set_operation(M2MBase::NOT_ALLOWED);
00416                     }
00417                 }
00418             }
00419             break;
00420         case UpdateResult:
00421             if (value >= 0 && value <= 7) {
00422                 success = true;
00423             }
00424             break;
00425     default:
00426         break;
00427     }
00428     return success;
00429 }
00430 
00431 void M2MFirmware::set_zero_value(M2MResource *resource)
00432 {
00433     resource->set_value((const uint8_t*)"0", 1);
00434 }