MQTTAsync.c File Reference

Asynchronous API implementation. More...

#include <stdlib.h>
#include <sys/time.h>
#include "MQTTPersistence.h"
#include "MQTTAsync.h"
#include "utf-8.h"
#include "MQTTProtocol.h"
#include "MQTTProtocolOut.h"
#include "Thread.h"
#include "SocketBuffer.h"
#include "StackTrace.h"
#include "Heap.h"
#include "VersionInfo.h"
Include dependency graph for MQTTAsync.c:

Data Structures

struct  qEntry
struct  MQTTAsync_command
struct  MQTTAsync_struct
struct  MQTTAsync_queuedCommand

Defines

#define _GNU_SOURCE
#define URI_TCP   "tcp://"
#define WINAPI
#define START_TIME_TYPE   struct timeval
#define MAX_INFO_STRINGS   8

Typedefs

typedef struct MQTTAsync_struct MQTTAsyncs

Enumerations

enum  MQTTAsync_threadStates { STOPPED, STARTING, RUNNING, STOPPING }

Functions

void MQTTAsync_global_init (MQTTAsync_init_options *inits)
 Global init of mqtt library.
void MQTTAsync_init (void)
START_TIME_TYPE MQTTAsync_start_clock (void)
long MQTTAsync_elapsed (struct timeval start)
static int clientSockCompare (void *a, void *b)
 List callback function for comparing clients by socket.
static void MQTTAsync_lock_mutex (mutex_type amutex)
static void MQTTAsync_unlock_mutex (mutex_type amutex)
static int MQTTAsync_checkConn (MQTTAsync_command *command, MQTTAsyncs *client)
static void MQTTAsync_terminate (void)
static int MQTTAsync_unpersistCommand (MQTTAsync_queuedCommand *qcmd)
static int MQTTAsync_persistCommand (MQTTAsync_queuedCommand *qcmd)
static MQTTAsync_queuedCommandMQTTAsync_restoreCommand (char *buffer, int buflen)
static int MQTTAsync_restoreCommands (MQTTAsyncs *client)
static int MQTTAsync_addCommand (MQTTAsync_queuedCommand *command, int command_size)
static void MQTTAsync_startConnectRetry (MQTTAsyncs *m)
static void MQTTAsync_checkDisconnect (MQTTAsync handle, MQTTAsync_command *command)
static void MQTTProtocol_checkPendingWrites (void)
 See if any pending writes have been completed, and cleanup if so.
static void MQTTAsync_freeServerURIs (MQTTAsyncs *m)
static void MQTTAsync_freeCommand1 (MQTTAsync_queuedCommand *command)
static void MQTTAsync_freeCommand (MQTTAsync_queuedCommand *command)
static void MQTTAsync_writeComplete (int socket)
static int MQTTAsync_processCommand (void)
static void MQTTAsync_checkTimeouts (void)
static thread_return_type WINAPI MQTTAsync_sendThread (void *n)
static void MQTTAsync_emptyMessageQueue (Clients *client)
static void MQTTAsync_removeResponsesAndCommands (MQTTAsyncs *m)
static int MQTTAsync_completeConnection (MQTTAsyncs *m, MQTTPacket *pack)
static thread_return_type WINAPI MQTTAsync_receiveThread (void *n)
static void MQTTAsync_stop (void)
static void MQTTAsync_closeOnly (Clients *client)
static void MQTTAsync_closeSession (Clients *client)
static int clientStructCompare (void *a, void *b)
 List callback function for comparing clients by client structure.
static int MQTTAsync_cleanSession (Clients *client)
static int MQTTAsync_deliverMessage (MQTTAsyncs *m, char *topicName, size_t topicLen, MQTTAsync_message *mm)
static int MQTTAsync_disconnect1 (MQTTAsync handle, const MQTTAsync_disconnectOptions *options, int internal)
static int MQTTAsync_disconnect_internal (MQTTAsync handle, int timeout)
static int cmdMessageIDCompare (void *a, void *b)
static int MQTTAsync_assignMsgId (MQTTAsyncs *m)
 Assign a new message id for a client.
