m2mbase.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015-2021 Pelion. 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.
 */
#ifndef M2M_BASE_H
#define M2M_BASE_H

// Support for std args
#include <stdint.h>
#include "mbed-client/m2mconfig.h"
#include "mbed-client/m2mreportobserver.h"
#include "mbed-client/functionpointer.h"
#include "mbed-client/m2mstringbuffer.h"
#include "mbed-client/coap_response.h"
#include "nsdl-c/sn_nsdl.h"
#include "sn_coap_header.h"
#include "nsdl-c/sn_nsdl_lib.h"

//FORWARD DECLARATION
struct sn_coap_hdr_;
typedef sn_coap_hdr_ sn_coap_hdr_s;
struct nsdl_s;
struct sn_nsdl_addr_;
typedef sn_nsdl_addr_ sn_nsdl_addr_s;

typedef FP1<void, const char *> value_updated_callback;
typedef void(*value_updated_callback2)(const char *object_name);
class M2MObservationHandler;
class M2MReportHandler;

class M2MObjectInstance;
class M2MObject;
class M2MResource;
class M2MEndpoint;


class M2MBase : public M2MReportObserver {

public:

    typedef enum {
        Object = 0x0,
        Resource = 0x1,
        ObjectInstance = 0x2,
        ResourceInstance = 0x3
#ifdef MBED_CLOUD_CLIENT_EDGE_EXTENSION
        , ObjectDirectory = 0x4
#endif
    } BaseType;

    typedef enum {
        None                 = 0x0,
        R_Attribute          = 0x01,
        OI_Attribute         = 0x02,
        OIR_Attribute        = 0x03,
        O_Attribute          = 0x04,
        OR_Attribute         = 0x05,
        OOI_Attribute        = 0x06,
        OOIR_Attribute       = 0x07
    } Observation;


    typedef enum {
        Static,     
        Dynamic,    
        Directory   
    } Mode;

    typedef enum {
        STRING,
        INTEGER,
        FLOAT,
        BOOLEAN,
        OPAQUE,
        TIME,
        OBJLINK
    } DataType;

    typedef enum {
        NOT_ALLOWED                 = 0x00, 
        GET_ALLOWED                 = 0x01, 
        PUT_ALLOWED                 = 0x02, 
        GET_PUT_ALLOWED             = 0x03, 
        POST_ALLOWED                = 0x04, 
        GET_POST_ALLOWED            = 0x05, 
        PUT_POST_ALLOWED            = 0x06, 
        GET_PUT_POST_ALLOWED        = 0x07, 
        DELETE_ALLOWED              = 0x08, 
        GET_DELETE_ALLOWED          = 0x09, 
        PUT_DELETE_ALLOWED          = 0x0A, 
        GET_PUT_DELETE_ALLOWED      = 0x0B, 
        POST_DELETE_ALLOWED         = 0x0C, 
        GET_POST_DELETE_ALLOWED     = 0x0D, 
        PUT_POST_DELETE_ALLOWED     = 0x0E, 
        GET_PUT_POST_DELETE_ALLOWED = 0x0F  
    } Operation;

    typedef enum {
        MESSAGE_STATUS_INIT = 0,           // Initial state.
        MESSAGE_STATUS_BUILD_ERROR,        // CoAP message building fails.
        MESSAGE_STATUS_RESEND_QUEUE_FULL,  // CoAP resend queue full.
        MESSAGE_STATUS_SENT,               // Message sent to the server but ACK not yet received.
        MESSAGE_STATUS_DELIVERED,          // Received ACK from server.
        MESSAGE_STATUS_SEND_FAILED,        // Message sending failed.
        MESSAGE_STATUS_SUBSCRIBED,         // Server has started the observation
        MESSAGE_STATUS_UNSUBSCRIBED,       // Server has stopped the observation (RESET message or GET with observe 1)
        MESSAGE_STATUS_REJECTED            // Server has rejected the response
    } MessageDeliveryStatus;

    typedef enum {
        NOTIFICATION = 0,
        DELAYED_POST_RESPONSE,
        BLOCK_SUBSCRIBE,
        PING,
        DELAYED_RESPONSE
    } MessageType;

    enum MaxPathSize {
        MAX_NAME_SIZE = 64,
        MAX_INSTANCE_SIZE = 5,

        MAX_PATH_SIZE = ((MAX_NAME_SIZE * 2) + (MAX_INSTANCE_SIZE * 2) + 3 + 1),
        MAX_PATH_SIZE_2 = ((MAX_NAME_SIZE * 2) + MAX_INSTANCE_SIZE + 2 + 1),
        MAX_PATH_SIZE_3 = (MAX_NAME_SIZE + (MAX_INSTANCE_SIZE * 2) + 2 + 1),
        MAX_PATH_SIZE_4 = (MAX_NAME_SIZE + MAX_INSTANCE_SIZE + 1 + 1)
    };

    typedef void(*message_delivery_status_cb)(const M2MBase &base,
                                              const MessageDeliveryStatus status,
                                              const MessageType type,
                                              void *client_args);

#ifdef ENABLE_ASYNC_REST_RESPONSE

