lwm2m.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Linaro Limited
 * Copyright (c) 2017-2019 Foundries.io
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_LWM2M_H_
#define ZEPHYR_INCLUDE_NET_LWM2M_H_
 
#include <time.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/mutex.h>
#include <zephyr/net/coap.h>
#include <zephyr/net/lwm2m_path.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* clang-format off */
#define LWM2M_OBJECT_SECURITY_ID                0  
#define LWM2M_OBJECT_SERVER_ID                  1  
#define LWM2M_OBJECT_ACCESS_CONTROL_ID          2  
#define LWM2M_OBJECT_DEVICE_ID                  3  
#define LWM2M_OBJECT_CONNECTIVITY_MONITORING_ID 4  
#define LWM2M_OBJECT_FIRMWARE_ID                5  
#define LWM2M_OBJECT_LOCATION_ID                6  
#define LWM2M_OBJECT_CONNECTIVITY_STATISTICS_ID 7  
#define LWM2M_OBJECT_SOFTWARE_MANAGEMENT_ID     9  
#define LWM2M_OBJECT_PORTFOLIO_ID               16 
#define LWM2M_OBJECT_BINARYAPPDATACONTAINER_ID  19 
#define LWM2M_OBJECT_EVENT_LOG_ID               20 
#define LWM2M_OBJECT_OSCORE_ID                  21 
#define LWM2M_OBJECT_GATEWAY_ID                 25 
/* clang-format on */
 
/* clang-format off */
#define IPSO_OBJECT_GENERIC_SENSOR_ID       3300 
#define IPSO_OBJECT_TEMP_SENSOR_ID          3303 
#define IPSO_OBJECT_HUMIDITY_SENSOR_ID      3304 
#define IPSO_OBJECT_LIGHT_CONTROL_ID        3311 
#define IPSO_OBJECT_ACCELEROMETER_ID        3313 
#define IPSO_OBJECT_VOLTAGE_SENSOR_ID       3316 
#define IPSO_OBJECT_CURRENT_SENSOR_ID       3317 
#define IPSO_OBJECT_PRESSURE_ID             3323 
#define IPSO_OBJECT_BUZZER_ID               3338 
#define IPSO_OBJECT_TIMER_ID                3340 
#define IPSO_OBJECT_ONOFF_SWITCH_ID         3342 
#define IPSO_OBJECT_PUSH_BUTTON_ID          3347 
#define UCIFI_OBJECT_BATTERY_ID             3411 
#define IPSO_OBJECT_FILLING_LEVEL_SENSOR_ID 3435 
/* clang-format on */
 
typedef void (*lwm2m_socket_fault_cb_t)(int error);
 
struct lwm2m_obj_path {
        uint16_t obj_id;         
        uint16_t obj_inst_id;    
        uint16_t res_id;         
        uint16_t res_inst_id;    
        uint8_t  level;          
};
 
enum lwm2m_observe_event {
        LWM2M_OBSERVE_EVENT_OBSERVER_ADDED,    
        LWM2M_OBSERVE_EVENT_OBSERVER_REMOVED,  
        LWM2M_OBSERVE_EVENT_NOTIFY_ACK,        
        LWM2M_OBSERVE_EVENT_NOTIFY_TIMEOUT,    
};
 
typedef void (*lwm2m_observe_cb_t)(enum lwm2m_observe_event event, struct lwm2m_obj_path *path,
                                   void *user_data);
 
 
struct lwm2m_ctx;
 
enum lwm2m_rd_client_event {
        LWM2M_RD_CLIENT_EVENT_NONE,
        LWM2M_RD_CLIENT_EVENT_BOOTSTRAP_REG_FAILURE,
        LWM2M_RD_CLIENT_EVENT_BOOTSTRAP_REG_COMPLETE,
        LWM2M_RD_CLIENT_EVENT_BOOTSTRAP_TRANSFER_COMPLETE,
        LWM2M_RD_CLIENT_EVENT_REGISTRATION_FAILURE,
        LWM2M_RD_CLIENT_EVENT_REGISTRATION_COMPLETE,
        LWM2M_RD_CLIENT_EVENT_REG_TIMEOUT,
        LWM2M_RD_CLIENT_EVENT_REG_UPDATE_COMPLETE,
        LWM2M_RD_CLIENT_EVENT_DEREGISTER_FAILURE,
        LWM2M_RD_CLIENT_EVENT_DISCONNECT,
        LWM2M_RD_CLIENT_EVENT_QUEUE_MODE_RX_OFF,
        LWM2M_RD_CLIENT_EVENT_ENGINE_SUSPENDED,
        LWM2M_RD_CLIENT_EVENT_NETWORK_ERROR,
        LWM2M_RD_CLIENT_EVENT_REG_UPDATE,
        LWM2M_RD_CLIENT_EVENT_DEREGISTER,
        LWM2M_RD_CLIENT_EVENT_SERVER_DISABLED,
};
 
 
typedef void (*lwm2m_ctx_event_cb_t)(struct lwm2m_ctx *ctx,
                                     enum lwm2m_rd_client_event event);
 
 
