Add MQTT support

Signed-off-by: Benjamin <benjamin@ewft.org>

Makefile

@@ -1,4 +1,7 @@
-all : emit listen
+all : emit listen mqtt
+
+mqtt : mqtt.o buffer.o home_easy.o utils.o
+	gcc -o $@ $^ -lwiringPi -lpaho-mqtt3cs
 
 listen : listen.o buffer.o home_easy.o utils.o analyze.o
 	gcc -o $@ $^ -lwiringPi

mqtt.c

@@ -0,0 +1,303 @@
+/*******************************************************************************
+ * Copyright (c) 2012, 2013 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *   http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial contribution
+ *    Ian Craggs - change delimiter option from char to string
+ *    Guilherme Maciel Ferreira - add keep alive option
+ *******************************************************************************/
+
+/*
+
+ stdout subscriber
+
+ compulsory parameters:
+
+  --topic topic to subscribe to
+
+ defaulted parameters:
+
+	--host localhost
+	--port 1883
+	--qos 2
+	--delimiter \n
+	--clientid stdout-subscriber
+	--showtopics off
+	--keepalive 10
+
+	--userid none
+	--password none
+
+*/
+#include "MQTTClient.h"
+#include "MQTTClientPersistence.h"
+
+#include <stdio.h>
+#include <signal.h>
+#include <string.h>
+#include <stdlib.h>
+#include "home_easy.h"
+
+
+
+#if defined(WIN32)
+#define sleep Sleep
+#else
+#include <sys/time.h>
+#endif
+
+
+
+unsigned int id = 0x01379F0E;
+
+
+
+volatile int toStop = 0;
+
+typedef struct Item {
+	    char * topic;
+	    unsigned int id;
+	    char section;
+	    char channel;
+} Item;
+
+
+struct opts_struct
+{
+	char* clientid;
+	int nodelimiter;
+	char* delimiter;
+	int qos;
+	char* username;
+	char* password;
+	char* host;
+	char* port;
+	int showtopics;
+	int keepalive;
+} opts =
+{
+	"stdout-subscriber", 0, "\n", 2, NULL, NULL, "localhost", "1883", 0, 10
+};
+
+
+void usage(void)
+{
+	printf("MQTT stdout subscriber\n");
+	printf("Usage: stdoutsub topicname <options>, where options are:\n");
+	printf("  --host <hostname> (default is %s)\n", opts.host);
+	printf("  --port <port> (default is %s)\n", opts.port);
+	printf("  --qos <qos> (default is %d)\n", opts.qos);
+	printf("  --delimiter <delim> (default is \\n)\n");
+	printf("  --clientid <clientid> (default is %s)\n", opts.clientid);
+	printf("  --username none\n");
+	printf("  --password none\n");
+	printf("  --showtopics <on or off> (default is on if the topic has a wildcard, else off)\n");
+	printf("  --keepalive <seconds> (default is %d seconds)\n", opts.keepalive);
+	exit(EXIT_FAILURE);
+}
+
+
+void myconnect(MQTTClient* client, MQTTClient_connectOptions* opts)
+{
+	int rc = 0;
+	if ((rc = MQTTClient_connect(*client, opts)) != 0)
+	{
+		printf("Failed to connect, return code %d\n", rc);
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+void cfinish(int sig)
+{
+	signal(SIGINT, NULL);
+	toStop = 1;
+}
+
+void getopts(int argc, char** argv);
+
+int main(int argc, char** argv)
+{
+	MQTTClient client;
+	MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
+	
+	
+	Item lampH = { "chacon/maison/salon/lampehaute", 0x01379F0E, 'A', 1};
+ 	
+	Item videoP = { "chacon/maison/salon/videoproj", 0x01379F0E, 'A', 2};
+	Item tardis = { "chacon/maison/salon/tardis", 0x01379F0E, 'A', 3};
+	Item lampC = { "chacon/maison/chambre/lampe", 0x00DE29E6, 'A', 1};
+	//Item lampH = { "chacon/maison/salon/lampehaute", 0x01379F0E, 'A', 1};
+
+	Item * listItem[10];
+	listItem[0] = &lampH;
+	listItem[1] = &videoP;
+	listItem[2] = &tardis;
+	listItem[3] = &lampC;
+
+	char* topic = "chacon/#";
+	int rc = 0;
+	char url[100];
+
+
+	opts.showtopics = 1;
+	if (opts.showtopics)
+		printf("topic is %s\n", topic);
+
+	getopts(argc, argv);
+	sprintf(url, "%s:%s", opts.host, opts.port);
+
+	rc = MQTTClient_create(&client, url, opts.clientid, MQTTCLIENT_PERSISTENCE_NONE, NULL);
+
+	signal(SIGINT, cfinish);
+	signal(SIGTERM, cfinish);
+
+	conn_opts.keepAliveInterval = opts.keepalive;
+	conn_opts.reliable = 0;
+	conn_opts.cleansession = 1;
+//	conn_opts.username = opts.username;
+//	conn_opts.password = opts.password;
+
+	myconnect(&client, &conn_opts);
+
+	rc = MQTTClient_subscribe(client, topic, opts.qos);
+
+	while (!toStop)
+	{
+		char* topicName = NULL;
+		int topicLen;
+		MQTTClient_message* message = NULL;
+
+		rc = MQTTClient_receive(client, &topicName, &topicLen, &message, 1000);
+		if (message)
+		{
+			if (opts.showtopics)
+				printf("%s\t", topicName);
+			
+			for(int i=0;i < 4; i++){
+				if(strcmp(listItem[i]->topic, topicName) == 0){
+					
+					initIO();
+					char onoff = strcmp(message->payload,"1") ? 0 : 1;
+					sendHomeEasyCommand(listItem[i]->id,listItem[i]->section,listItem[i]->channel, onoff,10);
+				}
+			}
+			if (opts.nodelimiter)
+				printf("%.*s", message->payloadlen, (char*)message->payload);
+			else
+				printf("%.*s%s", message->payloadlen, (char*)message->payload, opts.delimiter);
+			fflush(stdout);
+			MQTTClient_freeMessage(&message);
+			MQTTClient_free(topicName);
+		}
+		if (rc != 0)
+			myconnect(&client, &conn_opts);
+	}
+
+	printf("Stopping\n");
+
+	MQTTClient_disconnect(client, 0);
+
+	MQTTClient_destroy(&client);
+
+	return EXIT_SUCCESS;
+}
+
+void getopts(int argc, char** argv)
+{
+	int count = 2;
+
+	while (count < argc)
+	{
+		if (strcmp(argv[count], "--qos") == 0)
+		{
+			if (++count < argc)
+			{
+				if (strcmp(argv[count], "0") == 0)
+					opts.qos = 0;
+				else if (strcmp(argv[count], "1") == 0)
+					opts.qos = 1;
+				else if (strcmp(argv[count], "2") == 0)
+					opts.qos = 2;
+				else
+					usage();
+			}
+			else
+				usage();
+		}
+		else if (strcmp(argv[count], "--host") == 0)
+		{
+			if (++count < argc)
+				opts.host = argv[count];
+			else
+				usage();
+		}
+		else if (strcmp(argv[count], "--port") == 0)
+		{
+			if (++count < argc)
+				opts.port = argv[count];
+			else
+				usage();
+		}
+		else if (strcmp(argv[count], "--clientid") == 0)
+		{
+			if (++count < argc)
+				opts.clientid = argv[count];
+			else
+				usage();
+		}
+		else if (strcmp(argv[count], "--username") == 0)
+		{
+			if (++count < argc)
+				opts.username = argv[count];
+			else
+				usage();
+		}
+		else if (strcmp(argv[count], "--password") == 0)
+		{
+			if (++count < argc)
+				opts.password = argv[count];
+			else
+				usage();
+		}
+		else if (strcmp(argv[count], "--delimiter") == 0)
+		{
+			if (++count < argc)
+				opts.delimiter = argv[count];
+			else
+				opts.nodelimiter = 1;
+		}
+		else if (strcmp(argv[count], "--showtopics") == 0)
+		{
+			if (++count < argc)
+			{
+				if (strcmp(argv[count], "on") == 0)
+					opts.showtopics = 1;
+				else if (strcmp(argv[count], "off") == 0)
+					opts.showtopics = 0;
+				else
+					usage();
+			}
+			else
+				usage();
+		}
+		else if (strcmp(argv[count], "--keepalive") == 0)
+		{
+			if (++count < argc)
+				opts.keepalive = atoi(argv[count]);
+			else
+				usage();
+		}
+		count++;
+	}
+
+}

paho.mqtt.c/Clients.h

@@ -0,0 +1,209 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2017 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *    Ian Craggs - add SSL support
+ *    Ian Craggs - fix for bug 413429 - connectionLost not called
+ *    Ian Craggs - change will payload to binary
+ *    Ian Craggs - password to binary
+ *******************************************************************************/
+
+#if !defined(CLIENTS_H)
+#define CLIENTS_H
+
+#include <time.h>
+#if defined(OPENSSL)
+#if defined(WIN32) || defined(WIN64)
+#include <winsock2.h>
+#endif
+#include <openssl/ssl.h>
+#endif
+#include "MQTTClient.h"
+#include "LinkedList.h"
+#include "MQTTClientPersistence.h"
+/*BE
+include "LinkedList"
+BE*/
+
+/*BE
+def PUBLICATIONS
+{
+   n32 ptr STRING open "topic"
+   n32 ptr DATA "payload"
+   n32 dec "payloadlen"
+   n32 dec "refcount"
+}
+BE*/
+/**
+ * Stored publication data to minimize copying
+ */
+typedef struct
+{
+	char *topic;
+	int topiclen;
+	char* payload;
+	int payloadlen;
+	int refcount;
+} Publications;
+
+/*BE
+// This should get moved to MQTTProtocol, but the includes don't quite work yet
+map MESSAGE_TYPES
+{
+   "PUBREC" 5
+   "PUBREL" .
+   "PUBCOMP" .
+}
+
+
+def MESSAGES
+{
+   n32 dec "qos"
+   n32 map bool "retain"
+   n32 dec "msgid"
+   n32 ptr PUBLICATIONS "publish"
+   n32 time "lastTouch"
+   n8 map MESSAGE_TYPES "nextMessageType"
+   n32 dec "len"
+}
+defList(MESSAGES)
+BE*/
+/**
+ * Client publication message data
+ */
+typedef struct
+{
+	int qos;
+	int retain;
+	int msgid;
+	Publications *publish;
+	time_t lastTouch;		/**> used for retry and expiry */
+	char nextMessageType;	/**> PUBREC, PUBREL, PUBCOMP */
+	int len;				/**> length of the whole structure+data */
+} Messages;
+
+
+/*BE
+def WILLMESSAGES
+{
+   n32 ptr STRING open "topic"
+   n32 ptr DATA open "msg"
+   n32 dec "retained"
+   n32 dec "qos"
+}
+BE*/
+
+/**
+ * Client will message data
+ */
+typedef struct
+{
+	char *topic;
+	int payloadlen;
+	void *payload;
+	int retained;
+	int qos;
+} willMessages;
+
+/*BE
+map CLIENT_BITS
+{
+	"cleansession" 1 : .
+	"connected" 2 : .
+	"good" 4 : .
+	"ping_outstanding" 8 : .
+}
+def CLIENTS
+{
+	n32 ptr STRING open "clientID"
+	n32 ptr STRING open "username"
+	n32 ptr STRING open "password"
+	n32 map CLIENT_BITS "bits"
+	at 4 n8 bits 7:6 dec "connect_state"
+	at 8
+	n32 dec "socket"
+	n32 ptr "SSL"
+	n32 dec "msgID"
+	n32 dec "keepAliveInterval"
+	n32 dec "maxInflightMessages"
+	n32 ptr BRIDGECONNECTIONS "bridge_context"
+	n32 time "lastContact"
+	n32 ptr WILLMESSAGES "will"
+	n32 ptr MESSAGESList open "inboundMsgs"
+	n32 ptr MESSAGESList open "outboundMsgs"
+	n32 ptr MESSAGESList open "messageQueue"
+	n32 dec "discardedMsgs"
+}
+
+defList(CLIENTS)
+
+BE*/
+
+typedef struct
+{
+	int socket;
+	time_t lastSent;
+	time_t lastReceived;
+#if defined(OPENSSL)
+	SSL* ssl;
+	SSL_CTX* ctx;
+#endif
+} networkHandles;
+
+/**
+ * Data related to one client
+ */
+typedef struct
+{
+	char* clientID;					      /**< the string id of the client */
+	const char* username;					/**< MQTT v3.1 user name */
+	int passwordlen;              /**< MQTT password length */
+	const void* password;					/**< MQTT v3.1 binary password */
+	unsigned int cleansession : 1;	/**< MQTT clean session flag */
+	unsigned int connected : 1;		/**< whether it is currently connected */
+	unsigned int good : 1; 			  /**< if we have an error on the socket we turn this off */
+	unsigned int ping_outstanding : 1;
+	int connect_state : 4;
+	networkHandles net;
+	int msgID;
+	int keepAliveInterval;
+	int retryInterval;
+	int maxInflightMessages;
+	willMessages* will;
+	List* inboundMsgs;
+	List* outboundMsgs;				/**< in flight */
+	List* messageQueue;
+	unsigned int qentry_seqno;
+	void* phandle;  /* the persistence handle */
+	MQTTClient_persistence* persistence; /* a persistence implementation */
+	void* context; /* calling context - used when calling disconnect_internal */
+	int MQTTVersion;
+#if defined(OPENSSL)
+	MQTTClient_SSLOptions *sslopts;
+	SSL_SESSION* session;    /***< SSL session pointer for fast handhake */
+#endif
+} Clients;
+
+int clientIDCompare(void* a, void* b);
+int clientSocketCompare(void* a, void* b);
+
+/**
+ * Configuration data related to all clients
+ */
+typedef struct
+{
+	const char* version;
+	List* clients;
+} ClientStates;
+
+#endif

paho.mqtt.c/Heap.h

@@ -0,0 +1,76 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2013 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *    Ian Craggs - use tree data structure instead of list
+ *******************************************************************************/
+
+
+#if !defined(HEAP_H)
+#define HEAP_H
+
+#if defined(HIGH_PERFORMANCE)
+#define NO_HEAP_TRACKING 1
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#if !defined(NO_HEAP_TRACKING)
+/**
+ * redefines malloc to use "mymalloc" so that heap allocation can be tracked
+ * @param x the size of the item to be allocated
+ * @return the pointer to the item allocated, or NULL
+ */
+#define malloc(x) mymalloc(__FILE__, __LINE__, x)
+
+/**
+ * redefines realloc to use "myrealloc" so that heap allocation can be tracked
+ * @param a the heap item to be reallocated
+ * @param b the new size of the item
+ * @return the new pointer to the heap item
+ */
+#define realloc(a, b) myrealloc(__FILE__, __LINE__, a, b)
+
+/**
+ * redefines free to use "myfree" so that heap allocation can be tracked
+ * @param x the size of the item to be freed
+ */
+#define free(x) myfree(__FILE__, __LINE__, x)
+
+#endif
+
+/**
+ * Information about the state of the heap.
+ */
+typedef struct
+{
+	size_t current_size;	/**< current size of the heap in bytes */
+	size_t max_size;		/**< max size the heap has reached in bytes */
+} heap_info;
+
+
+void* mymalloc(char*, int, size_t size);
+void* myrealloc(char*, int, void* p, size_t size);
+void myfree(char*, int, void* p);
+
+void Heap_scan(FILE* file);
+int Heap_initialize(void);
+void Heap_terminate(void);
+heap_info* Heap_get_info(void);
+int HeapDump(FILE* file);
+int HeapDumpString(FILE* file, char* str);
+void* Heap_findItem(void* p);
+void Heap_unlink(char* file, int line, void* p);
+
+#endif

paho.mqtt.c/LinkedList.h

@@ -0,0 +1,105 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2013 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *    Ian Craggs - updates for the async client
+ *    Ian Craggs - change size types from int to size_t
+ *******************************************************************************/
+
+#if !defined(LINKEDLIST_H)
+#define LINKEDLIST_H
+
+#include <stdlib.h> /* for size_t definition */
+
+/*BE
+defm defList(T)
+
+def T concat Item
+{
+	at 4
+	n32 ptr T concat Item suppress "next"
+	at 0
+	n32 ptr T concat Item suppress "prev"
+	at 8
+	n32 ptr T id2str(T)
+}
+
+def T concat List
+{
+	n32 ptr T concat Item suppress "first"
+	n32 ptr T concat Item suppress "last"
+	n32 ptr T concat Item suppress "current"
+	n32 dec "count"
+	n32 suppress "size"
+}
+endm
+
+defList(INT)
+defList(STRING)
+defList(TMP)
+
+BE*/
+
+/**
+ * Structure to hold all data for one list element
+ */
+typedef struct ListElementStruct
+{
+	struct ListElementStruct *prev, /**< pointer to previous list element */
+							*next;	/**< pointer to next list element */
+	void* content;					/**< pointer to element content */
+} ListElement;
+
+
+/**
+ * Structure to hold all data for one list
+ */
+typedef struct
+{
+	ListElement *first,	/**< first element in the list */
+				*last,	/**< last element in the list */
+				*current;	/**< current element in the list, for iteration */
+	int count;  /**< no of items */
+	size_t size;  /**< heap storage used */
+} List;
+
+void ListZero(List*);
+List* ListInitialize(void);
+
+void ListAppend(List* aList, void* content, size_t size);
+void ListAppendNoMalloc(List* aList, void* content, ListElement* newel, size_t size);
+void ListInsert(List* aList, void* content, size_t size, ListElement* index);
+
+int ListRemove(List* aList, void* content);
+int ListRemoveItem(List* aList, void* content, int(*callback)(void*, void*));
+void* ListDetachHead(List* aList);
+int ListRemoveHead(List* aList);
+void* ListPopTail(List* aList);
+
+int ListDetach(List* aList, void* content);
+int ListDetachItem(List* aList, void* content, int(*callback)(void*, void*));
+
+void ListFree(List* aList);
+void ListEmpty(List* aList);
+void ListFreeNoContent(List* aList);
+
+ListElement* ListNextElement(List* aList, ListElement** pos);
+ListElement* ListPrevElement(List* aList, ListElement** pos);
+
+ListElement* ListFind(List* aList, void* content);
+ListElement* ListFindItem(List* aList, void* content, int(*callback)(void*, void*));
+
+int intcompare(void* a, void* b);
+int stringcompare(void* a, void* b);
+
+#endif

paho.mqtt.c/Log.h

@@ -0,0 +1,85 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2013 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *    Ian Craggs - updates for the async client
+ *******************************************************************************/
+
+#if !defined(LOG_H)
+#define LOG_H
+
+/*BE
+map LOG_LEVELS
+{
+	"TRACE_MAXIMUM" 1
+	"TRACE_MEDIUM" 2
+	"TRACE_MINIMUM" 3
+	"TRACE_PROTOCOL" 4
+
+	"ERROR" 5
+	"SEVERE" 6
+	"FATAL" 7
+}
+BE*/
+
+enum LOG_LEVELS {
+	INVALID_LEVEL = -1,
+	TRACE_MAXIMUM = 1,
+	TRACE_MEDIUM,
+	TRACE_MINIMUM,
+	TRACE_PROTOCOL,
+	LOG_ERROR,
+	LOG_SEVERE,
+	LOG_FATAL,
+};
+
+
+/*BE
+def trace_settings_type
+{
+   n32 map LOG_LEVELS "trace_level"
+   n32 dec "max_trace_entries"
+   n32 dec "trace_output_level"
+}
+BE*/
+typedef struct
+{
+	enum LOG_LEVELS trace_level;	/**< trace level */
+	int max_trace_entries;		/**< max no of entries in the trace buffer */
+	enum LOG_LEVELS trace_output_level;		/**< trace level to output to destination */
+} trace_settings_type;
+
+extern trace_settings_type trace_settings;
+
+#define LOG_PROTOCOL TRACE_PROTOCOL
+#define TRACE_MAX TRACE_MAXIMUM
+#define TRACE_MIN TRACE_MINIMUM
+#define TRACE_MED TRACE_MEDIUM
+
+typedef struct
+{
+	const char* name;
+	const char* value;
+} Log_nameValue;
+
+int Log_initialize(Log_nameValue*);
+void Log_terminate(void);
+
+void Log(enum LOG_LEVELS, int, const char *, ...);
+void Log_stackTrace(enum LOG_LEVELS, int, int, int, const char*, int, int*);
+
+typedef void Log_traceCallback(enum LOG_LEVELS level, const char *message);
+void Log_setTraceCallback(Log_traceCallback* callback);
+void Log_setTraceLevel(enum LOG_LEVELS level);
+
+#endif

paho.mqtt.c/MQTTAsync.h

@@ -0,0 +1,1717 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2017 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation
+ *    Ian Craggs, Allan Stockdill-Mander - SSL connections
+ *    Ian Craggs - multiple server connection support
+ *    Ian Craggs - MQTT 3.1.1 support
+ *    Ian Craggs - fix for bug 444103 - success/failure callbacks not invoked
+ *    Ian Craggs - automatic reconnect and offline buffering (send while disconnected)
+ *    Ian Craggs - binary will message
+ *    Ian Craggs - binary password
+ *    Ian Craggs - remove const on eyecatchers #168
+ *******************************************************************************/
+
+/********************************************************************/
+
+/**
+ * @cond MQTTAsync_main
+ * @mainpage Asynchronous MQTT client library for C
+ *
+ * © Copyright IBM Corp. 2009, 2017
+ *
+ * @brief An Asynchronous MQTT client library for C.
+ *
+ * An MQTT client application connects to MQTT-capable servers.
+ * A typical client is responsible for collecting information from a telemetry
+ * device and publishing the information to the server. It can also subscribe
+ * to topics, receive messages, and use this information to control the
+ * telemetry device.
+ *
+ * MQTT clients implement the published MQTT v3 protocol. You can write your own
+ * API to the MQTT protocol using the programming language and platform of your
+ * choice. This can be time-consuming and error-prone.
+ *
+ * To simplify writing MQTT client applications, this library encapsulates
+ * the MQTT v3 protocol for you. Using this library enables a fully functional
+ * MQTT client application to be written in a few lines of code.
+ * The information presented here documents the API provided
+ * by the Asynchronous MQTT Client library for C.
+ *
+ * <b>Using the client</b><br>
+ * Applications that use the client library typically use a similar structure:
+ * <ul>
+ * <li>Create a client object</li>
+ * <li>Set the options to connect to an MQTT server</li>
+ * <li>Set up callback functions</li>
+ * <li>Connect the client to an MQTT server</li>
+ * <li>Subscribe to any topics the client needs to receive</li>
+ * <li>Repeat until finished:</li>
+ *     <ul>
+ *     <li>Publish any messages the client needs to</li>
+ *     <li>Handle any incoming messages</li>
+ *     </ul>
+ * <li>Disconnect the client</li>
+ * <li>Free any memory being used by the client</li>
+ * </ul>
+ * Some simple examples are shown here:
+ * <ul>
+ * <li>@ref publish</li>
+ * <li>@ref subscribe</li>
+ * </ul>
+ * Additional information about important concepts is provided here:
+ * <ul>
+ * <li>@ref async</li>
+ * <li>@ref wildcard</li>
+ * <li>@ref qos</li>
+ * <li>@ref tracing</li>
+ * <li>@ref auto_reconnect</li>
+ * <li>@ref offline_publish</li>
+ * </ul>
+ * @endcond
+ */
+
+
+/*
+/// @cond EXCLUDE
+*/
+#if defined(__cplusplus)
+ extern "C" {
+#endif
+
+#if !defined(MQTTASYNC_H)
+#define MQTTASYNC_H
+
+#if defined(WIN32) || defined(WIN64)
+  #define DLLImport __declspec(dllimport)
+  #define DLLExport __declspec(dllexport)
+#else
+  #define DLLImport extern
+  #define DLLExport  __attribute__ ((visibility ("default")))
+#endif
+
+#include <stdio.h>
+/*
+/// @endcond
+*/
+
+#if !defined(NO_PERSISTENCE)
+#include "MQTTClientPersistence.h"
+#endif
+
+/**
+ * Return code: No error. Indicates successful completion of an MQTT client
+ * operation.
+ */
+#define MQTTASYNC_SUCCESS 0
+/**
+ * Return code: A generic error code indicating the failure of an MQTT client
+ * operation.
+ */
+#define MQTTASYNC_FAILURE -1
+
+/* error code -2 is MQTTAsync_PERSISTENCE_ERROR */
+
+#define MQTTASYNC_PERSISTENCE_ERROR -2
+
+/**
+ * Return code: The client is disconnected.
+ */
+#define MQTTASYNC_DISCONNECTED -3
+/**
+ * Return code: The maximum number of messages allowed to be simultaneously
+ * in-flight has been reached.
+ */
+#define MQTTASYNC_MAX_MESSAGES_INFLIGHT -4
+/**
+ * Return code: An invalid UTF-8 string has been detected.
+ */
+#define MQTTASYNC_BAD_UTF8_STRING -5
+/**
+ * Return code: A NULL parameter has been supplied when this is invalid.
+ */
+#define MQTTASYNC_NULL_PARAMETER -6
+/**
+ * Return code: The topic has been truncated (the topic string includes
+ * embedded NULL characters). String functions will not access the full topic.
+ * Use the topic length value to access the full topic.
+ */
+#define MQTTASYNC_TOPICNAME_TRUNCATED -7
+/**
+ * Return code: A structure parameter does not have the correct eyecatcher
+ * and version number.
+ */
+#define MQTTASYNC_BAD_STRUCTURE -8
+/**
+ * Return code: A qos parameter is not 0, 1 or 2
+ */
+#define MQTTASYNC_BAD_QOS -9
+/**
+ * Return code: All 65535 MQTT msgids are being used
+ */
+#define MQTTASYNC_NO_MORE_MSGIDS -10
+/**
+ * Return code: the request is being discarded when not complete
+ */
+#define MQTTASYNC_OPERATION_INCOMPLETE -11
+/**
+ * Return code: no more messages can be buffered
+ */
+#define MQTTASYNC_MAX_BUFFERED_MESSAGES -12
+/**
+ * Return code: Attempting SSL connection using non-SSL version of library
+ */
+#define MQTTASYNC_SSL_NOT_SUPPORTED -13
+
+/**
+ * Default MQTT version to connect with.  Use 3.1.1 then fall back to 3.1
+ */
+#define MQTTVERSION_DEFAULT 0
+/**
+ * MQTT version to connect with: 3.1
+ */
+#define MQTTVERSION_3_1 3
+/**
+ * MQTT version to connect with: 3.1.1
+ */
+#define MQTTVERSION_3_1_1 4
+/**
+ * Bad return code from subscribe, as defined in the 3.1.1 specification
+ */
+#define MQTT_BAD_SUBSCRIBE 0x80
+
+
+/**
+ *  Initialization options
+ */
+typedef struct
+{
+	/** The eyecatcher for this structure.  Must be MQTG. */
+	char struct_id[4];
+	/** The version number of this structure.  Must be 0 */
+	int struct_version;
+	/** 1 = we do openssl init, 0 = leave it to the application */
+	int do_openssl_init;
+} MQTTAsync_init_options;
+
+#define MQTTAsync_init_options_initializer { {'M', 'Q', 'T', 'G'}, 0, 0 }
+
+/**
+ * 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)
+ */
+DLLExport void MQTTAsync_global_init(MQTTAsync_init_options* inits);
+
+/**
+ * A handle representing an MQTT client. A valid client handle is available
+ * following a successful call to MQTTAsync_create().
+ */
+typedef void* MQTTAsync;
+/**
+ * A value representing an MQTT message. A token is returned to the
+ * client application when a message is published. The token can then be used to
+ * check that the message was successfully delivered to its destination (see
+ * MQTTAsync_publish(),
+ * MQTTAsync_publishMessage(),
+ * MQTTAsync_deliveryComplete(), and
+ * MQTTAsync_getPendingTokens()).
+ */
+typedef int MQTTAsync_token;
+
+/**
+ * A structure representing the payload and attributes of an MQTT message. The
+ * message topic is not part of this structure (see MQTTAsync_publishMessage(),
+ * MQTTAsync_publish(), MQTTAsync_receive(), MQTTAsync_freeMessage()
+ * and MQTTAsync_messageArrived()).
+ */
+typedef struct
+{
+	/** The eyecatcher for this structure.  must be MQTM. */
+	char struct_id[4];
+	/** The version number of this structure.  Must be 0 */
+	int struct_version;
+	/** The length of the MQTT message payload in bytes. */
+	int payloadlen;
+	/** A pointer to the payload of the MQTT message. */
+	void* payload;
+	/**
+     * The quality of service (QoS) assigned to the message.
+     * There are three levels of QoS:
+     * <DL>
+     * <DT><B>QoS0</B></DT>
+     * <DD>Fire and forget - the message may not be delivered</DD>
+     * <DT><B>QoS1</B></DT>
+     * <DD>At least once - the message will be delivered, but may be
+     * delivered more than once in some circumstances.</DD>
+     * <DT><B>QoS2</B></DT>
+     * <DD>Once and one only - the message will be delivered exactly once.</DD>
+     * </DL>
+     */
+	int qos;
+	/**
+     * The retained flag serves two purposes depending on whether the message
+     * it is associated with is being published or received.
+     *
+     * <b>retained = true</b><br>
+     * For messages being published, a true setting indicates that the MQTT
+     * server should retain a copy of the message. The message will then be
+     * transmitted to new subscribers to a topic that matches the message topic.
+     * For subscribers registering a new subscription, the flag being true
+     * indicates that the received message is not a new one, but one that has
+     * been retained by the MQTT server.
+     *
+     * <b>retained = false</b> <br>
+     * For publishers, this ndicates that this message should not be retained
+     * by the MQTT server. For subscribers, a false setting indicates this is
+     * a normal message, received as a result of it being published to the
+     * server.
+     */
+	int retained;
+	/**
+      * The dup flag indicates whether or not this message is a duplicate.
+      * It is only meaningful when receiving QoS1 messages. When true, the
+      * client application should take appropriate action to deal with the
+      * duplicate message.
+      */
+	int dup;
+	/** The message identifier is normally reserved for internal use by the
+      * MQTT client and server.
+      */
+	int msgid;
+} MQTTAsync_message;
+
+#define MQTTAsync_message_initializer { {'M', 'Q', 'T', 'M'}, 0, 0, NULL, 0, 0, 0, 0 }
+
+/**
+ * This is a callback function. The client application
+ * must provide an implementation of this function to enable asynchronous
+ * receipt of messages. The function is registered with the client library by
+ * passing it as an argument to MQTTAsync_setCallbacks(). It is
+ * called by the client library when a new message that matches a client
+ * subscription has been received from the server. This function is executed on
+ * a separate thread to the one on which the client application is running.
+ * @param context A pointer to the <i>context</i> value originally passed to
+ * MQTTAsync_setCallbacks(), which contains any application-specific context.
+ * @param topicName The topic associated with the received message.
+ * @param topicLen The length of the topic if there are one
+ * more NULL characters embedded in <i>topicName</i>, otherwise <i>topicLen</i>
+ * is 0. If <i>topicLen</i> is 0, the value returned by <i>strlen(topicName)</i>
+ * can be trusted. If <i>topicLen</i> is greater than 0, the full topic name
+ * can be retrieved by accessing <i>topicName</i> as a byte array of length
+ * <i>topicLen</i>.
+ * @param message The MQTTAsync_message structure for the received message.
+ * This structure contains the message payload and attributes.
+ * @return This function must return a boolean value indicating whether or not
+ * the message has been safely received by the client application. Returning
+ * true indicates that the message has been successfully handled.
+ * Returning false indicates that there was a problem. In this
+ * case, the client library will reinvoke MQTTAsync_messageArrived() to
+ * attempt to deliver the message to the application again.
+ */
+typedef int MQTTAsync_messageArrived(void* context, char* topicName, int topicLen, MQTTAsync_message* message);
+
+/**
+ * This is a callback function. The client application
+ * must provide an implementation of this function to enable asynchronous
+ * notification of delivery of messages to the server. The function is
+ * registered with the client library by passing it as an argument to MQTTAsync_setCallbacks().
+ * It is called by the client library after the client application has
+ * published a message to the server. It indicates that the necessary
+ * handshaking and acknowledgements for the requested quality of service (see
+ * MQTTAsync_message.qos) have been completed. This function is executed on a
+ * separate thread to the one on which the client application is running.
+ * @param context A pointer to the <i>context</i> value originally passed to
+ * MQTTAsync_setCallbacks(), which contains any application-specific context.
+ * @param token The ::MQTTAsync_token associated with
+ * the published message. Applications can check that all messages have been
+ * correctly published by matching the tokens returned from calls to
+ * MQTTAsync_send() and MQTTAsync_sendMessage() with the tokens passed
+ * to this callback.
+ */
+typedef void MQTTAsync_deliveryComplete(void* context, MQTTAsync_token token);
+
+/**
+ * This is a callback function. The client application
+ * must provide an implementation of this function to enable asynchronous
+ * notification of the loss of connection to the server. The function is
+ * registered with the client library by passing it as an argument to
+ * MQTTAsync_setCallbacks(). It is called by the client library if the client
+ * loses its connection to the server. The client application must take
+ * appropriate action, such as trying to reconnect or reporting the problem.
+ * This function is executed on a separate thread to the one on which the
+ * client application is running.
+ * @param context A pointer to the <i>context</i> value originally passed to
+ * MQTTAsync_setCallbacks(), which contains any application-specific context.
+ * @param cause The reason for the disconnection.
+ * Currently, <i>cause</i> is always set to NULL.
+ */
+typedef void MQTTAsync_connectionLost(void* context, char* cause);
+
+
+/**
+ * This is a callback function, which will be called when the client
+ * library successfully connects.  This is superfluous when the connection
+ * is made in response to a MQTTAsync_connect call, because the onSuccess
+ * callback can be used.  It is intended for use when automatic reconnect
+ * is enabled, so that when a reconnection attempt succeeds in the background,
+ * the application is notified and can take any required actions.
+ * @param context A pointer to the <i>context</i> value originally passed to
+ * MQTTAsync_setCallbacks(), which contains any application-specific context.
+ * @param cause The reason for the disconnection.
+ * Currently, <i>cause</i> is always set to NULL.
+ */
+typedef void MQTTAsync_connected(void* context, char* cause);
+
+
+
+/** The data returned on completion of an unsuccessful API call in the response callback onFailure. */
+typedef struct
+{
+	/** A token identifying the failed request. */
+	MQTTAsync_token token;
+	/** A numeric code identifying the error. */
+	int code;
+	/** Optional text explaining the error. Can be NULL. */
+	const char *message;
+} MQTTAsync_failureData;
+
+/** The data returned on completion of a successful API call in the response callback onSuccess. */
+typedef struct
+{
+	/** A token identifying the successful request. Can be used to refer to the request later. */
+	MQTTAsync_token token;
+	/** A union of the different values that can be returned for subscribe, unsubscribe and publish. */
+	union
+	{
+		/** For subscribe, the granted QoS of the subscription returned by the server. */
+		int qos;
+		/** For subscribeMany, the list of granted QoSs of the subscriptions returned by the server. */
+		int* qosList;
+		/** For publish, the message being sent to the server. */
+		struct
+		{
+			MQTTAsync_message message;
+			char* destinationName;
+		} pub;
+		/* For connect, the server connected to, MQTT version used, and sessionPresent flag */
+		struct
+		{
+			char* serverURI;
+			int MQTTVersion;
+			int sessionPresent;
+		} connect;
+	} alt;
+} MQTTAsync_successData;
+
+/**
+ * This is a callback function. The client application
+ * must provide an implementation of this function to enable asynchronous
+ * notification of the successful completion of an API call. The function is
+ * registered with the client library by passing it as an argument in
+ * ::MQTTAsync_responseOptions.
+ * @param context A pointer to the <i>context</i> value originally passed to
+ * ::MQTTAsync_responseOptions, which contains any application-specific context.
+ * @param response Any success data associated with the API completion.
+ */
+typedef void MQTTAsync_onSuccess(void* context, MQTTAsync_successData* response);
+
+/**
+ * This is a callback function. The client application
+ * must provide an implementation of this function to enable asynchronous
+ * notification of the unsuccessful completion of an API call. The function is
+ * registered with the client library by passing it as an argument in
+ * ::MQTTAsync_responseOptions.
+ * @param context A pointer to the <i>context</i> value originally passed to
+ * ::MQTTAsync_responseOptions, which contains any application-specific context.
+ * @param response Any failure data associated with the API completion.
+ */
+typedef void MQTTAsync_onFailure(void* context,  MQTTAsync_failureData* response);
+
+typedef struct
+{
+	/** The eyecatcher for this structure.  Must be MQTR */
+	char struct_id[4];
+	/** The version number of this structure.  Must be 0 */
+	int struct_version;
+	/**
+    * A pointer to a callback function to be called if the API call successfully
+    * completes.  Can be set to NULL, in which case no indication of successful
+    * completion will be received.
+    */
+	MQTTAsync_onSuccess* onSuccess;
+	/**
+    * A pointer to a callback function to be called if the API call fails.
+    * Can be set to NULL, in which case no indication of unsuccessful
+    * completion will be received.
+    */
+	MQTTAsync_onFailure* onFailure;
+	/**
+	* A pointer to any application-specific context. The
+    * the <i>context</i> pointer is passed to success or failure callback functions to
+    * provide access to the context information in the callback.
+    */
+	void* context;
+	MQTTAsync_token token;   /* output */
+} MQTTAsync_responseOptions;
+
+#define MQTTAsync_responseOptions_initializer { {'M', 'Q', 'T', 'R'}, 0, NULL, NULL, 0, 0 }
+
+
+/**
+ * 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.
+ *
+ * <b>Note:</b> The MQTT client must be disconnected when this function is
+ * called.
+ * @param handle A valid client handle from a successful call to
+ * MQTTAsync_create().
+ * @param context A pointer to any application-specific context. The
+ * the <i>context</i> pointer is passed to each of the callback functions to
+ * provide access to the context information in the callback.
+ * @param cl A pointer to an MQTTAsync_connectionLost() callback
+ * function. You can set this to NULL if your application doesn't handle
+ * disconnections.
+ * @param ma A pointer to an MQTTAsync_messageArrived() callback
+ * function.  You can set this to NULL if your application doesn't handle
+ * receipt of messages.
+ * @param 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.
+ * @return ::MQTTASYNC_SUCCESS if the callbacks were correctly set,
+ * ::MQTTASYNC_FAILURE if an error occurred.
+ */
+DLLExport int MQTTAsync_setCallbacks(MQTTAsync handle, void* context, MQTTAsync_connectionLost* cl,
+									MQTTAsync_messageArrived* ma, MQTTAsync_deliveryComplete* dc);
+
+
+/**
+ * Sets the MQTTAsync_connected() callback function for a client.
+ * @param handle A valid client handle from a successful call to
+ * MQTTAsync_create().
+ * @param context A pointer to any application-specific context. The
+ * the <i>context</i> pointer is passed to each of the callback functions to
+ * provide access to the context information in the callback.
+ * @param co A pointer to an MQTTAsync_connected() callback
+ * function.  NULL removes the callback setting.
+ * @return ::MQTTASYNC_SUCCESS if the callbacks were correctly set,
+ * ::MQTTASYNC_FAILURE if an error occurred.
+ */
+DLLExport int MQTTAsync_setConnected(MQTTAsync handle, void* context, MQTTAsync_connected* co);
+
+
+/**
+ * Reconnects a client with the previously used connect options.  Connect
+ * must have previously been called for this to work.
+ * @param handle A valid client handle from a successful call to
+ * MQTTAsync_create().
+ * @return ::MQTTASYNC_SUCCESS if the callbacks were correctly set,
+ * ::MQTTASYNC_FAILURE if an error occurred.
+ */
+DLLExport int MQTTAsync_reconnect(MQTTAsync handle);
+
+
+/**
+ * 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().
+ * @param handle A pointer to an ::MQTTAsync handle. The handle is
+ * populated with a valid client reference following a successful return from
+ * this function.
+ * @param serverURI A null-terminated string specifying the server to
+ * which the client will connect. It takes the form <i>protocol://host:port</i>.
+ * <i>protocol</i> must be <i>tcp</i> or <i>ssl</i>. For <i>host</i>, 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
+ * <i>tcp://localhost:1883</i>.
+ * @param clientId The client identifier passed to the server when the
+ * client connects to it. It is a null-terminated UTF-8 encoded string.
+ * @param persistence_type The type of persistence to be used by the client:
+ * <br>
+ * ::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.
+ * <br>
+ * ::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.
+ * <br>
+ * ::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.
+ * @param 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.
+ * @return ::MQTTASYNC_SUCCESS if the client is successfully created, otherwise
+ * an error code is returned.
+ */
+DLLExport int MQTTAsync_create(MQTTAsync* handle, const char* serverURI, const char* clientId,
+		int persistence_type, void* persistence_context);
+
+typedef struct
+{
+	/** The eyecatcher for this structure.  must be MQCO. */
+	char struct_id[4];
+	/** The version number of this structure.  Must be 0 */
+	int struct_version;
+	/** Whether to allow messages to be sent when the client library is not connected. */
+	int sendWhileDisconnected;
+	/** the maximum number of messages allowed to be buffered while not connected. */
+	int maxBufferedMessages;
+} MQTTAsync_createOptions;
+
+#define MQTTAsync_createOptions_initializer { {'M', 'Q', 'C', 'O'}, 0, 0, 100 }
+
+
+DLLExport int MQTTAsync_createWithOptions(MQTTAsync* handle, const char* serverURI, const char* clientId,
+		int persistence_type, void* persistence_context, MQTTAsync_createOptions* options);
+
+/**
+ * MQTTAsync_willOptions defines the MQTT "Last Will and Testament" (LWT) settings for
+ * the client. In the event that a client unexpectedly loses its connection to
+ * the server, the server publishes the LWT message to the LWT topic on
+ * behalf of the client. This allows other clients (subscribed to the LWT topic)
+ * to be made aware that the client has disconnected. To enable the LWT
+ * function for a specific client, a valid pointer to an MQTTAsync_willOptions
+ * structure is passed in the MQTTAsync_connectOptions structure used in the
+ * MQTTAsync_connect() call that connects the client to the server. The pointer
+ * to MQTTAsync_willOptions can be set to NULL if the LWT function is not
+ * required.
+ */
+typedef struct
+{
+	/** The eyecatcher for this structure.  must be MQTW. */
+	char struct_id[4];
+	/** The version number of this structure.  Must be 0 or 1
+	    0 indicates no binary will message support
+	 */
+	int struct_version;
+	/** The LWT topic to which the LWT message will be published. */
+	const char* topicName;
+	/** The LWT payload. */
+	const char* message;
+	/**
+      * The retained flag for the LWT message (see MQTTAsync_message.retained).
+      */
+	int retained;
+	/**
+      * The quality of service setting for the LWT message (see
+      * MQTTAsync_message.qos and @ref qos).
+      */
+	int qos;
+  /** The LWT payload in binary form. This is only checked and used if the message option is NULL */
+	struct
+	{
+  	int len;            /**< binary payload length */
+		const void* data;  /**< binary payload data */
+	} payload;
+} MQTTAsync_willOptions;
+
+#define MQTTAsync_willOptions_initializer { {'M', 'Q', 'T', 'W'}, 1, NULL, NULL, 0, 0, { 0, NULL } }
+
+/**
+* MQTTAsync_sslProperties defines the settings to establish an SSL/TLS connection using the
+* OpenSSL library. It covers the following scenarios:
+* - Server authentication: The client needs the digital certificate of the server. It is included
+*   in a store containting trusted material (also known as "trust store").
+* - Mutual authentication: Both client and server are authenticated during the SSL handshake. In
+*   addition to the digital certificate of the server in a trust store, the client will need its own
+*   digital certificate and the private key used to sign its digital certificate stored in a "key store".
+* - Anonymous connection: Both client and server do not get authenticated and no credentials are needed
+*   to establish an SSL connection. Note that this scenario is not fully secure since it is subject to
+*   man-in-the-middle attacks.
+*/
+typedef struct
+{
+	/** The eyecatcher for this structure.  Must be MQTS */
+	char struct_id[4];
+	/** The version number of this structure.  Must be 0 */
+	int struct_version;
+
+	/** The file in PEM format containing the public digital certificates trusted by the client. */
+	const char* trustStore;
+
+	/** The file in PEM format containing the public certificate chain of the client. It may also include
+	* the client's private key.
+	*/
+	const char* keyStore;
+
+	/** If not included in the sslKeyStore, this setting points to the file in PEM format containing
+	* the client's private key.
+	*/
+	const char* privateKey;
+	/** The password to load the client's privateKey if encrypted. */
+	const char* privateKeyPassword;
+
+	/**
+	* The list of cipher suites that the client will present to the server during the SSL handshake. For a
+	* full explanation of the cipher list format, please see the OpenSSL on-line documentation:
+	* http://www.openssl.org/docs/apps/ciphers.html#CIPHER_LIST_FORMAT
+	* If this setting is ommitted, its default value will be "ALL", that is, all the cipher suites -excluding
+	* those offering no encryption- will be considered.
+	* This setting can be used to set an SSL anonymous connection ("aNULL" string value, for instance).
+	*/
+	const char* enabledCipherSuites;
+
+    /** True/False option to enable verification of the server certificate **/
+    int enableServerCertAuth;
+
+} MQTTAsync_SSLOptions;
+
+#define MQTTAsync_SSLOptions_initializer { {'M', 'Q', 'T', 'S'}, 0, NULL, NULL, NULL, NULL, NULL, 1 }
+
+/**
+ * MQTTAsync_connectOptions defines several settings that control the way the
+ * client connects to an MQTT server.  Default values are set in
+ * MQTTAsync_connectOptions_initializer.
+ */
+typedef struct
+{
+	/** The eyecatcher for this structure.  must be MQTC. */
+	char struct_id[4];
+	/** The version number of this structure.  Must be 0, 1, 2, 3 4 or 5.
+	  * 0 signifies no SSL options and no serverURIs
+	  * 1 signifies no serverURIs
+    * 2 signifies no MQTTVersion
+    * 3 signifies no automatic reconnect options
+    * 4 signifies no binary password option (just string)
+	  */
+	int struct_version;
+	/** The "keep alive" interval, measured in seconds, defines the maximum time
+      * that should pass without communication between the client and the server
+      * The client will ensure that at least one message travels across the
+      * network within each keep alive period.  In the absence of a data-related
+	  * message during the time period, the client sends a very small MQTT
+      * "ping" message, which the server will acknowledge. The keep alive
+      * interval enables the client to detect when the server is no longer
+	  * available without having to wait for the long TCP/IP timeout.
+	  * Set to 0 if you do not want any keep alive processing.
+	  */
+	int keepAliveInterval;
+	/**
+      * This is a boolean value. The cleansession setting controls the behaviour
+      * of both the client and the server at connection and disconnection time.
+      * The client and server both maintain session state information. This
+      * information is used to ensure "at least once" and "exactly once"
+      * delivery, and "exactly once" receipt of messages. Session state also
+      * includes subscriptions created by an MQTT client. You can choose to
+      * maintain or discard state information between sessions.
+      *
+      * When cleansession is true, the state information is discarded at
+      * connect and disconnect. Setting cleansession to false keeps the state
+      * information. When you connect an MQTT client application with
+      * MQTTAsync_connect(), the client identifies the connection using the
+      * client identifier and the address of the server. The server checks
+      * whether session information for this client
+      * has been saved from a previous connection to the server. If a previous
+      * session still exists, and cleansession=true, then the previous session
+      * information at the client and server is cleared. If cleansession=false,
+      * the previous session is resumed. If no previous session exists, a new
+      * session is started.
+	  */
+	int cleansession;
+	/**
+      * This controls how many messages can be in-flight simultaneously.
+	  */
+	int maxInflight;
+	/**
+      * This is a pointer to an MQTTAsync_willOptions structure. If your
+      * application does not make use of the Last Will and Testament feature,
+      * set this pointer to NULL.
+      */
+	MQTTAsync_willOptions* will;
+	/**
+      * MQTT servers that support the MQTT v3.1 protocol provide authentication
+      * and authorisation by user name and password. This is the user name
+      * parameter.
+      */
+	const char* username;
+	/**
+      * MQTT servers that support the MQTT v3.1 protocol provide authentication
+      * and authorisation by user name and password. This is the password
+      * parameter.
+      */
+	const char* password;
+	/**
+      * The time interval in seconds to allow a connect to complete.
+      */
+	int connectTimeout;
+	/**
+	 * The time interval in seconds
+	 */
+	int retryInterval;
+	/**
+      * This is a pointer to an MQTTAsync_SSLOptions structure. If your
+      * application does not make use of SSL, set this pointer to NULL.
+      */
+	MQTTAsync_SSLOptions* ssl;
+	/**
+      * A pointer to a callback function to be called if the connect successfully
+      * completes.  Can be set to NULL, in which case no indication of successful
+      * completion will be received.
+      */
+	MQTTAsync_onSuccess* onSuccess;
+	/**
+      * A pointer to a callback function to be called if the connect fails.
+      * Can be set to NULL, in which case no indication of unsuccessful
+      * completion will be received.
+      */
+	MQTTAsync_onFailure* onFailure;
+	/**
+	  * A pointer to any application-specific context. The
+      * the <i>context</i> pointer is passed to success or failure callback functions to
+      * provide access to the context information in the callback.
+      */
+	void* context;
+	/**
+	  * The number of entries in the serverURIs array.
+	  */
+	int serverURIcount;
+	/**
+	  * An array of null-terminated strings specifying the servers to
+      * which the client will connect. Each string takes the form <i>protocol://host:port</i>.
+      * <i>protocol</i> must be <i>tcp</i> or <i>ssl</i>. For <i>host</i>, you can
+      * specify either an IP address or a domain name. For instance, to connect to
+      * a server running on the local machines with the default MQTT port, specify
+      * <i>tcp://localhost:1883</i>.
+      */
+	char* const* serverURIs;
+	/**
+      * Sets the version of MQTT to be used on the connect.
+      * MQTTVERSION_DEFAULT (0) = default: start with 3.1.1, and if that fails, fall back to 3.1
+      * MQTTVERSION_3_1 (3) = only try version 3.1
+      * MQTTVERSION_3_1_1 (4) = only try version 3.1.1
+	  */
+	int MQTTVersion;
+	/**
+	  * Reconnect automatically in the case of a connection being lost?
+	  */
+	int automaticReconnect;
+	/**
+	  * Minimum retry interval in seconds.  Doubled on each failed retry.
+	  */
+	int minRetryInterval;
+	/**
+	  * Maximum retry interval in seconds.  The doubling stops here on failed retries.
+	  */
+	int maxRetryInterval;
+	/**
+   * Optional binary password.  Only checked and used if the password option is NULL
+   */
+  struct {
+  	int len;            /**< binary password length */
+		const void* data;  /**< binary password data */
+	} binarypwd;
+} MQTTAsync_connectOptions;
+
+
+#define MQTTAsync_connectOptions_initializer { {'M', 'Q', 'T', 'C'}, 5, 60, 1, 10, NULL, NULL, NULL, 30, 0,\
+NULL, NULL, NULL, NULL, 0, NULL, 0, 0, 1, 60, {0, NULL}}
+
+/**
+  * 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().
+  * @param handle A valid client handle from a successful call to
+  * MQTTAsync_create().
+  * @param options A pointer to a valid MQTTAsync_connectOptions
+  * structure.
+  * @return ::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:<br><br>
+  * <b>1</b>: Connection refused: Unacceptable protocol version<br>
+  * <b>2</b>: Connection refused: Identifier rejected<br>
+  * <b>3</b>: Connection refused: Server unavailable<br>
+  * <b>4</b>: Connection refused: Bad user name or password<br>
+  * <b>5</b>: Connection refused: Not authorized<br>
+  * <b>6-255</b>: Reserved for future use<br>
+  */
+DLLExport int MQTTAsync_connect(MQTTAsync handle, const MQTTAsync_connectOptions* options);
+
+
+typedef struct
+{
+	/** The eyecatcher for this structure. Must be MQTD. */
+	char struct_id[4];
+	/** The version number of this structure.  Must be 0 or 1.  0 signifies no SSL options */
+	int struct_version;
+	/**
+      * The client delays disconnection for up to this time (in
+      * milliseconds) in order to allow in-flight message transfers to complete.
+      */
+	int timeout;
+	/**
+    * A pointer to a callback function to be called if the disconnect successfully
+    * completes.  Can be set to NULL, in which case no indication of successful
+    * completion will be received.
+    */
+	MQTTAsync_onSuccess* onSuccess;
+	/**
+    * A pointer to a callback function to be called if the disconnect fails.
+    * Can be set to NULL, in which case no indication of unsuccessful
+    * completion will be received.
+    */
+	MQTTAsync_onFailure* onFailure;
+	/**
+	* A pointer to any application-specific context. The
+    * the <i>context</i> pointer is passed to success or failure callback functions to
+    * provide access to the context information in the callback.
+    */
+	void* context;
+} MQTTAsync_disconnectOptions;
+
+#define MQTTAsync_disconnectOptions_initializer { {'M', 'Q', 'T', 'D'}, 0, 0, NULL, NULL, NULL }
+
+
+/**
+  * 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()).
+  * @param handle A valid client handle from a successful call to
+  * MQTTAsync_create().
+  * @param options The client delays disconnection for up to this time (in
+  * milliseconds) in order to allow in-flight message transfers to complete.
+  * @return ::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
+  */
+DLLExport int MQTTAsync_disconnect(MQTTAsync handle, const MQTTAsync_disconnectOptions* options);
+
+
+/**
+  * This function allows the client application to test whether or not a
+  * client is currently connected to the MQTT server.
+  * @param handle A valid client handle from a successful call to
+  * MQTTAsync_create().
+  * @return Boolean true if the client is connected, otherwise false.
+  */
+DLLExport int MQTTAsync_isConnected(MQTTAsync handle);
+
+
+/**
+  * This function attempts to subscribe a client to a single topic, which may
+  * contain wildcards (see @ref wildcard). This call also specifies the
+  * @ref qos requested for the subscription
+  * (see also MQTTAsync_subscribeMany()).
+  * @param handle A valid client handle from a successful call to
+  * MQTTAsync_create().
+  * @param topic The subscription topic, which may include wildcards.
+  * @param qos The requested quality of service for the subscription.
+  * @param response A pointer to a response options structure. Used to set callback functions.
+  * @return ::MQTTASYNC_SUCCESS if the subscription request is successful.
+  * An error code is returned if there was a problem registering the
+  * subscription.
+  */
+DLLExport int MQTTAsync_subscribe(MQTTAsync handle, const char* topic, int qos, MQTTAsync_responseOptions* response);
+
+
+/**
+  * This function attempts to subscribe a client to a list of topics, which may
+  * contain wildcards (see @ref wildcard). This call also specifies the
+  * @ref qos requested for each topic (see also MQTTAsync_subscribe()).
+  * @param handle A valid client handle from a successful call to
+  * MQTTAsync_create().
+  * @param count The number of topics for which the client is requesting
+  * subscriptions.
+  * @param topic An array (of length <i>count</i>) of pointers to
+  * topics, each of which may include wildcards.
+  * @param qos An array (of length <i>count</i>) of @ref qos
+  * values. qos[n] is the requested QoS for topic[n].
+  * @param response A pointer to a response options structure. Used to set callback functions.
+  * @return ::MQTTASYNC_SUCCESS if the subscription request is successful.
+  * An error code is returned if there was a problem registering the
+  * subscriptions.
+  */
+DLLExport int MQTTAsync_subscribeMany(MQTTAsync handle, int count, char* const* topic, int* qos, MQTTAsync_responseOptions* response);
+
+/**
+  * This function attempts to remove an existing subscription made by the
+  * specified client.
+  * @param handle A valid client handle from a successful call to
+  * MQTTAsync_create().
+  * @param topic The topic for the subscription to be removed, which may
+  * include wildcards (see @ref wildcard).
+  * @param response A pointer to a response options structure. Used to set callback functions.
+  * @return ::MQTTASYNC_SUCCESS if the subscription is removed.
+  * An error code is returned if there was a problem removing the
+  * subscription.
+  */
+DLLExport int MQTTAsync_unsubscribe(MQTTAsync handle, const char* topic, MQTTAsync_responseOptions* response);
+
+/**
+  * This function attempts to remove existing subscriptions to a list of topics
+  * made by the specified client.
+  * @param handle A valid client handle from a successful call to
+  * MQTTAsync_create().
+  * @param count The number subscriptions to be removed.
+  * @param topic An array (of length <i>count</i>) of pointers to the topics of
+  * the subscriptions to be removed, each of which may include wildcards.
+  * @param response A pointer to a response options structure. Used to set callback functions.
+  * @return ::MQTTASYNC_SUCCESS if the subscriptions are removed.
+  * An error code is returned if there was a problem removing the subscriptions.
+  */
+DLLExport int MQTTAsync_unsubscribeMany(MQTTAsync handle, int count, char* const* topic, 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()).
+  * @param handle A valid client handle from a successful call to
+  * MQTTAsync_create().
+  * @param destinationName The topic associated with this message.
+  * @param payloadlen The length of the payload in bytes.
+  * @param payload A pointer to the byte array payload of the message.
+  * @param qos The @ref qos of the message.
+  * @param retained The retained flag for the message.
+  * @param response A pointer to an ::MQTTAsync_responseOptions structure. Used to set callback functions.
+  * This is optional and can be set to NULL.
+  * @return ::MQTTASYNC_SUCCESS if the message is accepted for publication.
+  * An error code is returned if there was a problem accepting the message.
+  */
+DLLExport 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_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()).
+  * @param handle A valid client handle from a successful call to
+  * MQTTAsync_create().
+  * @param destinationName The topic associated with this message.
+  * @param msg A pointer to a valid MQTTAsync_message structure containing
+  * the payload and attributes of the message to be published.
+  * @param response A pointer to an ::MQTTAsync_responseOptions structure. Used to set callback functions.
+  * @return ::MQTTASYNC_SUCCESS if the message is accepted for publication.
+  * An error code is returned if there was a problem accepting the message.
+  */
+DLLExport int MQTTAsync_sendMessage(MQTTAsync handle, const char* destinationName, const MQTTAsync_message* msg, MQTTAsync_responseOptions* response);
+
+
+/**
+  * This function sets a pointer to an array of tokens for
+  * messages that are currently in-flight (pending completion).
+  *
+  * <b>Important note:</b> 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.
+  * @param handle A valid client handle from a successful call to
+  * MQTTAsync_create().
+  * @param 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.
+  * @return ::MQTTASYNC_SUCCESS if the function returns successfully.
+  * An error code is returned if there was a problem obtaining the list of
+  * pending tokens.
+  */
+DLLExport int MQTTAsync_getPendingTokens(MQTTAsync handle, MQTTAsync_token **tokens);
+
+/**
+ * Tests whether a request corresponding to a token is complete.
+ *
+ * @param handle A valid client handle from a successful call to
+ * MQTTAsync_create().
+ * @param token An ::MQTTAsync_token associated with a request.
+ * @return 1 if the request has been completed, 0 if not.
+ */
+#define MQTTASYNC_TRUE 1
+DLLExport int MQTTAsync_isComplete(MQTTAsync handle, MQTTAsync_token token);
+
+
+/**
+ * Waits for a request corresponding to a token to complete.
+ *
+ * @param handle A valid client handle from a successful call to
+ * MQTTAsync_create().
+ * @param token An ::MQTTAsync_token associated with a request.
+ * @param timeout the maximum time to wait for completion, in milliseconds
+ * @return ::MQTTASYNC_SUCCESS if the request has been completed in the time allocated,
+ *  ::MQTTASYNC_FAILURE if not.
+ */
+DLLExport int MQTTAsync_waitForCompletion(MQTTAsync handle, MQTTAsync_token token, unsigned long timeout);
+
+
+/**
+  * 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. <b>Important
+  * note:</b> 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.
+  * @param msg The address of a pointer to the ::MQTTAsync_message structure
+  * to be freed.
+  */
+DLLExport void MQTTAsync_freeMessage(MQTTAsync_message** msg);
+
+/**
+  * 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.
+  * @param ptr The pointer to the client library storage to be freed.
+  */
+DLLExport void MQTTAsync_free(void* ptr);
+
+/**
+  * This function frees the memory allocated to an MQTT client (see
+  * MQTTAsync_create()). It should be called when the client is no longer
+  * required.
+  * @param handle A pointer to the handle referring to the ::MQTTAsync
+  * structure to be freed.
+  */
+DLLExport void MQTTAsync_destroy(MQTTAsync* handle);
+
+
+
+enum MQTTASYNC_TRACE_LEVELS
+{
+	MQTTASYNC_TRACE_MAXIMUM = 1,
+	MQTTASYNC_TRACE_MEDIUM,
+	MQTTASYNC_TRACE_MINIMUM,
+	MQTTASYNC_TRACE_PROTOCOL,
+	MQTTASYNC_TRACE_ERROR,
+	MQTTASYNC_TRACE_SEVERE,
+	MQTTASYNC_TRACE_FATAL,
+};
+
+
+/**
+  * This function sets the level of trace information which will be
+  * returned in the trace callback.
+  * @param level the trace level required
+  */
+DLLExport void MQTTAsync_setTraceLevel(enum MQTTASYNC_TRACE_LEVELS level);
+
+
+/**
+  * This is a callback function prototype which must be implemented if you want
+  * to receive trace information.
+  * @param level the trace level of the message returned
+  * @param meesage the trace message.  This is a pointer to a static buffer which
+  * will be overwritten on each call.  You must copy the data if you want to keep
+  * it for later.
+  */
+typedef void MQTTAsync_traceCallback(enum MQTTASYNC_TRACE_LEVELS level, char* message);
+
+/**
+  * 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.
+  * @param callback a pointer to the function which will handle the trace information
+  */
+DLLExport void MQTTAsync_setTraceCallback(MQTTAsync_traceCallback* callback);
+
+
+typedef struct
+{
+	const char* name;
+	const char* value;
+} MQTTAsync_nameValue;
+
+/**
+  * This function returns version information about the library.
+  * no trace information will be returned.  The default trace level is
+  * MQTTASYNC_TRACE_MINIMUM
+  * @return an array of strings describing the library.  The last entry is a NULL pointer.
+  */
+DLLExport MQTTAsync_nameValue* MQTTAsync_getVersionInfo(void);
+
+
+/**
+  * @cond MQTTAsync_main
+  * @page async Threading
+  * The client application runs on several threads.
+  * Processing of handshaking and maintaining
+  * the network connection is performed in the background.
+  * This API is thread safe: functions may be called by multiple application
+  * threads.
+  * Notifications of status and message reception are provided to the client
+  * application using callbacks registered with the library by the call to
+  * MQTTAsync_setCallbacks() (see MQTTAsync_messageArrived(),
+  * MQTTAsync_connectionLost() and MQTTAsync_deliveryComplete()).
+  * In addition, some functions allow success and failure callbacks to be set
+  * for individual requests, in the ::MQTTAsync_responseOptions structure.  Applications
+  * can be written as a chain of callback functions. Note that it is a theoretically
+  * possible but unlikely event, that a success or failure callback could be called
+  * before function requesting the callback has returned.  In this case the token
+  * delivered in the callback would not yet be known to the application program (see
+  * Race condition for MQTTAsync_token in MQTTAsync.c
+  * https://bugs.eclipse.org/bugs/show_bug.cgi?id=444093)
+  *
+  * @page auto_reconnect Automatic Reconnect
+  * The ability for the client library to reconnect automatically in the event
+  * of a connection failure was added in 1.1.  The connection lost callback
+  * allows a flexible response to the loss of a connection, so almost any
+  * behaviour can be implemented in that way.  Automatic reconnect does have the
+  * advantage of being a little simpler to use.
+  *
+  * To switch on automatic reconnect, the connect options field
+  * automaticReconnect should be set to non-zero.  The minimum and maximum times
+  * before the next connection attempt can also be set, the defaults being 1 and
+  * 60 seconds.  At each failure to reconnect, the retry interval is doubled until
+  * the maximum value is reached, and there it stays until the connection is
+  * successfully re-established whereupon it is reset.
+  *
+  * When a reconnection attempt is successful, the ::MQTTAsync_connected callback
+  * function is invoked, if set by calling ::MQTTAsync_setConnected.  This allows
+  * the application to take any actions needed, such as amending subscriptions.
+  *
+  * @page offline_publish Publish While Disconnected
+  * This feature was not originally available because with persistence enabled,
+  * messages could be stored locally without ever knowing if they could be sent.
+  * The client application could have created the client with an erroneous broker
+  * address or port for instance.
+  *
+  * To enable messages to be published when the application is disconnected
+  * ::MQTTAsync_createWithOptions must be used instead of ::MQTTAsync_create to
+  * create the client object.  The ::createOptions field sendWhileDisconnected
+  * must be set to non-zero, and the maxBufferedMessages field set as required -
+  * the default being 100.
+  *
+  * ::MQTTAsync_getPendingTokens can be called to return the ids of the messages
+  * waiting to be sent, or for which the sending process has not completed.
+  *
+  * @page wildcard Subscription wildcards
+  * Every MQTT message includes a topic that classifies it. MQTT servers use
+  * topics to determine which subscribers should receive messages published to
+  * the server.
+  *
+  * Consider the server receiving messages from several environmental sensors.
+  * Each sensor publishes its measurement data as a message with an associated
+  * topic. Subscribing applications need to know which sensor originally
+  * published each received message. A unique topic is thus used to identify
+  * each sensor and measurement type. Topics such as SENSOR1TEMP,
+  * SENSOR1HUMIDITY, SENSOR2TEMP and so on achieve this but are not very
+  * flexible. If additional sensors are added to the system at a later date,
+  * subscribing applications must be modified to receive them.
+  *
+  * To provide more flexibility, MQTT supports a hierarchical topic namespace.
+  * This allows application designers to organize topics to simplify their
+  * management. Levels in the hierarchy are delimited by the '/' character,
+  * such as SENSOR/1/HUMIDITY. Publishers and subscribers use these
+  * hierarchical topics as already described.
+  *
+  * For subscriptions, two wildcard characters are supported:
+  * <ul>
+  * <li>A '#' character represents a complete sub-tree of the hierarchy and
+  * thus must be the last character in a subscription topic string, such as
+  * SENSOR/#. This will match any topic starting with SENSOR/, such as
+  * SENSOR/1/TEMP and SENSOR/2/HUMIDITY.</li>
+  * <li> A '+' character represents a single level of the hierarchy and is
+  * used between delimiters. For example, SENSOR/+/TEMP will match
+  * SENSOR/1/TEMP and SENSOR/2/TEMP.</li>
+  * </ul>
+  * Publishers are not allowed to use the wildcard characters in their topic
+  * names.
+  *
+  * Deciding on your topic hierarchy is an important step in your system design.
+  *
+  * @page qos Quality of service
+  * The MQTT protocol provides three qualities of service for delivering
+  * messages between clients and servers: "at most once", "at least once" and
+  * "exactly once".
+  *
+  * Quality of service (QoS) is an attribute of an individual message being
+  * published. An application sets the QoS for a specific message by setting the
+  * MQTTAsync_message.qos field to the required value.
+  *
+  * A subscribing client can set the maximum quality of service a server uses
+  * to send messages that match the client subscriptions. The
+  * MQTTAsync_subscribe() and MQTTAsync_subscribeMany() functions set this
+  * maximum. The QoS of a message forwarded to a subscriber thus might be
+  * different to the QoS given to the message by the original publisher.
+  * The lower of the two values is used to forward a message.
+  *
+  * The three levels are:
+  *
+  * <b>QoS0, At most once:</b> The message is delivered at most once, or it
+  * may not be delivered at all. Its delivery across the network is not
+  * acknowledged. The message is not stored. The message could be lost if the
+  * client is disconnected, or if the server fails. QoS0 is the fastest mode of
+  * transfer. It is sometimes called "fire and forget".
+  *
+  * The MQTT protocol does not require servers to forward publications at QoS0
+  * to a client. If the client is disconnected at the time the server receives
+  * the publication, the publication might be discarded, depending on the
+  * server implementation.
+  *
+  * <b>QoS1, At least once:</b> The message is always delivered at least once.
+  * It might be delivered multiple times if there is a failure before an
+  * acknowledgment is received by the sender. The message must be stored
+  * locally at the sender, until the sender receives confirmation that the
+  * message has been published by the receiver. The message is stored in case
+  * the message must be sent again.
+  *
+  * <b>QoS2, Exactly once:</b> The message is always delivered exactly once.
+  * The message must be stored locally at the sender, until the sender receives
+  * confirmation that the message has been published by the receiver. The
+  * message is stored in case the message must be sent again. QoS2 is the
+  * safest, but slowest mode of transfer. A more sophisticated handshaking
+  * and acknowledgement sequence is used than for QoS1 to ensure no duplication
+  * of messages occurs.
+
+
+  * @page publish Publication example
+@code
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "MQTTAsync.h"
+
+#define ADDRESS     "tcp://localhost:1883"
+#define CLIENTID    "ExampleClientPub"
+#define TOPIC       "MQTT Examples"
+#define PAYLOAD     "Hello World!"
+#define QOS         1
+#define TIMEOUT     10000L
+
+volatile MQTTAsync_token deliveredtoken;
+
+int finished = 0;
+
+void connlost(void *context, char *cause)
+{
+	MQTTAsync client = (MQTTAsync)context;
+	MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
+	int rc;
+
+	printf("\nConnection lost\n");
+	printf("     cause: %s\n", cause);
+
+	printf("Reconnecting\n");
+	conn_opts.keepAliveInterval = 20;
+	conn_opts.cleansession = 1;
+	if ((rc = MQTTAsync_connect(client, &conn_opts)) != MQTTASYNC_SUCCESS)
+	{
+		printf("Failed to start connect, return code %d\n", rc);
+ 		finished = 1;
+	}
+}
+
+
+void onDisconnect(void* context, MQTTAsync_successData* response)
+{
+	printf("Successful disconnection\n");
+	finished = 1;
+}
+
+
+void onSend(void* context, MQTTAsync_successData* response)
+{
+	MQTTAsync client = (MQTTAsync)context;
+	MQTTAsync_disconnectOptions opts = MQTTAsync_disconnectOptions_initializer;
+	int rc;
+
+	printf("Message with token value %d delivery confirmed\n", response->token);
+
+	opts.onSuccess = onDisconnect;
+	opts.context = client;
+
+	if ((rc = MQTTAsync_disconnect(client, &opts)) != MQTTASYNC_SUCCESS)
+	{
+		printf("Failed to start sendMessage, return code %d\n", rc);
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+void onConnectFailure(void* context, MQTTAsync_failureData* response)
+{
+	printf("Connect failed, rc %d\n", response ? response->code : 0);
+	finished = 1;
+}
+
+
+void onConnect(void* context, MQTTAsync_successData* response)
+{
+	MQTTAsync client = (MQTTAsync)context;
+	MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
+	MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
+	int rc;
+
+	printf("Successful connection\n");
+
+	opts.onSuccess = onSend;
+	opts.context = client;
+
+	pubmsg.payload = PAYLOAD;
+	pubmsg.payloadlen = strlen(PAYLOAD);
+	pubmsg.qos = QOS;
+	pubmsg.retained = 0;
+	deliveredtoken = 0;
+
+	if ((rc = MQTTAsync_sendMessage(client, TOPIC, &pubmsg, &opts)) != MQTTASYNC_SUCCESS)
+	{
+		printf("Failed to start sendMessage, return code %d\n", rc);
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+int main(int argc, char* argv[])
+{
+	MQTTAsync client;
+	MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
+	MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
+	MQTTAsync_token token;
+	int rc;
+
+	MQTTAsync_create(&client, ADDRESS, CLIENTID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
+
+	MQTTAsync_setCallbacks(client, NULL, connlost, NULL, NULL);
+
+	conn_opts.keepAliveInterval = 20;
+	conn_opts.cleansession = 1;
+	conn_opts.onSuccess = onConnect;
+	conn_opts.onFailure = onConnectFailure;
+	conn_opts.context = client;
+	if ((rc = MQTTAsync_connect(client, &conn_opts)) != MQTTASYNC_SUCCESS)
+	{
+		printf("Failed to start connect, return code %d\n", rc);
+		exit(EXIT_FAILURE);
+	}
+
+	printf("Waiting for publication of %s\n"
+         "on topic %s for client with ClientID: %s\n",
+         PAYLOAD, TOPIC, CLIENTID);
+	while (!finished)
+		#if defined(WIN32) || defined(WIN64)
+			Sleep(100);
+		#else
+			usleep(10000L);
+		#endif
+
+	MQTTAsync_destroy(&client);
+ 	return rc;
+}
+
+  * @endcode
+  * @page subscribe Subscription example
+@code
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "MQTTAsync.h"
+
+#define ADDRESS     "tcp://localhost:1883"
+#define CLIENTID    "ExampleClientSub"
+#define TOPIC       "MQTT Examples"
+#define PAYLOAD     "Hello World!"
+#define QOS         1
+#define TIMEOUT     10000L
+
+volatile MQTTAsync_token deliveredtoken;
+
+int disc_finished = 0;
+int subscribed = 0;
+int finished = 0;
+
+void connlost(void *context, char *cause)
+{
+	MQTTAsync client = (MQTTAsync)context;
+	MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
+	int rc;
+
+	printf("\nConnection lost\n");
+	printf("     cause: %s\n", cause);
+
+	printf("Reconnecting\n");
+	conn_opts.keepAliveInterval = 20;
+	conn_opts.cleansession = 1;
+	if ((rc = MQTTAsync_connect(client, &conn_opts)) != MQTTASYNC_SUCCESS)
+	{
+		printf("Failed to start connect, return code %d\n", rc);
+	    finished = 1;
+	}
+}
+
+
+int msgarrvd(void *context, char *topicName, int topicLen, MQTTAsync_message *message)
+{
+    int i;
+    char* payloadptr;
+
+    printf("Message arrived\n");
+    printf("     topic: %s\n", topicName);
+    printf("   message: ");
+
+    payloadptr = message->payload;
+    for(i=0; i<message->payloadlen; i++)
+    {
+        putchar(*payloadptr++);
+    }
+    putchar('\n');
+    MQTTAsync_freeMessage(&message);
+    MQTTAsync_free(topicName);
+    return 1;
+}
+
+
+void onDisconnect(void* context, MQTTAsync_successData* response)
+{
+	printf("Successful disconnection\n");
+	disc_finished = 1;
+}
+
+
+void onSubscribe(void* context, MQTTAsync_successData* response)
+{
+	printf("Subscribe succeeded\n");
+	subscribed = 1;
+}
+
+void onSubscribeFailure(void* context, MQTTAsync_failureData* response)
+{
+	printf("Subscribe failed, rc %d\n", response ? response->code : 0);
+	finished = 1;
+}
+
+
+void onConnectFailure(void* context, MQTTAsync_failureData* response)
+{
+	printf("Connect failed, rc %d\n", response ? response->code : 0);
+	finished = 1;
+}
+
+
+void onConnect(void* context, MQTTAsync_successData* response)
+{
+	MQTTAsync client = (MQTTAsync)context;
+	MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
+	MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
+	int rc;
+
+	printf("Successful connection\n");
+
+	printf("Subscribing to topic %s\nfor client %s using QoS%d\n\n"
+           "Press Q<Enter> to quit\n\n", TOPIC, CLIENTID, QOS);
+	opts.onSuccess = onSubscribe;
+	opts.onFailure = onSubscribeFailure;
+	opts.context = client;
+
+	deliveredtoken = 0;
+
+	if ((rc = MQTTAsync_subscribe(client, TOPIC, QOS, &opts)) != MQTTASYNC_SUCCESS)
+	{
+		printf("Failed to start subscribe, return code %d\n", rc);
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+int main(int argc, char* argv[])
+{
+	MQTTAsync client;
+	MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
+	MQTTAsync_disconnectOptions disc_opts = MQTTAsync_disconnectOptions_initializer;
+	MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
+	MQTTAsync_token token;
+	int rc;
+	int ch;
+
+	MQTTAsync_create(&client, ADDRESS, CLIENTID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
+
+	MQTTAsync_setCallbacks(client, NULL, connlost, msgarrvd, NULL);
+
+	conn_opts.keepAliveInterval = 20;
+	conn_opts.cleansession = 1;
+	conn_opts.onSuccess = onConnect;
+	conn_opts.onFailure = onConnectFailure;
+	conn_opts.context = client;
+	if ((rc = MQTTAsync_connect(client, &conn_opts)) != MQTTASYNC_SUCCESS)
+	{
+		printf("Failed to start connect, return code %d\n", rc);
+		exit(EXIT_FAILURE);
+	}
+
+	while	(!subscribed)
+		#if defined(WIN32) || defined(WIN64)
+			Sleep(100);
+		#else
+			usleep(10000L);
+		#endif
+
+	if (finished)
+		goto exit;
+
+	do
+	{
+		ch = getchar();
+	} while (ch!='Q' && ch != 'q');
+
+	disc_opts.onSuccess = onDisconnect;
+	if ((rc = MQTTAsync_disconnect(client, &disc_opts)) != MQTTASYNC_SUCCESS)
+	{
+		printf("Failed to start disconnect, return code %d\n", rc);
+		exit(EXIT_FAILURE);
+	}
+ 	while	(!disc_finished)
+		#if defined(WIN32) || defined(WIN64)
+			Sleep(100);
+		#else
+			usleep(10000L);
+		#endif
+
+exit:
+	MQTTAsync_destroy(&client);
+ 	return rc;
+}
+
+  * @endcode
+* @page tracing Tracing
+  *
+  * Runtime tracing can be controlled by environment variables or API calls.
+  *
+  * #### Environment variables
+  *
+  * Tracing is switched on by setting the MQTT_C_CLIENT_TRACE environment variable.
+  * A value of ON, or stdout, prints to stdout, any other value is interpreted as a file name to use.
+  *
+  * The amount of trace detail is controlled with the MQTT_C_CLIENT_TRACE_LEVEL environment
+  * variable - valid values are ERROR, PROTOCOL, MINIMUM, MEDIUM and MAXIMUM
+  * (from least to most verbose).
+  *
+  * The variable MQTT_C_CLIENT_TRACE_MAX_LINES limits the number of lines of trace that are output
+  * to a file.  Two files are used at most, when they are full, the last one is overwritten with the
+  * new trace entries.  The default size is 1000 lines.
+  *
+  * #### Trace API calls
+  *
+  * MQTTAsync_traceCallback() is used to set a callback function which is called whenever trace
+  * information is available.  This will be the same information as that printed if the
+  * environment variables were used to control the trace.
+  *
+  * The MQTTAsync_setTraceLevel() calls is used to set the maximum level of trace entries that will be
+  * passed to the callback function.  The levels are:
+  * 1. ::MQTTASYNC_TRACE_MAXIMUM
+  * 2. ::MQTTASYNC_TRACE_MEDIUM
+  * 3. ::MQTTASYNC_TRACE_MINIMUM
+  * 4. ::MQTTASYNC_TRACE_PROTOCOL
+  * 5. ::MQTTASYNC_TRACE_ERROR
+  * 6. ::MQTTASYNC_TRACE_SEVERE
+  * 7. ::MQTTASYNC_TRACE_FATAL
+  *
+  * Selecting ::MQTTASYNC_TRACE_MAXIMUM will cause all trace entries at all levels to be returned.
+  * Choosing ::MQTTASYNC_TRACE_ERROR will cause ERROR, SEVERE and FATAL trace entries to be returned
+  * to the callback function.
+  *
+  * ### MQTT Packet Tracing
+  *
+  * A feature that can be very useful is printing the MQTT packets that are sent and received.  To
+  * achieve this, use the following environment variable settings:
+  * @code
+    MQTT_C_CLIENT_TRACE=ON
+    MQTT_C_CLIENT_TRACE_LEVEL=PROTOCOL
+  * @endcode
+  * The output you should see looks like this:
+  * @code
+    20130528 155936.813 3 stdout-subscriber -> CONNECT cleansession: 1 (0)
+    20130528 155936.813 3 stdout-subscriber <- CONNACK rc: 0
+    20130528 155936.813 3 stdout-subscriber -> SUBSCRIBE msgid: 1 (0)
+    20130528 155936.813 3 stdout-subscriber <- SUBACK msgid: 1
+    20130528 155941.818 3 stdout-subscriber -> DISCONNECT (0)
+  * @endcode
+  * where the fields are:
+  * 1. date
+  * 2. time
+  * 3. socket number
+  * 4. client id
+  * 5. direction (-> from client to server, <- from server to client)
+  * 6. packet details
+  *
+  * ### Default Level Tracing
+  *
+  * This is an extract of a default level trace of a call to connect:
+  * @code
+    19700101 010000.000 (1152206656) (0)> MQTTClient_connect:893
+    19700101 010000.000 (1152206656)  (1)> MQTTClient_connectURI:716
+    20130528 160447.479 Connecting to serverURI localhost:1883
+    20130528 160447.479 (1152206656)   (2)> MQTTProtocol_connect:98
+    20130528 160447.479 (1152206656)    (3)> MQTTProtocol_addressPort:48
+    20130528 160447.479 (1152206656)    (3)< MQTTProtocol_addressPort:73
+    20130528 160447.479 (1152206656)    (3)> Socket_new:599
+    20130528 160447.479 New socket 4 for localhost, port 1883
+    20130528 160447.479 (1152206656)     (4)> Socket_addSocket:163
+    20130528 160447.479 (1152206656)      (5)> Socket_setnonblocking:73
+    20130528 160447.479 (1152206656)      (5)< Socket_setnonblocking:78 (0)
+    20130528 160447.479 (1152206656)     (4)< Socket_addSocket:176 (0)
+    20130528 160447.479 (1152206656)     (4)> Socket_error:95
+    20130528 160447.479 (1152206656)     (4)< Socket_error:104 (115)
+    20130528 160447.479 Connect pending
+    20130528 160447.479 (1152206656)    (3)< Socket_new:683 (115)
+    20130528 160447.479 (1152206656)   (2)< MQTTProtocol_connect:131 (115)
+  * @endcode
+  * where the fields are:
+  * 1. date
+  * 2. time
+  * 3. thread id
+  * 4. function nesting level
+  * 5. function entry (>) or exit (<)
+  * 6. function name : line of source code file
+  * 7. return value (if there is one)
+  *
+  * ### Memory Allocation Tracing
+  *
+  * Setting the trace level to maximum causes memory allocations and frees to be traced along with
+  * the default trace entries, with messages like the following:
+  * @code
+    20130528 161819.657 Allocating 16 bytes in heap at file /home/icraggs/workspaces/mqrtc/mqttv3c/src/MQTTPacket.c line 177 ptr 0x179f930
+
+    20130528 161819.657 Freeing 16 bytes in heap at file /home/icraggs/workspaces/mqrtc/mqttv3c/src/MQTTPacket.c line 201, heap use now 896 bytes
+  * @endcode
+  * When the last MQTT client object is destroyed, if the trace is being recorded
+  * and all memory allocated by the client library has not been freed, an error message will be
+  * written to the trace.  This can help with fixing memory leaks.  The message will look like this:
+  * @code
+    20130528 163909.208 Some memory not freed at shutdown, possible memory leak
+    20130528 163909.208 Heap scan start, total 880 bytes
+    20130528 163909.208 Heap element size 32, line 354, file /home/icraggs/workspaces/mqrtc/mqttv3c/src/MQTTPacket.c, ptr 0x260cb00
+    20130528 163909.208   Content
+    20130528 163909.209 Heap scan end
+  * @endcode
+  * @endcond
+  */
+
+
+#endif
+
+#ifdef __cplusplus
+     }
+#endif

