Diff: mbed-client/source/m2mbase.cpp

Revision:

11:cada08fc8a70

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed-client/source/m2mbase.cpp	Thu Jun 09 17:08:36 2016 +0000
@@ -0,0 +1,402 @@
+/*
+ * Copyright (c) 2015 ARM Limited. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "mbed-client/m2mbase.h"
+#include "mbed-client/m2mobservationhandler.h"
+#include "mbed-client/m2mconstants.h"
+#include "mbed-client/m2mtimer.h"
+#include "include/m2mreporthandler.h"
+#include "include/nsdllinker.h"
+#include "ns_trace.h"
+#include <ctype.h>
+#include <string.h>
+
+M2MBase& M2MBase::operator=(const M2MBase& other)
+{
+    if (this != &other) { // protect against invalid self-assignment
+        _operation = other._operation;
+        _mode = other._mode;
+        _name = other._name;
+        _resource_type = other._resource_type;
+        _interface_description = other._interface_description;
+        _coap_content_type = other._coap_content_type;
+        _instance_id = other._instance_id;
+        _observable = other._observable;
+        _observation_number = other._observation_number;
+        _observation_level = other._observation_level;
+        _observation_handler = other._observation_handler;
+
+        if(_token) {
+            free(_token);
+            _token = NULL;
+            _token_length = 0;
+        }
+        _token_length = other._token_length;
+        if(other._token) {
+            _token = (uint8_t *)malloc(other._token_length+1);
+            if(_token) {
+                memset(_token, 0, other._token_length+1);
+                memcpy((uint8_t *)_token, (uint8_t *)other._token, other._token_length);
+            }
+        }
+
+        if(_report_handler) {
+            delete _report_handler;
+            _report_handler = NULL;
+        }
+        if(other._report_handler) {
+            _report_handler = new M2MReportHandler(*other._report_handler);
+        }
+    }
+    return *this;
+}
+
+M2MBase::M2MBase(const M2MBase& other) :
+    _report_handler(NULL),
+    _token(NULL),
+    _token_length(0)
+{
+    _operation = other._operation;
+    _mode = other._mode;
+    _name = other._name;
+    _resource_type = other._resource_type;
+    _interface_description = other._interface_description;
+    _coap_content_type = other._coap_content_type;
+    _instance_id = other._instance_id;
+    _observable = other._observable;
+    _observation_handler = other._observation_handler;
+    _observation_number = other._observation_number;
+    _observation_level = other._observation_level;
+
+    _token_length = other._token_length;
+    if(other._token) {
+        _token = (uint8_t *)malloc(other._token_length+1);
+        if(_token) {
+            memset(_token, 0, other._token_length+1);
+            memcpy((uint8_t *)_token, (uint8_t *)other._token, other._token_length);
+        }
+    }
+
+    if(other._report_handler) {
+        _report_handler = new M2MReportHandler(*other._report_handler);
+    }
+}
+
+M2MBase::M2MBase(const String & resource_name,
+                 M2MBase::Mode mde)
+: _report_handler(NULL),
+  _observation_handler(NULL),
+  _operation(M2MBase::NOT_ALLOWED),  
+  _mode(mde),
+  _observation_level(M2MBase::None),
+  _name(resource_name),
+  _coap_content_type(0),
+  _instance_id(0),
+  _observable(false),
+  _observation_number(0),
+  _token(NULL),
+  _token_length(0)
+{
+    if(is_integer(_name) && _name.size() <= MAX_ALLOWED_STRING_LENGTH) {
+        _name_id = strtoul(_name.c_str(), NULL, 10);
+        if(_name_id > 65535){
+            _name_id = -1;
+        }
+    } else {
+        _name_id = -1;
+    }
+}
+
+M2MBase::~M2MBase()
+{
+    if(_report_handler) {
+        delete _report_handler;
+        _report_handler = NULL;
+    }
+    if(_token) {
+        free(_token);
+        _token = NULL;
+        _token_length = 0;
+    }
+}
+
+void M2MBase::set_operation(M2MBase::Operation opr)
+{
+    // If the mode is Static, there is only GET_ALLOWED
+   // supported.
+    if(M2MBase::Static == _mode) {
+            _operation = M2MBase::GET_ALLOWED;
+    } else {
+        _operation = opr;
+    }
+}
+
+void M2MBase::set_interface_description(const String &desc)
+{
+    _interface_description = desc;
+}
+
+void M2MBase::set_resource_type(const String &res_type)
+{
+    _resource_type = res_type;
+}
+
+void M2MBase::set_coap_content_type(const uint8_t con_type)
+{
+    _coap_content_type = con_type;
+}
+
+void M2MBase::set_observable(bool observable)
+{
+   _observable = observable;
+}
+
+void M2MBase::add_observation_level(M2MBase::Observation observation_level)
+{
+    _observation_level = (M2MBase::Observation)(_observation_level | observation_level);
+}
+
+void M2MBase::remove_observation_level(M2MBase::Observation observation_level)
+{
+    _observation_level = (M2MBase::Observation)(_observation_level ^ observation_level);
+}
+
+void M2MBase::set_under_observation(bool observed,
+                                    M2MObservationHandler *handler)
+{
+
+    tr_debug("M2MBase::set_under_observation - observed: %d", observed);
+    tr_debug("M2MBase::set_under_observation - _base_type: %d", _base_type);
+    _observation_handler = handler;
+    if(handler) {
+        if (_base_type != M2MBase::ResourceInstance) {
+            if(!_report_handler){
+                _report_handler = new M2MReportHandler(*this);
+            }
+            _report_handler->set_under_observation(observed);
+        }
+    } else {
+        if(_report_handler) {
+            delete _report_handler;
+            _report_handler = NULL;
+        }
+    }
+}
+
+void M2MBase::set_observation_token(const uint8_t *token, const uint8_t length)
+{
+    if(_token) {
+         free(_token);
+         _token = NULL;
+         _token_length = 0;
+    }
+
+    if( token != NULL && length > 0 ) {
+        _token = (uint8_t *)malloc(length+1);
+       if(_token) {
+            memset(_token, 0, length+1);
+            memcpy((uint8_t *)_token, (uint8_t *)token, length);
+            _token_length = length;
+        }
+    }
+}
+
+void M2MBase::set_instance_id(const uint16_t inst_id)
+{
+    _instance_id = inst_id;
+}
+
+void M2MBase::set_observation_number(const uint16_t observation_number)
+{
+    _observation_number = observation_number;
+}
+
+M2MBase::BaseType M2MBase::base_type() const
+{
+    return _base_type;
+}
+
+M2MBase::Operation M2MBase::operation() const
+{
+    return _operation;
+}
+
+const String& M2MBase::name() const
+{
+    return _name;
+}
+
+int32_t M2MBase::name_id() const
+{
+    return _name_id;
+}
+
+uint16_t M2MBase::instance_id() const
+{
+    return _instance_id;
+}
+
+const String& M2MBase::interface_description() const
+{
+    return _interface_description;
+}
+
+const String& M2MBase::resource_type() const
+{
+    return _resource_type;
+}
+
+uint8_t M2MBase::coap_content_type() const
+{
+    return _coap_content_type;
+}
+
+bool M2MBase::is_observable() const
+{
+    return _observable;
+}
+
+M2MBase::Observation M2MBase::observation_level() const
+{
+    return _observation_level;
+}
+
+void M2MBase::get_observation_token(uint8_t *&token, uint32_t &token_length)
+{
+    token_length = 0;
+    if(token) {
+        free(token);
+        token = NULL;
+    }
+    token = (uint8_t *)malloc(_token_length+1);
+    if(token) {
+        token_length = _token_length;
+        memset(token, 0, _token_length+1);
+        memcpy((uint8_t *)token, (uint8_t *)_token, token_length);
+    }
+}
+
+M2MBase::Mode M2MBase::mode() const
+{
+    return _mode;
+}
+
+uint16_t M2MBase::observation_number() const
+{
+    return _observation_number;
+}
+
+bool M2MBase::handle_observation_attribute(char *&query)
+{
+    tr_debug("M2MBase::handle_observation_attribute");
+    bool success = false;
+    if(_report_handler) {
+        success = _report_handler->parse_notification_attribute(query,_base_type);
+        if (success) {
+            if ((_report_handler->attribute_flags() & M2MReportHandler::Cancel) == 0) {
+                _report_handler->set_under_observation(true);
+            } else {
+                _report_handler->set_under_observation(false);
+            }
+        }
+    }
+    return success;
+}
+
+void M2MBase::observation_to_be_sent()
+{
+    //TODO: Move this to M2MResourceInstance
+    if(_observation_handler) {
+       _observation_handler->observation_to_be_sent(this);
+    }
+}
+
+void M2MBase::set_base_type(M2MBase::BaseType type)
+{
+    _base_type = type;
+}
+
+void M2MBase::remove_resource_from_coap(const String &resource_name)
+{
+    if(_observation_handler) {
+        _observation_handler->resource_to_be_deleted(resource_name);
+    }
+}
+
+void M2MBase::remove_object_from_coap()
+{
+    if(_observation_handler) {
+        _observation_handler->remove_object(this);
+    }
+}
+
+sn_coap_hdr_s* M2MBase::handle_get_request(nsdl_s */*nsdl*/,
+                                           sn_coap_hdr_s */*received_coap_header*/,
+                                           M2MObservationHandler */*observation_handler*/)
+{
+    //Handled in M2MResource, M2MObjectInstance and M2MObject classes
+    return NULL;
+}
+
+sn_coap_hdr_s* M2MBase::handle_put_request(nsdl_s */*nsdl*/,
+                                           sn_coap_hdr_s */*received_coap_header*/,
+                                           M2MObservationHandler */*observation_handler*/)
+{
+    //Handled in M2MResource, M2MObjectInstance and M2MObject classes
+    return NULL;
+}
+
+sn_coap_hdr_s* M2MBase::handle_post_request(nsdl_s */*nsdl*/,
+                                            sn_coap_hdr_s */*received_coap_header*/,
+                                            M2MObservationHandler */*observation_handler*/)
+{
+    //Handled in M2MResource, M2MObjectInstance and M2MObject classes
+    return NULL;
+}
+
+void *M2MBase::memory_alloc(uint16_t size)
+{
+    if(size)
+        return malloc(size);
+    else
+        return 0;
+}
+
+void M2MBase::memory_free(void *ptr)
+{
+    if(ptr)
+        free(ptr);
+}
+
+M2MReportHandler* M2MBase::report_handler()
+{
+    return _report_handler;
+}
+
+M2MObservationHandler* M2MBase::observation_handler()
+{
+    return _observation_handler;
+}
+
+bool M2MBase::is_integer(const String &value)
+{
+    const char *s = value.c_str();
+    if(value.empty() || ((!isdigit(s[0])) && (s[0] != '-') && (s[0] != '+'))) {
+        return false;
+    }
+    char * p ;
+    strtol(value.c_str(), &p, 10);
+    return (*p == 0);
+}