    typedef void (*handle_async_coap_request_cb)(const M2MBase &base,
                                                 M2MBase::Operation operation,
                                                 const uint8_t *token,
                                                 const uint8_t token_len,
                                                 const uint8_t *buffer,
                                                 size_t buffer_size,
                                                 void *client_args);
#endif // ENABLE_ASYNC_REST_RESPONSE

    typedef struct lwm2m_parameters {
        //add multiple_instances
        uint32_t            max_age; // todo: add flag
        union {
            char               *name; //for backwards compatibility
            uint16_t            instance_id; // XXX: this is not properly aligned now, need to reorder these after the elimination is done
        } identifier;
        sn_nsdl_dynamic_resource_parameters_s *dynamic_resource_params;
        BaseType            base_type : 3;
        M2MBase::DataType   data_type : 3;
        bool                multiple_instance;
        bool                free_on_delete;   
        bool                 identifier_int_type;
        bool                 read_write_callback_set; 
    } lwm2m_parameters_s;

protected:

    // Prevents the use of default constructor.
    M2MBase();

    // Prevents the use of assignment operator.
    M2MBase &operator=(const M2MBase & /*other*/);

    // Prevents the use of copy constructor
    M2MBase(const M2MBase & /*other*/);

    M2MBase(const String &name,
            M2MBase::Mode mode,
#ifndef DISABLE_RESOURCE_TYPE
            const String &resource_type,
#endif
            char *path,
            bool external_blockwise_store,
            bool multiple_instance,
            M2MBase::DataType type = M2MBase::OBJLINK);

    M2MBase(const lwm2m_parameters_s *s);

public:

    virtual ~M2MBase();

    void set_operation(M2MBase::Operation operation);

#if !defined(MEMORY_OPTIMIZED_API) || defined(RESOURCE_ATTRIBUTES_LIST)
#if !defined(DISABLE_INTERFACE_DESCRIPTION) || defined(RESOURCE_ATTRIBUTES_LIST)

    void set_interface_description(const String &description);

    void set_interface_description(const char *description);

    const char *interface_description() const;
#endif
#if !defined(DISABLE_RESOURCE_TYPE) || defined(RESOURCE_ATTRIBUTES_LIST)

    virtual void set_resource_type(const String &resource_type);

    virtual void set_resource_type(const char *resource_type);

    const char *resource_type() const;
#endif
#endif

    void set_coap_content_type(const uint16_t content_type);

    void set_observable(bool observable);

    void set_auto_observable(bool auto_observable);

    void set_confirmable(bool confirmable);

    virtual void add_observation_level(M2MBase::Observation observation_level);

    virtual void remove_observation_level(M2MBase::Observation observation_level);

    void set_under_observation(bool observed,
                               M2MObservationHandler *handler);
    virtual M2MObservationHandler *observation_handler() const = 0;

    virtual void set_observation_handler(M2MObservationHandler *handler) = 0;

    void set_instance_id(const uint16_t instance_id);

    void set_max_age(const uint32_t max_age);

    M2MBase::BaseType base_type() const;

    M2MBase::Operation operation() const;

    const char *name() const;

    int32_t name_id() const;

    uint16_t instance_id() const;

    const char *uri_path() const;

    uint16_t coap_content_type() const;

#if defined (MBED_CLIENT_ENABLE_DYNAMIC_OBSERVABLE) && (MBED_CLIENT_ENABLE_DYNAMIC_OBSERVABLE == 1)

    bool is_observable() const;
#else

    bool is_readable() const;
#endif //MBED_CLIENT_ENABLE_DYNAMIC_OBSERVABLE

    bool is_auto_observable() const;

    M2MBase::Observation observation_level() const;

    Mode mode() const;

    uint16_t observation_number() const;

    uint32_t max_age() const;

#if defined (MBED_CONF_MBED_CLIENT_ENABLE_OBSERVATION_PARAMETERS) && (MBED_CONF_MBED_CLIENT_ENABLE_OBSERVATION_PARAMETERS == 1)

    virtual bool handle_observation_attribute(const char *query);
#endif

    virtual sn_coap_hdr_s *handle_get_request(nsdl_s *nsdl,
                                              sn_coap_hdr_s *received_coap_header,
                                              M2MObservationHandler *observation_handler = NULL);
    virtual sn_coap_hdr_s *handle_put_request(nsdl_s *nsdl,
                                              sn_coap_hdr_s *received_coap_header,
                                              M2MObservationHandler *observation_handler,
                                              bool &execute_value_updated);

    virtual sn_coap_hdr_s *handle_post_request(nsdl_s *nsdl,
                                               sn_coap_hdr_s *received_coap_header,
                                               M2MObservationHandler *observation_handler,
                                               bool &execute_value_updated,
                                               sn_nsdl_addr_s *address = NULL);

    void send_message_delivery_status(const M2MBase &object, const MessageDeliveryStatus status, const MessageType type);

    void set_register_uri(bool register_uri);

    bool register_uri();

    bool is_under_observation() const;