paho.mqtt.c/MQTTClient.h

@@ -0,0 +1,1385 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2017 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *    Ian Craggs, Allan Stockdill-Mander - SSL updates
+ *    Ian Craggs - multiple server connection support
+ *    Ian Craggs - MQTT 3.1.1 support
+ *    Ian Craggs - remove const from eyecatchers #168
+ *******************************************************************************/
+
+/**
+ * @cond MQTTClient_internal
+ * @mainpage MQTT Client Library Internals
+ * In the beginning there was one MQTT C client library, MQTTClient, as implemented in MQTTClient.c
+ * This library was designed to be easy to use for applications which didn't mind if some of the calls
+ * blocked for a while.  For instance, the MQTTClient_connect call will block until a successful
+ * connection has completed, or a connection has failed, which could be as long as the "connection
+ * timeout" interval, whose default is 30 seconds.
+ *
+ * However in mobile devices and other windowing environments, blocking on the GUI thread is a bad
+ * thing as it causes the user interface to freeze.  Hence a new API, MQTTAsync, implemented
+ * in MQTTAsync.c, was devised.  There are no blocking calls in this library, so it is well suited
+ * to GUI and mobile environments, at the expense of some extra complexity.
+ *
+ * Both libraries are designed to be sparing in the use of threads.  So multiple client objects are
+ * handled by one or two threads, with a select call in Socket_getReadySocket(), used to determine
+ * when a socket has incoming data.  This API is thread safe: functions may be called by multiple application
+ * threads, with the exception of ::MQTTClient_yield and ::MQTTClient_receive, which are intended
+ * for single threaded environments only.
+ *
+ * @endcond
+ * @cond MQTTClient_main
+ * @mainpage MQTT Client library for C
+ * © Copyright IBM Corp. 2009, 2017
+ *
+ * @brief An MQTT client library in C.
+ *
+ * These pages describe the original more synchronous API which might be
+ * considered easier to use.  Some of the calls will block.  For the new
+ * totally asynchronous API where no calls block, which is especially suitable
+ * for use in windowed environments, see the
+ * <a href="../../MQTTAsync/html/index.html">MQTT C Client Asynchronous API Documentation</a>.
+ * The MQTTClient API is not thread safe, whereas the MQTTAsync API is.
+ *
+ * An MQTT client application connects to MQTT-capable servers.
+ * A typical client is responsible for collecting information from a telemetry
+ * device and publishing the information to the server. It can also subscribe
+ * to topics, receive messages, and use this information to control the
+ * telemetry device.
+ *
+ * MQTT clients implement the published MQTT v3 protocol. You can write your own
+ * API to the MQTT protocol using the programming language and platform of your
+ * choice. This can be time-consuming and error-prone.
+ *
+ * To simplify writing MQTT client applications, this library encapsulates
+ * the MQTT v3 protocol for you. Using this library enables a fully functional
+ * MQTT client application to be written in a few lines of code.
+ * The information presented here documents the API provided
+ * by the MQTT Client library for C.
+ *
+ * <b>Using the client</b><br>
+ * Applications that use the client library typically use a similar structure:
+ * <ul>
+ * <li>Create a client object</li>
+ * <li>Set the options to connect to an MQTT server</li>
+ * <li>Set up callback functions if multi-threaded (asynchronous mode)
+ * operation is being used (see @ref async).</li>
+ * <li>Subscribe to any topics the client needs to receive</li>
+ * <li>Repeat until finished:</li>
+ *     <ul>
+ *     <li>Publish any messages the client needs to</li>
+ *     <li>Handle any incoming messages</li>
+ *     </ul>
+ * <li>Disconnect the client</li>
+ * <li>Free any memory being used by the client</li>
+ * </ul>
+ * Some simple examples are shown here:
+ * <ul>
+ * <li>@ref pubsync</li>
+ * <li>@ref pubasync</li>
+ * <li>@ref subasync</li>
+ * </ul>
+ * Additional information about important concepts is provided here:
+ * <ul>
+ * <li>@ref async</li>
+ * <li>@ref wildcard</li>
+ * <li>@ref qos</li>
+ * <li>@ref tracing</li>
+ * </ul>
+ * @endcond
+ */
+
+/*
+/// @cond EXCLUDE
+*/
+#if defined(__cplusplus)
+ extern "C" {
+#endif
+#if !defined(MQTTCLIENT_H)
+#define MQTTCLIENT_H
+
+#if defined(WIN32) || defined(WIN64)
+  #define DLLImport __declspec(dllimport)
+  #define DLLExport __declspec(dllexport)
+#else
+  #define DLLImport extern
+  #define DLLExport __attribute__ ((visibility ("default")))
+#endif
+
+#include <stdio.h>
+/*
+/// @endcond
+*/
+
+#if !defined(NO_PERSISTENCE)
+#include "MQTTClientPersistence.h"
+#endif
+
+/**
+ * Return code: No error. Indicates successful completion of an MQTT client
+ * operation.
+ */
+#define MQTTCLIENT_SUCCESS 0
+/**
+ * Return code: A generic error code indicating the failure of an MQTT client
+ * operation.
+ */
+#define MQTTCLIENT_FAILURE -1
+
+/* error code -2 is MQTTCLIENT_PERSISTENCE_ERROR */
+
+/**
+ * Return code: The client is disconnected.
+ */
+#define MQTTCLIENT_DISCONNECTED -3
+/**
+ * Return code: The maximum number of messages allowed to be simultaneously
+ * in-flight has been reached.
+ */
+#define MQTTCLIENT_MAX_MESSAGES_INFLIGHT -4
+/**
+ * Return code: An invalid UTF-8 string has been detected.
+ */
+#define MQTTCLIENT_BAD_UTF8_STRING -5
+/**
+ * Return code: A NULL parameter has been supplied when this is invalid.
+ */
+#define MQTTCLIENT_NULL_PARAMETER -6
+/**
+ * Return code: The topic has been truncated (the topic string includes
+ * embedded NULL characters). String functions will not access the full topic.
+ * Use the topic length value to access the full topic.
+ */
+#define MQTTCLIENT_TOPICNAME_TRUNCATED -7
+/**
+ * Return code: A structure parameter does not have the correct eyecatcher
+ * and version number.
+ */
+#define MQTTCLIENT_BAD_STRUCTURE -8
+/**
+ * Return code: A QoS value that falls outside of the acceptable range (0,1,2)
+ */
+#define MQTTCLIENT_BAD_QOS -9
+/**
+ * Return code: Attempting SSL connection using non-SSL version of library
+ */
+#define MQTTCLIENT_SSL_NOT_SUPPORTED -10
+
+/**
+ * Default MQTT version to connect with.  Use 3.1.1 then fall back to 3.1
+ */
+#define MQTTVERSION_DEFAULT 0
+/**
+ * MQTT version to connect with: 3.1
+ */
+#define MQTTVERSION_3_1 3
+/**
+ * MQTT version to connect with: 3.1.1
+ */
+#define MQTTVERSION_3_1_1 4
+/**
+ * Bad return code from subscribe, as defined in the 3.1.1 specification
+ */
+#define MQTT_BAD_SUBSCRIBE 0x80
+
+/**
+ *  Initialization options
+ */
+typedef struct
+{
+	/** The eyecatcher for this structure.  Must be MQTG. */
+	char struct_id[4];
+	/** The version number of this structure.  Must be 0 */
+	int struct_version;
+	/** 1 = we do openssl init, 0 = leave it to the application */
+	int do_openssl_init;
+} MQTTClient_init_options;
+
+#define MQTTClient_init_options_initializer { {'M', 'Q', 'T', 'G'}, 0, 0 }
+
+/**
+ * Global init of mqtt library. Call once on program start to set global behaviour.
+ * do_openssl_init - if mqtt library should initialize OpenSSL (1) or rely on the caller to do it before using the library (0)
+ */
+DLLExport void MQTTClient_global_init(MQTTClient_init_options* inits);
+
+/**
+ * A handle representing an MQTT client. A valid client handle is available
+ * following a successful call to MQTTClient_create().
+ */
+typedef void* MQTTClient;
+/**
+ * A value representing an MQTT message. A delivery token is returned to the
+ * client application when a message is published. The token can then be used to
+ * check that the message was successfully delivered to its destination (see
+ * MQTTClient_publish(),
+ * MQTTClient_publishMessage(),
+ * MQTTClient_deliveryComplete(),
+ * MQTTClient_waitForCompletion() and
+ * MQTTClient_getPendingDeliveryTokens()).
+ */
+typedef int MQTTClient_deliveryToken;
+typedef int MQTTClient_token;
+
+/**
+ * A structure representing the payload and attributes of an MQTT message. The
+ * message topic is not part of this structure (see MQTTClient_publishMessage(),
+ * MQTTClient_publish(), MQTTClient_receive(), MQTTClient_freeMessage()
+ * and MQTTClient_messageArrived()).
+ */
+typedef struct
+{
+	/** The eyecatcher for this structure.  must be MQTM. */
+	char struct_id[4];
+	/** The version number of this structure.  Must be 0 */
+	int struct_version;
+	/** The length of the MQTT message payload in bytes. */
+	int payloadlen;
+	/** A pointer to the payload of the MQTT message. */
+	void* payload;
+	/**
+     * The quality of service (QoS) assigned to the message.
+     * There are three levels of QoS:
+     * <DL>
+     * <DT><B>QoS0</B></DT>
+     * <DD>Fire and forget - the message may not be delivered</DD>
+     * <DT><B>QoS1</B></DT>
+     * <DD>At least once - the message will be delivered, but may be
+     * delivered more than once in some circumstances.</DD>
+     * <DT><B>QoS2</B></DT>
+     * <DD>Once and one only - the message will be delivered exactly once.</DD>
+     * </DL>
+     */
+	int qos;
+	/**
+     * The retained flag serves two purposes depending on whether the message
+     * it is associated with is being published or received.
+     *
+     * <b>retained = true</b><br>
+     * For messages being published, a true setting indicates that the MQTT
+     * server should retain a copy of the message. The message will then be
+     * transmitted to new subscribers to a topic that matches the message topic.
+     * For subscribers registering a new subscription, the flag being true
+     * indicates that the received message is not a new one, but one that has
+     * been retained by the MQTT server.
+     *
+     * <b>retained = false</b> <br>
+     * For publishers, this ndicates that this message should not be retained
+     * by the MQTT server. For subscribers, a false setting indicates this is
+     * a normal message, received as a result of it being published to the
+     * server.
+     */
+	int retained;
+	/**
+      * The dup flag indicates whether or not this message is a duplicate.
+      * It is only meaningful when receiving QoS1 messages. When true, the
+      * client application should take appropriate action to deal with the
+      * duplicate message.
+      */
+	int dup;
+	/** The message identifier is normally reserved for internal use by the
+      * MQTT client and server.
+      */
+	int msgid;
+} MQTTClient_message;
+
+#define MQTTClient_message_initializer { {'M', 'Q', 'T', 'M'}, 0, 0, NULL, 0, 0, 0, 0 }
+
+/**
+ * This is a callback function. The client application
+ * must provide an implementation of this function to enable asynchronous
+ * receipt of messages. The function is registered with the client library by
+ * passing it as an argument to MQTTClient_setCallbacks(). It is
+ * called by the client library when a new message that matches a client
+ * subscription has been received from the server. This function is executed on
+ * a separate thread to the one on which the client application is running.
+ * @param context A pointer to the <i>context</i> value originally passed to
+ * MQTTClient_setCallbacks(), which contains any application-specific context.
+ * @param topicName The topic associated with the received message.
+ * @param topicLen The length of the topic if there are one
+ * more NULL characters embedded in <i>topicName</i>, otherwise <i>topicLen</i>
+ * is 0. If <i>topicLen</i> is 0, the value returned by <i>strlen(topicName)</i>
+ * can be trusted. If <i>topicLen</i> is greater than 0, the full topic name
+ * can be retrieved by accessing <i>topicName</i> as a byte array of length
+ * <i>topicLen</i>.
+ * @param message The MQTTClient_message structure for the received message.
+ * This structure contains the message payload and attributes.
+ * @return This function must return a boolean value indicating whether or not
+ * the message has been safely received by the client application. Returning
+ * true indicates that the message has been successfully handled.
+ * Returning false indicates that there was a problem. In this
+ * case, the client library will reinvoke MQTTClient_messageArrived() to
+ * attempt to deliver the message to the application again.
+ */
+typedef int MQTTClient_messageArrived(void* context, char* topicName, int topicLen, MQTTClient_message* message);
+
+/**
+ * This is a callback function. The client application
+ * must provide an implementation of this function to enable asynchronous
+ * notification of delivery of messages. The function is registered with the
+ * client library by passing it as an argument to MQTTClient_setCallbacks().
+ * It is called by the client library after the client application has
+ * published a message to the server. It indicates that the necessary
+ * handshaking and acknowledgements for the requested quality of service (see
+ * MQTTClient_message.qos) have been completed. This function is executed on a
+ * separate thread to the one on which the client application is running.
+ * <b>Note:</b>MQTTClient_deliveryComplete() is not called when messages are
+ * published at QoS0.
+ * @param context A pointer to the <i>context</i> value originally passed to
+ * MQTTClient_setCallbacks(), which contains any application-specific context.
+ * @param dt The ::MQTTClient_deliveryToken associated with
+ * the published message. Applications can check that all messages have been
+ * correctly published by matching the delivery tokens returned from calls to
+ * MQTTClient_publish() and MQTTClient_publishMessage() with the tokens passed
+ * to this callback.
+ */
+typedef void MQTTClient_deliveryComplete(void* context, MQTTClient_deliveryToken dt);
+
+/**
+ * This is a callback function. The client application
+ * must provide an implementation of this function to enable asynchronous
+ * notification of the loss of connection to the server. The function is
+ * registered with the client library by passing it as an argument to
+ * MQTTClient_setCallbacks(). It is called by the client library if the client
+ * loses its connection to the server. The client application must take
+ * appropriate action, such as trying to reconnect or reporting the problem.
+ * This function is executed on a separate thread to the one on which the
+ * client application is running.
+ * @param context A pointer to the <i>context</i> value originally passed to
+ * MQTTClient_setCallbacks(), which contains any application-specific context.
+ * @param cause The reason for the disconnection.
+ * Currently, <i>cause</i> is always set to NULL.
+ */
+typedef void MQTTClient_connectionLost(void* context, char* cause);
+
+/**
+ * This function sets the callback functions for a specific client.
+ * If your client application doesn't use a particular callback, set the
+ * relevant parameter to NULL. Calling MQTTClient_setCallbacks() puts the
+ * client into multi-threaded mode. Any necessary message acknowledgements and
+ * status communications are handled in the background without any intervention
+ * from the client application. See @ref async for more information.
+ *
+ * <b>Note:</b> The MQTT client must be disconnected when this function is
+ * called.
+ * @param handle A valid client handle from a successful call to
+ * MQTTClient_create().
+ * @param context A pointer to any application-specific context. The
+ * the <i>context</i> pointer is passed to each of the callback functions to
+ * provide access to the context information in the callback.
+ * @param cl A pointer to an MQTTClient_connectionLost() callback
+ * function. You can set this to NULL if your application doesn't handle
+ * disconnections.
+ * @param ma A pointer to an MQTTClient_messageArrived() callback
+ * function. This callback function must be specified when you call
+ * MQTTClient_setCallbacks().
+ * @param dc A pointer to an MQTTClient_deliveryComplete() callback
+ * function. You can set this to NULL if your application publishes
+ * synchronously or if you do not want to check for successful delivery.
+ * @return ::MQTTCLIENT_SUCCESS if the callbacks were correctly set,
+ * ::MQTTCLIENT_FAILURE if an error occurred.
+ */
+DLLExport int MQTTClient_setCallbacks(MQTTClient handle, void* context, MQTTClient_connectionLost* cl,
+									MQTTClient_messageArrived* ma, MQTTClient_deliveryComplete* dc);
+
+
+/**
+ * This function creates an MQTT client ready for connection to the
+ * specified server and using the specified persistent storage (see
+ * MQTTClient_persistence). See also MQTTClient_destroy().
+ * @param handle A pointer to an ::MQTTClient handle. The handle is
+ * populated with a valid client reference following a successful return from
+ * this function.
+ * @param serverURI A null-terminated string specifying the server to
+ * which the client will connect. It takes the form <i>protocol://host:port</i>.
+ * Currently, <i>protocol</i> must be <i>tcp</i> or <i>ssl</i>.
+ * For <i>host</i>, 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
+ * <i>tcp://localhost:1883</i>.
+ * @param clientId The client identifier passed to the server when the
+ * client connects to it. It is a null-terminated UTF-8 encoded string.
+ * @param persistence_type The type of persistence to be used by the client:
+ * <br>
+ * ::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.
+ * <br>
+ * ::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.
+ * <br>
+ * ::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.
+ * @param 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.
+ * @return ::MQTTCLIENT_SUCCESS if the client is successfully created, otherwise
+ * an error code is returned.
+ */
+DLLExport int MQTTClient_create(MQTTClient* handle, const char* serverURI, const char* clientId,
+		int persistence_type, void* persistence_context);
+
+/**
+ * MQTTClient_willOptions defines the MQTT "Last Will and Testament" (LWT) settings for
+ * the client. In the event that a client unexpectedly loses its connection to
+ * the server, the server publishes the LWT message to the LWT topic on
+ * behalf of the client. This allows other clients (subscribed to the LWT topic)
+ * to be made aware that the client has disconnected. To enable the LWT
+ * function for a specific client, a valid pointer to an MQTTClient_willOptions
+ * structure is passed in the MQTTClient_connectOptions structure used in the
+ * MQTTClient_connect() call that connects the client to the server. The pointer
+ * to MQTTClient_willOptions can be set to NULL if the LWT function is not
+ * required.
+ */
+typedef struct
+{
+	/** The eyecatcher for this structure.  must be MQTW. */
+	char struct_id[4];
+	/** The version number of this structure.  Must be 0 or 1
+		   0 means there is no binary payload option
+	 */
+	int struct_version;
+	/** The LWT topic to which the LWT message will be published. */
+	const char* topicName;
+	/** The LWT payload in string form. */
+	const char* message;
+	/**
+	 * The retained flag for the LWT message (see MQTTClient_message.retained).
+	 */
+	int retained;
+	/**
+	 * The quality of service setting for the LWT message (see
+	 * MQTTClient_message.qos and @ref qos).
+	 */
+	int qos;
+  /** The LWT payload in binary form. This is only checked and used if the message option is NULL */
+	struct
+	{
+  	int len;            /**< binary payload length */
+		const void* data;  /**< binary payload data */
+	} payload;
+} MQTTClient_willOptions;
+
+#define MQTTClient_willOptions_initializer { {'M', 'Q', 'T', 'W'}, 1, NULL, NULL, 0, 0, {0, NULL} }
+
+/**
+* MQTTClient_sslProperties defines the settings to establish an SSL/TLS connection using the
+* OpenSSL library. It covers the following scenarios:
+* - Server authentication: The client needs the digital certificate of the server. It is included
+*   in a store containting trusted material (also known as "trust store").
+* - Mutual authentication: Both client and server are authenticated during the SSL handshake. In
+*   addition to the digital certificate of the server in a trust store, the client will need its own
+*   digital certificate and the private key used to sign its digital certificate stored in a "key store".
+* - Anonymous connection: Both client and server do not get authenticated and no credentials are needed
+*   to establish an SSL connection. Note that this scenario is not fully secure since it is subject to
+*   man-in-the-middle attacks.
+*/
+typedef struct
+{
+	/** The eyecatcher for this structure.  Must be MQTS */
+	char struct_id[4];
+	/** The version number of this structure.  Must be 0 */
+	int struct_version;
+
+	/** The file in PEM format containing the public digital certificates trusted by the client. */
+	const char* trustStore;
+
+	/** The file in PEM format containing the public certificate chain of the client. It may also include
+	* the client's private key.
+	*/
+	const char* keyStore;
+
+	/** If not included in the sslKeyStore, this setting points to the file in PEM format containing
+	* the client's private key.
+	*/
+	const char* privateKey;
+	/** The password to load the client's privateKey if encrypted. */
+	const char* privateKeyPassword;
+
+	/**
+	* The list of cipher suites that the client will present to the server during the SSL handshake. For a
+	* full explanation of the cipher list format, please see the OpenSSL on-line documentation:
+	* http://www.openssl.org/docs/apps/ciphers.html#CIPHER_LIST_FORMAT
+	* If this setting is ommitted, its default value will be "ALL", that is, all the cipher suites -excluding
+	* those offering no encryption- will be considered.
+	* This setting can be used to set an SSL anonymous connection ("aNULL" string value, for instance).
+	*/
+	const char* enabledCipherSuites;
+
+    /** True/False option to enable verification of the server certificate **/
+    int enableServerCertAuth;
+
+} MQTTClient_SSLOptions;
+
+#define MQTTClient_SSLOptions_initializer { {'M', 'Q', 'T', 'S'}, 0, NULL, NULL, NULL, NULL, NULL, 1 }
+
+/**
+ * MQTTClient_connectOptions defines several settings that control the way the
+ * client connects to an MQTT server.
+ *
+ * <b>Note:</b> Default values are not defined for members of
+ * MQTTClient_connectOptions so it is good practice to specify all settings.
+ * If the MQTTClient_connectOptions structure is defined as an automatic
+ * variable, all members are set to random values and thus must be set by the
+ * client application. If the MQTTClient_connectOptions structure is defined
+ * as a static variable, initialization (in compliant compilers) sets all
+ * values to 0 (NULL for pointers). A #keepAliveInterval setting of 0 prevents
+ * correct operation of the client and so you <b>must</b> at least set a value
+ * for #keepAliveInterval.
+ */
+typedef struct
+{
+	/** The eyecatcher for this structure.  must be MQTC. */
+	char struct_id[4];
+	/** The version number of this structure.  Must be 0, 1, 2, 3, 4 or 5.
+	 * 0 signifies no SSL options and no serverURIs
+	 * 1 signifies no serverURIs
+	 * 2 signifies no MQTTVersion
+	 * 3 signifies no returned values
+	 * 4 signifies no binary password option
+	 */
+	int struct_version;
+	/** The "keep alive" interval, measured in seconds, defines the maximum time
+   * that should pass without communication between the client and the server
+   * The client will ensure that at least one message travels across the
+   * network within each keep alive period.  In the absence of a data-related
+	 * message during the time period, the client sends a very small MQTT
+   * "ping" message, which the server will acknowledge. The keep alive
+   * interval enables the client to detect when the server is no longer
+	 * available without having to wait for the long TCP/IP timeout.
+	 */
+	int keepAliveInterval;
+	/**
+   * This is a boolean value. The cleansession setting controls the behaviour
+   * of both the client and the server at connection and disconnection time.
+   * The client and server both maintain session state information. This
+   * information is used to ensure "at least once" and "exactly once"
+   * delivery, and "exactly once" receipt of messages. Session state also
+   * includes subscriptions created by an MQTT client. You can choose to
+   * maintain or discard state information between sessions.
+   *
+   * When cleansession is true, the state information is discarded at
+   * connect and disconnect. Setting cleansession to false keeps the state
+   * information. When you connect an MQTT client application with
+   * MQTTClient_connect(), the client identifies the connection using the
+   * client identifier and the address of the server. The server checks
+   * whether session information for this client
+   * has been saved from a previous connection to the server. If a previous
+   * session still exists, and cleansession=true, then the previous session
+   * information at the client and server is cleared. If cleansession=false,
+   * the previous session is resumed. If no previous session exists, a new
+   * session is started.
+	 */
+	int cleansession;
+	/**
+   * This is a boolean value that controls how many messages can be in-flight
+   * simultaneously. Setting <i>reliable</i> to true means that a published
+   * message must be completed (acknowledgements received) before another
+   * can be sent. Attempts to publish additional messages receive an
+   * ::MQTTCLIENT_MAX_MESSAGES_INFLIGHT return code. Setting this flag to
+	 * false allows up to 10 messages to be in-flight. This can increase
+   * overall throughput in some circumstances.
+	 */
+	int reliable;
+	/**
+   * This is a pointer to an MQTTClient_willOptions structure. If your
+   * application does not make use of the Last Will and Testament feature,
+   * set this pointer to NULL.
+   */
+	MQTTClient_willOptions* will;
+	/**
+   * MQTT servers that support the MQTT v3.1.1 protocol provide authentication
+   * and authorisation by user name and password. This is the user name
+   * parameter.
+   */
+	const char* username;
+	/**
+   * MQTT servers that support the MQTT v3.1.1 protocol provide authentication
+   * and authorisation by user name and password. This is the password
+   * parameter.
+   */
+	const char* password;
+	/**
+   * The time interval in seconds to allow a connect to complete.
+   */
+	int connectTimeout;
+	/**
+	 * The time interval in seconds
+	 */
+	int retryInterval;
+	/**
+   * This is a pointer to an MQTTClient_SSLOptions structure. If your
+   * application does not make use of SSL, set this pointer to NULL.
+   */
+	MQTTClient_SSLOptions* ssl;
+	/**
+	 * The number of entries in the optional serverURIs array. Defaults to 0.
+	 */
+	int serverURIcount;
+	/**
+   * An optional array of null-terminated strings specifying the servers to
+   * which the client will connect. Each string takes the form <i>protocol://host:port</i>.
+   * <i>protocol</i> must be <i>tcp</i> or <i>ssl</i>. For <i>host</i>, 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
+   * <i>tcp://localhost:1883</i>.
+   * If this list is empty (the default), the server URI specified on MQTTClient_create()
+   * is used.
+   */
+	char* const* serverURIs;
+	/**
+	 * Sets the version of MQTT to be used on the connect.
+	 * MQTTVERSION_DEFAULT (0) = default: start with 3.1.1, and if that fails, fall back to 3.1
+	 * MQTTVERSION_3_1 (3) = only try version 3.1
+	 * MQTTVERSION_3_1_1 (4) = only try version 3.1.1
+	 */
+	int MQTTVersion;
+	/**
+	 * Returned from the connect when the MQTT version used to connect is 3.1.1
+	 */
+	struct
+	{
+		const char* serverURI;     /**< the serverURI connected to */
+		int MQTTVersion;     /**< the MQTT version used to connect with */
+		int sessionPresent;  /**< if the MQTT version is 3.1.1, the value of sessionPresent returned in the connack */
+	} returned;
+	/**
+   * Optional binary password.  Only checked and used if the password option is NULL
+   */
+  struct {
+  	int len;            /**< binary password length */
+		const void* data;  /**< binary password data */
+	} binarypwd;
+} MQTTClient_connectOptions;
+
+#define MQTTClient_connectOptions_initializer { {'M', 'Q', 'T', 'C'}, 5, 60, 1, 1, NULL, NULL, NULL, 30, 20, NULL, 0, NULL, 0,         {NULL, 0, 0}, {0, NULL} }
+
+/**
+  * MQTTClient_libraryInfo is used to store details relating to the currently used
+  * library such as the version in use, the time it was built and relevant openSSL
+  * options.
+  * There is one static instance of this struct in MQTTClient.c
+  */
+
+typedef struct
+{
+	const char* name;
+	const char* value;
+} MQTTClient_nameValue;
+
+/**
+  * This function returns version information about the library.
+  * no trace information will be returned.
+  * @return an array of strings describing the library.  The last entry is a NULL pointer.
+  */
+DLLExport MQTTClient_nameValue* MQTTClient_getVersionInfo(void);
+
+/**
+  * This function attempts to connect a previously-created client (see
+  * MQTTClient_create()) to an MQTT server using the specified options. If you
+  * want to enable asynchronous message and status notifications, you must call
+  * MQTTClient_setCallbacks() prior to MQTTClient_connect().
+  * @param handle A valid client handle from a successful call to
+  * MQTTClient_create().
+  * @param options A pointer to a valid MQTTClient_connectOptions
+  * structure.
+  * @return ::MQTTCLIENT_SUCCESS if the client successfully connects to the
+  * server. An error code is returned if the client was unable to connect to
+  * the server.
+  * Error codes greater than 0 are returned by the MQTT protocol:<br><br>
+  * <b>1</b>: Connection refused: Unacceptable protocol version<br>
+  * <b>2</b>: Connection refused: Identifier rejected<br>
+  * <b>3</b>: Connection refused: Server unavailable<br>
+  * <b>4</b>: Connection refused: Bad user name or password<br>
+  * <b>5</b>: Connection refused: Not authorized<br>
+  * <b>6-255</b>: Reserved for future use<br>
+  */
+DLLExport int MQTTClient_connect(MQTTClient handle, MQTTClient_connectOptions* 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
+  * MQTTClient_connectOptions.cleansession and MQTTClient_connect()).
+  * @param handle A valid client handle from a successful call to
+  * MQTTClient_create().
+  * @param timeout The client delays disconnection for up to this time (in
+  * milliseconds) in order to allow in-flight message transfers to complete.
+  * @return ::MQTTCLIENT_SUCCESS if the client successfully disconnects from
+  * the server. An error code is returned if the client was unable to disconnect
+  * from the server
+  */
+DLLExport int MQTTClient_disconnect(MQTTClient handle, int timeout);
+
+/**
+  * This function allows the client application to test whether or not a
+  * client is currently connected to the MQTT server.
+  * @param handle A valid client handle from a successful call to
+  * MQTTClient_create().
+  * @return Boolean true if the client is connected, otherwise false.
+  */
+DLLExport int MQTTClient_isConnected(MQTTClient handle);
+
+
+/* Subscribe is synchronous.  QoS list parameter is changed on return to granted QoSs.
+   Returns return code, MQTTCLIENT_SUCCESS == success, non-zero some sort of error (TBD) */
+
+/**
+  * This function attempts to subscribe a client to a single topic, which may
+  * contain wildcards (see @ref wildcard). This call also specifies the
+  * @ref qos requested for the subscription
+  * (see also MQTTClient_subscribeMany()).
+  * @param handle A valid client handle from a successful call to
+  * MQTTClient_create().
+  * @param topic The subscription topic, which may include wildcards.
+  * @param qos The requested quality of service for the subscription.
+  * @return ::MQTTCLIENT_SUCCESS if the subscription request is successful.
+  * An error code is returned if there was a problem registering the
+  * subscription.
+  */
+DLLExport int MQTTClient_subscribe(MQTTClient handle, const char* topic, int qos);
+
+/**
+  * This function attempts to subscribe a client to a list of topics, which may
+  * contain wildcards (see @ref wildcard). This call also specifies the
+  * @ref qos requested for each topic (see also MQTTClient_subscribe()).
+  * @param handle A valid client handle from a successful call to
+  * MQTTClient_create().
+  * @param count The number of topics for which the client is requesting
+  * subscriptions.
+  * @param topic An array (of length <i>count</i>) of pointers to
+  * topics, each of which may include wildcards.
+  * @param qos An array (of length <i>count</i>) of @ref qos
+  * values. qos[n] is the requested QoS for topic[n].
+  * @return ::MQTTCLIENT_SUCCESS if the subscription request is successful.
+  * An error code is returned if there was a problem registering the
+  * subscriptions.
+  */
+DLLExport int MQTTClient_subscribeMany(MQTTClient handle, int count, char* const* topic, int* qos);
+
+/**
+  * This function attempts to remove an existing subscription made by the
+  * specified client.
+  * @param handle A valid client handle from a successful call to
+  * MQTTClient_create().
+  * @param topic The topic for the subscription to be removed, which may
+  * include wildcards (see @ref wildcard).
+  * @return ::MQTTCLIENT_SUCCESS if the subscription is removed.
+  * An error code is returned if there was a problem removing the
+  * subscription.
+  */
+DLLExport int MQTTClient_unsubscribe(MQTTClient handle, const char* topic);
+
+/**
+  * This function attempts to remove existing subscriptions to a list of topics
+  * made by the specified client.
+  * @param handle A valid client handle from a successful call to
+  * MQTTClient_create().
+  * @param count The number subscriptions to be removed.
+  * @param topic An array (of length <i>count</i>) of pointers to the topics of
+  * the subscriptions to be removed, each of which may include wildcards.
+  * @return ::MQTTCLIENT_SUCCESS if the subscriptions are removed.
+  * An error code is returned if there was a problem removing the subscriptions.
+  */
+DLLExport int MQTTClient_unsubscribeMany(MQTTClient handle, int count, char* const* topic);
+
+/**
+  * This function attempts to publish a message to a given topic (see also
+  * MQTTClient_publishMessage()). An ::MQTTClient_deliveryToken is issued when
+  * this function returns successfully. If the client application needs to
+  * test for succesful delivery of QoS1 and QoS2 messages, this can be done
+  * either asynchronously or synchronously (see @ref async,
+  * ::MQTTClient_waitForCompletion and MQTTClient_deliveryComplete()).
+  * @param handle A valid client handle from a successful call to
+  * MQTTClient_create().
+  * @param topicName The topic associated with this message.
+  * @param payloadlen The length of the payload in bytes.
+  * @param payload A pointer to the byte array payload of the message.
+  * @param qos The @ref qos of the message.
+  * @param retained The retained flag for the message.
+  * @param dt A pointer to an ::MQTTClient_deliveryToken. This is populated
+  * with a token representing the message when the function returns
+  * successfully. If your application does not use delivery tokens, set this
+  * argument to NULL.
+  * @return ::MQTTCLIENT_SUCCESS if the message is accepted for publication.
+  * An error code is returned if there was a problem accepting the message.
+  */
+DLLExport int MQTTClient_publish(MQTTClient handle, const char* topicName, int payloadlen, void* payload, int qos, int retained,
+																 MQTTClient_deliveryToken* dt);
+/**
+  * This function attempts to publish a message to a given topic (see also
+  * MQTTClient_publish()). An ::MQTTClient_deliveryToken is issued when
+  * this function returns successfully. If the client application needs to
+  * test for succesful delivery of QoS1 and QoS2 messages, this can be done
+  * either asynchronously or synchronously (see @ref async,
+  * ::MQTTClient_waitForCompletion and MQTTClient_deliveryComplete()).
+  * @param handle A valid client handle from a successful call to
+  * MQTTClient_create().
+  * @param topicName The topic associated with this message.
+  * @param msg A pointer to a valid MQTTClient_message structure containing
+  * the payload and attributes of the message to be published.
+  * @param dt A pointer to an ::MQTTClient_deliveryToken. This is populated
+  * with a token representing the message when the function returns
+  * successfully. If your application does not use delivery tokens, set this
+  * argument to NULL.
+  * @return ::MQTTCLIENT_SUCCESS if the message is accepted for publication.
+  * An error code is returned if there was a problem accepting the message.
+  */
+DLLExport int MQTTClient_publishMessage(MQTTClient handle, const char* topicName, MQTTClient_message* msg, MQTTClient_deliveryToken* dt);
+
+
+/**
+  * This function is called by the client application to synchronize execution
+  * of the main thread with completed publication of a message. When called,
+  * MQTTClient_waitForCompletion() blocks execution until the message has been
+  * successful delivered or the specified timeout has expired. See @ref async.
+  * @param handle A valid client handle from a successful call to
+  * MQTTClient_create().
+  * @param dt The ::MQTTClient_deliveryToken that represents the message being
+  * tested for successful delivery. Delivery tokens are issued by the
+  * publishing functions MQTTClient_publish() and MQTTClient_publishMessage().
+  * @param timeout The maximum time to wait in milliseconds.
+  * @return ::MQTTCLIENT_SUCCESS if the message was successfully delivered.
+  * An error code is returned if the timeout expires or there was a problem
+  * checking the token.
+  */
+DLLExport int MQTTClient_waitForCompletion(MQTTClient handle, MQTTClient_deliveryToken dt, unsigned long timeout);
+
+
+/**
+  * This function sets a pointer to an array of delivery tokens for
+  * messages that are currently in-flight (pending completion).
+  *
+  * <b>Important note:</b> 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.
+  * @param handle A valid client handle from a successful call to
+  * MQTTClient_create().
+  * @param tokens The address of a pointer to an ::MQTTClient_deliveryToken.
+  * 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.
+  * @return ::MQTTCLIENT_SUCCESS if the function returns successfully.
+  * An error code is returned if there was a problem obtaining the list of
+  * pending tokens.
+  */
+DLLExport int MQTTClient_getPendingDeliveryTokens(MQTTClient handle, MQTTClient_deliveryToken **tokens);
+
+/**
+  * When implementing a single-threaded client, call this function periodically
+  * to allow processing of message retries and to send MQTT keepalive pings.
+  * If the application is calling MQTTClient_receive() regularly, then it is
+  * not necessary to call this function.
+  */
+DLLExport void MQTTClient_yield(void);
+
+/**
+  * This function performs a synchronous receive of incoming messages. It should
+  * be used only when the client application has not set callback methods to
+  * support asynchronous receipt of messages (see @ref async and
+  * MQTTClient_setCallbacks()). Using this function allows a single-threaded
+  * client subscriber application to be written. When called, this function
+  * blocks until the next message arrives or the specified timeout expires
+  *(see also MQTTClient_yield()).
+  *
+  * <b>Important note:</b> The application must free() the memory allocated
+  * to the topic and the message when processing is complete (see
+  * MQTTClient_freeMessage()).
+  * @param handle A valid client handle from a successful call to
+  * MQTTClient_create().
+  * @param topicName The address of a pointer to a topic. This function
+  * allocates the memory for the topic and returns it to the application
+  * by setting <i>topicName</i> to point to the topic.
+  * @param topicLen The length of the topic. If the return code from this
+  * function is ::MQTTCLIENT_TOPICNAME_TRUNCATED, the topic contains embedded
+  * NULL characters and the full topic should be retrieved by using
+  * <i>topicLen</i>.
+  * @param message The address of a pointer to the received message. This
+  * function allocates the memory for the message and returns it to the
+  * application by setting <i>message</i> to point to the received message.
+  * The pointer is set to NULL if the timeout expires.
+  * @param timeout The length of time to wait for a message in milliseconds.
+  * @return ::MQTTCLIENT_SUCCESS or ::MQTTCLIENT_TOPICNAME_TRUNCATED if a
+  * message is received. ::MQTTCLIENT_SUCCESS can also indicate that the
+  * timeout expired, in which case <i>message</i> is NULL. An error code is
+  * returned if there was a problem trying to receive a message.
+  */
+DLLExport int MQTTClient_receive(MQTTClient handle, char** topicName, int* topicLen, MQTTClient_message** message,
+		unsigned long timeout);
+
+/**
+  * 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. <b>Important
+  * note:</b> 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 MQTTClient_free() library function.
+  * @param msg The address of a pointer to the ::MQTTClient_message structure
+  * to be freed.
+  */
+DLLExport void MQTTClient_freeMessage(MQTTClient_message** msg);
+
+/**
+  * 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.
+  * @param ptr The pointer to the client library storage to be freed.
+  */
+DLLExport void MQTTClient_free(void* ptr);
+
+/**
+  * This function frees the memory allocated to an MQTT client (see
+  * MQTTClient_create()). It should be called when the client is no longer
+  * required.
+  * @param handle A pointer to the handle referring to the ::MQTTClient
+  * structure to be freed.
+  */
+DLLExport void MQTTClient_destroy(MQTTClient* handle);
+
+#endif
+#ifdef __cplusplus
+     }
+#endif
+
+/**
+  * @cond MQTTClient_main
+  * @page async Asynchronous vs synchronous client applications
+  * The client library supports two modes of operation. These are referred to
+  * as <b>synchronous</b> and <b>asynchronous</b> modes. If your application
+  * calls MQTTClient_setCallbacks(), this puts the client into asynchronous
+  * mode, otherwise it operates in synchronous mode.
+  *
+  * In synchronous mode, the client application runs on a single thread.
+  * Messages are published using the MQTTClient_publish() and
+  * MQTTClient_publishMessage() functions. To determine that a QoS1 or QoS2
+  * (see @ref qos) message has been successfully delivered, the application
+  * must call the MQTTClient_waitForCompletion() function. An example showing
+  * synchronous publication is shown in @ref pubsync. Receiving messages in
+  * synchronous mode uses the MQTTClient_receive() function. Client applications
+  * must call either MQTTClient_receive() or MQTTClient_yield() relatively
+  * frequently in order to allow processing of acknowledgements and the MQTT
+  * "pings" that keep the network connection to the server alive.
+  *
+  * In asynchronous mode, the client application runs on several threads. The
+  * main program calls functions in the client library to publish and subscribe,
+  * just as for the synchronous mode. Processing of handshaking and maintaining
+  * the network connection is performed in the background, however.
+  * Notifications of status and message reception are provided to the client
+  * application using callbacks registered with the library by the call to
+  * MQTTClient_setCallbacks() (see MQTTClient_messageArrived(),
+  * MQTTClient_connectionLost() and MQTTClient_deliveryComplete()).
+  * This API is not thread safe however - it is not possible to call it from multiple
+  * threads without synchronization.  You can use the MQTTAsync API for that.
+  *
+  * @page wildcard Subscription wildcards
+  * Every MQTT message includes a topic that classifies it. MQTT servers use
+  * topics to determine which subscribers should receive messages published to
+  * the server.
+  *
+  * Consider the server receiving messages from several environmental sensors.
+  * Each sensor publishes its measurement data as a message with an associated
+  * topic. Subscribing applications need to know which sensor originally
+  * published each received message. A unique topic is thus used to identify
+  * each sensor and measurement type. Topics such as SENSOR1TEMP,
+  * SENSOR1HUMIDITY, SENSOR2TEMP and so on achieve this but are not very
+  * flexible. If additional sensors are added to the system at a later date,
+  * subscribing applications must be modified to receive them.
+  *
+  * To provide more flexibility, MQTT supports a hierarchical topic namespace.
+  * This allows application designers to organize topics to simplify their
+  * management. Levels in the hierarchy are delimited by the '/' character,
+  * such as SENSOR/1/HUMIDITY. Publishers and subscribers use these
+  * hierarchical topics as already described.
+  *
+  * For subscriptions, two wildcard characters are supported:
+  * <ul>
+  * <li>A '#' character represents a complete sub-tree of the hierarchy and
+  * thus must be the last character in a subscription topic string, such as
+  * SENSOR/#. This will match any topic starting with SENSOR/, such as
+  * SENSOR/1/TEMP and SENSOR/2/HUMIDITY.</li>
+  * <li> A '+' character represents a single level of the hierarchy and is
+  * used between delimiters. For example, SENSOR/+/TEMP will match
+  * SENSOR/1/TEMP and SENSOR/2/TEMP.</li>
+  * </ul>
+  * Publishers are not allowed to use the wildcard characters in their topic
+  * names.
+  *
+  * Deciding on your topic hierarchy is an important step in your system design.
+  *
+  * @page qos Quality of service
+  * The MQTT protocol provides three qualities of service for delivering
+  * messages between clients and servers: "at most once", "at least once" and
+  * "exactly once".
+  *
+  * Quality of service (QoS) is an attribute of an individual message being
+  * published. An application sets the QoS for a specific message by setting the
+  * MQTTClient_message.qos field to the required value.
+  *
+  * A subscribing client can set the maximum quality of service a server uses
+  * to send messages that match the client subscriptions. The
+  * MQTTClient_subscribe() and MQTTClient_subscribeMany() functions set this
+  * maximum. The QoS of a message forwarded to a subscriber thus might be
+  * different to the QoS given to the message by the original publisher.
+  * The lower of the two values is used to forward a message.
+  *
+  * The three levels are:
+  *
+  * <b>QoS0, At most once:</b> The message is delivered at most once, or it
+  * may not be delivered at all. Its delivery across the network is not
+  * acknowledged. The message is not stored. The message could be lost if the
+  * client is disconnected, or if the server fails. QoS0 is the fastest mode of
+  * transfer. It is sometimes called "fire and forget".
+  *
+  * The MQTT protocol does not require servers to forward publications at QoS0
+  * to a client. If the client is disconnected at the time the server receives
+  * the publication, the publication might be discarded, depending on the
+  * server implementation.
+  *
+  * <b>QoS1, At least once:</b> The message is always delivered at least once.
+  * It might be delivered multiple times if there is a failure before an
+  * acknowledgment is received by the sender. The message must be stored
+  * locally at the sender, until the sender receives confirmation that the
+  * message has been published by the receiver. The message is stored in case
+  * the message must be sent again.
+  *
+  * <b>QoS2, Exactly once:</b> The message is always delivered exactly once.
+  * The message must be stored locally at the sender, until the sender receives
+  * confirmation that the message has been published by the receiver. The
+  * message is stored in case the message must be sent again. QoS2 is the
+  * safest, but slowest mode of transfer. A more sophisticated handshaking
+  * and acknowledgement sequence is used than for QoS1 to ensure no duplication
+  * of messages occurs.
+  * @page pubsync Synchronous publication example
+@code
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "MQTTClient.h"
+
+#define ADDRESS     "tcp://localhost:1883"
+#define CLIENTID    "ExampleClientPub"
+#define TOPIC       "MQTT Examples"
+#define PAYLOAD     "Hello World!"
+#define QOS         1
+#define TIMEOUT     10000L
+
+int main(int argc, char* argv[])
+{
+    MQTTClient client;
+    MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
+    MQTTClient_message pubmsg = MQTTClient_message_initializer;
+    MQTTClient_deliveryToken token;
+    int rc;
+
+    MQTTClient_create(&client, ADDRESS, CLIENTID,
+        MQTTCLIENT_PERSISTENCE_NONE, NULL);
+    conn_opts.keepAliveInterval = 20;
+    conn_opts.cleansession = 1;
+
+    if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS)
+    {
+        printf("Failed to connect, return code %d\n", rc);
+        exit(EXIT_FAILURE);
+    }
+    pubmsg.payload = PAYLOAD;
+    pubmsg.payloadlen = strlen(PAYLOAD);
+    pubmsg.qos = QOS;
+    pubmsg.retained = 0;
+    MQTTClient_publishMessage(client, TOPIC, &pubmsg, &token);
+    printf("Waiting for up to %d seconds for publication of %s\n"
+            "on topic %s for client with ClientID: %s\n",
+            (int)(TIMEOUT/1000), PAYLOAD, TOPIC, CLIENTID);
+    rc = MQTTClient_waitForCompletion(client, token, TIMEOUT);
+    printf("Message with delivery token %d delivered\n", token);
+    MQTTClient_disconnect(client, 10000);
+    MQTTClient_destroy(&client);
+    return rc;
+}
+
+  * @endcode
+  *
+  * @page pubasync Asynchronous publication example
+@code{.c}
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "MQTTClient.h"
+
+#define ADDRESS     "tcp://localhost:1883"
+#define CLIENTID    "ExampleClientPub"
+#define TOPIC       "MQTT Examples"
+#define PAYLOAD     "Hello World!"
+#define QOS         1
+#define TIMEOUT     10000L
+
+volatile MQTTClient_deliveryToken deliveredtoken;
+
+void delivered(void *context, MQTTClient_deliveryToken dt)
+{
+    printf("Message with token value %d delivery confirmed\n", dt);
+    deliveredtoken = dt;
+}
+
+int msgarrvd(void *context, char *topicName, int topicLen, MQTTClient_message *message)
+{
+    int i;
+    char* payloadptr;
+
+    printf("Message arrived\n");
+    printf("     topic: %s\n", topicName);
+    printf("   message: ");
+
+    payloadptr = message->payload;
+    for(i=0; i<message->payloadlen; i++)
+    {
+        putchar(*payloadptr++);
+    }
+    putchar('\n');
+    MQTTClient_freeMessage(&message);
+    MQTTClient_free(topicName);
+    return 1;
+}
+
+void connlost(void *context, char *cause)
+{
+    printf("\nConnection lost\n");
+    printf("     cause: %s\n", cause);
+}
+
+int main(int argc, char* argv[])
+{
+    MQTTClient client;
+    MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
+    MQTTClient_message pubmsg = MQTTClient_message_initializer;
+    MQTTClient_deliveryToken token;
+    int rc;
+
+    MQTTClient_create(&client, ADDRESS, CLIENTID,
+        MQTTCLIENT_PERSISTENCE_NONE, NULL);
+    conn_opts.keepAliveInterval = 20;
+    conn_opts.cleansession = 1;
+
+    MQTTClient_setCallbacks(client, NULL, connlost, msgarrvd, delivered);
+
+    if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS)
+    {
+        printf("Failed to connect, return code %d\n", rc);
+        exit(EXIT_FAILURE);
+    }
+    pubmsg.payload = PAYLOAD;
+    pubmsg.payloadlen = strlen(PAYLOAD);
+    pubmsg.qos = QOS;
+    pubmsg.retained = 0;
+    deliveredtoken = 0;
+    MQTTClient_publishMessage(client, TOPIC, &pubmsg, &token);
+    printf("Waiting for publication of %s\n"
+            "on topic %s for client with ClientID: %s\n",
+            PAYLOAD, TOPIC, CLIENTID);
+    while(deliveredtoken != token);
+    MQTTClient_disconnect(client, 10000);
+    MQTTClient_destroy(&client);
+    return rc;
+}
+
+  * @endcode
+  * @page subasync Asynchronous subscription example
+@code
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "MQTTClient.h"
+
+#define ADDRESS     "tcp://localhost:1883"
+#define CLIENTID    "ExampleClientSub"
+#define TOPIC       "MQTT Examples"
+#define PAYLOAD     "Hello World!"
+#define QOS         1
+#define TIMEOUT     10000L
+
+volatile MQTTClient_deliveryToken deliveredtoken;
+
+void delivered(void *context, MQTTClient_deliveryToken dt)
+{
+    printf("Message with token value %d delivery confirmed\n", dt);
+    deliveredtoken = dt;
+}
+
+int msgarrvd(void *context, char *topicName, int topicLen, MQTTClient_message *message)
+{
+    int i;
+    char* payloadptr;
+
+    printf("Message arrived\n");
+    printf("     topic: %s\n", topicName);
+    printf("   message: ");
+
+    payloadptr = message->payload;
+    for(i=0; i<message->payloadlen; i++)
+    {
+        putchar(*payloadptr++);
+    }
+    putchar('\n');
+    MQTTClient_freeMessage(&message);
+    MQTTClient_free(topicName);
+    return 1;
+}
+
+void connlost(void *context, char *cause)
+{
+    printf("\nConnection lost\n");
+    printf("     cause: %s\n", cause);
+}
+
+int main(int argc, char* argv[])
+{
+    MQTTClient client;
+    MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
+    int rc;
+    int ch;
+
+    MQTTClient_create(&client, ADDRESS, CLIENTID,
+        MQTTCLIENT_PERSISTENCE_NONE, NULL);
+    conn_opts.keepAliveInterval = 20;
+    conn_opts.cleansession = 1;
+
+    MQTTClient_setCallbacks(client, NULL, connlost, msgarrvd, delivered);
+
+    if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS)
+    {
+        printf("Failed to connect, return code %d\n", rc);
+        exit(EXIT_FAILURE);
+    }
+    printf("Subscribing to topic %s\nfor client %s using QoS%d\n\n"
+           "Press Q<Enter> to quit\n\n", TOPIC, CLIENTID, QOS);
+    MQTTClient_subscribe(client, TOPIC, QOS);
+
+    do
+    {
+        ch = getchar();
+    } while(ch!='Q' && ch != 'q');
+
+    MQTTClient_disconnect(client, 10000);
+    MQTTClient_destroy(&client);
+    return rc;
+}
+
+  * @endcode
+  * @page tracing Tracing
+  *
+  * Runtime tracing is controlled by environment variables.
+  *
+  * Tracing is switched on by setting MQTT_C_CLIENT_TRACE.  A value of ON, or stdout, prints to
+  * stdout, any other value is interpreted as a file name to use.
+  *
+  * The amount of trace detail is controlled with the MQTT_C_CLIENT_TRACE_LEVEL environment
+  * variable - valid values are ERROR, PROTOCOL, MINIMUM, MEDIUM and MAXIMUM
+  * (from least to most verbose).
+  *
+  * The variable MQTT_C_CLIENT_TRACE_MAX_LINES limits the number of lines of trace that are output
+  * to a file.  Two files are used at most, when they are full, the last one is overwritten with the
+  * new trace entries.  The default size is 1000 lines.
+  *
+  * ### MQTT Packet Tracing
+  *
+  * A feature that can be very useful is printing the MQTT packets that are sent and received.  To
+  * achieve this, use the following environment variable settings:
+  * @code
+    MQTT_C_CLIENT_TRACE=ON
+    MQTT_C_CLIENT_TRACE_LEVEL=PROTOCOL
+  * @endcode
+  * The output you should see looks like this:
+  * @code
+    20130528 155936.813 3 stdout-subscriber -> CONNECT cleansession: 1 (0)
+    20130528 155936.813 3 stdout-subscriber <- CONNACK rc: 0
+    20130528 155936.813 3 stdout-subscriber -> SUBSCRIBE msgid: 1 (0)
+    20130528 155936.813 3 stdout-subscriber <- SUBACK msgid: 1
+    20130528 155941.818 3 stdout-subscriber -> DISCONNECT (0)
+  * @endcode
+  * where the fields are:
+  * 1. date
+  * 2. time
+  * 3. socket number
+  * 4. client id
+  * 5. direction (-> from client to server, <- from server to client)
+  * 6. packet details
+  *
+  * ### Default Level Tracing
+  *
+  * This is an extract of a default level trace of a call to connect:
+  * @code
+    19700101 010000.000 (1152206656) (0)> MQTTClient_connect:893
+    19700101 010000.000 (1152206656)  (1)> MQTTClient_connectURI:716
+    20130528 160447.479 Connecting to serverURI localhost:1883
+    20130528 160447.479 (1152206656)   (2)> MQTTProtocol_connect:98
+    20130528 160447.479 (1152206656)    (3)> MQTTProtocol_addressPort:48
+    20130528 160447.479 (1152206656)    (3)< MQTTProtocol_addressPort:73
+    20130528 160447.479 (1152206656)    (3)> Socket_new:599
+    20130528 160447.479 New socket 4 for localhost, port 1883
+    20130528 160447.479 (1152206656)     (4)> Socket_addSocket:163
+    20130528 160447.479 (1152206656)      (5)> Socket_setnonblocking:73
+    20130528 160447.479 (1152206656)      (5)< Socket_setnonblocking:78 (0)
+    20130528 160447.479 (1152206656)     (4)< Socket_addSocket:176 (0)
+    20130528 160447.479 (1152206656)     (4)> Socket_error:95
+    20130528 160447.479 (1152206656)     (4)< Socket_error:104 (115)
+    20130528 160447.479 Connect pending
+    20130528 160447.479 (1152206656)    (3)< Socket_new:683 (115)
+    20130528 160447.479 (1152206656)   (2)< MQTTProtocol_connect:131 (115)
+  * @endcode
+  * where the fields are:
+  * 1. date
+  * 2. time
+  * 3. thread id
+  * 4. function nesting level
+  * 5. function entry (>) or exit (<)
+  * 6. function name : line of source code file
+  * 7. return value (if there is one)
+  *
+  * ### Memory Allocation Tracing
+  *
+  * Setting the trace level to maximum causes memory allocations and frees to be traced along with
+  * the default trace entries, with messages like the following:
+  * @code
+    20130528 161819.657 Allocating 16 bytes in heap at file /home/icraggs/workspaces/mqrtc/mqttv3c/src/MQTTPacket.c line 177 ptr 0x179f930
+
+    20130528 161819.657 Freeing 16 bytes in heap at file /home/icraggs/workspaces/mqrtc/mqttv3c/src/MQTTPacket.c line 201, heap use now 896 bytes
+  * @endcode
+  * When the last MQTT client object is destroyed, if the trace is being recorded
+  * and all memory allocated by the client library has not been freed, an error message will be
+  * written to the trace.  This can help with fixing memory leaks.  The message will look like this:
+  * @code
+    20130528 163909.208 Some memory not freed at shutdown, possible memory leak
+    20130528 163909.208 Heap scan start, total 880 bytes
+    20130528 163909.208 Heap element size 32, line 354, file /home/icraggs/workspaces/mqrtc/mqttv3c/src/MQTTPacket.c, ptr 0x260cb00
+    20130528 163909.208   Content
+    20130528 163909.209 Heap scan end
+  * @endcode
+  * @endcond
+  */