enum lwm2m_socket_states {
        LWM2M_SOCKET_STATE_ONGOING,      
        LWM2M_SOCKET_STATE_ONE_RESPONSE, 
        LWM2M_SOCKET_STATE_LAST,         
        LWM2M_SOCKET_STATE_NO_DATA,      
};
 
struct lwm2m_ctx {
        struct sockaddr remote_addr;
 
        struct coap_pending pendings[CONFIG_LWM2M_ENGINE_MAX_PENDING + 1];
        struct coap_reply replies[CONFIG_LWM2M_ENGINE_MAX_REPLIES + 1];
        sys_slist_t pending_sends;
#if defined(CONFIG_LWM2M_QUEUE_MODE_ENABLED)
        sys_slist_t queued_messages;
#endif
        sys_slist_t observer;
        struct k_mutex lock;
        void *processed_req;
 
#if defined(CONFIG_LWM2M_DTLS_SUPPORT) || defined(__DOXYGEN__)
        int tls_tag;
 
        char *desthostname;
        uint16_t desthostnamelen;
 
        int (*load_credentials)(struct lwm2m_ctx *client_ctx);
#endif
        int (*set_socketoptions)(struct lwm2m_ctx *client_ctx);
 
        bool use_dtls;
 
        bool connection_suspended;
 
#if defined(CONFIG_LWM2M_QUEUE_MODE_ENABLED) || defined(__DOXYGEN__)
        bool buffer_client_messages;
#endif
        int sec_obj_inst;
 
        int srv_obj_inst;
 
        bool bootstrap_mode;
 
        int sock_fd;
 
        lwm2m_socket_fault_cb_t fault_cb;
 
        lwm2m_observe_cb_t observe_cb;
 
        lwm2m_ctx_event_cb_t event_cb;
 
        uint8_t validate_buf[CONFIG_LWM2M_ENGINE_VALIDATION_BUFFER_SIZE];
 
        void (*set_socket_state)(int fd, enum lwm2m_socket_states state);
};
 
struct lwm2m_time_series_elem {
        time_t t;
        union {
                uint8_t u8;
                uint16_t u16;
                uint32_t u32;
                uint64_t u64;
                int8_t i8;
                int16_t i16;
                int32_t i32;
                int64_t i64;
                time_t time;
                double f;
                bool b;
        };
};
 
typedef void *(*lwm2m_engine_get_data_cb_t)(uint16_t obj_inst_id,
                                            uint16_t res_id,
                                            uint16_t res_inst_id,
                                            size_t *data_len);
 
typedef int (*lwm2m_engine_set_data_cb_t)(uint16_t obj_inst_id,
                                          uint16_t res_id, uint16_t res_inst_id,
                                          uint8_t *data, uint16_t data_len,
                                          bool last_block, size_t total_size, size_t offset);
 
typedef int (*lwm2m_engine_user_cb_t)(uint16_t obj_inst_id);
 
typedef int (*lwm2m_engine_execute_cb_t)(uint16_t obj_inst_id,
                                         uint8_t *args, uint16_t args_len);
 