    bool set_value_updated_function(value_updated_callback callback);

    bool set_value_updated_function(value_updated_callback2 callback);

    bool is_value_updated_function_set() const;

    void execute_value_updated(const String &name);

    size_t resource_name_length() const;

    sn_nsdl_dynamic_resource_parameters_s *get_nsdl_resource() const;

    M2MBase::lwm2m_parameters_s *get_lwm2m_parameters() const;

#ifdef ENABLE_ASYNC_REST_RESPONSE

    bool send_async_response_with_code(const uint8_t *payload,
                                       size_t payload_len,
                                       const uint8_t *token,
                                       const uint8_t token_len,
                                       coap_response_code_e code = COAP_RESPONSE_CHANGED);

    bool set_async_coap_request_cb(handle_async_coap_request_cb callback, void *client_args);

#endif //ENABLE_ASYNC_REST_RESPONSE

    uint16_t get_notification_msgid() const m2m_deprecated;

    void set_notification_msgid(uint16_t msgid) m2m_deprecated;

    bool set_message_delivery_status_cb(message_delivery_status_cb callback, void *client_args);

#ifdef MBED_CLOUD_CLIENT_EDGE_EXTENSION
    static char *create_path(const M2MEndpoint &parent, const char *name);
#endif
    static char *create_path(const M2MObject &parent, const char *name);
    static char *create_path(const M2MObject &parent, uint16_t object_instance);
    static char *create_path(const M2MResource &parent, uint16_t resource_instance);
    static char *create_path(const M2MResource &parent, const char *name);
    static char *create_path(const M2MObjectInstance &parent, const char *name);

#ifdef MBED_CLOUD_CLIENT_EDGE_EXTENSION

    virtual void set_deleted();


    virtual bool is_deleted();

#endif // MBED_CLOUD_CLIENT_EDGE_EXTENSION

    M2MReportHandler *report_handler() const;

protected: // from M2MReportObserver

    virtual bool observation_to_be_sent(const m2m::Vector<uint16_t> &changed_instance_ids,
                                        uint16_t obs_number,
                                        bool send_object = false);

    void set_base_type(M2MBase::BaseType type);

    static void *memory_alloc(uint32_t size);

    static void memory_free(void *ptr);

    static char *alloc_string_copy(const char *source);

    static uint8_t *alloc_string_copy(const uint8_t *source, uint32_t size);

    static uint8_t *alloc_copy(const uint8_t *source, uint32_t size);

    // validate string length to be [min_length..max_length]
    static bool validate_string_length(const String &string, size_t min_length, size_t max_length);
    static bool validate_string_length(const char *string, size_t min_length, size_t max_length);

    M2MReportHandler *create_report_handler();

    static bool build_path(StringBuffer<MAX_PATH_SIZE> &buffer, const char *s1, uint16_t i1, const char *s2, uint16_t i2);

    static bool build_path(StringBuffer<MAX_PATH_SIZE_2> &buffer, const char *s1, uint16_t i1, const char *s2);

    static bool build_path(StringBuffer<MAX_PATH_SIZE_3> &buffer, const char *s1, uint16_t i1, uint16_t i2);

    static bool build_path(StringBuffer<MAX_PATH_SIZE_4> &buffer, const char *s1, uint16_t i1);

    static char *stringdup(const char *s);

    void free_resources();

    void clear_notification_delivery_status() m2m_deprecated;

    void get_observation_token(uint8_t *token, uint8_t &token_length) const;

    void set_observation_token(const uint8_t *token,
                               const uint8_t length);

    virtual void set_changed();

    virtual M2MBase *get_parent() const;

    static bool is_blockwise_needed(const nsdl_s *nsdl, uint32_t payload_len);

    void handle_observation(nsdl_s *nsdl,
                            const sn_coap_hdr_s &received_coap_header,
                            sn_coap_hdr_s &coap_response,
                            M2MObservationHandler *observation_handler,
                            sn_coap_msg_code_e &response_code);

    void cancel_observation(M2MBase::MessageDeliveryStatus status = M2MBase::MESSAGE_STATUS_UNSUBSCRIBED, bool notify = true);

    void start_observation(const sn_coap_hdr_s &received_coap_header, M2MObservationHandler *observation_handler);

#ifdef ENABLE_ASYNC_REST_RESPONSE

    void call_async_coap_request_callback(sn_coap_hdr_s *coap_request,
                                          M2MBase::Operation operation,
                                          bool &handled);

    bool is_async_coap_request_callback_set();

#endif //ENABLE_ASYNC_REST_RESPONSE

private:

    static bool is_integer(const String &value);

    static bool is_integer(const char *value);

    static char *create_path_base(const M2MBase &parent, const char *name);

    lwm2m_parameters_s          *_sn_resource;
    M2MReportHandler            *_report_handler; // TODO: can be broken down to smaller classes with inheritance.

    friend class Test_M2MBase;
    friend class Test_M2MObject;
    friend class M2MNsdlInterface;
    friend class M2MInterfaceFactory;
    friend class M2MObject;
};

#endif // M2M_BASE_H