paho.mqtt.c/MQTTClientPersistence.h

@@ -0,0 +1,254 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2012 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *******************************************************************************/
+
+/**
+ * @file
+ * \brief This structure represents a persistent data store, used to store 
+ * outbound and inbound messages, in order to achieve reliable messaging.
+ *
+ * The MQTT Client persists QoS1 and QoS2 messages in order to meet the
+ * assurances of delivery associated with these @ref qos levels. The messages 
+ * are saved in persistent storage
+ * The type and context of the persistence implementation are specified when 
+ * the MQTT client is created (see MQTTClient_create()). The default 
+ * persistence type (::MQTTCLIENT_PERSISTENCE_DEFAULT) uses a file system-based
+ * persistence mechanism. The <i>persistence_context</i> argument passed to 
+ * MQTTClient_create() when using the default peristence is a string 
+ * representing the location of the persistence directory. If the context 
+ * argument is NULL, the working directory will be used. 
+ *
+ * To use memory-based persistence, an application passes 
+ * ::MQTTCLIENT_PERSISTENCE_NONE as the <i>persistence_type</i> to 
+ * MQTTClient_create(). This can lead to message loss in certain situations, 
+ * but can be appropriate in some cases (see @ref qos).
+ *
+ * Client applications can provide their own persistence mechanism by passing
+ * ::MQTTCLIENT_PERSISTENCE_USER as the <i>persistence_type</i>. To implement a
+ * custom persistence mechanism, the application must pass an initialized
+ * ::MQTTClient_persistence structure as the <i>persistence_context</i> 
+ * argument to MQTTClient_create().
+ *
+ * If the functions defined return an ::MQTTCLIENT_PERSISTENCE_ERROR then the 
+ * state of the persisted data should remain as it was prior to the function 
+ * being called. For example, if Persistence_put() returns 
+ * ::MQTTCLIENT_PERSISTENCE_ERROR, then it is assumed tha tthe persistent store
+ * does not contain the data that was passed to the function. Similarly,  if 
+ * Persistence_remove() returns ::MQTTCLIENT_PERSISTENCE_ERROR then it is 
+ * assumed that the data to be removed is still held in the persistent store.
+ *
+ * It is up to the persistence implementation to log any error information that
+ * may be required to diagnose a persistence mechanism failure.
+ */
+
+/*
+/// @cond EXCLUDE
+*/
+#if !defined(MQTTCLIENTPERSISTENCE_H)
+#define MQTTCLIENTPERSISTENCE_H
+/*
+/// @endcond
+*/
+
+/**
+  * This <i>persistence_type</i> value specifies the default file system-based 
+  * persistence mechanism (see MQTTClient_create()).
+  */
+#define MQTTCLIENT_PERSISTENCE_DEFAULT 0
+/**
+  * This <i>persistence_type</i> value specifies a memory-based 
+  * persistence mechanism (see MQTTClient_create()).
+  */
+#define MQTTCLIENT_PERSISTENCE_NONE 1
+/**
+  * This <i>persistence_type</i> value specifies an application-specific 
+  * persistence mechanism (see MQTTClient_create()).
+  */
+#define MQTTCLIENT_PERSISTENCE_USER 2
+
+/** 
+  * Application-specific persistence functions must return this error code if 
+  * there is a problem executing the function. 
+  */
+#define MQTTCLIENT_PERSISTENCE_ERROR -2
+
+/**
+  * @brief Initialize the persistent store.
+  * 
+  * Either open the existing persistent store for this client ID or create a new
+  * one if one doesn't exist. If the persistent store is already open, return 
+  * without taking any action.
+  *
+  * An application can use the same client identifier to connect to many
+  * different servers. The <i>clientid</i> in conjunction with the 
+  * <i>serverURI</i> uniquely identifies the persistence store required.
+  *
+  * @param handle The address of a pointer to a handle for this persistence 
+  * implementation. This function must set handle to a valid reference to the 
+  * persistence following a successful return. 
+  * The handle pointer is passed as an argument to all the other
+  * persistence functions. It may include the context parameter and/or any other
+  * data for use by the persistence functions.
+  * @param clientID The client identifier for which the persistent store should 
+  * be opened.
+  * @param serverURI The connection string specified when the MQTT client was
+  * created (see MQTTClient_create()).
+  * @param context A pointer to any data required to initialize the persistent
+  * store (see ::MQTTClient_persistence).
+  * @return Return 0 if the function completes successfully, otherwise return
+  * ::MQTTCLIENT_PERSISTENCE_ERROR.
+  */
+typedef int (*Persistence_open)(void** handle, const char* clientID, const char* serverURI, void* context);
+
+/**
+  * @brief Close the persistent store referred to by the handle.
+  *
+  * @param handle The handle pointer from a successful call to 
+  * Persistence_open().
+  * @return Return 0 if the function completes successfully, otherwise return
+  * ::MQTTCLIENT_PERSISTENCE_ERROR.
+  */
+typedef int (*Persistence_close)(void* handle); 
+
+/**
+  * @brief Put the specified data into the persistent store.
+  *
+  * @param handle The handle pointer from a successful call to 
+  * Persistence_open().
+  * @param key A string used as the key for the data to be put in the store. The
+  * key is later used to retrieve data from the store with Persistence_get().
+  * @param bufcount The number of buffers to write to the persistence store.
+  * @param buffers An array of pointers to the data buffers associated with 
+  * this <i>key</i>.
+  * @param buflens An array of lengths of the data buffers. <i>buflen[n]</i> 
+  * gives the length of <i>buffer[n]</i>.
+  * @return Return 0 if the function completes successfully, otherwise return
+  * ::MQTTCLIENT_PERSISTENCE_ERROR.
+  */
+typedef int (*Persistence_put)(void* handle, char* key, int bufcount, char* buffers[], int buflens[]);
+
+/**
+  * @brief Retrieve the specified data from the persistent store. 
+  *
+  * @param handle The handle pointer from a successful call to 
+  * Persistence_open().
+  * @param key A string that is the key for the data to be retrieved. This is 
+  * the same key used to save the data to the store with Persistence_put().
+  * @param buffer The address of a pointer to a buffer. This function sets the
+  * pointer to point at the retrieved data, if successful.
+  * @param buflen The address of an int that is set to the length of 
+  * <i>buffer</i> by this function if successful.
+  * @return Return 0 if the function completes successfully, otherwise return
+  * ::MQTTCLIENT_PERSISTENCE_ERROR.
+  */
+typedef int (*Persistence_get)(void* handle, char* key, char** buffer, int* buflen);
+
+/**
+  * @brief Remove the data for the specified key from the store.
+  *
+  * @param handle The handle pointer from a successful call to 
+  * Persistence_open().
+  * @param key A string that is the key for the data to be removed from the
+  * store. This is the same key used to save the data to the store with 
+  * Persistence_put().
+  * @return Return 0 if the function completes successfully, otherwise return
+  * ::MQTTCLIENT_PERSISTENCE_ERROR.
+  */
+typedef int (*Persistence_remove)(void* handle, char* key);
+
+/**
+  * @brief Returns the keys in this persistent data store.
+  *
+  * @param handle The handle pointer from a successful call to 
+  * Persistence_open().
+  * @param keys The address of a pointer to pointers to strings. Assuming
+  * successful execution, this function allocates memory to hold the returned
+  * keys (strings used to store the data with Persistence_put()). It also 
+  * allocates memory to hold an array of pointers to these strings. <i>keys</i>
+  * is set to point to the array of pointers to strings.
+  * @param nkeys A pointer to the number of keys in this persistent data store. 
+  * This function sets the number of keys, if successful.
+  * @return Return 0 if the function completes successfully, otherwise return
+  * ::MQTTCLIENT_PERSISTENCE_ERROR.
+  */
+typedef int (*Persistence_keys)(void* handle, char*** keys, int* nkeys);
+
+/**
+  * @brief Clears the persistence store, so that it no longer contains any 
+  * persisted data.
+  *
+  * @param handle The handle pointer from a successful call to 
+  * Persistence_open().
+  * @return Return 0 if the function completes successfully, otherwise return
+  * ::MQTTCLIENT_PERSISTENCE_ERROR.
+  */
+typedef int (*Persistence_clear)(void* handle);
+
+/**
+  * @brief Returns whether any data has been persisted using the specified key.
+  *
+  * @param handle The handle pointer from a successful call to 
+  * Persistence_open().
+  * @param key The string to be tested for existence in the store.
+  * @return Return 0 if the key was found in the store, otherwise return
+  * ::MQTTCLIENT_PERSISTENCE_ERROR.
+  */
+typedef int (*Persistence_containskey)(void* handle, char* key);
+
+/**
+  * @brief A structure containing the function pointers to a persistence 
+  * implementation and the context or state that will be shared across all 
+  * the persistence functions.
+  */
+typedef struct {
+  /** 
+    * A pointer to any data required to initialize the persistent store.
+    */
+	void* context;
+  /** 
+    * A function pointer to an implementation of Persistence_open().
+    */
+	Persistence_open popen;
+  /** 
+    * A function pointer to an implementation of Persistence_close().
+    */
+	Persistence_close pclose;
+  /**
+    * A function pointer to an implementation of Persistence_put().
+    */
+	Persistence_put pput;
+  /** 
+    * A function pointer to an implementation of Persistence_get().
+    */
+	Persistence_get pget;
+  /** 
+    * A function pointer to an implementation of Persistence_remove().
+    */
+	Persistence_remove premove;
+  /** 
+    * A function pointer to an implementation of Persistence_keys().
+    */
+	Persistence_keys pkeys;
+  /** 
+    * A function pointer to an implementation of Persistence_clear().
+    */
+	Persistence_clear pclear;
+  /** 
+    * A function pointer to an implementation of Persistence_containskey().
+    */
+	Persistence_containskey pcontainskey;
+} MQTTClient_persistence;
+
+#endif