static int MQTTAsync_countBufferedMessages (MQTTAsyncs *m)
static void MQTTAsync_retry (void)
static int MQTTAsync_connecting (MQTTAsyncs *m)
static MQTTPacketMQTTAsync_cycle (int *sock, unsigned long timeout, int *rc)
void MQTTAsync_sleep (long milliseconds)
int MQTTAsync_createWithOptions (MQTTAsync *handle, const char *serverURI, const char *clientId, int persistence_type, void *persistence_context, MQTTAsync_createOptions *options)
int MQTTAsync_create (MQTTAsync *handle, const char *serverURI, const char *clientId, int persistence_type, void *persistence_context)
 This function creates an MQTT client ready for connection to the specified server and using the specified persistent storage (see MQTTAsync_persistence).
int MQTTAsync_reconnect (MQTTAsync handle)
 Reconnects a client with the previously used connect options.
static void nextOrClose (MQTTAsyncs *m, int rc, char *message)
void MQTTAsync_destroy (MQTTAsync *handle)
 This function frees the memory allocated to an MQTT client (see MQTTAsync_create()).
void MQTTAsync_freeMessage (MQTTAsync_message **message)
 This function frees memory allocated to an MQTT message, including the additional memory allocated to the message payload.
void MQTTAsync_free (void *memory)
 This function frees memory allocated by the MQTT C client library, especially the topic name.
int MQTTAsync_setCallbacks (MQTTAsync handle, void *context, MQTTAsync_connectionLost *cl, MQTTAsync_messageArrived *ma, MQTTAsync_deliveryComplete *dc)
 This function sets the global callback functions for a specific client.
int MQTTAsync_setConnected (MQTTAsync handle, void *context, MQTTAsync_connected *connected)
 Sets the MQTTAsync_connected() callback function for a client.
void Protocol_processPublication (Publish *publish, Clients *client)
static void setRetryLoopInterval (int keepalive)
int MQTTAsync_connect (MQTTAsync handle, const MQTTAsync_connectOptions *options)
 This function attempts to connect a previously-created client (see MQTTAsync_create()) to an MQTT server using the specified options.
void MQTTProtocol_closeSession (Clients *c, int sendwill)
int MQTTAsync_disconnect (MQTTAsync handle, const MQTTAsync_disconnectOptions *options)
 This function attempts to disconnect the client from the MQTT server.
int MQTTAsync_isConnected (MQTTAsync handle)
 This function allows the client application to test whether or not a client is currently connected to the MQTT server.
int MQTTAsync_subscribeMany (MQTTAsync handle, int count, char *const *topic, int *qos, MQTTAsync_responseOptions *response)
 This function attempts to subscribe a client to a list of topics, which may contain wildcards (see wildcard).
int MQTTAsync_subscribe (MQTTAsync handle, const char *topic, int qos, MQTTAsync_responseOptions *response)
 This function attempts to subscribe a client to a single topic, which may contain wildcards (see wildcard).
int MQTTAsync_unsubscribeMany (MQTTAsync handle, int count, char *const *topic, MQTTAsync_responseOptions *response)
 This function attempts to remove existing subscriptions to a list of topics made by the specified client.
int MQTTAsync_unsubscribe (MQTTAsync handle, const char *topic, MQTTAsync_responseOptions *response)
 This function attempts to remove an existing subscription made by the specified client.
int MQTTAsync_send (MQTTAsync handle, const char *destinationName, int payloadlen, void *payload, int qos, int retained, MQTTAsync_responseOptions *response)
 This function attempts to publish a message to a given topic (see also MQTTAsync_sendMessage()).
int MQTTAsync_sendMessage (MQTTAsync handle, const char *destinationName, const MQTTAsync_message *message, MQTTAsync_responseOptions *response)
 This function attempts to publish a message to a given topic (see also MQTTAsync_publish()).
int MQTTAsync_getPendingTokens (MQTTAsync handle, MQTTAsync_token **tokens)
 This function sets a pointer to an array of tokens for messages that are currently in-flight (pending completion).
int MQTTAsync_isComplete (MQTTAsync handle, MQTTAsync_token dt)
int MQTTAsync_waitForCompletion (MQTTAsync handle, MQTTAsync_token dt, unsigned long timeout)
 Waits for a request corresponding to a token to complete.
