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