m2mbase_stub.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 "m2mbase_stub.h"
00017 #include "m2mstringbufferbase_stub.h"
00018 #include <assert.h>
00019 
00020 uint8_t m2mbase_stub::uint8_value;
00021 uint16_t m2mbase_stub::uint16_value;
00022 uint32_t m2mbase_stub::uint32_value;
00023 uint16_t m2mbase_stub::int_value;
00024 int32_t m2mbase_stub::name_id_value;
00025 
00026 bool m2mbase_stub::bool_value;
00027 const char *m2mbase_stub::string_value;
00028 const char *m2mbase_stub::object_instance_name;
00029 const char *m2mbase_stub::resource_name;
00030 const char *m2mbase_stub::resource_name_inst;
00031 M2MBase::BaseType m2mbase_stub::base_type;
00032 M2MBase::Operation m2mbase_stub::operation;
00033 M2MBase::Mode m2mbase_stub::mode_value;
00034 M2MBase::Observation m2mbase_stub::observation_level_value;
00035 
00036 void *m2mbase_stub::void_value;
00037 M2MObservationHandler *m2mbase_stub::observe;
00038 M2MReportHandler *m2mbase_stub::report;
00039 bool m2mbase_stub::is_value_updated_function_set;
00040 uint8_t *m2mbase_stub::object_inst_token;
00041 uint32_t m2mbase_stub::object_inst_token_len;
00042 uint8_t *m2mbase_stub::object_token;
00043 uint32_t m2mbase_stub::object_token_len;
00044 uint8_t *m2mbase_stub::resource_token;
00045 uint32_t m2mbase_stub::resource_token_len;
00046 sn_nsdl_dynamic_resource_parameters_s *m2mbase_stub::nsdl_resource;
00047 bool m2mbase_stub::find_resource;
00048 int32_t m2mbase_stub::ret_counter;
00049 
00050 void m2mbase_stub::clear()
00051 {
00052     int_value = 0;
00053     uint8_value = 0;
00054     uint16_value = 0;
00055     uint32_value = 0;
00056     string_value = NULL;
00057     object_instance_name = NULL;
00058     resource_name = NULL;
00059     resource_name_inst = NULL;
00060     name_id_value = -1;
00061     mode_value = M2MBase::Static;
00062     base_type = M2MBase::Object;
00063     observation_level_value = M2MBase::None;
00064     bool_value = false;
00065     m2mbase_stub::operation = M2MBase::NOT_ALLOWED;
00066     void_value = NULL;
00067     observe = NULL;
00068     report = NULL;
00069     is_value_updated_function_set = false;
00070     object_token = NULL;
00071     object_token_len = 0;
00072     resource_token = NULL;
00073     resource_token_len = 0;
00074     object_inst_token = NULL;
00075     object_inst_token_len = 0;
00076     find_resource = false;
00077     ret_counter = 0;
00078 }
00079 
00080 M2MBase::M2MBase(const String& resource_name,
00081                  M2MBase::Mode mode,
00082                  const String &resource_type,
00083                  char *path,
00084                  bool external_blockwise_store)
00085 :
00086   _sn_resource(NULL),
00087   _report_handler(NULL),
00088   _observation_handler(NULL),
00089   _token(NULL),
00090   _function_pointer(NULL),
00091   _observation_number(0),
00092   _token_length(0),
00093   _observation_level(M2MBase::None),
00094   _is_under_observation(false)
00095 {
00096 
00097 }
00098 
00099 M2MBase::M2MBase(const lwm2m_parameters_s *s):
00100     _sn_resource((lwm2m_parameters_s*) s),
00101     _report_handler(NULL),
00102     _observation_handler(NULL),
00103     _token(NULL),
00104     _function_pointer(NULL),
00105     _observation_number(0),
00106     _token_length(0),
00107     _observation_level(M2MBase::None),
00108     _is_under_observation(false)
00109 {
00110 }
00111 
00112 M2MBase::~M2MBase()
00113 {
00114 }
00115 
00116 void M2MBase::set_operation(M2MBase::Operation opr)
00117 {
00118     m2mbase_stub::operation = opr;
00119 }
00120 
00121 void M2MBase::set_interface_description(const String &/*desc*/)
00122 {
00123 }
00124 
00125 void M2MBase::set_resource_type(const String &/*res_type*/)
00126 {
00127 }
00128 
00129 void M2MBase::set_interface_description(const char */*desc*/)
00130 {
00131 }
00132 
00133 void M2MBase::set_resource_type(const char */*res_type*/)
00134 {
00135 }
00136 
00137 void M2MBase::set_coap_content_type(const uint8_t /*con_type*/)
00138 {
00139 }
00140 
00141 void M2MBase::set_instance_id(const uint16_t /*inst_id*/)
00142 {
00143 }
00144 
00145 void M2MBase::set_observation_number(const uint16_t /*observation_number*/)
00146 {
00147 }
00148 
00149 void M2MBase::set_max_age(const uint32_t /*max_age*/)
00150 {
00151 }
00152 
00153 M2MBase::Operation M2MBase::operation() const
00154 {
00155     return m2mbase_stub::operation;
00156 }
00157 
00158 const char* M2MBase::name() const
00159 {
00160     return m2mbase_stub::string_value;
00161 }
00162 
00163 int32_t M2MBase::name_id() const
00164 {
00165     return m2mbase_stub::name_id_value;
00166 }
00167 
00168 uint16_t M2MBase::instance_id() const
00169 {
00170     return m2mbase_stub::int_value;
00171 }
00172 
00173 const char* M2MBase::interface_description() const
00174 {
00175     return m2mbase_stub::string_value;
00176 }
00177 
00178 const char* M2MBase::resource_type() const
00179 {
00180     return m2mbase_stub::string_value;
00181 }
00182 
00183 uint8_t M2MBase::coap_content_type() const
00184 {
00185     return m2mbase_stub::uint8_value;
00186 }
00187 
00188 uint32_t M2MBase::max_age() const
00189 {
00190     return m2mbase_stub::uint32_value;
00191 }
00192 
00193 void M2MBase::set_observable(bool /*observable*/)
00194 {
00195 }
00196 
00197 void M2MBase::add_observation_level(M2MBase::Observation)
00198 {
00199 }
00200 
00201 void M2MBase::remove_observation_level(M2MBase::Observation)
00202 {
00203 }
00204 
00205 void M2MBase::set_under_observation(bool /*observed*/,
00206                                    M2MObservationHandler */*handler*/)
00207 {
00208 }
00209 
00210 void M2MBase::set_observation_token(const uint8_t */*token*/,
00211                                     const uint8_t /*length*/)
00212 {
00213 }
00214 
00215 bool M2MBase::is_observable() const
00216 {
00217     return m2mbase_stub::bool_value;
00218 }
00219 
00220 M2MBase::Observation M2MBase::observation_level() const
00221 {
00222     return m2mbase_stub::observation_level_value;
00223 }
00224 
00225 void M2MBase::get_observation_token(uint8_t *&token,
00226                                     uint32_t &length)
00227 {
00228     length = 0;
00229     if(token) {
00230         free(token);
00231         token = NULL;
00232     }
00233 
00234     if (m2mbase_stub::find_resource) {
00235         if (m2mbase_stub::ret_counter == 1) {
00236             token = (uint8_t *)malloc(m2mbase_stub::object_inst_token_len);
00237             if(token) {
00238                 length = m2mbase_stub::object_inst_token_len;
00239                 memcpy((uint8_t *)token, (uint8_t *)m2mbase_stub::object_inst_token, length);
00240             }
00241         } else if (m2mbase_stub::ret_counter == 2) {
00242             token = (uint8_t *)malloc(m2mbase_stub::resource_token_len);
00243             if(token) {
00244                 length = m2mbase_stub::resource_token_len;
00245                 memcpy((uint8_t *)token, (uint8_t *)m2mbase_stub::resource_token, length);
00246             }
00247         } else {
00248             token = (uint8_t *)malloc(m2mbase_stub::object_token_len);
00249             if(token) {
00250                 length = m2mbase_stub::object_token_len;
00251                 memcpy((uint8_t *)token, (uint8_t *)m2mbase_stub::object_token, length);
00252             }
00253         }
00254         m2mbase_stub::ret_counter++;
00255     } else {
00256         token = (uint8_t *)malloc(m2mbase_stub::object_token_len);
00257         if(token) {
00258             length = m2mbase_stub::object_token_len;
00259             memcpy((uint8_t *)token, (uint8_t *)m2mbase_stub::object_token, length);
00260         }
00261     }
00262 }
00263 
00264 void M2MBase::set_base_type(M2MBase::BaseType /*type*/)
00265 {
00266 }
00267 
00268 M2MBase::BaseType M2MBase::base_type() const
00269 {
00270     return m2mbase_stub::base_type;
00271 }
00272 
00273 M2MBase::Mode M2MBase::mode() const
00274 {
00275     return m2mbase_stub::mode_value;
00276 }
00277 
00278 uint16_t M2MBase::observation_number() const
00279 {
00280     return m2mbase_stub::uint16_value;
00281 }
00282 
00283 bool M2MBase::handle_observation_attribute(const char *query)
00284 {
00285     return m2mbase_stub::bool_value;
00286 }
00287 
00288 void M2MBase::observation_to_be_sent(m2m::Vector<uint16_t>, bool)
00289 {
00290 }
00291 
00292 void *M2MBase::memory_alloc(uint32_t size)
00293 {
00294     if(size)
00295         return malloc(size);
00296     else
00297         return 0;
00298 }
00299 
00300 void M2MBase::memory_free(void *ptr)
00301 {
00302     if(ptr)
00303         free(ptr);
00304 }
00305 
00306 uint8_t* M2MBase::alloc_string_copy(const uint8_t* source, uint32_t size)
00307 {
00308     assert(source != NULL);
00309 
00310     uint8_t* result = (uint8_t*)memory_alloc(size + 1);
00311     if (result) {
00312         memcpy(result, source, size);
00313         result[size] = '\0';
00314     }
00315     return result;
00316 }
00317 
00318 uint8_t* M2MBase::alloc_copy(const uint8_t* source, uint32_t size)
00319 {
00320     assert(source != NULL);
00321 
00322     uint8_t* result = (uint8_t*)memory_alloc(size);
00323     if (result) {
00324         memcpy(result, source, size);
00325     }
00326     return result;
00327 }
00328 
00329 M2MReportHandler* M2MBase::report_handler()
00330 {
00331     return m2mbase_stub::report;
00332 }
00333 
00334 M2MObservationHandler* M2MBase::observation_handler()
00335 {
00336     return m2mbase_stub::observe;
00337 }
00338 
00339 sn_coap_hdr_s* M2MBase::handle_get_request(nsdl_s */*nsdl*/,
00340                                            sn_coap_hdr_s */*received_coap_header*/,
00341                                            M2MObservationHandler */*observation_handler*/)
00342 {
00343     //Handled in M2MResource, M2MObjectInstance and M2MObject classes
00344     return NULL;
00345 }
00346 
00347 sn_coap_hdr_s* M2MBase::handle_put_request(nsdl_s */*nsdl*/,
00348                                            sn_coap_hdr_s */*received_coap_header*/,
00349                                            M2MObservationHandler */*observation_handler*/,
00350                                            bool &execute_value_updated)
00351 {
00352     //Handled in M2MResource, M2MObjectInstance and M2MObject classes
00353     return NULL;
00354 }
00355 
00356 sn_coap_hdr_s* M2MBase::handle_post_request(nsdl_s */*nsdl*/,
00357                                             sn_coap_hdr_s */*received_coap_header*/,
00358                                             M2MObservationHandler */*observation_handler*/,
00359                                             bool &, sn_nsdl_addr_s *address)
00360 {
00361     //Handled in M2MResource, M2MObjectInstance and M2MObject classes
00362     return NULL;
00363 }
00364 
00365 void M2MBase::set_register_uri( bool register_uri)
00366 {
00367 }
00368 
00369 bool M2MBase::register_uri()
00370 {
00371     return m2mbase_stub::bool_value;
00372 }
00373 
00374 const char* M2MBase::uri_path() const
00375 {
00376     if (m2mbase_stub::find_resource) {
00377         m2mbase_stub::ret_counter++;
00378         if (m2mbase_stub::ret_counter == 2) {
00379             return m2mbase_stub::object_instance_name;
00380         } else if (m2mbase_stub::ret_counter == 3) {
00381             return m2mbase_stub::resource_name;
00382         } else if (m2mbase_stub::ret_counter == 4 || m2mbase_stub::ret_counter == 5) {
00383             return m2mbase_stub::resource_name_inst;
00384         } else {
00385             return m2mbase_stub::string_value;
00386         }
00387     } else {
00388         return m2mbase_stub::string_value;
00389     }
00390 }
00391 
00392 bool M2MBase::is_under_observation() const
00393 {
00394     return m2mbase_stub::bool_value;
00395 }
00396 
00397 void M2MBase::set_value_updated_function(value_updated_callback  callback)
00398 {
00399 
00400 }
00401 
00402 void M2MBase::set_value_updated_function(value_updated_callback2 callback)
00403 {
00404 
00405 }
00406 
00407 bool M2MBase::is_value_updated_function_set()
00408 {
00409     return m2mbase_stub::is_value_updated_function_set;
00410 }
00411 
00412 void M2MBase::execute_value_updated(const String& name)
00413 {
00414 
00415 }
00416 bool M2MBase::build_path(StringBuffer<MAX_PATH_SIZE> &buffer, const char *s1, uint16_t i1, const char *s2, uint16_t i2)
00417 {
00418 
00419     if(!buffer.ensure_space(strlen(s1) + strlen(s2) + 10 + 3 + 1)){
00420         return false;
00421     }
00422 
00423     buffer.append(s1);
00424     buffer.append('/');
00425     buffer.append_int(i1);
00426     buffer.append('/');
00427     buffer.append(s2);
00428     buffer.append('/');
00429     buffer.append_int(i2);
00430 
00431     return true;
00432 
00433 }
00434 
00435 bool M2MBase::build_path(StringBuffer<MAX_PATH_SIZE_2> &buffer, const char *s1, uint16_t i1, const char *s2)
00436 {
00437 
00438     if(!buffer.ensure_space(strlen(s1) + strlen(s2) + 5 + 2 + 1)){
00439         return false;
00440     }
00441 
00442     buffer.append(s1);
00443     buffer.append('/');
00444     buffer.append_int(i1);
00445     buffer.append('/');
00446     buffer.append(s2);
00447 
00448     return true;
00449 
00450 }
00451 
00452 bool M2MBase::build_path(StringBuffer<MAX_PATH_SIZE_3> &buffer, const char *s1, uint16_t i1, uint16_t i2)
00453 {
00454 
00455     if(!buffer.ensure_space(strlen(s1) + 10 + 2 + 1)){
00456         return false;
00457     }
00458 
00459     buffer.append(s1);
00460     buffer.append('/');
00461     buffer.append_int(i1);
00462     buffer.append('/');
00463     buffer.append_int(i2);
00464 
00465     return true;
00466 
00467 }
00468 
00469 bool M2MBase::build_path(StringBuffer<MAX_PATH_SIZE_4> &buffer, const char *s1, uint16_t i1)
00470 {
00471 
00472     if(!buffer.ensure_space(strlen(s1) + 5 + 1 + 1)){
00473         return false;
00474     }
00475 
00476     buffer.append(s1);
00477     buffer.append('/');
00478     buffer.append_int(i1);
00479 
00480     return true;
00481 
00482 }
00483 
00484 sn_nsdl_dynamic_resource_parameters_s* M2MBase::get_nsdl_resource()
00485 {
00486     return m2mbase_stub::nsdl_resource;
00487 }
00488 
00489 char* M2MBase::stringdup(const char* src)
00490 {
00491 
00492 }
00493 
00494 char* M2MBase::create_path(const M2MObject &parent, uint16_t object_instance)
00495 {
00496 
00497 }
00498 
00499 char* M2MBase::create_path(const M2MObject &parent, const char *name)
00500 {
00501 
00502 }
00503 
00504 char* M2MBase::create_path(const M2MResource &parent, uint16_t resource_instance)
00505 {
00506 
00507 }
00508 
00509 char* M2MBase::create_path(const M2MResource &parent, const char *name)
00510 {
00511 
00512 }
00513 
00514 char* M2MBase::create_path(const M2MObjectInstance &parent, const char *name)
00515 {
00516 
00517 }
00518 
00519 void M2MBase::set_observation_handler(M2MObservationHandler *handler)
00520 {
00521 
00522 }
00523 
00524 size_t M2MBase::resource_name_length() const
00525 {
00526 
00527 }
00528 
00529 bool M2MBase::validate_string_length(const String &string, size_t min_length, size_t max_length)
00530 {
00531     return m2mbase_stub::bool_value;
00532 }
00533 
00534 bool M2MBase::validate_string_length(const char* string, size_t min_length, size_t max_length)
00535 {
00536     return m2mbase_stub::bool_value;
00537 }
00538 
00539 M2MReportHandler* M2MBase::create_report_handler()
00540 {
00541 
00542 }