void MQTTAsync_setTraceLevel (enum MQTTASYNC_TRACE_LEVELS level)
 This function sets the level of trace information which will be returned in the trace callback.
void MQTTAsync_setTraceCallback (MQTTAsync_traceCallback *callback)
 This function sets the trace callback if needed.
MQTTAsync_nameValueMQTTAsync_getVersionInfo (void)
 This function returns version information about the library.

Variables

const char * client_timestamp_eye = "MQTTAsyncV3_Timestamp " BUILD_TIMESTAMP
const char * client_version_eye = "MQTTAsyncV3_Version " CLIENT_VERSION
static ClientStates ClientState
ClientStatesbstate = &ClientState
MQTTProtocol state
enum MQTTAsync_threadStates sendThread_state = STOPPED
enum MQTTAsync_threadStates receiveThread_state = STOPPED
static thread_id_type sendThread_id = 0
static thread_id_type receiveThread_id = 0
static pthread_mutex_t mqttasync_mutex_store = PTHREAD_MUTEX_INITIALIZER
static mutex_type mqttasync_mutex = &mqttasync_mutex_store
static pthread_mutex_t socket_mutex_store = PTHREAD_MUTEX_INITIALIZER
static mutex_type socket_mutex = &socket_mutex_store
static pthread_mutex_t mqttcommand_mutex_store = PTHREAD_MUTEX_INITIALIZER
static mutex_type mqttcommand_mutex = &mqttcommand_mutex_store
static cond_type_struct send_cond_store = { PTHREAD_COND_INITIALIZER, PTHREAD_MUTEX_INITIALIZER }
static cond_type send_cond = &send_cond_store
static volatile int initialized = 0
static Listhandles = NULL
static int tostop = 0
static Listcommands = NULL
static int retryLoopInterval = 5

Detailed Description

Asynchronous API implementation.


Function Documentation

static int clientSockCompare ( void *  a,
void *  b 
) [static]

List callback function for comparing clients by socket.

Parameters:
a first integer value
b second integer value
Returns:
boolean indicating whether a and b are equal
static int clientStructCompare ( void *  a,
void *  b 
) [static]

List callback function for comparing clients by client structure.

Parameters:
a Async structure
b Client structure
Returns:
boolean indicating whether a and b are equal
static int MQTTAsync_assignMsgId ( MQTTAsyncs m  )  [static]

Assign a new message id for a client.

Make sure it isn't already being used and does not exceed the maximum.

Parameters:
m a client structure
Returns:
the next message id to use, or 0 if none available

Here is the call graph for this function:

int MQTTAsync_connect ( MQTTAsync  handle,
const MQTTAsync_connectOptions options 
)

This function attempts to connect a previously-created client (see MQTTAsync_create()) to an MQTT server using the specified options.

If you want to enable asynchronous message and status notifications, you must call MQTTAsync_setCallbacks() prior to MQTTAsync_connect().

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
options A pointer to a valid MQTTAsync_connectOptions structure.
Returns:
MQTTASYNC_SUCCESS if the client connect request was accepted. If the client was unable to connect to the server, an error code is returned via the onFailure callback, if set. Error codes greater than 0 are returned by the MQTT protocol:

1: Connection refused: Unacceptable protocol version
2: Connection refused: Identifier rejected
3: Connection refused: Server unavailable
4: Connection refused: Bad user name or password
5: Connection refused: Not authorized
6-255: Reserved for future use

Here is the call graph for this function:

int MQTTAsync_create ( MQTTAsync *  handle,
const char *  serverURI,
const char *  clientId,
int  persistence_type,
void *  persistence_context 
)

This function creates an MQTT client ready for connection to the specified server and using the specified persistent storage (see MQTTAsync_persistence).

See also MQTTAsync_destroy().