paho.mqtt.c/MQTTPacket.h

@@ -0,0 +1,262 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2017 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *    Ian Craggs, Allan Stockdill-Mander - SSL updates
+ *    Ian Craggs - MQTT 3.1.1 support
+ *    Ian Craggs - big endian Linux reversed definition
+ *******************************************************************************/
+
+#if !defined(MQTTPACKET_H)
+#define MQTTPACKET_H
+
+#include "Socket.h"
+#if defined(OPENSSL)
+#include "SSLSocket.h"
+#endif
+#include "LinkedList.h"
+#include "Clients.h"
+
+/*BE
+include "Socket"
+include "LinkedList"
+include "Clients"
+BE*/
+
+typedef unsigned int bool;
+typedef void* (*pf)(unsigned char, char*, size_t);
+
+#define BAD_MQTT_PACKET -4
+
+enum msgTypes
+{
+	CONNECT = 1, CONNACK, PUBLISH, PUBACK, PUBREC, PUBREL,
+	PUBCOMP, SUBSCRIBE, SUBACK, UNSUBSCRIBE, UNSUBACK,
+	PINGREQ, PINGRESP, DISCONNECT
+};
+
+#if defined(__linux__)
+#include <endian.h>
+#if __BYTE_ORDER == __BIG_ENDIAN
+	#define REVERSED 1
+#endif
+#endif
+
+/**
+ * Bitfields for the MQTT header byte.
+ */
+typedef union
+{
+	/*unsigned*/ char byte;	/**< the whole byte */
+#if defined(REVERSED)
+	struct
+	{
+		unsigned int type : 4;	/**< message type nibble */
+		bool dup : 1;			/**< DUP flag bit */
+		unsigned int qos : 2;	/**< QoS value, 0, 1 or 2 */
+		bool retain : 1;		/**< retained flag bit */
+	} bits;
+#else
+	struct
+	{
+		bool retain : 1;		/**< retained flag bit */
+		unsigned int qos : 2;	/**< QoS value, 0, 1 or 2 */
+		bool dup : 1;			/**< DUP flag bit */
+		unsigned int type : 4;	/**< message type nibble */
+	} bits;
+#endif
+} Header;
+
+
+/**
+ * Data for a connect packet.
+ */
+typedef struct
+{
+	Header header;	/**< MQTT header byte */
+	union
+	{
+		unsigned char all;	/**< all connect flags */
+#if defined(REVERSED)
+		struct
+		{
+			bool username : 1;			/**< 3.1 user name */
+			bool password : 1; 			/**< 3.1 password */
+			bool willRetain : 1;		/**< will retain setting */
+			unsigned int willQoS : 2;	/**< will QoS value */
+			bool will : 1;			/**< will flag */
+			bool cleanstart : 1;	/**< cleansession flag */
+			int : 1;	/**< unused */
+		} bits;
+#else
+		struct
+		{
+			int : 1;	/**< unused */
+			bool cleanstart : 1;	/**< cleansession flag */
+			bool will : 1;			/**< will flag */
+			unsigned int willQoS : 2;	/**< will QoS value */
+			bool willRetain : 1;		/**< will retain setting */
+			bool password : 1; 			/**< 3.1 password */
+			bool username : 1;			/**< 3.1 user name */
+		} bits;
+#endif
+	} flags;	/**< connect flags byte */
+
+	char *Protocol, /**< MQTT protocol name */
+		*clientID,	/**< string client id */
+        *willTopic,	/**< will topic */
+        *willMsg;	/**< will payload */
+
+	int keepAliveTimer;		/**< keepalive timeout value in seconds */
+	unsigned char version;	/**< MQTT version number */
+} Connect;
+
+
+/**
+ * Data for a connack packet.
+ */
+typedef struct
+{
+	Header header; /**< MQTT header byte */
+	union
+	{
+		unsigned char all;	/**< all connack flags */
+#if defined(REVERSED)
+		struct
+		{
+			unsigned int reserved : 7;	/**< message type nibble */
+			bool sessionPresent : 1;    /**< was a session found on the server? */
+		} bits;
+#else
+		struct
+		{
+			bool sessionPresent : 1;    /**< was a session found on the server? */
+			unsigned int reserved : 7;	/**< message type nibble */
+		} bits;
+#endif
+	} flags;	 /**< connack flags byte */
+	char rc; /**< connack return code */
+} Connack;
+
+
+/**
+ * Data for a packet with header only.
+ */
+typedef struct
+{
+	Header header;	/**< MQTT header byte */
+} MQTTPacket;
+
+
+/**
+ * Data for a subscribe packet.
+ */
+typedef struct
+{
+	Header header;	/**< MQTT header byte */
+	int msgId;		/**< MQTT message id */
+	List* topics;	/**< list of topic strings */
+	List* qoss;		/**< list of corresponding QoSs */
+	int noTopics;	/**< topic and qos count */
+} Subscribe;
+
+
+/**
+ * Data for a suback packet.
+ */
+typedef struct
+{
+	Header header;	/**< MQTT header byte */
+	int msgId;		/**< MQTT message id */
+	List* qoss;		/**< list of granted QoSs */
+} Suback;
+
+
+/**
+ * Data for an unsubscribe packet.
+ */
+typedef struct
+{
+	Header header;	/**< MQTT header byte */
+	int msgId;		/**< MQTT message id */
+	List* topics;	/**< list of topic strings */
+	int noTopics;	/**< topic count */
+} Unsubscribe;
+
+
+/**
+ * Data for a publish packet.
+ */
+typedef struct
+{
+	Header header;	/**< MQTT header byte */
+	char* topic;	/**< topic string */
+	int topiclen;
+	int msgId;		/**< MQTT message id */
+	char* payload;	/**< binary payload, length delimited */
+	int payloadlen;	/**< payload length */
+} Publish;
+
+
+/**
+ * Data for one of the ack packets.
+ */
+typedef struct
+{
+	Header header;	/**< MQTT header byte */
+	int msgId;		/**< MQTT message id */
+} Ack;
+
+typedef Ack Puback;
+typedef Ack Pubrec;
+typedef Ack Pubrel;
+typedef Ack Pubcomp;
+typedef Ack Unsuback;
+
+int MQTTPacket_encode(char* buf, size_t length);
+int MQTTPacket_decode(networkHandles* net, size_t* value);
+int readInt(char** pptr);
+char* readUTF(char** pptr, char* enddata);
+unsigned char readChar(char** pptr);
+void writeChar(char** pptr, char c);
+void writeInt(char** pptr, int anInt);
+void writeUTF(char** pptr, const char* string);
+void writeData(char** pptr, const void* data, int datalen);
+
+const char* MQTTPacket_name(int ptype);
+
+void* MQTTPacket_Factory(networkHandles* net, int* error);
+int MQTTPacket_send(networkHandles* net, Header header, char* buffer, size_t buflen, int free);
+int MQTTPacket_sends(networkHandles* net, Header header, int count, char** buffers, size_t* buflens, int* frees);
+
+void* MQTTPacket_header_only(unsigned char aHeader, char* data, size_t datalen);
+int MQTTPacket_send_disconnect(networkHandles* net, const char* clientID);
+
+void* MQTTPacket_publish(unsigned char aHeader, char* data, size_t datalen);
+void MQTTPacket_freePublish(Publish* pack);
+int MQTTPacket_send_publish(Publish* pack, int dup, int qos, int retained, networkHandles* net, const char* clientID);
+int MQTTPacket_send_puback(int msgid, networkHandles* net, const char* clientID);
+void* MQTTPacket_ack(unsigned char aHeader, char* data, size_t datalen);
+
+void MQTTPacket_freeSuback(Suback* pack);
+int MQTTPacket_send_pubrec(int msgid, networkHandles* net, const char* clientID);
+int MQTTPacket_send_pubrel(int msgid, int dup, networkHandles* net, const char* clientID);
+int MQTTPacket_send_pubcomp(int msgid, networkHandles* net, const char* clientID);
+
+void MQTTPacket_free_packet(MQTTPacket* pack);
+
+#if !defined(NO_BRIDGE)
+	#include "MQTTPacketOut.h"
+#endif
+
+#endif /* MQTTPACKET_H */