#define LWM2M_DEVICE_PWR_SRC_TYPE_DC_POWER      0 
#define LWM2M_DEVICE_PWR_SRC_TYPE_BAT_INT       1 
#define LWM2M_DEVICE_PWR_SRC_TYPE_BAT_EXT       2 
#define LWM2M_DEVICE_PWR_SRC_TYPE_FUEL_CELL     3 
#define LWM2M_DEVICE_PWR_SRC_TYPE_PWR_OVER_ETH  4 
#define LWM2M_DEVICE_PWR_SRC_TYPE_USB           5 
#define LWM2M_DEVICE_PWR_SRC_TYPE_AC_POWER      6 
#define LWM2M_DEVICE_PWR_SRC_TYPE_SOLAR         7 
#define LWM2M_DEVICE_PWR_SRC_TYPE_MAX           8 
#define LWM2M_DEVICE_ERROR_NONE                 0 
#define LWM2M_DEVICE_ERROR_LOW_POWER            1 
#define LWM2M_DEVICE_ERROR_EXT_POWER_SUPPLY_OFF 2 
#define LWM2M_DEVICE_ERROR_GPS_FAILURE          3 
#define LWM2M_DEVICE_ERROR_LOW_SIGNAL_STRENGTH  4 
#define LWM2M_DEVICE_ERROR_OUT_OF_MEMORY        5 
#define LWM2M_DEVICE_ERROR_SMS_FAILURE          6 
#define LWM2M_DEVICE_ERROR_NETWORK_FAILURE      7 
#define LWM2M_DEVICE_ERROR_PERIPHERAL_FAILURE   8 
#define LWM2M_DEVICE_BATTERY_STATUS_NORMAL      0 
#define LWM2M_DEVICE_BATTERY_STATUS_CHARGING    1 
#define LWM2M_DEVICE_BATTERY_STATUS_CHARGE_COMP 2 
#define LWM2M_DEVICE_BATTERY_STATUS_DAMAGED     3 
#define LWM2M_DEVICE_BATTERY_STATUS_LOW         4 
#define LWM2M_DEVICE_BATTERY_STATUS_NOT_INST    5 
#define LWM2M_DEVICE_BATTERY_STATUS_UNKNOWN     6 
int lwm2m_device_add_err(uint8_t error_code);
 
 
#define STATE_IDLE              0
#define STATE_DOWNLOADING       1
#define STATE_DOWNLOADED        2
#define STATE_UPDATING          3
 
#define RESULT_DEFAULT          0       
#define RESULT_SUCCESS          1       
#define RESULT_NO_STORAGE       2       
#define RESULT_OUT_OF_MEM       3       
#define RESULT_CONNECTION_LOST  4       
#define RESULT_INTEGRITY_FAILED 5       
#define RESULT_UNSUP_FW         6       
#define RESULT_INVALID_URI      7       
#define RESULT_UPDATE_FAILED    8       
#define RESULT_UNSUP_PROTO      9       
#if defined(CONFIG_LWM2M_FIRMWARE_UPDATE_OBJ_SUPPORT) || defined(__DOXYGEN__)
void lwm2m_firmware_set_write_cb(lwm2m_engine_set_data_cb_t cb);
 
lwm2m_engine_set_data_cb_t lwm2m_firmware_get_write_cb(void);
 
void lwm2m_firmware_set_write_cb_inst(uint16_t obj_inst_id, lwm2m_engine_set_data_cb_t cb);
 
lwm2m_engine_set_data_cb_t lwm2m_firmware_get_write_cb_inst(uint16_t obj_inst_id);
 
void lwm2m_firmware_set_cancel_cb(lwm2m_engine_user_cb_t cb);
 
lwm2m_engine_user_cb_t lwm2m_firmware_get_cancel_cb(void);
 
void lwm2m_firmware_set_cancel_cb_inst(uint16_t obj_inst_id, lwm2m_engine_user_cb_t cb);
 
lwm2m_engine_user_cb_t lwm2m_firmware_get_cancel_cb_inst(uint16_t obj_inst_id);
 
void lwm2m_firmware_set_update_cb(lwm2m_engine_execute_cb_t cb);
 
lwm2m_engine_execute_cb_t lwm2m_firmware_get_update_cb(void);
 
void lwm2m_firmware_set_update_cb_inst(uint16_t obj_inst_id, lwm2m_engine_execute_cb_t cb);
 
lwm2m_engine_execute_cb_t lwm2m_firmware_get_update_cb_inst(uint16_t obj_inst_id);
#endif
 
#if defined(CONFIG_LWM2M_SWMGMT_OBJ_SUPPORT) || defined(__DOXYGEN__)
 
int lwm2m_swmgmt_set_activate_cb(uint16_t obj_inst_id, lwm2m_engine_execute_cb_t cb);
 
int lwm2m_swmgmt_set_deactivate_cb(uint16_t obj_inst_id, lwm2m_engine_execute_cb_t cb);
 
int lwm2m_swmgmt_set_install_package_cb(uint16_t obj_inst_id, lwm2m_engine_execute_cb_t cb);
 
int lwm2m_swmgmt_set_delete_package_cb(uint16_t obj_inst_id, lwm2m_engine_execute_cb_t cb);
 
