mqtt.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_MQTT_H_
#define ZEPHYR_INCLUDE_NET_MQTT_H_
 
#include <stddef.h>
 
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <zephyr/net/tls_credentials.h>
#include <zephyr/net/net_ip.h>
#include <zephyr/sys/mutex.h>
#include <zephyr/net/websocket.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum mqtt_evt_type {
        MQTT_EVT_CONNACK,
 
        MQTT_EVT_DISCONNECT,
 
        MQTT_EVT_PUBLISH,
 
        MQTT_EVT_PUBACK,
 
        MQTT_EVT_PUBREC,
 
        MQTT_EVT_PUBREL,
 
        MQTT_EVT_PUBCOMP,
 
        MQTT_EVT_SUBACK,
 
        MQTT_EVT_UNSUBACK,
 
        MQTT_EVT_PINGRESP,
};
 
enum mqtt_version {
        MQTT_VERSION_3_1_0 = 3, 
        MQTT_VERSION_3_1_1 = 4  
};
 
enum mqtt_qos {
        MQTT_QOS_0_AT_MOST_ONCE = 0x00,
 
        MQTT_QOS_1_AT_LEAST_ONCE = 0x01,
 
        MQTT_QOS_2_EXACTLY_ONCE  = 0x02
};
 
enum mqtt_conn_return_code {
        MQTT_CONNECTION_ACCEPTED                = 0x00,
 
        MQTT_UNACCEPTABLE_PROTOCOL_VERSION      = 0x01,
 
        MQTT_IDENTIFIER_REJECTED                = 0x02,
 
        MQTT_SERVER_UNAVAILABLE                 = 0x03,
 
        MQTT_BAD_USER_NAME_OR_PASSWORD          = 0x04,
 
        MQTT_NOT_AUTHORIZED                     = 0x05
};
 
enum mqtt_suback_return_code {
        MQTT_SUBACK_SUCCESS_QoS_0 = 0x00,
 
        MQTT_SUBACK_SUCCESS_QoS_1 = 0x01,
 
        MQTT_SUBACK_SUCCESS_QoS_2 = 0x02,
 
        MQTT_SUBACK_FAILURE = 0x80
};
 
struct mqtt_utf8 {
        const uint8_t *utf8;       
        uint32_t size;             
};
 
#define MQTT_UTF8_LITERAL(literal)                              \
        ((struct mqtt_utf8) {literal, sizeof(literal) - 1})
 
struct mqtt_binstr {
        uint8_t *data;             
        uint32_t len;              
};
 
struct mqtt_topic {
        struct mqtt_utf8 topic;
 
        uint8_t qos;
};
 
struct mqtt_publish_message {
        struct mqtt_topic topic;     
        struct mqtt_binstr payload; 
};
 
struct mqtt_connack_param {
        uint8_t session_present_flag;
 
        enum mqtt_conn_return_code return_code;
};
 
struct mqtt_puback_param {
        uint16_t message_id;
};
 
struct mqtt_pubrec_param {
        uint16_t message_id;
};
 
struct mqtt_pubrel_param {
        uint16_t message_id;
};
 
struct mqtt_pubcomp_param {
        uint16_t message_id;
};
 
struct mqtt_suback_param {
        uint16_t message_id;
        struct mqtt_binstr return_codes;
};
 
struct mqtt_unsuback_param {
        uint16_t message_id;
};
 
struct mqtt_publish_param {
        struct mqtt_publish_message message;
 
        uint16_t message_id;
 
        uint8_t dup_flag : 1;
 
        uint8_t retain_flag : 1;
};
 
struct mqtt_subscription_list {
        struct mqtt_topic *list;
 
        uint16_t list_count;
 
        uint16_t message_id;
};
 
union mqtt_evt_param {
        struct mqtt_connack_param connack;
 
        struct mqtt_publish_param publish;
 
        struct mqtt_puback_param puback;
 
        struct mqtt_pubrec_param pubrec;
 
        struct mqtt_pubrel_param pubrel;
 
        struct mqtt_pubcomp_param pubcomp;
 
        struct mqtt_suback_param suback;
 
        struct mqtt_unsuback_param unsuback;
};
 
struct mqtt_evt {
        enum mqtt_evt_type type;
 
        union mqtt_evt_param param;
 
        int result;
};
 
struct mqtt_client;
 
typedef void (*mqtt_evt_cb_t)(struct mqtt_client *client,
                              const struct mqtt_evt *evt);
 
struct mqtt_sec_config {
        int peer_verify;
 
        uint32_t cipher_count;
 
        const int *cipher_list;
 
        uint32_t sec_tag_count;
 
        const sec_tag_t *sec_tag_list;
 
#if defined(CONFIG_MQTT_LIB_TLS_USE_ALPN)
        const char **alpn_protocol_name_list;
 
        uint32_t alpn_protocol_name_count;
#endif
 
        int session_cache;
 
        const char *hostname;
 
        int cert_nocopy;
 
        bool set_native_tls;
};
 