paho.mqtt.c/MQTTPacketOut.h

@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2014 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *    Ian Craggs, Allan Stockdill-Mander - SSL updates
+ *    Ian Craggs - MQTT 3.1.1 support
+ *******************************************************************************/
+
+#if !defined(MQTTPACKETOUT_H)
+#define MQTTPACKETOUT_H
+
+#include "MQTTPacket.h"
+
+int MQTTPacket_send_connect(Clients* client, int MQTTVersion);
+void* MQTTPacket_connack(unsigned char aHeader, char* data, size_t datalen);
+
+int MQTTPacket_send_pingreq(networkHandles* net, const char* clientID);
+
+int MQTTPacket_send_subscribe(List* topics, List* qoss, int msgid, int dup, networkHandles* net, const char* clientID);
+void* MQTTPacket_suback(unsigned char aHeader, char* data, size_t datalen);
+
+int MQTTPacket_send_unsubscribe(List* topics, int msgid, int dup, networkHandles* net, const char* clientID);
+
+#endif

paho.mqtt.c/MQTTPersistence.h

@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2013 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *    Ian Craggs - async client updates
+ *    Ian Craggs - fix for bug 432903 - queue persistence
+ *******************************************************************************/
+
+#if defined(__cplusplus)
+ extern "C" {
+#endif
+
+#include "Clients.h"
+
+/** Stem of the key for a sent PUBLISH QoS1 or QoS2 */
+#define PERSISTENCE_PUBLISH_SENT "s-"
+/** Stem of the key for a sent PUBREL */
+#define PERSISTENCE_PUBREL "sc-"
+/** Stem of the key for a received PUBLISH QoS2 */
+#define PERSISTENCE_PUBLISH_RECEIVED "r-"
+/** Stem of the key for an async client command */
+#define PERSISTENCE_COMMAND_KEY "c-"
+/** Stem of the key for an async client message queue */
+#define PERSISTENCE_QUEUE_KEY "q-"
+#define PERSISTENCE_MAX_KEY_LENGTH 8
+
+int MQTTPersistence_create(MQTTClient_persistence** per, int type, void* pcontext);
+int MQTTPersistence_initialize(Clients* c, const char* serverURI);
+int MQTTPersistence_close(Clients* c);
+int MQTTPersistence_clear(Clients* c);
+int MQTTPersistence_restore(Clients* c);
+void* MQTTPersistence_restorePacket(char* buffer, size_t buflen);
+void MQTTPersistence_insertInOrder(List* list, void* content, size_t size);
+int MQTTPersistence_put(int socket, char* buf0, size_t buf0len, int count, 
+								 char** buffers, size_t* buflens, int htype, int msgId, int scr);
+int MQTTPersistence_remove(Clients* c, char* type, int qos, int msgId);
+void MQTTPersistence_wrapMsgID(Clients *c);
+
+typedef struct
+{
+	char struct_id[4];
+	int struct_version;
+	int payloadlen;
+	void* payload;
+	int qos;
+	int retained;
+	int dup;
+	int msgid;
+} MQTTPersistence_message;
+
+typedef struct
+{
+	MQTTPersistence_message* msg;
+	char* topicName;
+	int topicLen;
+	unsigned int seqno; /* only used on restore */
+} MQTTPersistence_qEntry;
+
+int MQTTPersistence_unpersistQueueEntry(Clients* client, MQTTPersistence_qEntry* qe);
+int MQTTPersistence_persistQueueEntry(Clients* aclient, MQTTPersistence_qEntry* qe);
+int MQTTPersistence_restoreMessageQueue(Clients* c);
+#ifdef __cplusplus
+     }
+#endif

