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     const char* server_id_ptr = "";
00084     if(!is_resource_present(resource)) {
00085         switch(resource) {
00086         case DefaultMinPeriod:
00087             server_id_ptr = SERVER_DEFAULT_MIN_PERIOD;
00088             break;
00089         case DefaultMaxPeriod:
00090             server_id_ptr = SERVER_DEFAULT_MAX_PERIOD;
00091             break;
00092         case DisableTimeout:
00093             server_id_ptr = SERVER_DISABLE_TIMEOUT;
00094             break;
00095         default:
00096             break;
00097         }
00098     }
00099     String server_id(server_id_ptr);
00100     
00101     if(!server_id.empty()) {
00102         if(_server_instance) {
00103             res = _server_instance->create_dynamic_resource(server_id,
00104                                                             OMA_RESOURCE_TYPE,
00105                                                             M2MResourceInstance::INTEGER,
00106                                                             true);
00107             if(res) {
00108                 res->set_operation(M2MBase::GET_PUT_POST_ALLOWED);
00109                 
00110                 res->set_value(value);
00111             }
00112         }
00113     }
00114     return res;
00115 }
00116 
00117 M2MResource* M2MServer::create_resource(ServerResource resource)
00118 {
00119     M2MResource* res = NULL;
00120     if(!is_resource_present(resource)) {
00121         if(M2MServer::Disable == resource) {
00122                 if(_server_instance) {
00123                     res = _server_instance->create_dynamic_resource(SERVER_DISABLE,
00124                                                                     OMA_RESOURCE_TYPE,
00125                                                                     M2MResourceInstance::OPAQUE,
00126                                                                     false);
00127                 if(res) {
00128                     res->set_operation(M2MBase::POST_ALLOWED);
00129                 }
00130             }
00131         }
00132     }
00133     return res;
00134 }
00135 
00136 bool M2MServer::delete_resource(ServerResource resource)
00137 {
00138     bool success = false;
00139     const char* server_id_ptr;
00140     switch(resource) {
00141         case DefaultMinPeriod:
00142            server_id_ptr = SERVER_DEFAULT_MIN_PERIOD;
00143            break;
00144         case DefaultMaxPeriod:
00145             server_id_ptr = SERVER_DEFAULT_MAX_PERIOD;
00146             break;
00147         case Disable:
00148             server_id_ptr = SERVER_DISABLE;
00149             break;
00150         case DisableTimeout:
00151             server_id_ptr = SERVER_DISABLE_TIMEOUT;
00152             break;
00153         default:
00154             server_id_ptr = "";
00155             break;
00156     }
00157     String server_id(server_id_ptr);
00158     
00159     if(!server_id.empty()) {
00160         if(_server_instance) {
00161             success = _server_instance->remove_resource(server_id);
00162         }
00163     }
00164     return success;
00165 }
00166 
00167 bool M2MServer::set_resource_value(ServerResource resource,
00168                                    const String &value)
00169 {
00170     bool success = false;
00171     M2MResource* res = get_resource(resource);
00172     if(res && (M2MServer::Binding == resource)) {
00173         success = res->set_value((const uint8_t*)value.c_str(),(uint32_t)value.length());
00174     }
00175     return success;
00176 }
00177 
00178 bool M2MServer::set_resource_value(ServerResource resource,
00179                                    uint32_t value)
00180 {
00181     bool success = false;
00182     M2MResource* res = get_resource(resource);
00183     if(res) {
00184         if(M2MServer::ShortServerID == resource     ||
00185            M2MServer::Lifetime == resource          ||
00186            M2MServer::DefaultMinPeriod == resource  ||
00187            M2MServer::DefaultMaxPeriod == resource  ||
00188            M2MServer::DisableTimeout == resource    ||
00189            M2MServer::NotificationStorage == resource) {
00190             // If it is any of the above resource
00191             // set the value of the resource.
00192 
00193             success = res->set_value(value);
00194         }
00195     }
00196     return success;
00197 }
00198 
00199 String M2MServer::resource_value_string(ServerResource resource) const
00200 {
00201     String value = "";
00202     M2MResource* res = get_resource(resource);
00203     if(res && (M2MServer::Binding == resource)) {
00204 
00205         value = res->get_value_string();
00206     }
00207     return value;
00208 }
00209 
00210 
00211 uint32_t M2MServer::resource_value_int(ServerResource resource) const
00212 {
00213     uint32_t value = 0;
00214     M2MResource* res = get_resource(resource);
00215     if(res) {
00216         if(M2MServer::ShortServerID == resource     ||
00217            M2MServer::Lifetime == resource          ||
00218            M2MServer::DefaultMinPeriod == resource  ||
00219            M2MServer::DefaultMaxPeriod == resource  ||
00220            M2MServer::DisableTimeout == resource    ||
00221            M2MServer::NotificationStorage == resource) {
00222 
00223             value = res->get_value_int();
00224         }
00225     }
00226     return value;
00227 }
00228 
00229 bool M2MServer::is_resource_present(ServerResource resource) const
00230 {
00231     bool success = false;
00232     M2MResource *res = get_resource(resource);
00233     if(res) {
00234         success = true;
00235     }
00236     return success;
00237 }
00238 
00239 uint16_t M2MServer::total_resource_count() const
00240 {
00241     uint16_t total_count = 0;
00242     if(_server_instance) {
00243     total_count = _server_instance->resources().size();
00244     }
00245     return total_count;
00246 }
00247 
00248 M2MResource* M2MServer::get_resource(ServerResource res) const
00249 {
00250     M2MResource* res_object = NULL;
00251     const char* res_name_ptr = "";
00252     switch(res) {
00253     case ShortServerID:
00254         res_name_ptr = SERVER_SHORT_SERVER_ID;
00255         break;
00256     case Lifetime:
00257         res_name_ptr = SERVER_LIFETIME;
00258         break;
00259     case DefaultMinPeriod:
00260         res_name_ptr = SERVER_DEFAULT_MIN_PERIOD;
00261         break;
00262     case DefaultMaxPeriod:
00263         res_name_ptr = SERVER_DEFAULT_MAX_PERIOD;
00264         break;
00265     case Disable:
00266         res_name_ptr = SERVER_DISABLE;
00267         break;
00268     case DisableTimeout:
00269         res_name_ptr = SERVER_DISABLE_TIMEOUT;
00270         break;
00271     case NotificationStorage:
00272         res_name_ptr = SERVER_NOTIFICATION_STORAGE;
00273         break;
00274     case Binding:
00275         res_name_ptr = SERVER_BINDING;
00276         break;
00277     case RegistrationUpdate:
00278         res_name_ptr = SERVER_REGISTRATION_UPDATE;
00279         break;
00280     }
00281 
00282     const String res_name(res_name_ptr);
00283 
00284     if(!res_name.empty()) {
00285         if(_server_instance) {
00286         res_object = _server_instance->resource(res_name);
00287         }
00288     }
00289     return res_object;
00290 }