m2mserver.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/m2mserver.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 "mbed-client/m2mstring.h"
00023 
00024 #define TRACE_GROUP "mClt"
00025 
00026 #define BUFFER_SIZE 21
00027 
00028 M2MServer::M2MServer()
00029 : M2MObject(M2M_SERVER_ID)
00030 {
00031     M2MObject::create_object_instance();
00032 
00033     _server_instance = object_instance();
00034 
00035     if(_server_instance) {
00036 
00037         M2MResource* res = _server_instance->create_dynamic_resource(SERVER_SHORT_SERVER_ID,
00038                                                                      OMA_RESOURCE_TYPE,
00039                                                                      M2MResourceInstance::INTEGER,
00040                                                                      true);
00041         if(res) {
00042             res->set_operation(M2MBase::GET_PUT_ALLOWED);
00043         }
00044         res = _server_instance->create_dynamic_resource(SERVER_LIFETIME,
00045                                                         OMA_RESOURCE_TYPE,
00046                                                         M2MResourceInstance::INTEGER,
00047                                                         true);
00048         if(res) {
00049             res->set_operation(M2MBase::GET_PUT_POST_ALLOWED);
00050         }
00051         res = _server_instance->create_dynamic_resource(SERVER_NOTIFICATION_STORAGE,
00052                                                         OMA_RESOURCE_TYPE,
00053                                                         M2MResourceInstance::BOOLEAN,
00054                                                         true);
00055         if(res) {
00056             res->set_operation(M2MBase::GET_PUT_POST_ALLOWED);
00057         }
00058         res = _server_instance->create_dynamic_resource(SERVER_BINDING,
00059                                                         OMA_RESOURCE_TYPE,
00060                                                         M2MResourceInstance::STRING,
00061                                                         true);
00062         if(res) {
00063             res->set_operation(M2MBase::GET_PUT_POST_ALLOWED);
00064         }
00065         res = _server_instance->create_dynamic_resource(SERVER_REGISTRATION_UPDATE,
00066                                                         OMA_RESOURCE_TYPE,
00067                                                         M2MResourceInstance::OPAQUE,
00068                                                         false);
00069         if(res) {
00070           res->set_operation(M2MBase::POST_ALLOWED);
00071         }
00072     }
00073 }
00074 
00075 M2MServer::~M2MServer()
00076 {
00077 
00078 }
00079 
00080 M2MResource* M2MServer::create_resource(ServerResource resource, uint32_t value)
00081 {
00082     M2MResource* res = NULL;
00083     String server_id = "";
00084     if(!is_resource_present(resource)) {
00085         switch(resource) {
00086         case DefaultMinPeriod:
00087             server_id = SERVER_DEFAULT_MIN_PERIOD;
00088             break;
00089         case DefaultMaxPeriod:
00090             server_id = SERVER_DEFAULT_MAX_PERIOD;
00091             break;
00092         case DisableTimeout:
00093             server_id = SERVER_DISABLE_TIMEOUT;
00094             break;
00095         default:
00096             break;
00097         }
00098     }
00099     if(!server_id.empty()) {
00100         if(_server_instance) {
00101             res = _server_instance->create_dynamic_resource(server_id,
00102                                                             OMA_RESOURCE_TYPE,
00103                                                             M2MResourceInstance::INTEGER,
00104                                                             true);
00105             if(res) {
00106                 res->set_operation(M2MBase::GET_PUT_POST_ALLOWED);
00107                 // If resource is created then set the value.                
00108                 char *buffer = (char*)malloc(BUFFER_SIZE);
00109                 if(buffer) {
00110                     uint32_t size = m2m::itoa_c(value, buffer);
00111                     if (size <= BUFFER_SIZE) {
00112                         res->set_value((const uint8_t*)buffer, size);
00113                     }
00114                     free(buffer);
00115                 }
00116             }
00117         }
00118     }
00119     return res;
00120 }
00121 
00122 M2MResource* M2MServer::create_resource(ServerResource resource)
00123 {
00124     M2MResource* res = NULL;
00125     if(!is_resource_present(resource)) {
00126         if(M2MServer::Disable == resource) {
00127                 if(_server_instance) {
00128                     res = _server_instance->create_dynamic_resource(SERVER_DISABLE,
00129                                                                     OMA_RESOURCE_TYPE,
00130                                                                     M2MResourceInstance::OPAQUE,
00131                                                                     false);
00132                 if(res) {
00133                     res->set_operation(M2MBase::POST_ALLOWED);
00134                 }
00135             }
00136         }
00137     }
00138     return res;
00139 }
00140 
00141 bool M2MServer::delete_resource(ServerResource resource)
00142 {
00143     bool success = false;
00144     String server_id = "";
00145     switch(resource) {
00146         case DefaultMinPeriod:
00147            server_id = SERVER_DEFAULT_MIN_PERIOD;
00148            break;
00149         case DefaultMaxPeriod:
00150             server_id = SERVER_DEFAULT_MAX_PERIOD;
00151             break;
00152         case Disable:
00153             server_id = SERVER_DISABLE;
00154             break;
00155         case DisableTimeout:
00156             server_id = SERVER_DISABLE_TIMEOUT;
00157             break;
00158         default:
00159             break;
00160     }
00161     if(!server_id.empty()) {
00162         if(_server_instance) {
00163             success = _server_instance->remove_resource(server_id);
00164         }
00165     }
00166     return success;
00167 }
00168 
00169 bool M2MServer::set_resource_value(ServerResource resource,
00170                                    const String &value)
00171 {
00172     bool success = false;
00173     M2MResource* res = get_resource(resource);
00174     if(res && (M2MServer::Binding == resource)) {
00175         success = res->set_value((const uint8_t*)value.c_str(),(uint32_t)value.length());
00176     }
00177     return success;
00178 }
00179 
00180 bool M2MServer::set_resource_value(ServerResource resource,
00181                                    uint32_t value)
00182 {
00183     bool success = false;
00184     M2MResource* res = get_resource(resource);
00185     if(res) {
00186         if(M2MServer::ShortServerID == resource     ||
00187            M2MServer::Lifetime == resource          ||
00188            M2MServer::DefaultMinPeriod == resource  ||
00189            M2MServer::DefaultMaxPeriod == resource  ||
00190            M2MServer::DisableTimeout == resource    ||
00191            M2MServer::NotificationStorage == resource) {
00192             // If it is any of the above resource
00193             // set the value of the resource.
00194             char *buffer = (char*)malloc(BUFFER_SIZE);
00195             if(buffer) {
00196                 uint32_t size = m2m::itoa_c(value, buffer);
00197                 if (size <= BUFFER_SIZE) {
00198                     success = res->set_value((const uint8_t*)buffer, size);
00199                 }
00200                 free(buffer);
00201             }
00202         }
00203     }
00204     return success;
00205 }
00206 
00207 String M2MServer::resource_value_string(ServerResource resource) const
00208 {
00209     String value = "";
00210     M2MResource* res = get_resource(resource);
00211     if(res && (M2MServer::Binding == resource)) {
00212         uint8_t* buffer = NULL;
00213         uint32_t length = 0;
00214         res->get_value(buffer,length);
00215 
00216         char *char_buffer = (char*)malloc(length+1);
00217         if(char_buffer) {
00218             memset(char_buffer,0,length+1);
00219             memcpy(char_buffer,(char*)buffer,length);
00220 
00221             String s_name(char_buffer);
00222             value = s_name;
00223             if(char_buffer) {
00224                 free(char_buffer);
00225             }
00226         }
00227         if(buffer) {
00228             free(buffer);
00229         }
00230     }
00231     return value;
00232 }
00233 
00234 
00235 uint32_t M2MServer::resource_value_int(ServerResource resource) const
00236 {
00237     uint32_t value = 0;
00238     M2MResource* res = get_resource(resource);
00239     if(res) {
00240         if(M2MServer::ShortServerID == resource     ||
00241            M2MServer::Lifetime == resource          ||
00242            M2MServer::DefaultMinPeriod == resource  ||
00243            M2MServer::DefaultMaxPeriod == resource  ||
00244            M2MServer::DisableTimeout == resource    ||
00245            M2MServer::NotificationStorage == resource) {
00246             // Get the value and convert it into integer
00247             uint8_t* buffer = NULL;
00248             uint32_t length = 0;
00249             res->get_value(buffer,length);
00250             if(buffer) {
00251                 value = atoi((const char*)buffer);
00252                 free(buffer);
00253             }
00254         }
00255     }
00256     return value;
00257 }
00258 
00259 bool M2MServer::is_resource_present(ServerResource resource) const
00260 {
00261     bool success = false;
00262     M2MResource *res = get_resource(resource);
00263     if(res) {
00264         success = true;
00265     }
00266     return success;
00267 }
00268 
00269 uint16_t M2MServer::total_resource_count() const
00270 {
00271     uint16_t total_count = 0;
00272     if(_server_instance) {
00273     total_count = _server_instance->resources().size();
00274     }
00275     return total_count;
00276 }
00277 
00278 M2MResource* M2MServer::get_resource(ServerResource res) const
00279 {
00280     M2MResource* res_object = NULL;
00281     String res_name = "";
00282     switch(res) {
00283     case ShortServerID:
00284         res_name = SERVER_SHORT_SERVER_ID;
00285         break;
00286     case Lifetime:
00287         res_name = SERVER_LIFETIME;
00288         break;
00289     case DefaultMinPeriod:
00290         res_name = SERVER_DEFAULT_MIN_PERIOD;
00291         break;
00292     case DefaultMaxPeriod:
00293         res_name = SERVER_DEFAULT_MAX_PERIOD;
00294         break;
00295     case Disable:
00296         res_name = SERVER_DISABLE;
00297         break;
00298     case DisableTimeout:
00299         res_name = SERVER_DISABLE_TIMEOUT;
00300         break;
00301     case NotificationStorage:
00302         res_name = SERVER_NOTIFICATION_STORAGE;
00303         break;
00304     case Binding:
00305         res_name = SERVER_BINDING;
00306         break;
00307     case RegistrationUpdate:
00308         res_name = SERVER_REGISTRATION_UPDATE;
00309         break;
00310     }
00311     if(!res_name.empty()) {
00312         if(_server_instance) {
00313         res_object = _server_instance->resource(res_name);
00314         }
00315     }
00316     return res_object;
00317 }