paho.mqtt.c/MQTTPersistenceDefault.h

@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2013 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *******************************************************************************/
+
+/** 8.3 filesystem */
+#define MESSAGE_FILENAME_LENGTH 8    
+/** Extension of the filename */
+#define MESSAGE_FILENAME_EXTENSION ".msg"
+
+/* prototypes of the functions for the default file system persistence */
+int pstopen(void** handle, const char* clientID, const char* serverURI, void* context); 
+int pstclose(void* handle); 
+int pstput(void* handle, char* key, int bufcount, char* buffers[], int buflens[]); 
+int pstget(void* handle, char* key, char** buffer, int* buflen); 
+int pstremove(void* handle, char* key); 
+int pstkeys(void* handle, char*** keys, int* nkeys); 
+int pstclear(void* handle); 
+int pstcontainskey(void* handle, char* key);
+
+int pstmkdir(char *pPathname);
+

paho.mqtt.c/MQTTProtocol.h

@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2014 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *    Ian Craggs - MQTT 3.1.1 updates
+ *******************************************************************************/
+
+#if !defined(MQTTPROTOCOL_H)
+#define MQTTPROTOCOL_H
+
+#include "LinkedList.h"
+#include "MQTTPacket.h"
+#include "Clients.h"
+
+#define MAX_MSG_ID 65535
+#define MAX_CLIENTID_LEN 65535
+
+typedef struct
+{
+	int socket;
+	Publications* p;
+} pending_write;
+
+
+typedef struct
+{
+	List publications;
+	unsigned int msgs_received;
+	unsigned int msgs_sent;
+	List pending_writes; /* for qos 0 writes not complete */
+} MQTTProtocol;
+
+
+#include "MQTTProtocolOut.h"
+
+#endif

