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 <zephyr/kernel.h>
#include <zephyr/sys/mutex.h>
#include <zephyr/net/coap.h>
#include <zephyr/net/lwm2m_path.h>
 
/* 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_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_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;  /* 0/1/2/3/4 (4 = resource instance) */
};
 
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 {
        struct sockaddr remote_addr;
 
        struct coap_pending pendings[CONFIG_LWM2M_ENGINE_MAX_PENDING];
        struct coap_reply replies[CONFIG_LWM2M_ENGINE_MAX_REPLIES];
        sys_slist_t pending_sends;
#if defined(CONFIG_LWM2M_QUEUE_MODE_ENABLED)
        sys_slist_t queued_messages;
#endif
        sys_slist_t observer;
 
        void *processed_req;
 
#if defined(CONFIG_LWM2M_DTLS_SUPPORT)
        int tls_tag;
 
        char *desthostname;
        uint16_t desthostnamelen;
        bool hostname_verify;
 
        int (*load_credentials)(struct lwm2m_ctx *client_ctx);
#endif
        bool use_dtls;
 
#if defined(CONFIG_LWM2M_QUEUE_MODE_ENABLED)
        bool connection_suspended;
 
        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;
 
        uint8_t validate_buf[CONFIG_LWM2M_ENGINE_VALIDATION_BUFFER_SIZE];
};
 
 
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);
 
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_UNUSED        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)
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);
 
#if defined(CONFIG_LWM2M_FIRMWARE_UPDATE_PULL_SUPPORT)
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
#endif
 
 
#if defined(CONFIG_LWM2M_SWMGMT_OBJ_SUPPORT)
 
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
 
#define LWM2M_OBJLNK_MAX_ID USHRT_MAX
 
struct lwm2m_objlnk {
        uint16_t obj_id;
        uint16_t obj_inst;
};
 
int lwm2m_engine_update_observer_min_period(struct lwm2m_ctx *client_ctx, const char *pathstr,
                                            uint32_t period_s);
 
int lwm2m_engine_update_observer_max_period(struct lwm2m_ctx *client_ctx, const char *pathstr,
                                            uint32_t period_s);
 
int lwm2m_engine_create_obj_inst(const char *pathstr);
 
int lwm2m_engine_delete_obj_inst(const char *pathstr);
 
int lwm2m_engine_set_opaque(const char *pathstr, char *data_ptr, uint16_t data_len);
 
int lwm2m_engine_set_string(const char *pathstr, char *data_ptr);
 
int lwm2m_engine_set_u8(const char *pathstr, uint8_t value);
 
int lwm2m_engine_set_u16(const char *pathstr, uint16_t value);
 
int lwm2m_engine_set_u32(const char *pathstr, uint32_t value);
 
int lwm2m_engine_set_u64(const char *pathstr, uint64_t value);
 
int lwm2m_engine_set_s8(const char *pathstr, int8_t value);
 
int lwm2m_engine_set_s16(const char *pathstr, int16_t value);
 
int lwm2m_engine_set_s32(const char *pathstr, int32_t value);
 
int lwm2m_engine_set_s64(const char *pathstr, int64_t value);
 
int lwm2m_engine_set_bool(const char *pathstr, bool value);
 
int lwm2m_engine_set_float(const char *pathstr, double *value);
 
int lwm2m_engine_set_objlnk(const char *pathstr, struct lwm2m_objlnk *value);
 
int lwm2m_engine_get_opaque(const char *pathstr, void *buf, uint16_t buflen);
 
int lwm2m_engine_get_string(const char *pathstr, void *str, uint16_t strlen);
 
int lwm2m_engine_get_u8(const char *pathstr, uint8_t *value);
 
int lwm2m_engine_get_u16(const char *pathstr, uint16_t *value);
 
int lwm2m_engine_get_u32(const char *pathstr, uint32_t *value);
 
int lwm2m_engine_get_u64(const char *pathstr, uint64_t *value);
 
int lwm2m_engine_get_s8(const char *pathstr, int8_t *value);
 
int lwm2m_engine_get_s16(const char *pathstr, int16_t *value);
 
int lwm2m_engine_get_s32(const char *pathstr, int32_t *value);
 
int lwm2m_engine_get_s64(const char *pathstr, int64_t *value);
 
int lwm2m_engine_get_bool(const char *pathstr, bool *value);
 
int lwm2m_engine_get_float(const char *pathstr, double *buf);
 
int lwm2m_engine_get_objlnk(const char *pathstr, struct lwm2m_objlnk *buf);
 
 
int lwm2m_engine_register_read_callback(const char *pathstr,
                                        lwm2m_engine_get_data_cb_t cb);
 
int lwm2m_engine_register_pre_write_callback(const char *pathstr,
                                             lwm2m_engine_get_data_cb_t cb);
 
int lwm2m_engine_register_validate_callback(const char *pathstr,
                                            lwm2m_engine_set_data_cb_t cb);
 
int lwm2m_engine_register_post_write_callback(const char *pathstr,
                                              lwm2m_engine_set_data_cb_t cb);
 
int lwm2m_engine_register_exec_callback(const char *pathstr,
                                        lwm2m_engine_execute_cb_t cb);
 
int lwm2m_engine_register_create_callback(uint16_t obj_id,
                                          lwm2m_engine_user_cb_t cb);
 
int lwm2m_engine_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_engine_set_res_data(const char *pathstr, void *data_ptr, uint16_t data_len,
                              uint8_t data_flags);
 
int lwm2m_engine_get_res_data(const char *pathstr, void **data_ptr,
                              uint16_t *data_len, uint8_t *data_flags);
 
int lwm2m_engine_create_res_inst(const char *pathstr);
 
int lwm2m_engine_delete_res_inst(const char *pathstr);
 
int lwm2m_engine_update_service_period(k_work_handler_t service, uint32_t period_ms);
 
int lwm2m_update_device_service_period(uint32_t period_ms);
 
bool lwm2m_engine_path_is_observed(const char *pathstr);
 
int lwm2m_engine_start(struct lwm2m_ctx *client_ctx);
 
void lwm2m_acknowledge(struct lwm2m_ctx *client_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_UPDATE_FAILURE,
        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_NETWORK_ERROR,
};
 
/*
 * LwM2M RD client flags, used to configure LwM2M session.
 */
 
#define LWM2M_RD_CLIENT_FLAG_BOOTSTRAP BIT(0)
 
typedef void (*lwm2m_ctx_event_cb_t)(struct lwm2m_ctx *ctx,
                                     enum lwm2m_rd_client_event event);
 
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);
 
void lwm2m_rd_client_update(void);
 
#define LWM2M_MAX_PATH_STR_LEN sizeof("65535/65535/65535/65535")
 
char *lwm2m_path_log_strdup(char *buf, struct lwm2m_obj_path *path);
 
int lwm2m_engine_send(struct lwm2m_ctx *ctx, char const *path_list[], uint8_t path_list_size,
                      bool confirmation_request);
 
struct lwm2m_ctx *lwm2m_rd_client_ctx(void);
 
#endif  /* ZEPHYR_INCLUDE_NET_LWM2M_H_ */