mqtt_client.h

Go to the documentation of this file.

 
#ifndef _MQTT_CLIENT_H
#define _MQTT_CLIENT_H
 
//Dependencies
#include "core/net.h"
#include "mqtt/mqtt_common.h"
 
//MQTT client support
#ifndef MQTT_CLIENT_SUPPORT
   #define MQTT_CLIENT_SUPPORT ENABLED
#elif (MQTT_CLIENT_SUPPORT != ENABLED && MQTT_CLIENT_SUPPORT != DISABLED)
   #error MQTT_CLIENT_SUPPORT parameter is not valid
#endif
 
//MQTT over TLS
#ifndef MQTT_CLIENT_TLS_SUPPORT
   #define MQTT_CLIENT_TLS_SUPPORT DISABLED
#elif (MQTT_CLIENT_TLS_SUPPORT != ENABLED && MQTT_CLIENT_TLS_SUPPORT != DISABLED)
   #error MQTT_CLIENT_TLS_SUPPORT parameter is not valid
#endif
 
//MQTT over WebSocket
#ifndef MQTT_CLIENT_WS_SUPPORT
   #define MQTT_CLIENT_WS_SUPPORT DISABLED
#elif (MQTT_CLIENT_WS_SUPPORT != ENABLED && MQTT_CLIENT_WS_SUPPORT != DISABLED)
   #error MQTT_CLIENT_WS_SUPPORT parameter is not valid
#endif
 
//Default keep-alive time interval, in seconds
#ifndef MQTT_CLIENT_DEFAULT_KEEP_ALIVE
   #define MQTT_CLIENT_DEFAULT_KEEP_ALIVE 0
#elif (MQTT_CLIENT_DEFAULT_KEEP_ALIVE < 0)
   #error MQTT_CLIENT_DEFAULT_KEEP_ALIVE parameter is not valid
#endif
 
//Default communication timeout, in milliseconds
#ifndef MQTT_CLIENT_DEFAULT_TIMEOUT
   #define MQTT_CLIENT_DEFAULT_TIMEOUT 20000
#elif (MQTT_CLIENT_DEFAULT_TIMEOUT < 0)
   #error MQTT_CLIENT_DEFAULT_TIMEOUT parameter is not valid
#endif
 
//Maximum length of the hostname
#ifndef MQTT_CLIENT_MAX_HOST_LEN
   #define MQTT_CLIENT_MAX_HOST_LEN 32
#elif (MQTT_CLIENT_MAX_HOST_LEN < 1)
   #error MQTT_CLIENT_MAX_HOST_LEN parameter is not valid
#endif
 
//Maximum length of the resource name
#ifndef MQTT_CLIENT_MAX_URI_LEN
   #define MQTT_CLIENT_MAX_URI_LEN 16
#elif (MQTT_CLIENT_MAX_URI_LEN < 1)
   #error MQTT_CLIENT_MAX_URI_LEN parameter is not valid
#endif
 
//Maximum length of the client identifier
#ifndef MQTT_CLIENT_MAX_ID_LEN
   #define MQTT_CLIENT_MAX_ID_LEN 23
#elif (MQTT_CLIENT_MAX_ID_LEN < 0)
   #error MQTT_CLIENT_MAX_ID_LEN parameter is not valid
#endif
 
//Maximum length of the user name
#ifndef MQTT_CLIENT_MAX_USERNAME_LEN
   #define MQTT_CLIENT_MAX_USERNAME_LEN 16
#elif (MQTT_CLIENT_MAX_USERNAME_LEN < 0)
   #error MQTT_CLIENT_MAX_USERNAME_LEN parameter is not valid
#endif
 
//Maximum length of the password
#ifndef MQTT_CLIENT_MAX_PASSWORD_LEN
   #define MQTT_CLIENT_MAX_PASSWORD_LEN 16
#elif (MQTT_CLIENT_MAX_PASSWORD_LEN < 0)
   #error MQTT_CLIENT_MAX_PASSWORD_LEN parameter is not valid
#endif
 
//Maximum length of the will topic
#ifndef MQTT_CLIENT_MAX_WILL_TOPIC_LEN
   #define MQTT_CLIENT_MAX_WILL_TOPIC_LEN 16
#elif (MQTT_CLIENT_MAX_WILL_TOPIC_LEN < 0)
   #error MQTT_CLIENT_MAX_WILL_TOPIC_LEN parameter is not valid
#endif
 
//Maximum length of the will message payload
#ifndef MQTT_CLIENT_MAX_WILL_PAYLOAD_LEN
   #define MQTT_CLIENT_MAX_WILL_PAYLOAD_LEN 16