paho.mqtt.c/MQTTProtocolClient.h

@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2013 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *    Ian Craggs, Allan Stockdill-Mander - SSL updates
+ *    Ian Craggs - MQTT 3.1.1 updates
+ *    Rong Xiang, Ian Craggs - C++ compatibility
+ *******************************************************************************/
+
+#if !defined(MQTTPROTOCOLCLIENT_H)
+#define MQTTPROTOCOLCLIENT_H
+
+#include "LinkedList.h"
+#include "MQTTPacket.h"
+#include "Log.h"
+#include "MQTTProtocol.h"
+#include "Messages.h"
+
+#define MAX_MSG_ID 65535
+#define MAX_CLIENTID_LEN 65535
+
+int MQTTProtocol_startPublish(Clients* pubclient, Publish* publish, int qos, int retained, Messages** m);
+Messages* MQTTProtocol_createMessage(Publish* publish, Messages** mm, int qos, int retained);
+Publications* MQTTProtocol_storePublication(Publish* publish, int* len);
+int messageIDCompare(void* a, void* b);
+int MQTTProtocol_assignMsgId(Clients* client);
+void MQTTProtocol_removePublication(Publications* p);
+void Protocol_processPublication(Publish* publish, Clients* client);
+
+int MQTTProtocol_handlePublishes(void* pack, int sock);
+int MQTTProtocol_handlePubacks(void* pack, int sock);
+int MQTTProtocol_handlePubrecs(void* pack, int sock);
+int MQTTProtocol_handlePubrels(void* pack, int sock);
+int MQTTProtocol_handlePubcomps(void* pack, int sock);
+
+void MQTTProtocol_closeSession(Clients* c, int sendwill);
+void MQTTProtocol_keepalive(time_t);
+void MQTTProtocol_retry(time_t, int, int);
+void MQTTProtocol_freeClient(Clients* client);
+void MQTTProtocol_emptyMessageList(List* msgList);
+void MQTTProtocol_freeMessageList(List* msgList);
+
+char* MQTTStrncpy(char *dest, const char* src, size_t num);
+char* MQTTStrdup(const char* src);
+#endif

