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 
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, stringdup(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 = NULL;
00155             break;
00156     }
00157 
00158     if(server_id_ptr) {
00159         if(_server_instance) {
00160             success = _server_instance->remove_resource(server_id_ptr);
00161         }
00162     }
00163     return success;
00164 }
00165 
00166 bool M2MServer::set_resource_value(ServerResource resource,
00167                                    const String &value)
00168 {
00169     bool success = false;
00170     M2MResource* res = get_resource(resource);
00171     if(res && (M2MServer::Binding == resource)) {
00172         success = res->set_value((const uint8_t*)value.c_str(),(uint32_t)value.length());
00173     }
00174     return success;
00175 }
00176 
00177 bool M2MServer::set_resource_value(ServerResource resource,
00178                                    uint32_t value)
00179 {
00180     bool success = false;
00181     M2MResource* res = get_resource(resource);
00182     if(res) {
00183         if(M2MServer::ShortServerID == resource     ||
00184            M2MServer::Lifetime == resource          ||
00185            M2MServer::DefaultMinPeriod == resource  ||
00186            M2MServer::DefaultMaxPeriod == resource  ||
00187            M2MServer::DisableTimeout == resource    ||
00188            M2MServer::NotificationStorage == resource) {
00189             // If it is any of the above resource
00190             // set the value of the resource.
00191 
00192             success = res->set_value(value);
00193         }
00194     }
00195     return success;
00196 }
00197 
00198 String M2MServer::resource_value_string(ServerResource resource) const
00199 {
00200     String value = "";
00201     M2MResource* res = get_resource(resource);
00202     if(res && (M2MServer::Binding == resource)) {
00203 
00204         value = res->get_value_string();
00205     }
00206     return value;
00207 }
00208 
00209 
00210 uint32_t M2MServer::resource_value_int(ServerResource resource) const
00211 {
00212     uint32_t value = 0;
00213     M2MResource* res = get_resource(resource);
00214     if(res) {
00215         if(M2MServer::ShortServerID == resource     ||
00216            M2MServer::Lifetime == resource          ||
00217            M2MServer::DefaultMinPeriod == resource  ||
00218            M2MServer::DefaultMaxPeriod == resource  ||
00219            M2MServer::DisableTimeout == resource    ||
00220            M2MServer::NotificationStorage == resource) {
00221 
00222             value = res->get_value_int();
00223         }
00224     }
00225     return value;
00226 }
00227 
00228 bool M2MServer::is_resource_present(ServerResource resource) const
00229 {
00230     bool success = false;
00231     M2MResource *res = get_resource(resource);
00232     if(res) {
00233         success = true;
00234     }
00235     return success;
00236 }
00237 
00238 uint16_t M2MServer::total_resource_count() const
00239 {
00240     uint16_t total_count = 0;
00241     if(_server_instance) {
00242     total_count = _server_instance->resources().size();
00243     }
00244     return total_count;
00245 }
00246 
00247 M2MResource* M2MServer::get_resource(ServerResource res) const
00248 {
00249     M2MResource* res_object = NULL;
00250     const char* res_name_ptr = NULL;
00251     switch(res) {
00252     case ShortServerID:
00253         res_name_ptr = SERVER_SHORT_SERVER_ID;
00254         break;
00255     case Lifetime:
00256         res_name_ptr = SERVER_LIFETIME;
00257         break;
00258     case DefaultMinPeriod:
00259         res_name_ptr = SERVER_DEFAULT_MIN_PERIOD;
00260         break;
00261     case DefaultMaxPeriod:
00262         res_name_ptr = SERVER_DEFAULT_MAX_PERIOD;
00263         break;
00264     case Disable:
00265         res_name_ptr = SERVER_DISABLE;
00266         break;
00267     case DisableTimeout:
00268         res_name_ptr = SERVER_DISABLE_TIMEOUT;
00269         break;
00270     case NotificationStorage:
00271         res_name_ptr = SERVER_NOTIFICATION_STORAGE;
00272         break;
00273     case Binding:
00274         res_name_ptr = SERVER_BINDING;
00275         break;
00276     case RegistrationUpdate:
00277         res_name_ptr = SERVER_REGISTRATION_UPDATE;
00278         break;
00279     }
00280 
00281     if(res_name_ptr) {
00282         if(_server_instance) {
00283             res_object = _server_instance->resource(res_name_ptr);
00284         }
00285     }
00286     return res_object;
00287 }