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