enum mqtt_transport_type {
        MQTT_TRANSPORT_NON_SECURE,
 
#if defined(CONFIG_MQTT_LIB_TLS)
        MQTT_TRANSPORT_SECURE,
#endif /* CONFIG_MQTT_LIB_TLS */
 
#if defined(CONFIG_MQTT_LIB_WEBSOCKET)
        MQTT_TRANSPORT_NON_SECURE_WEBSOCKET,
#if defined(CONFIG_MQTT_LIB_TLS)
        MQTT_TRANSPORT_SECURE_WEBSOCKET,
#endif
#endif /* CONFIG_MQTT_LIB_WEBSOCKET */
#if defined(CONFIG_MQTT_LIB_CUSTOM_TRANSPORT)
        MQTT_TRANSPORT_CUSTOM,
#endif /* CONFIG_MQTT_LIB_CUSTOM_TRANSPORT */
 
        MQTT_TRANSPORT_NUM
};
 
struct mqtt_transport {
        enum mqtt_transport_type type;
 
        union {
                struct {
                        int sock;
                } tcp;
 
#if defined(CONFIG_MQTT_LIB_TLS)
                struct {
                        int sock;
 
                        struct mqtt_sec_config config;
                } tls;
#endif /* CONFIG_MQTT_LIB_TLS */
        };
 
#if defined(CONFIG_MQTT_LIB_WEBSOCKET)
        struct {
                struct websocket_request config;
 
                int sock;
 
                int32_t timeout;
        } websocket;
#endif
 
#if defined(CONFIG_MQTT_LIB_CUSTOM_TRANSPORT)
        void *custom_transport_data;
#endif /* CONFIG_MQTT_LIB_CUSTOM_TRANSPORT */
 
#if defined(CONFIG_SOCKS)
        struct {
                struct sockaddr addr;
                socklen_t addrlen;
        } proxy;
#endif
};
 
struct mqtt_internal {
        struct sys_mutex mutex;
 
        uint32_t last_activity;
 
        uint32_t state;
 
        uint32_t rx_buf_datalen;
 
        uint32_t remaining_payload;
};
 
struct mqtt_client {
        struct mqtt_internal internal;
 
        struct mqtt_transport transport;
 
        struct mqtt_utf8 client_id;
 
        const void *broker;
 
        struct mqtt_utf8 *user_name;
 
        struct mqtt_utf8 *password;
 
        struct mqtt_topic *will_topic;
 
        struct mqtt_utf8 *will_message;
 
        mqtt_evt_cb_t evt_cb;
 
        uint8_t *rx_buf;
 
        uint32_t rx_buf_size;
 
        uint8_t *tx_buf;
 
        uint32_t tx_buf_size;
 
        uint16_t keepalive;
 
        uint8_t protocol_version;
 
        int8_t unacked_ping;
 
        uint8_t will_retain : 1;
 
        uint8_t clean_session : 1;
 
        void *user_data;
};
 
void mqtt_client_init(struct mqtt_client *client);
 
#if defined(CONFIG_SOCKS)
/*
 * @brief Set proxy server details
 *
 * @param[in] client Client instance for which the procedure is requested,
 *                   Shall not be NULL.
 * @param[in] proxy_addr Proxy server address.
 * @param[in] addrlen Proxy server address length.
 *
 * @return 0 or a negative error code (errno.h) indicating reason of failure.
 *
 * @note Must be called before calling mqtt_connect().
 */
int mqtt_client_set_proxy(struct mqtt_client *client,
                          struct sockaddr *proxy_addr,
                          socklen_t addrlen);
#endif
 
int mqtt_connect(struct mqtt_client *client);
 
int mqtt_publish(struct mqtt_client *client,
                 const struct mqtt_publish_param *param);
 
int mqtt_publish_qos1_ack(struct mqtt_client *client,
                          const struct mqtt_puback_param *param);
 
int mqtt_publish_qos2_receive(struct mqtt_client *client,
                              const struct mqtt_pubrec_param *param);
 
int mqtt_publish_qos2_release(struct mqtt_client *client,
                              const struct mqtt_pubrel_param *param);
 
int mqtt_publish_qos2_complete(struct mqtt_client *client,
                               const struct mqtt_pubcomp_param *param);
 
int mqtt_subscribe(struct mqtt_client *client,
                   const struct mqtt_subscription_list *param);
 
int mqtt_unsubscribe(struct mqtt_client *client,
                     const struct mqtt_subscription_list *param);
 
int mqtt_ping(struct mqtt_client *client);
 
int mqtt_disconnect(struct mqtt_client *client);
 
int mqtt_abort(struct mqtt_client *client);
 
int mqtt_live(struct mqtt_client *client);
 
int mqtt_keepalive_time_left(const struct mqtt_client *client);
 
int mqtt_input(struct mqtt_client *client);
 
int mqtt_read_publish_payload(struct mqtt_client *client, void *buffer,
                              size_t length);
 
int mqtt_read_publish_payload_blocking(struct mqtt_client *client, void *buffer,
                                       size_t length);
 
int mqtt_readall_publish_payload(struct mqtt_client *client, uint8_t *buffer,
                                 size_t length);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_MQTT_H_ */