Parameters:
handle A pointer to an MQTTAsync handle. The handle is populated with a valid client reference following a successful return from this function.
serverURI A null-terminated string specifying the server to which the client will connect. It takes the form protocol://host:port. protocol must be tcp or ssl. For host, you can specify either an IP address or a host name. For instance, to connect to a server running on the local machines with the default MQTT port, specify tcp://localhost:1883.
clientId The client identifier passed to the server when the client connects to it. It is a null-terminated UTF-8 encoded string.
persistence_type The type of persistence to be used by the client:
MQTTCLIENT_PERSISTENCE_NONE: Use in-memory persistence. If the device or system on which the client is running fails or is switched off, the current state of any in-flight messages is lost and some messages may not be delivered even at QoS1 and QoS2.
MQTTCLIENT_PERSISTENCE_DEFAULT: Use the default (file system-based) persistence mechanism. Status about in-flight messages is held in persistent storage and provides some protection against message loss in the case of unexpected failure.
MQTTCLIENT_PERSISTENCE_USER: Use an application-specific persistence implementation. Using this type of persistence gives control of the persistence mechanism to the application. The application has to implement the MQTTClient_persistence interface.
persistence_context If the application uses MQTTCLIENT_PERSISTENCE_NONE persistence, this argument is unused and should be set to NULL. For MQTTCLIENT_PERSISTENCE_DEFAULT persistence, it should be set to the location of the persistence directory (if set to NULL, the persistence directory used is the working directory). Applications that use MQTTCLIENT_PERSISTENCE_USER persistence set this argument to point to a valid MQTTClient_persistence structure.
Returns:
MQTTASYNC_SUCCESS if the client is successfully created, otherwise an error code is returned.
void MQTTAsync_destroy ( MQTTAsync *  handle  ) 

This function frees the memory allocated to an MQTT client (see MQTTAsync_create()).

It should be called when the client is no longer required.

Parameters:
handle A pointer to the handle referring to the MQTTAsync structure to be freed.

Here is the call graph for this function:

int MQTTAsync_disconnect ( MQTTAsync  handle,
const MQTTAsync_disconnectOptions options 
)

This function attempts to disconnect the client from the MQTT server.

In order to allow the client time to complete handling of messages that are in-flight when this function is called, a timeout period is specified. When the timeout period has expired, the client disconnects even if there are still outstanding message acknowledgements. The next time the client connects to the same server, any QoS 1 or 2 messages which have not completed will be retried depending on the cleansession settings for both the previous and the new connection (see MQTTAsync_connectOptions.cleansession and MQTTAsync_connect()).

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
options The client delays disconnection for up to this time (in milliseconds) in order to allow in-flight message transfers to complete.
Returns:
MQTTASYNC_SUCCESS if the client successfully disconnects from the server. An error code is returned if the client was unable to disconnect from the server
void MQTTAsync_free ( void *  ptr  ) 

This function frees memory allocated by the MQTT C client library, especially the topic name.

This is needed on Windows when the client libary and application program have been compiled with different versions of the C compiler. It is thus good policy to always use this function when freeing any MQTT C client- allocated memory.

Parameters:
ptr The pointer to the client library storage to be freed.
void MQTTAsync_freeMessage ( MQTTAsync_message **  msg  ) 

This function frees memory allocated to an MQTT message, including the additional memory allocated to the message payload.

The client application calls this function when the message has been fully processed. Important note: This function does not free the memory allocated to a message topic string. It is the responsibility of the client application to free this memory using the MQTTAsync_free() library function.

Parameters:
msg The address of a pointer to the MQTTAsync_message structure to be freed.
int MQTTAsync_getPendingTokens ( MQTTAsync  handle,
MQTTAsync_token **  tokens 
)

This function sets a pointer to an array of tokens for messages that are currently in-flight (pending completion).

Important note: The memory used to hold the array of tokens is malloc()'d in this function. The client application is responsible for freeing this memory when it is no longer required.

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
tokens The address of a pointer to an MQTTAsync_token. When the function returns successfully, the pointer is set to point to an array of tokens representing messages pending completion. The last member of the array is set to -1 to indicate there are no more tokens. If no tokens are pending, the pointer is set to NULL.
Returns:
MQTTASYNC_SUCCESS if the function returns successfully. An error code is returned if there was a problem obtaining the list of pending tokens.

Here is the call graph for this function:

MQTTAsync_nameValue* MQTTAsync_getVersionInfo ( void   ) 

This function returns version information about the library.

no trace information will be returned. The default trace level is MQTTASYNC_TRACE_MINIMUM