int lwm2m_swmgmt_set_read_package_version_cb(uint16_t obj_inst_id, lwm2m_engine_get_data_cb_t cb);
 
int lwm2m_swmgmt_set_write_package_cb(uint16_t obj_inst_id, lwm2m_engine_set_data_cb_t cb);
 
int lwm2m_swmgmt_install_completed(uint16_t obj_inst_id, int error_code);
 
#endif
 
#if defined(CONFIG_LWM2M_EVENT_LOG_OBJ_SUPPORT) || defined(__DOXYGEN__)
 
void lwm2m_event_log_set_read_log_data_cb(lwm2m_engine_get_data_cb_t cb);
 
#endif
 
#define LWM2M_OBJLNK_MAX_ID USHRT_MAX
 
struct lwm2m_objlnk {
        uint16_t obj_id;     
        uint16_t obj_inst;   
};
 
int lwm2m_update_observer_min_period(struct lwm2m_ctx *client_ctx,
                                     const struct lwm2m_obj_path *path, uint32_t period_s);
 
int lwm2m_update_observer_max_period(struct lwm2m_ctx *client_ctx,
                                     const struct lwm2m_obj_path *path, uint32_t period_s);
 
int lwm2m_create_object_inst(const struct lwm2m_obj_path *path);
 
int lwm2m_delete_object_inst(const struct lwm2m_obj_path *path);
 
void lwm2m_registry_lock(void);
 
void lwm2m_registry_unlock(void);
 
int lwm2m_set_opaque(const struct lwm2m_obj_path *path, const char *data_ptr, uint16_t data_len);
 
int lwm2m_set_string(const struct lwm2m_obj_path *path, const char *data_ptr);
 
int lwm2m_set_u8(const struct lwm2m_obj_path *path, uint8_t value);
 
int lwm2m_set_u16(const struct lwm2m_obj_path *path, uint16_t value);
 
int lwm2m_set_u32(const struct lwm2m_obj_path *path, uint32_t value);
 
int lwm2m_set_s8(const struct lwm2m_obj_path *path, int8_t value);
 
int lwm2m_set_s16(const struct lwm2m_obj_path *path, int16_t value);
 
int lwm2m_set_s32(const struct lwm2m_obj_path *path, int32_t value);
 
int lwm2m_set_s64(const struct lwm2m_obj_path *path, int64_t value);
 
int lwm2m_set_bool(const struct lwm2m_obj_path *path, bool value);
 
int lwm2m_set_f64(const struct lwm2m_obj_path *path, const double value);
 
int lwm2m_set_objlnk(const struct lwm2m_obj_path *path, const struct lwm2m_objlnk *value);
 
int lwm2m_set_time(const struct lwm2m_obj_path *path, time_t value);
 
struct lwm2m_res_item {
        struct lwm2m_obj_path *path;
        void *value;
        uint16_t size;
};
 
int lwm2m_set_bulk(const struct lwm2m_res_item res_list[], size_t res_list_size);
 
int lwm2m_get_opaque(const struct lwm2m_obj_path *path, void *buf, uint16_t buflen);
 
int lwm2m_get_string(const struct lwm2m_obj_path *path, void *str, uint16_t buflen);
 
int lwm2m_get_u8(const struct lwm2m_obj_path *path, uint8_t *value);
 
int lwm2m_get_u16(const struct lwm2m_obj_path *path, uint16_t *value);
 
int lwm2m_get_u32(const struct lwm2m_obj_path *path, uint32_t *value);
 
int lwm2m_get_s8(const struct lwm2m_obj_path *path, int8_t *value);
 
int lwm2m_get_s16(const struct lwm2m_obj_path *path, int16_t *value);
 
int lwm2m_get_s32(const struct lwm2m_obj_path *path, int32_t *value);
 
int lwm2m_get_s64(const struct lwm2m_obj_path *path, int64_t *value);
 
int lwm2m_get_bool(const struct lwm2m_obj_path *path, bool *value);
 
int lwm2m_get_f64(const struct lwm2m_obj_path *path, double *value);
 
int lwm2m_get_objlnk(const struct lwm2m_obj_path *path, struct lwm2m_objlnk *buf);
 
int lwm2m_get_time(const struct lwm2m_obj_path *path, time_t *buf);
 
int lwm2m_register_read_callback(const struct lwm2m_obj_path *path, lwm2m_engine_get_data_cb_t cb);
 
int lwm2m_register_pre_write_callback(const struct lwm2m_obj_path *path,
                                      lwm2m_engine_get_data_cb_t cb);
 