#elif (MQTT_CLIENT_MAX_WILL_PAYLOAD_LEN < 0)
   #error MQTT_CLIENT_MAX_WILL_PAYLOAD_LEN parameter is not valid
#endif
 
//Size of the MQTT client buffer
#ifndef MQTT_CLIENT_BUFFER_SIZE
   #define MQTT_CLIENT_BUFFER_SIZE 1024
#elif (MQTT_CLIENT_BUFFER_SIZE < 1)
   #error MQTT_CLIENT_BUFFER_SIZE parameter is not valid
#endif
 
//Application specific context
#ifndef MQTT_CLIENT_PRIVATE_CONTEXT
   #define MQTT_CLIENT_PRIVATE_CONTEXT
#endif
 
//TLS supported?
#if (MQTT_CLIENT_TLS_SUPPORT == ENABLED)
   #include "core/crypto.h"
   #include "tls.h"
#endif
 
//WebSocket supported?
#if (MQTT_CLIENT_WS_SUPPORT == ENABLED)
   #include "web_socket/web_socket.h"
#endif
 
//Forward declaration of MqttClientContext structure
struct _MqttClientContext;
#define MqttClientContext struct _MqttClientContext
 
//C++ guard
#ifdef __cplusplus
extern "C" {
#endif
 
 
typedef enum
{
   MQTT_CLIENT_STATE_DISCONNECTED        = 0,
   MQTT_CLIENT_STATE_CONNECTING          = 1,
   MQTT_CLIENT_STATE_CONNECTED           = 2,
   MQTT_CLIENT_STATE_IDLE                = 3,
   MQTT_CLIENT_STATE_SENDING_PACKET      = 4,
   MQTT_CLIENT_STATE_PACKET_SENT         = 5,
   MQTT_CLIENT_STATE_WAITING_PACKET      = 6,
   MQTT_CLIENT_STATE_RECEIVING_PACKET    = 7,
   MQTT_CLIENT_STATE_PACKET_RECEIVED     = 8,
   MQTT_CLIENT_STATE_DISCONNECTING       = 9
} MqttClientState;
 
 
typedef void (*MqttClientConnAckCallback)(MqttClientContext *context,
   uint8_t connectAckFlags, uint8_t connectReturnCode);
 
 
typedef void (*MqttClientPublishCallback)(MqttClientContext *context,
   const char_t *topic, const uint8_t *message, size_t length,
   bool_t dup, MqttQosLevel qos, bool_t retain, uint16_t packetId);
 
 
typedef void (*MqttClientPubAckCallback)(MqttClientContext *context,
   uint16_t packetId);
 
 
typedef void (*MqttClientPubRecCallback)(MqttClientContext *context,
   uint16_t packetId);
 
 
typedef void (*MqttClientPubRelCallback)(MqttClientContext *context,
   uint16_t packetId);
 
 
typedef void (*MqttClientPubCompCallback)(MqttClientContext *context,
   uint16_t packetId);
 
 
typedef void (*MqttClientSubAckCallback)(MqttClientContext *context,
   uint16_t packetId);
 
 
typedef void (*MqttClientUnsubAckCallback)(MqttClientContext *context,
   uint16_t packetId);
 
 
typedef void (*MqttClientPingRespCallback)(MqttClientContext *context);
 
 
//TLS supported?
#if (MQTT_CLIENT_TLS_SUPPORT == ENABLED)
 
typedef error_t (*MqttClientTlsInitCallback)(MqttClientContext *context,
   TlsContext *tlsContext);
 
#endif
 
 
typedef struct
{
   char_t topic[MQTT_CLIENT_MAX_WILL_TOPIC_LEN + 1];  
   uint8_t payload[MQTT_CLIENT_MAX_WILL_PAYLOAD_LEN]; 
   size_t length;                                     
   MqttQosLevel qos;                                  
   bool_t retain;                                     
} MqttClientWillMessage;
 
 
typedef struct
{
   MqttClientConnAckCallback connAckCallback;   
   MqttClientPublishCallback publishCallback;   
   MqttClientPubAckCallback pubAckCallback;     
   MqttClientPubAckCallback pubRecCallback;     
   MqttClientPubAckCallback pubRelCallback;     
   MqttClientPubAckCallback pubCompCallback;    
   MqttClientPubAckCallback subAckCallback;     
   MqttClientPubAckCallback unsubAckCallback;   
   MqttClientPingRespCallback pingRespCallback; 
#if (MQTT_CLIENT_TLS_SUPPORT == ENABLED)
   MqttClientTlsInitCallback tlsInitCallback;   
#endif
} MqttClientCallbacks;
 
 
typedef struct
{
   MqttVersion version;                               
   MqttTransportProtocol transportProtocol;           
   uint16_t keepAlive;                                
   systime_t timeout;                                 
#if (MQTT_CLIENT_WS_SUPPORT == ENABLED)
   char_t host[MQTT_CLIENT_MAX_HOST_LEN + 1];         
   char_t uri[MQTT_CLIENT_MAX_URI_LEN + 1];           
#endif
   char_t clientId[MQTT_CLIENT_MAX_ID_LEN + 1];       
   char_t username[MQTT_CLIENT_MAX_USERNAME_LEN + 1]; 
   char_t password[MQTT_CLIENT_MAX_PASSWORD_LEN + 1]; 
   MqttClientWillMessage willMessage;                 
} MqttClientSettings;
 
 
struct _MqttClientContext
{
   MqttClientSettings settings;             
   MqttClientCallbacks callbacks;           
   MqttClientState state;                   
   NetInterface *interface;                 
   Socket *socket;                          
#if (MQTT_CLIENT_TLS_SUPPORT == ENABLED)
   TlsContext *tlsContext;                  
   TlsSessionState tlsSession;              
#endif
#if (MQTT_CLIENT_WS_SUPPORT == ENABLED)
   WebSocket *webSocket;                    
#endif
   systime_t startTime;                     
   systime_t keepAliveTimestamp;            
   uint8_t buffer[MQTT_CLIENT_BUFFER_SIZE]; 
   uint8_t *packet;                         
   size_t packetPos;                        
   size_t packetLen;                        
   MqttPacketType packetType;               
   uint16_t packetId;                       
   size_t remainingLen;                     
   MQTT_CLIENT_PRIVATE_CONTEXT              
};
 
 
//MQTT client related functions
error_t mqttClientInit(MqttClientContext *context);
void mqttClientInitCallbacks(MqttClientCallbacks *callbacks);
 
error_t mqttClientRegisterCallbacks(MqttClientContext *context,
   const MqttClientCallbacks *callbacks);
 
error_t mqttClientSetVersion(MqttClientContext *context, MqttVersion version);
 
error_t mqttClientSetTransportProtocol(MqttClientContext *context,
   MqttTransportProtocol transportProtocol);
 
#if (MQTT_CLIENT_TLS_SUPPORT == ENABLED)
 
error_t mqttClientRegisterTlsInitCallback(MqttClientContext *context,
   MqttClientTlsInitCallback callback);
 
#endif
 
error_t mqttClientRegisterPublishCallback(MqttClientContext *context,
   MqttClientPublishCallback callback);
 
error_t mqttClientSetTimeout(MqttClientContext *context, systime_t timeout);
error_t mqttClientSetKeepAlive(MqttClientContext *context, uint16_t keepAlive);
 
error_t mqttClientSetHost(MqttClientContext *context, const char_t *host);
error_t mqttClientSetUri(MqttClientContext *context, const char_t *uri);
 
error_t mqttClientSetIdentifier(MqttClientContext *context,
   const char_t *clientId);
 
error_t mqttClientSetAuthInfo(MqttClientContext *context,
   const char_t *username, const char_t *password);
 
error_t mqttClientSetWillMessage(MqttClientContext *context, const char_t *topic,
   const void *message, size_t length, MqttQosLevel qos, bool_t retain);
 
error_t mqttClientBindToInterface(MqttClientContext *context,
   NetInterface *interface);
 
error_t mqttClientConnect(MqttClientContext *context,
   const IpAddr *serverIpAddr, uint16_t serverPort, bool_t cleanSession);
 
error_t mqttClientPublish(MqttClientContext *context,
   const char_t *topic, const void *message, size_t length,
   MqttQosLevel qos, bool_t retain, uint16_t *packetId);
 
error_t mqttClientSubscribe(MqttClientContext *context,
   const char_t *topic, MqttQosLevel qos, uint16_t *packetId);
 
error_t mqttClientUnsubscribe(MqttClientContext *context,
   const char_t *topic, uint16_t *packetId);
 
error_t mqttClientPing(MqttClientContext *context, systime_t *rtt);
 
error_t mqttClientTask(MqttClientContext *context, systime_t timeout);
 
error_t mqttClientDisconnect(MqttClientContext *context);
error_t mqttClientClose(MqttClientContext *context);
 
void mqttClientDeinit(MqttClientContext *context);
 
//Deprecated functions
error_t mqttClientProcessEvents(MqttClientContext *context, systime_t timeout);
 
//C++ guard
#ifdef __cplusplus
}
#endif
 
#endif