Returns:
an array of strings describing the library. The last entry is a NULL pointer.
void MQTTAsync_global_init ( MQTTAsync_init_options inits  ) 

Global init of mqtt library.

Call once on program start to set global behaviour. handle_openssl_init - if mqtt library should handle openssl init (1) or rely on the caller to init it before using mqtt (0)

int MQTTAsync_isConnected ( MQTTAsync  handle  ) 

This function allows the client application to test whether or not a client is currently connected to the MQTT server.

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
Returns:
Boolean true if the client is connected, otherwise false.
int MQTTAsync_reconnect ( MQTTAsync  handle  ) 

Reconnects a client with the previously used connect options.

Connect must have previously been called for this to work.

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
Returns:
MQTTASYNC_SUCCESS if the callbacks were correctly set, MQTTASYNC_FAILURE if an error occurred.
int MQTTAsync_send ( MQTTAsync  handle,
const char *  destinationName,
int  payloadlen,
void *  payload,
int  qos,
int  retained,
MQTTAsync_responseOptions response 
)

This function attempts to publish a message to a given topic (see also MQTTAsync_sendMessage()).

An MQTTAsync_token is issued when this function returns successfully. If the client application needs to test for successful delivery of messages, a callback should be set (see MQTTAsync_onSuccess() and MQTTAsync_deliveryComplete()).

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
destinationName The topic associated with this message.
payloadlen The length of the payload in bytes.
payload A pointer to the byte array payload of the message.
qos The qos of the message.
retained The retained flag for the message.
response A pointer to an MQTTAsync_responseOptions structure. Used to set callback functions. This is optional and can be set to NULL.
Returns:
MQTTASYNC_SUCCESS if the message is accepted for publication. An error code is returned if there was a problem accepting the message.

Here is the call graph for this function:

int MQTTAsync_sendMessage ( MQTTAsync  handle,
const char *  destinationName,
const MQTTAsync_message msg,
MQTTAsync_responseOptions response 
)

This function attempts to publish a message to a given topic (see also MQTTAsync_publish()).

An MQTTAsync_token is issued when this function returns successfully. If the client application needs to test for successful delivery of messages, a callback should be set (see MQTTAsync_onSuccess() and MQTTAsync_deliveryComplete()).

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
destinationName The topic associated with this message.
msg A pointer to a valid MQTTAsync_message structure containing the payload and attributes of the message to be published.
response A pointer to an MQTTAsync_responseOptions structure. Used to set callback functions.
Returns:
MQTTASYNC_SUCCESS if the message is accepted for publication. An error code is returned if there was a problem accepting the message.

Here is the call graph for this function:

int MQTTAsync_setCallbacks ( MQTTAsync  handle,
void *  context,
MQTTAsync_connectionLost *  cl,
MQTTAsync_messageArrived *  ma,
MQTTAsync_deliveryComplete *  dc 
)

This function sets the global callback functions for a specific client.

If your client application doesn't use a particular callback, set the relevant parameter to NULL. Any necessary message acknowledgements and status communications are handled in the background without any intervention from the client application. If you do not set a messageArrived callback function, you will not be notified of the receipt of any messages as a result of a subscription.

Note: The MQTT client must be disconnected when this function is called.

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
context A pointer to any application-specific context. The the context pointer is passed to each of the callback functions to provide access to the context information in the callback.
cl A pointer to an MQTTAsync_connectionLost() callback function. You can set this to NULL if your application doesn't handle disconnections.
ma A pointer to an MQTTAsync_messageArrived() callback function. You can set this to NULL if your application doesn't handle receipt of messages.
dc A pointer to an MQTTAsync_deliveryComplete() callback function. You can set this to NULL if you do not want to check for successful delivery.
Returns:
MQTTASYNC_SUCCESS if the callbacks were correctly set, MQTTASYNC_FAILURE if an error occurred.
int MQTTAsync_setConnected ( MQTTAsync  handle,
void *  context,
MQTTAsync_connected *  co 
)