int lwm2m_register_validate_callback(const struct lwm2m_obj_path *path,
                                     lwm2m_engine_set_data_cb_t cb);
 
int lwm2m_register_post_write_callback(const struct lwm2m_obj_path *path,
                                       lwm2m_engine_set_data_cb_t cb);
 
int lwm2m_register_exec_callback(const struct lwm2m_obj_path *path, lwm2m_engine_execute_cb_t cb);
 
int lwm2m_register_create_callback(uint16_t obj_id,
                                   lwm2m_engine_user_cb_t cb);
 
int lwm2m_register_delete_callback(uint16_t obj_id,
                                          lwm2m_engine_user_cb_t cb);
 
#define LWM2M_RES_DATA_READ_ONLY        0
 
#define LWM2M_RES_DATA_FLAG_RO          BIT(LWM2M_RES_DATA_READ_ONLY)
 
#define LWM2M_HAS_RES_FLAG(res, f)      ((res->data_flags & f) == f)
 
int lwm2m_set_res_buf(const struct lwm2m_obj_path *path, void *buffer_ptr, uint16_t buffer_len,
                      uint16_t data_len, uint8_t data_flags);
 
int lwm2m_set_res_data_len(const struct lwm2m_obj_path *path, uint16_t data_len);
 
int lwm2m_get_res_buf(const struct lwm2m_obj_path *path, void **buffer_ptr, uint16_t *buffer_len,
                      uint16_t *data_len, uint8_t *data_flags);
 
int lwm2m_create_res_inst(const struct lwm2m_obj_path *path);
 
int lwm2m_delete_res_inst(const struct lwm2m_obj_path *path);
 
int lwm2m_update_device_service_period(uint32_t period_ms);
 
bool lwm2m_path_is_observed(const struct lwm2m_obj_path *path);
 
int lwm2m_engine_stop(struct lwm2m_ctx *client_ctx);
 
int lwm2m_engine_start(struct lwm2m_ctx *client_ctx);
 
void lwm2m_acknowledge(struct lwm2m_ctx *client_ctx);
 
/*
 * LwM2M RD client flags, used to configure LwM2M session.
 */
 
#define LWM2M_RD_CLIENT_FLAG_BOOTSTRAP BIT(0)
 
int lwm2m_rd_client_start(struct lwm2m_ctx *client_ctx, const char *ep_name,
                           uint32_t flags, lwm2m_ctx_event_cb_t event_cb,
                           lwm2m_observe_cb_t observe_cb);
 
int lwm2m_rd_client_stop(struct lwm2m_ctx *client_ctx,
                          lwm2m_ctx_event_cb_t event_cb, bool deregister);
 
int lwm2m_engine_pause(void);
 
int lwm2m_engine_resume(void);
 
void lwm2m_rd_client_update(void);
 
#define LWM2M_MAX_PATH_STR_SIZE sizeof("/65535/65535/65535/65535")
 
char *lwm2m_path_log_buf(char *buf, struct lwm2m_obj_path *path);
 
enum lwm2m_send_status {
        LWM2M_SEND_STATUS_SUCCESS,  
        LWM2M_SEND_STATUS_FAILURE,  
        LWM2M_SEND_STATUS_TIMEOUT,  
};
 
typedef void (*lwm2m_send_cb_t)(enum lwm2m_send_status status);
 
int lwm2m_send_cb(struct lwm2m_ctx *ctx, const struct lwm2m_obj_path path_list[],
                          uint8_t path_list_size, lwm2m_send_cb_t reply_cb);
 
struct lwm2m_ctx *lwm2m_rd_client_ctx(void);
 
int lwm2m_enable_cache(const struct lwm2m_obj_path *path, struct lwm2m_time_series_elem *data_cache,
                       size_t cache_len);
 
enum lwm2m_security_mode_e {
        LWM2M_SECURITY_PSK = 0,      
        LWM2M_SECURITY_RAW_PK = 1,   
        LWM2M_SECURITY_CERT = 2,     
        LWM2M_SECURITY_NOSEC = 3,    
        LWM2M_SECURITY_CERT_EST = 4, 
};
 
int lwm2m_security_mode(struct lwm2m_ctx *ctx);
 
int lwm2m_set_default_sockopt(struct lwm2m_ctx *ctx);
 
#ifdef __cplusplus
}
#endif
 
#endif  /* ZEPHYR_INCLUDE_NET_LWM2M_H_ */