paho.mqtt.c/MQTTProtocolOut.h

@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2017 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *    Ian Craggs, Allan Stockdill-Mander - SSL updates
+ *    Ian Craggs - MQTT 3.1.1 support
+ *    Ian Craggs - SNI support
+ *******************************************************************************/
+
+#if !defined(MQTTPROTOCOLOUT_H)
+#define MQTTPROTOCOLOUT_H
+
+#include "LinkedList.h"
+#include "MQTTPacket.h"
+#include "Clients.h"
+#include "Log.h"
+#include "Messages.h"
+#include "MQTTProtocol.h"
+#include "MQTTProtocolClient.h"
+
+#define DEFAULT_PORT 1883
+
+char* MQTTProtocol_addressPort(const char* uri, int* port);
+void MQTTProtocol_reconnect(const char* ip_address, Clients* client);
+#if defined(OPENSSL)
+int MQTTProtocol_connect(const char* ip_address, Clients* acClients, int ssl, int MQTTVersion);
+#else
+int MQTTProtocol_connect(const char* ip_address, Clients* acClients, int MQTTVersion);
+#endif
+int MQTTProtocol_handlePingresps(void* pack, int sock);
+int MQTTProtocol_subscribe(Clients* client, List* topics, List* qoss, int msgID);
+int MQTTProtocol_handleSubacks(void* pack, int sock);
+int MQTTProtocol_unsubscribe(Clients* client, List* topics, int msgID);
+int MQTTProtocol_handleUnsubacks(void* pack, int sock);
+
+#endif

paho.mqtt.c/Messages.h

@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2013 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *******************************************************************************/
+
+#if !defined(MESSAGES_H)
+#define MESSAGES_H
+
+#include "Log.h"
+
+const char* Messages_get(int, enum LOG_LEVELS);
+
+#endif

paho.mqtt.c/OsWrapper.h

@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * Copyright (c) 2016, 2017 logi.cals GmbH
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Gunter Raidl - timer support for VxWorks
+ *    Rainer Poisel - reusability
+ *******************************************************************************/
+
+#if !defined(OSWRAPPER_H)
+#define OSWRAPPER_H
+
+#if defined(_WRS_KERNEL)
+#include <time.h>
+
+#define lstat stat
+
+typedef unsigned long useconds_t;
+void usleep(useconds_t useconds);
+
+#define timersub(a, b, result) \
+	do \
+	{ \
+		(result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
+		(result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
+		if ((result)->tv_usec < 0) \
+		{ \
+			--(result)->tv_sec; \
+			(result)->tv_usec += 1000000L; \
+		} \
+	} while (0)
+#endif /* defined(_WRS_KERNEL) */
+
+#endif /* OSWRAPPER_H */

paho.mqtt.c/SSLSocket.h

@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2017 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs, Allan Stockdill-Mander - initial implementation 
+ *    Ian Craggs - SNI support
+ *******************************************************************************/
+#if !defined(SSLSOCKET_H)
+#define SSLSOCKET_H
+
+#if defined(WIN32) || defined(WIN64)
+	#define ssl_mutex_type HANDLE
+#else
+	#include <pthread.h>
+	#include <semaphore.h>
+	#define ssl_mutex_type pthread_mutex_t
+#endif
+
+#include <openssl/ssl.h>
+#include "SocketBuffer.h"
+#include "Clients.h"
+
+#define URI_SSL "ssl://"
+
+/** if we should handle openssl initialization (bool_value == 1) or depend on it to be initalized externally (bool_value == 0) */
+void SSLSocket_handleOpensslInit(int bool_value);
+
+int SSLSocket_initialize(void);
+void SSLSocket_terminate(void);
+int SSLSocket_setSocketForSSL(networkHandles* net, MQTTClient_SSLOptions* opts, char* hostname);
+
+int SSLSocket_getch(SSL* ssl, int socket, char* c);
+char *SSLSocket_getdata(SSL* ssl, int socket, size_t bytes, size_t* actual_len);
+
+int SSLSocket_close(networkHandles* net);
+int SSLSocket_putdatas(SSL* ssl, int socket, char* buf0, size_t buf0len, int count, char** buffers, size_t* buflens, int* frees);
+int SSLSocket_connect(SSL* ssl, int socket);
+
+int SSLSocket_getPendingRead(void);
+int SSLSocket_continueWrite(pending_writes* pw);
+
+#endif

paho.mqtt.c/Socket.h

@@ -0,0 +1,143 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2014 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial implementation and documentation
+ *    Ian Craggs - async client updates
+ *******************************************************************************/
+
+#if !defined(SOCKET_H)
+#define SOCKET_H
+
+#include <sys/types.h>
+
+#if defined(WIN32) || defined(WIN64)
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#define MAXHOSTNAMELEN 256
+#if !defined(SSLSOCKET_H)
+#undef EAGAIN
+#define EAGAIN WSAEWOULDBLOCK
+#undef EINTR
+#define EINTR WSAEINTR
+#undef EINPROGRESS
+#define EINPROGRESS WSAEINPROGRESS
+#undef EWOULDBLOCK
+#define EWOULDBLOCK WSAEWOULDBLOCK
+#undef ENOTCONN
+#define ENOTCONN WSAENOTCONN
+#undef ECONNRESET
+#define ECONNRESET WSAECONNRESET
+#undef ETIMEDOUT
+#define ETIMEDOUT WAIT_TIMEOUT
+#endif
+#define ioctl ioctlsocket
+#define socklen_t int
+#else
+#define INVALID_SOCKET SOCKET_ERROR
+#include <sys/socket.h>
+#if !defined(_WRS_KERNEL)
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/select.h>
+#include <sys/uio.h>
+#else
+#include <selectLib.h>
+#endif
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#define ULONG size_t
+#endif
+
+/** socket operation completed successfully */
+#define TCPSOCKET_COMPLETE 0
+#if !defined(SOCKET_ERROR)
+	/** error in socket operation */
+	#define SOCKET_ERROR -1
+#endif
+/** must be the same as SOCKETBUFFER_INTERRUPTED */
+#define TCPSOCKET_INTERRUPTED -22
+#define SSL_FATAL -3
+
+#if !defined(INET6_ADDRSTRLEN)
+#define INET6_ADDRSTRLEN 46 /** only needed for gcc/cygwin on windows */
+#endif
+
+
+#if !defined(max)
+#define max(A,B) ( (A) > (B) ? (A):(B))
+#endif
+
+#include "LinkedList.h"
+
+/*BE
+def FD_SET
+{
+   128 n8 "data"
+}
+
+def SOCKETS
+{
+	FD_SET "rset"
+	FD_SET "rset_saved"
+	n32 dec "maxfdp1"
+	n32 ptr INTList "clientsds"
+	n32 ptr INTItem "cur_clientsds"
+	n32 ptr INTList "connect_pending"
+	n32 ptr INTList "write_pending"
+	FD_SET "pending_wset"
+}
+BE*/
+
+
+/**
+ * Structure to hold all socket data for the module
+ */
+typedef struct
+{
+	fd_set rset, /**< socket read set (see select doc) */
+		rset_saved; /**< saved socket read set */
+	int maxfdp1; /**< max descriptor used +1 (again see select doc) */
+	List* clientsds; /**< list of client socket descriptors */
+	ListElement* cur_clientsds; /**< current client socket descriptor (iterator) */
+	List* connect_pending; /**< list of sockets for which a connect is pending */
+	List* write_pending; /**< list of sockets for which a write is pending */
+	fd_set pending_wset; /**< socket pending write set for select */
+} Sockets;
+
+
+void Socket_outInitialize(void);
+void Socket_outTerminate(void);
+int Socket_getReadySocket(int more_work, struct timeval *tp);
+int Socket_getch(int socket, char* c);
+char *Socket_getdata(int socket, size_t bytes, size_t* actual_len);
+int Socket_putdatas(int socket, char* buf0, size_t buf0len, int count, char** buffers, size_t* buflens, int* frees);
+void Socket_close(int socket);
+int Socket_new(char* addr, int port, int* socket);
+
+int Socket_noPendingWrites(int socket);
+char* Socket_getpeer(int sock);
+
+void Socket_addPendingWrite(int socket);
+void Socket_clearPendingWrite(int socket);
+
+typedef void Socket_writeComplete(int socket);
+void Socket_setWriteCompleteCallback(Socket_writeComplete*);
+
+#endif /* SOCKET_H */

paho.mqtt.c/SocketBuffer.h

@@ -0,0 +1,84 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2014 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *    Ian Craggs, Allan Stockdill-Mander - SSL updates
+ *******************************************************************************/
+
+#if !defined(SOCKETBUFFER_H)
+#define SOCKETBUFFER_H
+
+#if defined(WIN32) || defined(WIN64)
+#include <winsock2.h>
+#else
+#include <sys/socket.h>
+#endif
+
+#if defined(OPENSSL)
+#include <openssl/ssl.h>
+#endif
+
+#if defined(WIN32) || defined(WIN64)
+	typedef WSABUF iobuf;
+#else
+	typedef struct iovec iobuf;
+#endif
+
+typedef struct
+{
+	int socket;
+	unsigned int index;
+	size_t headerlen;
+	char fixed_header[5];	/**< header plus up to 4 length bytes */
+	size_t buflen, 			/**< total length of the buffer */
+		datalen; 			/**< current length of data in buf */
+	char* buf;
+} socket_queue;
+
+typedef struct
+{
+	int socket, count;
+	size_t total;
+#if defined(OPENSSL)
+	SSL* ssl;
+#endif
+	size_t bytes;
+	iobuf iovecs[5];
+	int frees[5];
+} pending_writes;
+
+#define SOCKETBUFFER_COMPLETE 0
+#if !defined(SOCKET_ERROR)
+	#define SOCKET_ERROR -1
+#endif
+#define SOCKETBUFFER_INTERRUPTED -22 /* must be the same value as TCPSOCKET_INTERRUPTED */
+
+void SocketBuffer_initialize(void);
+void SocketBuffer_terminate(void);
+void SocketBuffer_cleanup(int socket);
+char* SocketBuffer_getQueuedData(int socket, size_t bytes, size_t* actual_len);
+int SocketBuffer_getQueuedChar(int socket, char* c);
+void SocketBuffer_interrupted(int socket, size_t actual_len);
+char* SocketBuffer_complete(int socket);
+void SocketBuffer_queueChar(int socket, char c);
+
+#if defined(OPENSSL)
+void SocketBuffer_pendingWrite(int socket, SSL* ssl, int count, iobuf* iovecs, int* frees, size_t total, size_t bytes);
+#else
+void SocketBuffer_pendingWrite(int socket, int count, iobuf* iovecs, int* frees, size_t total, size_t bytes);
+#endif
+pending_writes* SocketBuffer_getWrite(int socket);
+int SocketBuffer_writeComplete(int socket);
+pending_writes* SocketBuffer_updateWrite(int socket, char* topic, char* payload);
+
+#endif

paho.mqtt.c/StackTrace.h

@@ -0,0 +1,71 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2014 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *******************************************************************************/
+
+#ifndef STACKTRACE_H_
+#define STACKTRACE_H_
+
+#include <stdio.h>
+#include "Log.h"
+#include "Thread.h"
+
+#if defined(NOSTACKTRACE)
+#define FUNC_ENTRY
+#define FUNC_ENTRY_NOLOG
+#define FUNC_ENTRY_MED
+#define FUNC_ENTRY_MAX
+#define FUNC_EXIT
+#define FUNC_EXIT_NOLOG
+#define FUNC_EXIT_MED
+#define FUNC_EXIT_MAX
+#define FUNC_EXIT_RC(x)
+#define FUNC_EXIT_MED_RC(x)
+#define FUNC_EXIT_MAX_RC(x)
+#else
+#if defined(WIN32) || defined(WIN64)
+#define inline __inline
+#define FUNC_ENTRY StackTrace_entry(__FUNCTION__, __LINE__, TRACE_MINIMUM)
+#define FUNC_ENTRY_NOLOG StackTrace_entry(__FUNCTION__, __LINE__, -1)
+#define FUNC_ENTRY_MED StackTrace_entry(__FUNCTION__, __LINE__, TRACE_MEDIUM)
+#define FUNC_ENTRY_MAX StackTrace_entry(__FUNCTION__, __LINE__, TRACE_MAXIMUM)
+#define FUNC_EXIT StackTrace_exit(__FUNCTION__, __LINE__, NULL, TRACE_MINIMUM)
+#define FUNC_EXIT_NOLOG StackTrace_exit(__FUNCTION__, __LINE__, -1)
+#define FUNC_EXIT_MED StackTrace_exit(__FUNCTION__, __LINE__, NULL, TRACE_MEDIUM)
+#define FUNC_EXIT_MAX StackTrace_exit(__FUNCTION__, __LINE__, NULL, TRACE_MAXIMUM)
+#define FUNC_EXIT_RC(x) StackTrace_exit(__FUNCTION__, __LINE__, &x, TRACE_MINIMUM)
+#define FUNC_EXIT_MED_RC(x) StackTrace_exit(__FUNCTION__, __LINE__, &x, TRACE_MEDIUM)
+#define FUNC_EXIT_MAX_RC(x) StackTrace_exit(__FUNCTION__, __LINE__, &x, TRACE_MAXIMUM)
+#else
+#define FUNC_ENTRY StackTrace_entry(__func__, __LINE__, TRACE_MINIMUM)
+#define FUNC_ENTRY_NOLOG StackTrace_entry(__func__, __LINE__, -1)
+#define FUNC_ENTRY_MED StackTrace_entry(__func__, __LINE__, TRACE_MEDIUM)
+#define FUNC_ENTRY_MAX StackTrace_entry(__func__, __LINE__, TRACE_MAXIMUM)
+#define FUNC_EXIT StackTrace_exit(__func__, __LINE__, NULL, TRACE_MINIMUM)
+#define FUNC_EXIT_NOLOG StackTrace_exit(__func__, __LINE__, NULL, -1)
+#define FUNC_EXIT_MED StackTrace_exit(__func__, __LINE__, NULL, TRACE_MEDIUM)
+#define FUNC_EXIT_MAX StackTrace_exit(__func__, __LINE__, NULL, TRACE_MAXIMUM)
+#define FUNC_EXIT_RC(x) StackTrace_exit(__func__, __LINE__, &x, TRACE_MINIMUM)
+#define FUNC_EXIT_MED_RC(x) StackTrace_exit(__func__, __LINE__, &x, TRACE_MEDIUM)
+#define FUNC_EXIT_MAX_RC(x) StackTrace_exit(__func__, __LINE__, &x, TRACE_MAXIMUM)
+#endif
+#endif
+
+void StackTrace_entry(const char* name, int line, enum LOG_LEVELS trace);
+void StackTrace_exit(const char* name, int line, void* return_value, enum LOG_LEVELS trace);
+
+void StackTrace_printStack(FILE* dest);
+char* StackTrace_get(thread_id_type);
+
+#endif /* STACKTRACE_H_ */

paho.mqtt.c/Thread.h

@@ -0,0 +1,73 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2017 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial implementation
+ *    Ian Craggs, Allan Stockdill-Mander - async client updates
+ *    Ian Craggs - fix for bug #420851
+ *    Ian Craggs - change MacOS semaphore implementation
+ *******************************************************************************/
+#include "MQTTClient.h"
+
+#if !defined(THREAD_H)
+#define THREAD_H
+
+#if defined(WIN32) || defined(WIN64)
+	#include <windows.h>
+	#define thread_type HANDLE
+	#define thread_id_type DWORD
+	#define thread_return_type DWORD
+	#define thread_fn LPTHREAD_START_ROUTINE
+	#define mutex_type HANDLE
+	#define cond_type HANDLE
+	#define sem_type HANDLE
+#else
+	#include <pthread.h>
+
+	#define thread_type pthread_t
+	#define thread_id_type pthread_t
+	#define thread_return_type void*
+	typedef thread_return_type (*thread_fn)(void*);
+	#define mutex_type pthread_mutex_t*
+	typedef struct { pthread_cond_t cond; pthread_mutex_t mutex; } cond_type_struct;
+	typedef cond_type_struct *cond_type;
+	#if defined(OSX)
+	  #include <dispatch/dispatch.h>
+	  typedef dispatch_semaphore_t sem_type;
+	#else
+	  #include <semaphore.h>
+	  typedef sem_t *sem_type;
+	#endif
+
+	cond_type Thread_create_cond(void);
+	int Thread_signal_cond(cond_type);
+	int Thread_wait_cond(cond_type condvar, int timeout);
+	int Thread_destroy_cond(cond_type);
+#endif
+
+DLLExport thread_type Thread_start(thread_fn, void*);
+
+DLLExport mutex_type Thread_create_mutex();
+DLLExport int Thread_lock_mutex(mutex_type);
+DLLExport int Thread_unlock_mutex(mutex_type);
+void Thread_destroy_mutex(mutex_type);
+
+DLLExport thread_id_type Thread_getid();
+
+sem_type Thread_create_sem(void);
+int Thread_wait_sem(sem_type sem, int timeout);
+int Thread_check_sem(sem_type sem);
+int Thread_post_sem(sem_type sem);
+int Thread_destroy_sem(sem_type sem);
+
+
+#endif

paho.mqtt.c/Tree.h

@@ -0,0 +1,115 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2013 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial implementation and documentation
+ *******************************************************************************/
+
+
+#if !defined(TREE_H)
+#define TREE_H
+
+#include <stdlib.h> /* for size_t definition */
+
+/*BE
+defm defTree(T) // macro to define a tree
+
+def T concat Node
+{
+	n32 ptr T concat Node "parent"
+	n32 ptr T concat Node "left"
+	n32 ptr T concat Node "right"
+	n32 ptr T id2str(T)
+	n32 suppress "size"
+}
+
+
+def T concat Tree
+{
+	struct
+	{
+		n32 ptr T concat Node suppress "root"
+		n32 ptr DATA suppress "compare"
+	} 
+	struct
+	{
+		n32 ptr T concat Node suppress "root"
+		n32 ptr DATA suppress "compare"
+	} 
+	n32 dec "count"
+	n32 dec suppress "size"
+}
+
+endm
+
+defTree(INT)
+defTree(STRING)
+defTree(TMP)
+
+BE*/
+
+/**
+ * Structure to hold all data for one list element
+ */
+typedef struct NodeStruct
+{
+	struct NodeStruct *parent,   /**< pointer to parent tree node, in case we need it */
+					  *child[2]; /**< pointers to child tree nodes 0 = left, 1 = right */
+	void* content;				 /**< pointer to element content */
+	size_t size;					 /**< size of content */
+	unsigned int red : 1;
+} Node;
+
+
+/**
+ * Structure to hold all data for one tree
+ */
+typedef struct
+{
+	struct
+	{
+		Node *root;	/**< root node pointer */
+		int (*compare)(void*, void*, int); /**< comparison function */
+	} index[2];
+	int indexes,  /**< no of indexes into tree */
+		count;    /**< no of items */
+	size_t size;  /**< heap storage used */
+	unsigned int heap_tracking : 1; /**< switch on heap tracking for this tree? */
+	unsigned int allow_duplicates : 1; /**< switch to allow duplicate entries */
+} Tree;
+
+
+Tree* TreeInitialize(int(*compare)(void*, void*, int));
+void TreeInitializeNoMalloc(Tree* aTree, int(*compare)(void*, void*, int));
+void TreeAddIndex(Tree* aTree, int(*compare)(void*, void*, int));
+
+void* TreeAdd(Tree* aTree, void* content, size_t size);
+
+void* TreeRemove(Tree* aTree, void* content);
+
+void* TreeRemoveKey(Tree* aTree, void* key);
+void* TreeRemoveKeyIndex(Tree* aTree, void* key, int index);
+
+void* TreeRemoveNodeIndex(Tree* aTree, Node* aNode, int index);
+
+void TreeFree(Tree* aTree);
+
+Node* TreeFind(Tree* aTree, void* key);
+Node* TreeFindIndex(Tree* aTree, void* key, int index);
+
+Node* TreeNextElement(Tree* aTree, Node* curnode);
+
+int TreeIntCompare(void* a, void* b, int);
+int TreePtrCompare(void* a, void* b, int);
+int TreeStringCompare(void* a, void* b, int);
+
+#endif

paho.mqtt.c/utf-8.h

@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2013 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Ian Craggs - initial API and implementation and/or initial documentation
+ *******************************************************************************/
+
+#if !defined(UTF8_H)
+#define UTF8_H
+
+int UTF8_validate(int len, const char *data);
+int UTF8_validateString(const char* string);
+
+#endif