Sets the MQTTAsync_connected() callback function for a client.

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
context A pointer to any application-specific context. The the context pointer is passed to each of the callback functions to provide access to the context information in the callback.
co A pointer to an MQTTAsync_connected() callback function. NULL removes the callback setting.
Returns:
MQTTASYNC_SUCCESS if the callbacks were correctly set, MQTTASYNC_FAILURE if an error occurred.
void MQTTAsync_setTraceCallback ( MQTTAsync_traceCallback *  callback  ) 

This function sets the trace callback if needed.

If set to NULL, no trace information will be returned. The default trace level is MQTTASYNC_TRACE_MINIMUM.

Parameters:
callback a pointer to the function which will handle the trace information
void MQTTAsync_setTraceLevel ( enum MQTTASYNC_TRACE_LEVELS  level  ) 

This function sets the level of trace information which will be returned in the trace callback.

Parameters:
level the trace level required
int MQTTAsync_subscribe ( MQTTAsync  handle,
const char *  topic,
int  qos,
MQTTAsync_responseOptions response 
)

This function attempts to subscribe a client to a single topic, which may contain wildcards (see wildcard).

This call also specifies the qos requested for the subscription (see also MQTTAsync_subscribeMany()).

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
topic The subscription topic, which may include wildcards.
qos The requested quality of service for the subscription.
response A pointer to a response options structure. Used to set callback functions.
Returns:
MQTTASYNC_SUCCESS if the subscription request is successful. An error code is returned if there was a problem registering the subscription.

Here is the call graph for this function:

int MQTTAsync_subscribeMany ( MQTTAsync  handle,
int  count,
char *const *  topic,
int *  qos,
MQTTAsync_responseOptions response 
)

This function attempts to subscribe a client to a list of topics, which may contain wildcards (see wildcard).

This call also specifies the qos requested for each topic (see also MQTTAsync_subscribe()).

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
count The number of topics for which the client is requesting subscriptions.
topic An array (of length count) of pointers to topics, each of which may include wildcards.
qos An array (of length count) of qos values. qos[n] is the requested QoS for topic[n].
response A pointer to a response options structure. Used to set callback functions.
Returns:
MQTTASYNC_SUCCESS if the subscription request is successful. An error code is returned if there was a problem registering the subscriptions.

Here is the call graph for this function:

int MQTTAsync_unsubscribe ( MQTTAsync  handle,
const char *  topic,
MQTTAsync_responseOptions response 
)

This function attempts to remove an existing subscription made by the specified client.

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
topic The topic for the subscription to be removed, which may include wildcards (see wildcard).
response A pointer to a response options structure. Used to set callback functions.
Returns:
MQTTASYNC_SUCCESS if the subscription is removed. An error code is returned if there was a problem removing the subscription.

Here is the call graph for this function:

int MQTTAsync_unsubscribeMany ( MQTTAsync  handle,
int  count,
char *const *  topic,
MQTTAsync_responseOptions response 
)

This function attempts to remove existing subscriptions to a list of topics made by the specified client.

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
count The number subscriptions to be removed.
topic An array (of length count) of pointers to the topics of the subscriptions to be removed, each of which may include wildcards.
response A pointer to a response options structure. Used to set callback functions.
Returns:
MQTTASYNC_SUCCESS if the subscriptions are removed. An error code is returned if there was a problem removing the subscriptions.

Here is the call graph for this function:

int MQTTAsync_waitForCompletion ( MQTTAsync  handle,
MQTTAsync_token  token,
unsigned long  timeout 
)

Waits for a request corresponding to a token to complete.

Parameters:
handle A valid client handle from a successful call to MQTTAsync_create().
token An MQTTAsync_token associated with a request.
timeout the maximum time to wait for completion, in milliseconds
Returns:
MQTTASYNC_SUCCESS if the request has been completed in the time allocated, MQTTASYNC_FAILURE if not.
static void MQTTProtocol_checkPendingWrites ( void   )  [static]

See if any pending writes have been completed, and cleanup if so.

Cleaning up means removing any publication data that was stored because the write did not originally complete.

Here is the call graph for this function:


Variable Documentation

ClientStates ClientState [static]
Initial value:
{
        CLIENT_VERSION, 
        NULL 
}
 All Data Structures Files Functions Variables Typedefs Defines

Generated on 26 Oct 2017 for MQTT C Client Libraries Internals by  doxygen 1.6.1