Fix for bug #420851

src/MQTTAsync.c

@@ -17,6 +17,7 @@
  *    Ian Craggs - fix for bug 413429 - connectionLost not called
  *    Ian Craggs - fix for bug# 415042 - using already freed structure
  *    Ian Craggs - fix for bug 419233 - mutexes not reporting errors
+ *    Ian Craggs - fix for bug #420851
  *******************************************************************************/
 
 /**
@@ -1224,9 +1225,9 @@ thread_return_type WINAPI MQTTAsync_sendThread(void* n)
 		while (commands->count > 0)
 			MQTTAsync_processCommand();
 #if !defined(WIN32)
-		/*rc =*/ Thread_wait_cond_timeout(send_cond, 1);
+		/*rc =*/ Thread_wait_cond(send_cond, 1);
 #else
-		/*rc =*/ Thread_wait_sem_timeout(send_sem, 1);
+		/*rc =*/ Thread_wait_sem(send_sem, 1000);
 #endif
 			
 		MQTTAsync_checkTimeouts();

src/MQTTAsync.c~

+/*******************************************************************************
+ * 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
+ *    Ian Craggs, Allan Stockdill-Mander - SSL support
+ *    Ian Craggs - multiple server connection support
+ *    Ian Craggs - fix for bug 413429 - connectionLost not called
+ *    Ian Craggs - fix for bug# 415042 - using already freed structure
+ *    Ian Craggs - fix for bug 419233 - mutexes not reporting errors
+ *******************************************************************************/
+
+/**
+ * @file
+ * \brief Asynchronous API implementation
+ *
+ */
+
+#define _GNU_SOURCE /* for pthread_mutexattr_settype */
+#include <stdlib.h>
+#if !defined(WIN32)
+	#include <sys/time.h>
+#endif
+
+#if !defined(NO_PERSISTENCE)
+#include "MQTTPersistence.h"
+#endif
+#include "MQTTAsync.h"
+#include "utf-8.h"
+#include "MQTTProtocol.h"
+#include "MQTTProtocolOut.h"
+#include "Thread.h"
+#include "SocketBuffer.h"
+#include "StackTrace.h"
+#include "Heap.h"
+
+#define URI_TCP "tcp://"
+
+#define BUILD_TIMESTAMP "##MQTTCLIENT_BUILD_TAG##"
+#define CLIENT_VERSION  "##MQTTCLIENT_VERSION_TAG##"
+
+char* client_timestamp_eye = "MQTTAsyncV3_Timestamp " BUILD_TIMESTAMP;
+char* client_version_eye = "MQTTAsyncV3_Version " CLIENT_VERSION;
+
+extern Sockets s;
+
+static ClientStates ClientState =
+{
+	CLIENT_VERSION, /* version */
+	NULL /* client list */	
+};
+
+ClientStates* bstate = &ClientState;
+
+MQTTProtocol state;
+
+enum MQTTAsync_threadStates
+{
+	STOPPED, STARTING, RUNNING, STOPPING
+};
+
+enum MQTTAsync_threadStates sendThread_state = STOPPED;
+enum MQTTAsync_threadStates receiveThread_state = STOPPED;
+
+#if defined(WIN32)
+static mutex_type mqttasync_mutex = NULL;
+static mutex_type mqttcommand_mutex = NULL;
+static sem_type send_sem = NULL;
+extern mutex_type stack_mutex;
+extern mutex_type heap_mutex;
+extern mutex_type log_mutex;
+BOOL APIENTRY DllMain(HANDLE hModule,
+					  DWORD  ul_reason_for_call,
+					  LPVOID lpReserved)
+{
+	switch (ul_reason_for_call)
+	{
+		case DLL_PROCESS_ATTACH:
+			Log(TRACE_MAX, -1, "DLL process attach");
+			if (mqttasync_mutex == NULL)
+			{
+				mqttasync_mutex = CreateMutex(NULL, 0, NULL);
+				mqttcommand_mutex = CreateMutex(NULL, 0, NULL);
+				send_sem = CreateEvent(
+		        NULL,               /* default security attributes */
+		        FALSE,              /* manual-reset event? */
+		        FALSE,              /* initial state is nonsignaled */
+		        NULL                /* object name */
+		        );
+				stack_mutex = CreateMutex(NULL, 0, NULL);
+				heap_mutex = CreateMutex(NULL, 0, NULL);
+				log_mutex = CreateMutex(NULL, 0, NULL);
+			}
+		case DLL_THREAD_ATTACH:
+			Log(TRACE_MAX, -1, "DLL thread attach");
+		case DLL_THREAD_DETACH:
+			Log(TRACE_MAX, -1, "DLL thread detach");
+		case DLL_PROCESS_DETACH:
+			Log(TRACE_MAX, -1, "DLL process detach");
+	}
+	return TRUE;
+}
+#else
+static pthread_mutex_t mqttasync_mutex_store = PTHREAD_MUTEX_INITIALIZER;
+static mutex_type mqttasync_mutex = &mqttasync_mutex_store;
+static pthread_mutex_t mqttcommand_mutex_store = PTHREAD_MUTEX_INITIALIZER;
+static mutex_type mqttcommand_mutex = &mqttcommand_mutex_store;
+static cond_type_struct send_cond_store = { PTHREAD_COND_INITIALIZER, PTHREAD_MUTEX_INITIALIZER };
+static cond_type send_cond = &send_cond_store;
+
+void MQTTAsync_init()
+{
+	pthread_mutexattr_t attr;
+	int rc;
+
+	pthread_mutexattr_init(&attr);
+	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
+	if ((rc = pthread_mutex_init(mqttasync_mutex, &attr)) != 0)
+		printf("MQTTAsync: error %d initializing async_mutex\n", rc);
+	if ((rc = pthread_mutex_init(mqttcommand_mutex, &attr)) != 0)
+		printf("MQTTAsync: error %d initializing command_mutex\n", rc);
+}
+
+#define WINAPI
+#endif
+
+static volatile int initialized = 0;
+static List* handles = NULL;
+static int tostop = 0;
+static List* commands = NULL;
+
+MQTTPacket* MQTTAsync_cycle(int* sock, unsigned long timeout, int* rc);
+int MQTTAsync_cleanSession(Clients* client);
+void MQTTAsync_stop();
+int MQTTAsync_disconnect_internal(MQTTAsync handle, int timeout);
+void MQTTAsync_closeOnly(Clients* client);
+void MQTTAsync_closeSession(Clients* client);
+void MQTTProtocol_closeSession(Clients* client, int sendwill);
+void MQTTAsync_writeComplete(int socket);
+
+#if defined(WIN32)
+#define START_TIME_TYPE DWORD
+START_TIME_TYPE MQTTAsync_start_clock(void)
+{
+	return GetTickCount();
+}
+#elif defined(AIX)
+#define START_TIME_TYPE struct timespec
+START_TIME_TYPE MQTTAsync_start_clock(void)
+{
+	static struct timespec start;
+	clock_gettime(CLOCK_REALTIME, &start);
+	return start;
+}
+#else
+#define START_TIME_TYPE struct timeval
+START_TIME_TYPE MQTTAsync_start_clock(void)
+{
+	static struct timeval start;
+	gettimeofday(&start, NULL);
+	return start;
+}
+#endif
+
+
+#if defined(WIN32)
+long MQTTAsync_elapsed(DWORD milliseconds)
+{
+	return GetTickCount() - milliseconds;
+}
+#elif defined(AIX)
+#define assert(a)
+long MQTTAsync_elapsed(struct timespec start)
+{
+	struct timespec now, res;
+
+	clock_gettime(CLOCK_REALTIME, &now);
+	ntimersub(now, start, res);
+	return (res.tv_sec)*1000L + (res.tv_nsec)/1000000L;
+}
+#else
+long MQTTAsync_elapsed(struct timeval start)
+{
+	struct timeval now, res;
+
+	gettimeofday(&now, NULL);
+	timersub(&now, &start, &res);
+	return (res.tv_sec)*1000 + (res.tv_usec)/1000;
+}
+#endif
+
+
+typedef struct
+{
+	MQTTAsync_message* msg;
+	char* topicName;
+	int topicLen;
+	unsigned int seqno; /* only used on restore */
+} qEntry;
+
+typedef struct
+{
+	int type;
+	MQTTAsync_onSuccess* onSuccess;
+	MQTTAsync_onFailure* onFailure;
+	MQTTAsync_token token;
+	void* context;
+	START_TIME_TYPE start_time;
+	union
+	{
+		struct
+		{
+			int count;
+			char** topics;
+			int* qoss;
+		} sub;
+		struct
+		{
+			int count;
+			char** topics;
+		} unsub;
+		struct
+		{
+			char* destinationName;
+			int payloadlen;
+			void* payload;
+			int qos;
+			int retained;
+		} pub;
+		struct
+		{
+			int internal;
+			int timeout;
+		} dis;
+		struct
+		{
+			int timeout;
+			int serverURIcount;
+			char** serverURIs;
+			int currentURI;
+		} conn;
+	} details;
+} MQTTAsync_command;
+
+
+typedef struct MQTTAsync_struct
+{
+	char* serverURI;
+	int ssl;
+	Clients* c;
+	
+	/* "Global", to the client, callback definitions */
+	MQTTAsync_connectionLost* cl;
+	MQTTAsync_messageArrived* ma;
+	MQTTAsync_deliveryComplete* dc;
+	void* context; /* the context to be associated with the main callbacks*/
+	
+	MQTTAsync_command connect;				/* Connect operation properties */
+	MQTTAsync_command disconnect;			/* Disconnect operation properties */
+	MQTTAsync_command* pending_write;       /* Is there a socket write pending? */
+	
+	List* responses;
+	unsigned int command_seqno;						
+
+	MQTTPacket* pack;
+
+} MQTTAsyncs;
+
+
+typedef struct
+{
+	MQTTAsync_command command;
+	MQTTAsyncs* client;
+	unsigned int seqno; /* only used on restore */
+} MQTTAsync_queuedCommand;
+
+void MQTTAsync_freeCommand(MQTTAsync_queuedCommand *command);
+void MQTTAsync_freeCommand1(MQTTAsync_queuedCommand *command);
+int MQTTAsync_deliverMessage(MQTTAsyncs* m, char* topicName, int topicLen, MQTTAsync_message* mm);
+#if !defined(NO_PERSISTENCE)
+int MQTTAsync_restoreCommands(MQTTAsyncs* client);
+int MQTTAsync_unpersistQueueEntry(Clients*, qEntry*);
+int MQTTAsync_restoreMessageQueue(MQTTAsyncs* client);
+#endif
+
+void MQTTAsync_sleep(long milliseconds)
+{
+	FUNC_ENTRY;
+#if defined(WIN32)
+	Sleep(milliseconds);
+#else
+	usleep(milliseconds*1000);
+#endif
+	FUNC_EXIT;
+}
+
+
+/**
+ * List callback function for comparing clients by socket
+ * @param a first integer value
+ * @param b second integer value
+ * @return boolean indicating whether a and b are equal
+ */
+int clientSockCompare(void* a, void* b)
+{
+	MQTTAsyncs* m = (MQTTAsyncs*)a;
+	return m->c->net.socket == *(int*)b;
+}
+
+
+void MQTTAsync_lock_mutex(mutex_type amutex)
+{
+	int rc = Thread_lock_mutex(amutex);
+	if (rc != 0)
+		Log(LOG_ERROR, 0, "Error %d locking mutex", rc);
+}
+
+
+void MQTTAsync_unlock_mutex(mutex_type amutex)
+{
+	int rc = Thread_unlock_mutex(amutex);
+	if (rc != 0)
+		Log(LOG_ERROR, 0, "Error %d unlocking mutex", rc);
+}
+
+
+int MQTTAsync_create(MQTTAsync* handle, char* serverURI, char* clientId,
+		int persistence_type, void* persistence_context)
+{
+	int rc = 0;
+	MQTTAsyncs *m = NULL;
+
+	FUNC_ENTRY;
+	MQTTAsync_lock_mutex(mqttasync_mutex);
+
+	if (serverURI == NULL || clientId == NULL)
+	{
+		rc = MQTTASYNC_NULL_PARAMETER;
+		goto exit;
+	}
+
+	if (!UTF8_validateString(clientId))
+	{
+		rc = MQTTASYNC_BAD_UTF8_STRING;
+		goto exit;
+	}
+
+	if (!initialized)
+	{
+		#if defined(HEAP_H)
+			Heap_initialize();
+		#endif
+		Log_initialize((Log_nameValue*)MQTTAsync_getVersionInfo());
+		bstate->clients = ListInitialize();
+		Socket_outInitialize();
+		Socket_setWriteCompleteCallback(MQTTAsync_writeComplete);
+		handles = ListInitialize();
+		commands = ListInitialize();
+#if defined(OPENSSL)
+		SSLSocket_initialize();
+#endif
+		initialized = 1;
+	}
+	m = malloc(sizeof(MQTTAsyncs));
+	*handle = m;
+	memset(m, '\0', sizeof(MQTTAsyncs));
+	if (strncmp(URI_TCP, serverURI, strlen(URI_TCP)) == 0)
+		serverURI += strlen(URI_TCP);
+#if defined(OPENSSL)
+	else if (strncmp(URI_SSL, serverURI, strlen(URI_SSL)) == 0)
+	{
+		serverURI += strlen(URI_SSL);
+		m->ssl = 1;
+	}
+#endif
+	m->serverURI = malloc(strlen(serverURI)+1);
+	strcpy(m->serverURI, serverURI);
+	m->responses = ListInitialize();
+	ListAppend(handles, m, sizeof(MQTTAsyncs));
+
+	m->c = malloc(sizeof(Clients));
+	memset(m->c, '\0', sizeof(Clients));
+	m->c->context = m;
+	m->c->outboundMsgs = ListInitialize();
+	m->c->inboundMsgs = ListInitialize();
+	m->c->messageQueue = ListInitialize();
+	m->c->clientID = malloc(strlen(clientId)+1);
+	strcpy(m->c->clientID, clientId);
+
+#if !defined(NO_PERSISTENCE)
+	rc = MQTTPersistence_create(&(m->c->persistence), persistence_type, persistence_context);
+	if (rc == 0)
+	{
+		rc = MQTTPersistence_initialize(m->c, m->serverURI);
+		if (rc == 0)
+		{
+			MQTTAsync_restoreCommands(m);
+			MQTTAsync_restoreMessageQueue(m);
+		}
+	}
+#endif
+	ListAppend(bstate->clients, m->c, sizeof(Clients) + 3*sizeof(List));
+
+exit:
+	MQTTAsync_unlock_mutex(mqttasync_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+void MQTTAsync_terminate(void)
+{
+	FUNC_ENTRY;
+	MQTTAsync_stop();
+	if (initialized)
+	{
+		ListElement* elem = NULL;
+		ListFree(bstate->clients);
+		ListFree(handles);
+		while (ListNextElement(commands, &elem))
+			MQTTAsync_freeCommand1((MQTTAsync_queuedCommand*)(elem->content));
+		ListFree(commands);
+		handles = NULL;
+		Socket_outTerminate();
+#if defined(OPENSSL)
+		SSLSocket_terminate();
+#endif
+		#if defined(HEAP_H)
+			Heap_terminate();
+		#endif
+		Log_terminate();
+		initialized = 0;
+	}
+	FUNC_EXIT;
+}
+
+
+#if !defined(NO_PERSISTENCE)
+int MQTTAsync_unpersistCommand(MQTTAsync_queuedCommand* qcmd)
+{
+	int rc = 0;
+	char key[PERSISTENCE_MAX_KEY_LENGTH + 1];
+	
+	FUNC_ENTRY;
+	sprintf(key, "%s%d", PERSISTENCE_COMMAND_KEY, qcmd->seqno);
+	if ((rc = qcmd->client->c->persistence->premove(qcmd->client->c->phandle, key)) != 0)
+		Log(LOG_ERROR, 0, "Error %d removing command from persistence", rc);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTAsync_persistCommand(MQTTAsync_queuedCommand* qcmd)
+{
+	int rc = 0;
+	MQTTAsyncs* aclient = qcmd->client;
+	MQTTAsync_command* command = &qcmd->command;
+	int* lens = NULL;
+	void** bufs = NULL;
+	int bufindex = 0, i, nbufs = 0;
+	char key[PERSISTENCE_MAX_KEY_LENGTH + 1];
+	
+	FUNC_ENTRY;
+	switch (command->type)
+	{
+		case SUBSCRIBE:
+			nbufs = 2 + (command->details.sub.count * 2);
+				
+			lens = (int*)malloc(nbufs * sizeof(int));
+			bufs = malloc(nbufs * sizeof(char *));
+				
+			bufs[bufindex] = &command->type;
+			lens[bufindex++] = sizeof(command->type);
+				
+			bufs[bufindex] = &command->details.sub.count;
+			lens[bufindex++] = sizeof(command->details.sub.count);		
+				
+			for (i = 0; i < command->details.sub.count; ++i)
+			{
+				bufs[bufindex] = command->details.sub.topics[i];
+				lens[bufindex++] = strlen(command->details.sub.topics[i]) + 1;	
+				bufs[bufindex] = &command->details.sub.qoss[i];
+				lens[bufindex++] = sizeof(command->details.sub.qoss[i]);
+			}			
+			sprintf(key, "%s%d", PERSISTENCE_COMMAND_KEY, ++aclient->command_seqno);
+			break;
+				
+		case UNSUBSCRIBE:
+			nbufs = 2 + command->details.unsub.count;
+			
+			lens = (int*)malloc(nbufs * sizeof(int));
+			bufs = malloc(nbufs * sizeof(char *));
+				
+			bufs[bufindex] = &command->type;
+			lens[bufindex++] = sizeof(command->type);
+				
+			bufs[bufindex] = &command->details.unsub.count;
+			lens[bufindex++] = sizeof(command->details.unsub.count);		
+				
+			for (i = 0; i < command->details.unsub.count; ++i)
+			{
+				bufs[bufindex] = command->details.unsub.topics[i];
+				lens[bufindex++] = strlen(command->details.unsub.topics[i]) + 1;	
+			}	
+			sprintf(key, "%s%d", PERSISTENCE_COMMAND_KEY, ++aclient->command_seqno);
+			break;	
+			
+		case PUBLISH:
+			nbufs = 6;
+				
+			lens = (int*)malloc(nbufs * sizeof(int));
+			bufs = malloc(nbufs * sizeof(char *));
+				
+			bufs[bufindex] = &command->type;
+			lens[bufindex++] = sizeof(command->type);
+				
+			bufs[bufindex] = command->details.pub.destinationName;
+			lens[bufindex++] = strlen(command->details.pub.destinationName) + 1;
+				
+			bufs[bufindex] = &command->details.pub.payloadlen;
+			lens[bufindex++] = sizeof(command->details.pub.payloadlen);
+				
+			bufs[bufindex] = command->details.pub.payload;
+			lens[bufindex++] = command->details.pub.payloadlen;
+				
+			bufs[bufindex] = &command->details.pub.qos;
+			lens[bufindex++] = sizeof(command->details.pub.qos);
+				
+			bufs[bufindex] = &command->details.pub.retained;
+			lens[bufindex++] = sizeof(command->details.pub.retained);				
+		
+			sprintf(key, "%s%d", PERSISTENCE_COMMAND_KEY, ++aclient->command_seqno);
+			break;	
+	}
+	if (nbufs > 0)
+	{
+		if ((rc = aclient->c->persistence->pput(aclient->c->phandle, key, nbufs, (char**)bufs, lens)) != 0)
+			Log(LOG_ERROR, 0, "Error persisting command, rc %d", rc);
+		qcmd->seqno = aclient->command_seqno;
+	}
+	if (lens)
+		free(lens);
+	if (bufs)
+		free(bufs);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+MQTTAsync_queuedCommand* MQTTAsync_restoreCommand(char* buffer, int buflen)
+{
+	MQTTAsync_command* command = NULL;
+	MQTTAsync_queuedCommand* qcommand = NULL;
+	char* ptr = buffer;
+	int i, data_size;
+	
+	FUNC_ENTRY;
+	qcommand = malloc(sizeof(MQTTAsync_queuedCommand));
+	memset(qcommand, '\0', sizeof(MQTTAsync_queuedCommand));
+	command = &qcommand->command;
+	
+	command->type = *(int*)ptr;
+	ptr += sizeof(int);
+	
+	switch (command->type)
+	{
+		case SUBSCRIBE:
+			command->details.sub.count = *(int*)ptr;
+			ptr += sizeof(int);
+				
+			for (i = 0; i < command->details.sub.count; ++i)
+			{
+				data_size = strlen(ptr) + 1;
+				
+				command->details.sub.topics[i] = malloc(data_size);
+				strcpy(command->details.sub.topics[i], ptr);
+				ptr += data_size;
+				
+				command->details.sub.qoss[i] = *(int*)ptr;
+				ptr += sizeof(int);
+			}			
+			break;
+			
+		case UNSUBSCRIBE:
+			command->details.sub.count = *(int*)ptr;
+			ptr += sizeof(int);
+				
+			for (i = 0; i < command->details.unsub.count; ++i)
+			{
+				int data_size = strlen(ptr) + 1;
+				
+				command->details.unsub.topics[i] = malloc(data_size);
+				strcpy(command->details.unsub.topics[i], ptr);
+				ptr += data_size;
+			}			
+			break;
+			
+		case PUBLISH:
+			data_size = strlen(ptr) + 1;	
+			command->details.pub.destinationName = malloc(data_size);
+			strcpy(command->details.pub.destinationName, ptr);
+			ptr += data_size;
+			
+			command->details.pub.payloadlen = *(int*)ptr;
+			ptr += sizeof(int);
+			
+			data_size = command->details.pub.payloadlen;
+			command->details.pub.payload = malloc(data_size);
+			memcpy(command->details.pub.payload, ptr, data_size);
+			ptr += data_size;
+			
+			command->details.pub.qos = *(int*)ptr;
+			ptr += sizeof(int);
+			
+			command->details.pub.retained = *(int*)ptr;
+			ptr += sizeof(int);	
+			break;
+			
+		default:
+			free(qcommand);
+			qcommand = NULL;
+			
+	}
+	
+	FUNC_EXIT;
+	return qcommand;
+}
+
+
+void MQTTAsync_insertInOrder(List* list, void* content, int size)
+{
+	ListElement* index = NULL;
+	ListElement* current = NULL;
+
+	FUNC_ENTRY;
+	while (ListNextElement(list, &current) != NULL && index == NULL)
+	{
+		if (((MQTTAsync_queuedCommand*)content)->seqno < ((MQTTAsync_queuedCommand*)current->content)->seqno)
+			index = current;
+	}
+
+	ListInsert(list, content, size, index);
+	FUNC_EXIT;
+}
+
+
+int MQTTAsync_restoreCommands(MQTTAsyncs* client)
+{
+	int rc = 0;
+	char **msgkeys;
+	int nkeys;
+	int i = 0;
+	Clients* c = client->c;
+	int commands_restored = 0;
+
+	FUNC_ENTRY;
+	if (c->persistence && (rc = c->persistence->pkeys(c->phandle, &msgkeys, &nkeys)) == 0)
+	{
+		while (rc == 0 && i < nkeys)
+		{
+			char *buffer = NULL;
+			int buflen;
+					
+			if (strncmp(msgkeys[i], PERSISTENCE_COMMAND_KEY, strlen(PERSISTENCE_COMMAND_KEY)) != 0)
+				;
+			else if ((rc = c->persistence->pget(c->phandle, msgkeys[i], &buffer, &buflen)) == 0)
+			{
+				MQTTAsync_queuedCommand* cmd = MQTTAsync_restoreCommand(buffer, buflen);
+				
+				if (cmd)
+				{
+					cmd->client = client;	
+					cmd->seqno = atoi(msgkeys[i]+2);
+					MQTTPersistence_insertInOrder(commands, cmd, sizeof(MQTTAsync_queuedCommand));
+					free(buffer);
+					client->command_seqno = max(client->command_seqno, cmd->seqno);
+					commands_restored++;
+				}
+			}
+			if (msgkeys[i])
+				free(msgkeys[i]);
+			i++;
+		}
+		if (msgkeys != NULL)
+			free(msgkeys);
+	}
+	Log(TRACE_MINIMUM, -1, "%d commands restored for client %s", commands_restored, c->clientID);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+#endif
+
+
+int MQTTAsync_addCommand(MQTTAsync_queuedCommand* command, int command_size)
+{
+	int rc = 0;
+	
+	FUNC_ENTRY;
+	MQTTAsync_lock_mutex(mqttcommand_mutex);
+	command->command.start_time = MQTTAsync_start_clock();
+	if (command->command.type == CONNECT || 
+		(command->command.type == DISCONNECT && command->command.details.dis.internal))
+	{
+		MQTTAsync_queuedCommand* head = NULL; 
+		
+		if (commands->first)
+			head = (MQTTAsync_queuedCommand*)(commands->first->content);
+		
+		if (head != NULL && head->client == command->client && head->command.type == command->command.type)
+			MQTTAsync_freeCommand(command); /* ignore duplicate connect or disconnect command */
+		else
+			ListInsert(commands, command, command_size, commands->first); /* add to the head of the list */
+	}
+	else
+	{
+		ListAppend(commands, command, command_size);
+#if !defined(NO_PERSISTENCE)
+		if (command->client->c->persistence)
+			MQTTAsync_persistCommand(command);
+#endif
+	}
+	MQTTAsync_unlock_mutex(mqttcommand_mutex);
+#if !defined(WIN32)
+	Thread_signal_cond(send_cond);
+#else
+	if (!Thread_check_sem(send_sem))
+		Thread_post_sem(send_sem);
+#endif
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+void MQTTAsync_checkDisconnect(MQTTAsync handle, MQTTAsync_command* command)
+{
+	MQTTAsyncs* m = handle;
+
+	FUNC_ENTRY;
+	/* wait for all inflight message flows to finish, up to timeout */;
+	if (m->c->outboundMsgs->count == 0 || MQTTAsync_elapsed(command->start_time) >= command->details.dis.timeout)
+	{	
+		int was_connected = m->c->connected;
+		MQTTAsync_closeSession(m->c);
+		if (command->details.dis.internal && m->cl && was_connected)
+		{
+			Log(TRACE_MIN, -1, "Calling connectionLost for client %s", m->c->clientID);
+			(*(m->cl))(m->context, NULL);
+		}
+		else if (!command->details.dis.internal && command->onSuccess)
+		{
+			Log(TRACE_MIN, -1, "Calling disconnect complete for client %s", m->c->clientID);
+			(*(command->onSuccess))(command->context, NULL);
+		}
+	}
+	FUNC_EXIT;
+}
+
+
+/**
+ * See if any pending writes have been completed, and cleanup if so.
+ * Cleaning up means removing any publication data that was stored because the write did
+ * not originally complete.
+ */
+void MQTTProtocol_checkPendingWrites()
+{
+	FUNC_ENTRY;
+	if (state.pending_writes.count > 0)
+	{
+		ListElement* le = state.pending_writes.first;
+		while (le)
+		{
+			if (Socket_noPendingWrites(((pending_write*)(le->content))->socket))
+			{
+				MQTTProtocol_removePublication(((pending_write*)(le->content))->p);
+				state.pending_writes.current = le;
+				ListRemove(&(state.pending_writes), le->content); /* does NextElement itself */
+				le = state.pending_writes.current;
+			}
+			else
+				ListNextElement(&(state.pending_writes), &le);
+		}
+	}
+	FUNC_EXIT;
+}
+
+
+void MQTTAsync_freeConnect(MQTTAsync_command command)
+{
+	if (command.type == CONNECT)
+	{
+		int i;
+		
+		for (i = 0; i < command.details.conn.serverURIcount; ++i)
+			free(command.details.conn.serverURIs[i]);
+		if (command.details.conn.serverURIs)
+			free(command.details.conn.serverURIs); 
+	}
+}
+
+
+void MQTTAsync_freeCommand1(MQTTAsync_queuedCommand *command)
+{
+	if (command->command.type == SUBSCRIBE)
+	{
+		int i;
+		
+		for (i = 0; i < command->command.details.sub.count; i++)
+		{
+			free(command->command.details.sub.topics[i]);
+			free(command->command.details.sub.topics);
+			free(command->command.details.sub.qoss);
+		}
+	}
+	else if (command->command.type == UNSUBSCRIBE)
+	{
+		int i;
+		
+		for (i = 0; i < command->command.details.unsub.count; i++)
+		{
+			free(command->command.details.unsub.topics[i]);
+			free(command->command.details.unsub.topics);
+		}
+	}
+	else if (command->command.type == PUBLISH)
+	{
+		/* qos 1 and 2 topics are freed in the protocol code when the flows are completed */
+		if (command->command.details.pub.destinationName)
+			free(command->command.details.pub.destinationName); 
+		free(command->command.details.pub.payload);
+	}
+}
+
+void MQTTAsync_freeCommand(MQTTAsync_queuedCommand *command)
+{
+	MQTTAsync_freeCommand1(command);
+	free(command);
+}
+
+
+void MQTTAsync_writeComplete(int socket)				
+{
+	ListElement* found = NULL;
+	
+	FUNC_ENTRY;
+	/* a partial write is now complete for a socket - this will be on a publish*/
+	
+	MQTTProtocol_checkPendingWrites();
+	
+	/* find the client using this socket */
+	if ((found = ListFindItem(handles, &socket, clientSockCompare)) != NULL)
+	{
+		MQTTAsyncs* m = (MQTTAsyncs*)(found->content);
+		
+		time(&(m->c->net.lastContact));
+				
+		/* see if there is a pending write flagged */
+		if (m->pending_write)
+		{
+			ListElement* cur_response = NULL;
+			MQTTAsync_command* command = m->pending_write;
+			MQTTAsync_queuedCommand* com = NULL;
+					
+			while (ListNextElement(m->responses, &cur_response))
+			{
+				com = (MQTTAsync_queuedCommand*)(cur_response->content);
+				if (com->client->pending_write == m->pending_write)
+					break;
+			}
+					
+			if (cur_response && command->onSuccess)
+			{
+				MQTTAsync_successData data;
+								
+				data.token = command->token;
+				data.alt.pub.destinationName = command->details.pub.destinationName;
+				data.alt.pub.message.payload = command->details.pub.payload;
+				data.alt.pub.message.payloadlen = command->details.pub.payloadlen;
+				data.alt.pub.message.qos = command->details.pub.qos;
+				data.alt.pub.message.retained = command->details.pub.retained;
+				Log(TRACE_MIN, -1, "Calling publish success for client %s", m->c->clientID);
+				(*(command->onSuccess))(command->context, &data);
+			}		
+			m->pending_write = NULL;
+			
+			ListDetach(m->responses, com);
+			MQTTAsync_freeCommand(com);
+		}
+	}
+	FUNC_EXIT;
+}
+			
+
+void MQTTAsync_processCommand()
+{
+	int rc = 0;
+	MQTTAsync_queuedCommand* command = NULL;
+	ListElement* cur_command = NULL;
+	List* ignored_clients = NULL;
+	
+	FUNC_ENTRY;
+	MQTTAsync_lock_mutex(mqttasync_mutex);
+	MQTTAsync_lock_mutex(mqttcommand_mutex);
+	
+	/* only the first command in the list must be processed for any particular client, so if we skip
+	   a command for a client, we must skip all following commands for that client.  Use a list of 
+	   ignored clients to keep track
+	*/
+	ignored_clients = ListInitialize();
+	
+	/* don't try a command until there isn't a pending write for that client, and we are not connecting */
+	while (ListNextElement(commands, &cur_command))
+	{
+		MQTTAsync_queuedCommand* cmd = (MQTTAsync_queuedCommand*)(cur_command->content);
+		
+		if (ListFind(ignored_clients, cmd->client))
+			continue;
+		
+		if (cmd->command.type == CONNECT || cmd->command.type == DISCONNECT || (cmd->client->c->connected && 
+			cmd->client->c->connect_state == 0 && Socket_noPendingWrites(cmd->client->c->net.socket)))
+		{
+			if ((cmd->command.type == PUBLISH || cmd->command.type == SUBSCRIBE || cmd->command.type == UNSUBSCRIBE) &&
+				cmd->client->c->outboundMsgs->count >= MAX_MSG_ID - 1)
+				; /* no more message ids available */
+			else
+			{
+				command = cmd;
+				break;
+			}
+		}
+		ListAppend(ignored_clients, cmd->client, sizeof(cmd->client));
+	}
+	ListFreeNoContent(ignored_clients);
+	if (command)
+	{
+		ListDetach(commands, command);
+#if !defined(NO_PERSISTENCE)
+		if (command->client->c->persistence)
+			MQTTAsync_unpersistCommand(command);
+#endif
+	}
+	MQTTAsync_unlock_mutex(mqttcommand_mutex);
+	
+	if (!command)
+		goto exit; /* nothing to do */
+	
+	if (command->command.type == CONNECT)
+	{
+		if (command->client->c->connect_state != 0 || command->client->c->connected)
+			rc = 0;
+		else
+		{
+			char* serverURI = command->client->serverURI;
+			
+			if (command->command.details.conn.serverURIcount > 0)
+			{
+				serverURI = command->command.details.conn.serverURIs[command->command.details.conn.currentURI++];
+					
+				if (strncmp(URI_TCP, serverURI, strlen(URI_TCP)) == 0)
+					serverURI += strlen(URI_TCP);
+#if defined(OPENSSL)
+				else if (strncmp(URI_SSL, serverURI, strlen(URI_SSL)) == 0)
+				{
+					serverURI += strlen(URI_SSL);
+					command->client->ssl = 1;
+				}
+#endif
+			}
+
+			Log(TRACE_MIN, -1, "Connecting to serverURI %s", serverURI);
+#if defined(OPENSSL)
+			rc = MQTTProtocol_connect(serverURI, command->client->c, command->client->ssl);
+#else
+			rc = MQTTProtocol_connect(serverURI, command->client->c);
+#endif
+			if (command->client->c->connect_state == 0)
+				rc = SOCKET_ERROR;
+			
+			/* if the TCP connect is pending, then we must call select to determine when the connect has completed,
+			which is indicated by the socket being ready *either* for reading *or* writing.  The next couple of lines
+			make sure we check for writeability as well as readability, otherwise we wait around longer than we need to
+			in Socket_getReadySocket() */ 
+			if (rc == EINPROGRESS)
+				Socket_addPendingWrite(command->client->c->net.socket);
+		}
+	}
+	else if (command->command.type == SUBSCRIBE)
+	{
+		List* topics = ListInitialize();
+		List* qoss = ListInitialize();
+		int i;
+		
+		for (i = 0; i < command->command.details.sub.count; i++)
+		{
+			ListAppend(topics, command->command.details.sub.topics[i], strlen(command->command.details.sub.topics[i]));
+			ListAppend(qoss, &command->command.details.sub.qoss[i], sizeof(int));
+		}
+		rc = MQTTProtocol_subscribe(command->client->c, topics, qoss);
+		ListFreeNoContent(topics);
+		ListFreeNoContent(qoss);
+	}
+	else if (command->command.type == UNSUBSCRIBE)
+	{
+		List* topics = ListInitialize();
+		int i;
+			
+		for (i = 0; i < command->command.details.unsub.count; i++)
+			ListAppend(topics, command->command.details.unsub.topics[i], strlen(command->command.details.unsub.topics[i]));
+			
+		rc = MQTTProtocol_unsubscribe(command->client->c, topics);
+		ListFreeNoContent(topics);
+	}
+	else if (command->command.type == PUBLISH)
+	{
+		Messages* msg = NULL;
+		Publish* p = NULL;
+	
+		p = malloc(sizeof(Publish));
+
+		p->payload = command->command.details.pub.payload;
+		p->payloadlen = command->command.details.pub.payloadlen;
+		p->topic = command->command.details.pub.destinationName;
+		p->msgId = -1;
+
+		rc = MQTTProtocol_startPublish(command->client->c, p, command->command.details.pub.qos, command->command.details.pub.retained, &msg);
+		
+		if (command->command.details.pub.qos == 0)
+		{ 
+			if (rc == TCPSOCKET_COMPLETE)
+			{		
+				if (command->command.onSuccess)
+				{
+					MQTTAsync_successData data;
+								
+					data.token = command->command.token;
+					data.alt.pub.destinationName = command->command.details.pub.destinationName;
+					data.alt.pub.message.payload = command->command.details.pub.payload;
+					data.alt.pub.message.payloadlen = command->command.details.pub.payloadlen;
+					data.alt.pub.message.qos = command->command.details.pub.qos;
+					data.alt.pub.message.retained = command->command.details.pub.retained;
+					Log(TRACE_MIN, -1, "Calling publish success for client %s", command->client->c->clientID);
+					(*(command->command.onSuccess))(command->command.context, &data);
+				}
+			}
+			else
+			{
+				command->command.details.pub.destinationName = NULL; /* this will be freed by the protocol code */
+				command->client->pending_write = &command->command;
+			}
+		}
+		else
+			command->command.details.pub.destinationName = NULL; /* this will be freed by the protocol code */
+		free(p); /* should this be done if the write isn't complete? */
+	}
+	else if (command->command.type == DISCONNECT)
+	{
+		if (command->client->c->connect_state != 0 || command->client->c->connected != 0)
+		{
+			command->client->c->connect_state = -2;
+			MQTTAsync_checkDisconnect(command->client, &command->command);
+		}
+	}
+
+	if (command->command.type == CONNECT && rc != SOCKET_ERROR && rc != MQTTASYNC_PERSISTENCE_ERROR)
+	{
+		command->client->connect = command->command;
+		MQTTAsync_freeCommand(command);
+	}
+	else if (command->command.type == DISCONNECT)
+	{
+		command->client->disconnect = command->command;
+		MQTTAsync_freeCommand(command);
+	}
+	else if (command->command.type == PUBLISH && command->command.details.pub.qos == 0)
+	{
+		if (rc == TCPSOCKET_INTERRUPTED)
+			ListAppend(command->client->responses, command, sizeof(command));
+		else
+			MQTTAsync_freeCommand(command);
+	}
+	else if (rc == SOCKET_ERROR || rc == MQTTASYNC_PERSISTENCE_ERROR)
+	{
+		if (command->command.type == CONNECT)
+		{
+			MQTTAsync_disconnectOptions opts = MQTTAsync_disconnectOptions_initializer;
+			MQTTAsync_disconnect(command->client, &opts); /* not "internal" because we don't want to call connection lost */
+		}
+		else
+			MQTTAsync_disconnect_internal(command->client, 0);
+			
+		if (command->command.type == CONNECT &&
+			command->command.details.conn.currentURI < command->command.details.conn.serverURIcount)
+		{
+			/* put the connect command back to the head of the command queue, using the next serverURI */
+			Log(TRACE_MIN, -1, "Connect failed, now trying %s", 
+				command->command.details.conn.serverURIs[command->command.details.conn.currentURI]);
+			rc = MQTTAsync_addCommand(command, sizeof(command->command.details.conn));
+		}
+		else
+		{
+			if (command->command.onFailure)
+			{
+				Log(TRACE_MIN, -1, "Calling command failure for client %s", command->client->c->clientID);
+				(*(command->command.onFailure))(command->command.context, NULL);
+			}
+			MQTTAsync_freeConnect(command->command);
+			MQTTAsync_freeCommand(command);  /* free up the command if necessary */
+		}
+	}
+	else
+	{
+		/* put the command into a waiting for response queue for each client, indexed by msgid */	
+		command->command.token = command->client->c->msgID;
+		ListAppend(command->client->responses, command, sizeof(command));
+	}
+
+exit:
+	MQTTAsync_unlock_mutex(mqttasync_mutex);
+	FUNC_EXIT;
+}
+
+
+void MQTTAsync_checkTimeouts()
+{
+	ListElement* current = NULL;
+	static time_t last = 0L;
+	time_t now;
+
+	FUNC_ENTRY;
+	time(&(now));
+	if (difftime(now, last) < 3)
+		goto exit;
+
+	MQTTAsync_lock_mutex(mqttasync_mutex);
+	last = now;
+	while (ListNextElement(handles, &current))		/* for each client */
+	{
+		ListElement* cur_response = NULL;
+		int i = 0, 
+			timed_out_count = 0;
+		
+		MQTTAsyncs* m = (MQTTAsyncs*)(current->content);
+		
+		/* check connect timeout */
+		if (m->c->connect_state != 0 && MQTTAsync_elapsed(m->connect.start_time) > (m->connect.details.conn.timeout * 1000))
+		{
+			if (m->connect.details.conn.currentURI < m->connect.details.conn.serverURIcount)
+			{
+				MQTTAsync_queuedCommand* conn;
+				
+				MQTTAsync_closeOnly(m->c);
+				/* put the connect command back to the head of the command queue, using the next serverURI */
+				conn = malloc(sizeof(MQTTAsync_queuedCommand));
+				memset(conn, '\0', sizeof(MQTTAsync_queuedCommand));
+				conn->client = m;
+				conn->command = m->connect; 
+				Log(TRACE_MIN, -1, "Connect failed, now trying %s", 
+					m->connect.details.conn.serverURIs[m->connect.details.conn.currentURI]);
+				MQTTAsync_addCommand(conn, sizeof(m->connect));
+			}
+			else
+			{
+				MQTTAsync_closeSession(m->c);
+				MQTTAsync_freeConnect(m->connect);
+				if (m->connect.onFailure)
+				{
+					Log(TRACE_MIN, -1, "Calling connect failure for client %s", m->c->clientID);
+					(*(m->connect.onFailure))(m->connect.context, NULL);
+				}
+			}
+			continue;
+		}
+	
+		/* check disconnect timeout */
+		if (m->c->connect_state == -2)
+			MQTTAsync_checkDisconnect(m, &m->disconnect);
+	
+		timed_out_count = 0;
+		/* check response timeouts */
+		while (ListNextElement(m->responses, &cur_response))
+		{
+			MQTTAsync_queuedCommand* com = (MQTTAsync_queuedCommand*)(cur_response->content);
+			
+			if (1 /*MQTTAsync_elapsed(com->command.start_time) < 120000*/)	
+				break; /* command has not timed out */
+			else
+			{
+				if (com->command.onFailure)
+				{		
+					Log(TRACE_MIN, -1, "Calling %s failure for client %s", 
+								MQTTPacket_name(com->command.type), m->c->clientID);
+					(*(com->command.onFailure))(com->command.context, NULL);
+				}
+				timed_out_count++;
+			}
+		}
+		for (i = 0; i < timed_out_count; ++i)
+			ListRemoveHead(m->responses);	/* remove the first response in the list */
+	}
+	MQTTAsync_unlock_mutex(mqttasync_mutex);
+exit:
+	FUNC_EXIT;
+}
+
+
+thread_return_type WINAPI MQTTAsync_sendThread(void* n)
+{
+	FUNC_ENTRY;
+	MQTTAsync_lock_mutex(mqttasync_mutex);
+	sendThread_state = RUNNING;
+	MQTTAsync_unlock_mutex(mqttasync_mutex);
+	while (!tostop)
+	{
+		/*int rc;*/
+		
+		while (commands->count > 0)
+			MQTTAsync_processCommand();
+#if !defined(WIN32)
+		/*rc =*/ Thread_wait_cond(send_cond, 1);
+#else
+		/*rc =*/ Thread_wait_sem(send_sem, 1000);
+#endif
+			
+		MQTTAsync_checkTimeouts();
+	}
+	sendThread_state = STOPPING;
+	MQTTAsync_lock_mutex(mqttasync_mutex);
+	sendThread_state = STOPPED;
+	MQTTAsync_unlock_mutex(mqttasync_mutex);
+	FUNC_EXIT;
+	return 0;
+}
+
+
+void MQTTAsync_emptyMessageQueue(Clients* client)
+{
+	FUNC_ENTRY;
+	/* empty message queue */
+	if (client->messageQueue->count > 0)
+	{
+		ListElement* current = NULL;
+		while (ListNextElement(client->messageQueue, &current))
+		{
+			qEntry* qe = (qEntry*)(current->content);
+			free(qe->topicName);
+			free(qe->msg->payload);
+			free(qe->msg);
+		}
+		ListEmpty(client->messageQueue);
+	}
+	FUNC_EXIT;
+}
+
+
+void MQTTAsync_removeResponsesAndCommands(MQTTAsyncs* m)
+{
+	int count = 0;	
+	ListElement* current = NULL;
+	ListElement *next = NULL;
+
+	FUNC_ENTRY;
+	if (m->responses)
+	{
+		ListElement* elem = NULL;
+
+		while (ListNextElement(m->responses, &elem))
+		{
+			MQTTAsync_freeCommand1((MQTTAsync_queuedCommand*) (elem->content));
+			count++;
+		}
+	}
+	Log(TRACE_MINIMUM, -1, "%d responses removed for client %s", count, m->c->clientID);
+	
+	/* remove commands in the command queue relating to this client */
+	count = 0;
+	current = ListNextElement(commands, &next);
+	ListNextElement(commands, &next);
+	while (current)
+	{
+		MQTTAsync_queuedCommand* cmd = (MQTTAsync_queuedCommand*)(current->content);
+		
+		if (cmd->client == m)
+		{
+			ListDetach(commands, cmd);
+			MQTTAsync_freeCommand(cmd);
+			count++;
+		}
+		current = next;
+		ListNextElement(commands, &next);
+	}
+	Log(TRACE_MINIMUM, -1, "%d commands removed for client %s", count, m->c->clientID);
+	FUNC_EXIT;
+}
+
+
+void MQTTAsync_destroy(MQTTAsync* handle)
+{
+	MQTTAsyncs* m = *handle;
+
+	FUNC_ENTRY;
+	MQTTAsync_lock_mutex(mqttasync_mutex);
+
+	if (m == NULL)
+		goto exit;
+
+	MQTTAsync_removeResponsesAndCommands(m);
+	ListFree(m->responses);
+	
+	if (m->c)
+	{
+		int saved_socket = m->c->net.socket;
+		char* saved_clientid = malloc(strlen(m->c->clientID)+1);
+		strcpy(saved_clientid, m->c->clientID);
+#if !defined(NO_PERSISTENCE)
+		MQTTPersistence_close(m->c);
+#endif
+		MQTTAsync_emptyMessageQueue(m->c);
+		MQTTProtocol_freeClient(m->c);
+		if (!ListRemove(bstate->clients, m->c))
+			Log(LOG_ERROR, 0, NULL);
+		else
+			Log(TRACE_MIN, 1, NULL, saved_clientid, saved_socket);
+		free(saved_clientid);
+	}
+		
+	if (m->serverURI)
+		free(m->serverURI);
+	if (!ListRemove(handles, m))
+		Log(LOG_ERROR, -1, "free error");
+	*handle = NULL;
+	if (bstate->clients->count == 0)
+		MQTTAsync_terminate();
+
+exit:
+	MQTTAsync_unlock_mutex(mqttasync_mutex);
+	FUNC_EXIT;
+}
+
+
+void MQTTAsync_freeMessage(MQTTAsync_message** message)
+{
+	FUNC_ENTRY;
+	free((*message)->payload);
+	free(*message);
+	*message = NULL;
+	FUNC_EXIT;
+}
+
+
+void MQTTAsync_free(void* memory)
+{
+	FUNC_ENTRY;
+	free(memory);
+	FUNC_EXIT;
+}
+
+
+int MQTTAsync_completeConnection(MQTTAsyncs* m, MQTTPacket* pack)
+{
+	int rc = MQTTASYNC_FAILURE;
+
+	FUNC_ENTRY;
+	if (m->c->connect_state == 3) /* MQTT connect sent - wait for CONNACK */
+	{
+		Connack* connack = (Connack*)pack;
+		Log(LOG_PROTOCOL, 1, NULL, m->c->net.socket, m->c->clientID, connack->rc);
+		if ((rc = connack->rc) == MQTTASYNC_SUCCESS)
+		{
+			m->c->connected = 1;
+			m->c->good = 1;
+			m->c->connect_state = 0;
+			if (m->c->cleansession)
+				rc = MQTTAsync_cleanSession(m->c);
+			if (m->c->outboundMsgs->count > 0)
+			{
+				ListElement* outcurrent = NULL;
+				while (ListNextElement(m->c->outboundMsgs, &outcurrent))
+				{
+					Messages* m = (Messages*)(outcurrent->content);
+					m->lastTouch = 0;
+				}
+				MQTTProtocol_retry(m->c->net.lastContact, 1);
+				if (m->c->connected != 1)
+					rc = MQTTASYNC_DISCONNECTED;
+			}
+		}
+		free(connack);
+		m->pack = NULL;
+	}
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+/* This is the thread function that handles the calling of callback functions if set */
+thread_return_type WINAPI MQTTAsync_receiveThread(void* n)
+{
+	long timeout = 10L; /* first time in we have a small timeout.  Gets things started more quickly */
+
+	FUNC_ENTRY;
+	MQTTAsync_lock_mutex(mqttasync_mutex);
+	receiveThread_state = RUNNING;
+	while (!tostop)
+	{
+		int rc = SOCKET_ERROR;
+		int sock = -1;
+		MQTTAsyncs* m = NULL;
+		MQTTPacket* pack = NULL;
+
+		MQTTAsync_unlock_mutex(mqttasync_mutex);
+		pack = MQTTAsync_cycle(&sock, timeout, &rc);
+		MQTTAsync_lock_mutex(mqttasync_mutex);
+		if (tostop)
+			break;
+		timeout = 1000L;
+
+		/* find client corresponding to socket */
+		if (ListFindItem(handles, &sock, clientSockCompare) == NULL)
+		{
+			/* assert: should not happen */
+			continue;
+		}
+		m = (MQTTAsyncs*)(handles->current->content);
+		if (m == NULL)
+		{
+			/* assert: should not happen */
+			continue;
+		}
+		if (rc == SOCKET_ERROR)
+		{
+			MQTTAsync_unlock_mutex(mqttasync_mutex);
+			MQTTAsync_disconnect_internal(m, 0);
+			MQTTAsync_lock_mutex(mqttasync_mutex);
+		}
+		else
+		{
+			if (m->c->messageQueue->count > 0)
+			{
+				qEntry* qe = (qEntry*)(m->c->messageQueue->first->content);
+				int topicLen = qe->topicLen;
+
+				if (strlen(qe->topicName) == topicLen)
+					topicLen = 0;
+
+				if (m->ma)
+					rc = MQTTAsync_deliverMessage(m, qe->topicName, topicLen, qe->msg);
+				else 
+					rc = 1;
+					
+				if (rc)
+				{
+					ListRemove(m->c->messageQueue, qe);
+#if !defined(NO_PERSISTENCE)
+					if (m->c->persistence)
+						MQTTAsync_unpersistQueueEntry(m->c, qe);
+#endif
+				}
+				else
+					Log(TRACE_MIN, -1, "False returned from messageArrived for client %s, message remains on queue",
+						m->c->clientID);
+			}
+			if (pack)
+			{
+				if (pack->header.bits.type == CONNACK)
+				{
+					int rc = MQTTAsync_completeConnection(m, pack);
+					
+					if (rc == MQTTASYNC_SUCCESS)
+					{
+						if (m->connect.details.conn.serverURIcount > 0)
+							Log(TRACE_MIN, -1, "Connect succeeded to %s", 
+								m->connect.details.conn.serverURIs[m->connect.details.conn.currentURI - 1]);
+						MQTTAsync_freeConnect(m->connect);
+						if (m->connect.onSuccess)
+						{
+							Log(TRACE_MIN, -1, "Calling connect success for client %s", m->c->clientID);
+							(*(m->connect.onSuccess))(m->connect.context, NULL);
+						}
+					}
+					else
+					{
+						if (m->connect.details.conn.currentURI < m->connect.details.conn.serverURIcount)
+						{
+							MQTTAsync_queuedCommand* conn;
+							
+							MQTTAsync_closeOnly(m->c);
+							/* put the connect command back to the head of the command queue, using the next serverURI */
+							conn = malloc(sizeof(MQTTAsync_queuedCommand));
+							memset(conn, '\0', sizeof(MQTTAsync_queuedCommand));
+							conn->client = m;
+							conn->command = m->connect; 
+							Log(TRACE_MIN, -1, "Connect failed, now trying %s", 
+								m->connect.details.conn.serverURIs[m->connect.details.conn.currentURI]);
+							MQTTAsync_addCommand(conn, sizeof(m->connect));
+						}
+						else
+						{
+							MQTTAsync_closeSession(m->c);
+							MQTTAsync_freeConnect(m->connect);
+							if (m->connect.onFailure)
+							{
+								MQTTAsync_failureData data;
+						
+								data.token = 0;
+								data.code = rc;
+								data.message = "CONNACK return code";
+								Log(TRACE_MIN, -1, "Calling connect failure for client %s", m->c->clientID);
+								(*(m->connect.onFailure))(m->connect.context, &data);
+							}
+						}
+					}
+				}
+				else if (pack->header.bits.type == SUBACK)
+				{
+					ListElement* current = NULL;
+					int handleCalled = 0;
+									
+					/* use the msgid to find the callback to be called */
+					while (ListNextElement(m->responses, &current))
+					{
+						MQTTAsync_queuedCommand* command = (MQTTAsync_queuedCommand*)(current->content);
+						if (command->command.token == ((Suback*)pack)->msgId)
+						{	
+							if (!ListDetach(m->responses, command)) /* remove the response from the list */
+								Log(LOG_ERROR, -1, "Subscribe command not removed from command list");
+							if (command->command.onSuccess)
+							{
+								MQTTAsync_successData data;
+								Suback* sub = (Suback*)pack;
+								int* array = NULL;
+								
+								if (sub->qoss->count == 1)
+									data.alt.qos = *(int*)(sub->qoss->first->content);
+								else if (sub->qoss->count > 1)
+								{
+									ListElement* cur_qos = NULL;
+									int* element = array = data.alt.qosList = malloc(sub->qoss->count * sizeof(int));
+									while (ListNextElement(sub->qoss, &cur_qos))
+										*element++ = *(int*)(cur_qos->content);
+								} 
+								data.token = command->command.token;
+								
+								rc = MQTTProtocol_handleSubacks(pack, m->c->net.socket);
+								handleCalled = 1;
+								Log(TRACE_MIN, -1, "Calling subscribe success for client %s", m->c->clientID);
+								(*(command->command.onSuccess))(command->command.context, &data);
+								if (array)
+									free(array);
+							}
+							MQTTAsync_freeCommand(command);
+							break;
+						}
+					}
+					if (!handleCalled)
+						rc = MQTTProtocol_handleSubacks(pack, m->c->net.socket);
+				}
+				else if (pack->header.bits.type == UNSUBACK)
+				{
+					ListElement* current = NULL;
+					int handleCalled = 0;
+					
+					/* use the msgid to find the callback to be called */
+					while (ListNextElement(m->responses, &current))
+					{
+						MQTTAsync_queuedCommand* command = (MQTTAsync_queuedCommand*)(current->content);
+						if (command->command.token == ((Unsuback*)pack)->msgId)
+						{		
+							if (!ListDetach(m->responses, command)) /* remove the response from the list */
+								Log(LOG_ERROR, -1, "Unsubscribe command not removed from command list");
+							if (command->command.onSuccess)
+							{
+								rc = MQTTProtocol_handleUnsubacks(pack, m->c->net.socket);
+								handleCalled = 1;
+								Log(TRACE_MIN, -1, "Calling unsubscribe success for client %s", m->c->clientID);
+								(*(command->command.onSuccess))(command->command.context, NULL);
+							}
+							MQTTAsync_freeCommand(command);
+							break;
+						}
+					}
+					if (!handleCalled)
+						rc = MQTTProtocol_handleUnsubacks(pack, m->c->net.socket);
+				}
+			}
+		}
+	}
+	receiveThread_state = STOPPED;
+	MQTTAsync_unlock_mutex(mqttasync_mutex);
+#if !defined(WIN32)
+	if (sendThread_state != STOPPED)
+		Thread_signal_cond(send_cond);
+#else
+	if (sendThread_state != STOPPED && !Thread_check_sem(send_sem))
+		Thread_post_sem(send_sem);
+#endif
+	FUNC_EXIT;
+	return 0;
+}
+
+
+void MQTTAsync_stop()
+{
+	int rc = 0;
+
+	FUNC_ENTRY;
+	if (sendThread_state != STOPPED || receiveThread_state != STOPPED)
+	{
+		int conn_count = 0;
+		ListElement* current = NULL;
+
+		if (handles != NULL)
+		{
+			/* find out how many handles are still connected */
+			while (ListNextElement(handles, &current))
+			{
+				if (((MQTTAsyncs*)(current->content))->c->connect_state > 0 ||
+						((MQTTAsyncs*)(current->content))->c->connected)
+					++conn_count;
+			}
+		}
+		Log(TRACE_MIN, -1, "Conn_count is %d", conn_count);
+		/* stop the background thread, if we are the last one to be using it */
+		if (conn_count == 0)
+		{
+			int count = 0;
+			tostop = 1;
+			while ((sendThread_state != STOPPED || receiveThread_state != STOPPED) && ++count < 100)
+			{
+				MQTTAsync_unlock_mutex(mqttasync_mutex);
+				Log(TRACE_MIN, -1, "sleeping");
+				MQTTAsync_sleep(100L);
+				MQTTAsync_lock_mutex(mqttasync_mutex);
+			}
+			rc = 1;
+			tostop = 0;
+		}
+	}
+	FUNC_EXIT_RC(rc);
+}
+
+
+int MQTTAsync_setCallbacks(MQTTAsync handle, void* context,
+									MQTTAsync_connectionLost* cl,
+									MQTTAsync_messageArrived* ma,
+									MQTTAsync_deliveryComplete* dc)
+{
+	int rc = MQTTASYNC_SUCCESS;
+	MQTTAsyncs* m = handle;
+
+	FUNC_ENTRY;
+	MQTTAsync_lock_mutex(mqttasync_mutex);
+
+	if (m == NULL || ma == NULL || m->c->connect_state != 0)
+		rc = MQTTASYNC_FAILURE;
+	else
+	{
+		m->context = context;
+		m->cl = cl;
+		m->ma = ma;
+		m->dc = dc;
+	}
+
+	MQTTAsync_unlock_mutex(mqttasync_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+void MQTTAsync_closeOnly(Clients* client)
+{
+	FUNC_ENTRY;
+	client->good = 0;
+	client->ping_outstanding = 0;
+	if (client->net.socket > 0)
+	{
+		if (client->connected || client->connect_state)
+			MQTTPacket_send_disconnect(&client->net, client->clientID);
+#if defined(OPENSSL)
+		SSLSocket_close(&client->net);
+#endif
+		Socket_close(client->net.socket);
+		client->net.socket = 0;
+#if defined(OPENSSL)
+		client->net.ssl = NULL;
+#endif
+	}
+	client->connected = 0;
+	client->connect_state = 0;		
+	FUNC_EXIT;
+}
+
+
+void MQTTAsync_closeSession(Clients* client)
+{
+	FUNC_ENTRY;
+	MQTTAsync_closeOnly(client);
+
+	if (client->cleansession)
+		MQTTAsync_cleanSession(client);
+		
+	FUNC_EXIT;
+}
+
+
+/**
+ * List callback function for comparing clients by client structure
+ * @param a Async structure
+ * @param b Client structure
+ * @return boolean indicating whether a and b are equal
+ */
+int clientStructCompare(void* a, void* b)
+{
+	MQTTAsyncs* m = (MQTTAsyncs*)a;
+	return m->c == (Clients*)b;
+}
+
+
+int MQTTAsync_cleanSession(Clients* client)
+{
+	int rc = 0;
+	ListElement* found = NULL;
+
+	FUNC_ENTRY;
+#if !defined(NO_PERSISTENCE)
+	rc = MQTTPersistence_clear(client);
+#endif
+	MQTTProtocol_emptyMessageList(client->inboundMsgs);
+	MQTTProtocol_emptyMessageList(client->outboundMsgs);
+	MQTTAsync_emptyMessageQueue(client);
+	client->msgID = 0;
+	
+	if ((found = ListFindItem(handles, client, clientStructCompare)) != NULL)
+	{
+		MQTTAsyncs* m = (MQTTAsyncs*)(found->content);
+		MQTTAsync_removeResponsesAndCommands(m);
+	}
+	else
+		Log(LOG_ERROR, -1, "cleanSession: did not find client structure in handles list");
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+#if !defined(NO_PERSISTENCE)
+int MQTTAsync_unpersistQueueEntry(Clients* client, qEntry* qe)
+{
+	int rc = 0;
+	char key[PERSISTENCE_MAX_KEY_LENGTH + 1];
+	
+	FUNC_ENTRY;
+	sprintf(key, "%s%d", PERSISTENCE_QUEUE_KEY, qe->seqno);
+	if ((rc = client->persistence->premove(client->phandle, key)) != 0)
+		Log(LOG_ERROR, 0, "Error %d removing qEntry from persistence", rc);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+int MQTTAsync_persistQueueEntry(Clients* aclient, qEntry* qe)
+{
+	int rc = 0;
+	int nbufs = 8;
+	int bufindex = 0;
+	char key[PERSISTENCE_MAX_KEY_LENGTH + 1];
+	int* lens = NULL;
+	void** bufs = NULL;
+		
+	FUNC_ENTRY;
+	lens = (int*)malloc(nbufs * sizeof(int));
+	bufs = malloc(nbufs * sizeof(char *));
+						
+	bufs[bufindex] = &qe->msg->payloadlen;
+	lens[bufindex++] = sizeof(qe->msg->payloadlen);
+				
+	bufs[bufindex] = qe->msg->payload;
+	lens[bufindex++] = qe->msg->payloadlen;
+		
+	bufs[bufindex] = &qe->msg->qos;
+	lens[bufindex++] = sizeof(qe->msg->qos);
+		
+	bufs[bufindex] = &qe->msg->retained;
+	lens[bufindex++] = sizeof(qe->msg->retained);
+		
+	bufs[bufindex] = &qe->msg->dup;
+	lens[bufindex++] = sizeof(qe->msg->dup);
+				
+	bufs[bufindex] = &qe->msg->msgid;
+	lens[bufindex++] = sizeof(qe->msg->msgid);
+						
+	bufs[bufindex] = qe->topicName;
+	lens[bufindex++] = strlen(qe->topicName) + 1;
+				
+	bufs[bufindex] = &qe->topicLen;
+	lens[bufindex++] = sizeof(qe->topicLen);			
+		
+	sprintf(key, "%s%d", PERSISTENCE_QUEUE_KEY, ++aclient->qentry_seqno);	
+	qe->seqno = aclient->qentry_seqno;
+
+	if ((rc = aclient->persistence->pput(aclient->phandle, key, nbufs, (char**)bufs, lens)) != 0)
+		Log(LOG_ERROR, 0, "Error persisting queue entry, rc %d", rc);
+
+	free(lens);
+	free(bufs);
+
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+qEntry* MQTTAsync_restoreQueueEntry(char* buffer, int buflen)
+{
+	qEntry* qe = NULL;
+	char* ptr = buffer;
+	int data_size;
+	
+	FUNC_ENTRY;
+	qe = malloc(sizeof(qEntry));
+	memset(qe, '\0', sizeof(qEntry));
+	
+	qe->msg = malloc(sizeof(MQTTAsync_message));
+	memset(qe->msg, '\0', sizeof(MQTTAsync_message));
+	
+	qe->msg->payloadlen = *(int*)ptr;
+	ptr += sizeof(int);
+	
+	data_size = qe->msg->payloadlen;
+	qe->msg->payload = malloc(data_size);
+	memcpy(qe->msg->payload, ptr, data_size);
+	ptr += data_size;
+	
+	qe->msg->qos = *(int*)ptr;
+	ptr += sizeof(int);
+	
+	qe->msg->retained = *(int*)ptr;
+	ptr += sizeof(int);
+	
+	qe->msg->dup = *(int*)ptr;
+	ptr += sizeof(int);
+	
+	qe->msg->msgid = *(int*)ptr;
+	ptr += sizeof(int);
+	
+	data_size = strlen(ptr) + 1;	
+	qe->topicName = malloc(data_size);
+	strcpy(qe->topicName, ptr);
+	ptr += data_size;
+	
+	qe->topicLen = *(int*)ptr;
+	ptr += sizeof(int);
+
+	FUNC_EXIT;
+	return qe;
+}
+
+
+int MQTTAsync_restoreMessageQueue(MQTTAsyncs* client)
+{
+	int rc = 0;
+	char **msgkeys;
+	int nkeys;
+	int i = 0;
+	Clients* c = client->c;
+	int entries_restored = 0;
+
+	FUNC_ENTRY;
+	if (c->persistence && (rc = c->persistence->pkeys(c->phandle, &msgkeys, &nkeys)) == 0)
+	{
+		while (rc == 0 && i < nkeys)
+		{
+			char *buffer = NULL;
+			int buflen;
+					
+			if (strncmp(msgkeys[i], PERSISTENCE_QUEUE_KEY, strlen(PERSISTENCE_QUEUE_KEY)) != 0)
+				;
+			else if ((rc = c->persistence->pget(c->phandle, msgkeys[i], &buffer, &buflen)) == 0)
+			{
+				qEntry* qe = MQTTAsync_restoreQueueEntry(buffer, buflen);
+				
+				if (qe)
+				{	
+					qe->seqno = atoi(msgkeys[i]+2);
+					MQTTPersistence_insertInOrder(c->messageQueue, qe, sizeof(qEntry));
+					free(buffer);
+					c->qentry_seqno = max(c->qentry_seqno, qe->seqno);
+					entries_restored++;
+				}
+			}
+			if (msgkeys[i])
+				free(msgkeys[i]);
+			i++;
+		}
+		if (msgkeys != NULL)
+			free(msgkeys);
+	}
+	Log(TRACE_MINIMUM, -1, "%d queued messages restored for client %s", entries_restored, c->clientID);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+#endif
+
+
+int MQTTAsync_deliverMessage(MQTTAsyncs* m, char* topicName, int topicLen, MQTTAsync_message* mm)
+{
+	int rc;
+					
+	Log(TRACE_MIN, -1, "Calling messageArrived for client %s, queue depth %d",
+					m->c->clientID, m->c->messageQueue->count);
+	rc = (*(m->ma))(m->context, topicName, topicLen, mm);
+	/* if 0 (false) is returned by the callback then it failed, so we don't remove the message from
+	 * the queue, and it will be retried later.  If 1 is returned then the message data may have been freed,
+	 * so we must be careful how we use it.
+	 */
+	return rc;
+}
+
+
+void Protocol_processPublication(Publish* publish, Clients* client)
+{
+	MQTTAsync_message* mm = NULL;
+	int rc = 0;
+
+	FUNC_ENTRY;
+	mm = malloc(sizeof(MQTTAsync_message));
+
+	/* If the message is QoS 2, then we have already stored the incoming payload
+	 * in an allocated buffer, so we don't need to copy again.
+	 */
+	if (publish->header.bits.qos == 2)
+		mm->payload = publish->payload;
+	else
+	{
+		mm->payload = malloc(publish->payloadlen);
+		memcpy(mm->payload, publish->payload, publish->payloadlen);
+	}
+
+	mm->payloadlen = publish->payloadlen;
+	mm->qos = publish->header.bits.qos;
+	mm->retained = publish->header.bits.retain;
+	if (publish->header.bits.qos == 2)
+		mm->dup = 0;  /* ensure that a QoS2 message is not passed to the application with dup = 1 */
+	else
+		mm->dup = publish->header.bits.dup;
+	mm->msgid = publish->msgId;
+	
+	if (client->messageQueue->count == 0 && client->connected)
+	{
+		ListElement* found = NULL;
+		
+		if ((found = ListFindItem(handles, client, clientStructCompare)) == NULL)
+			Log(LOG_ERROR, -1, "processPublication: did not find client structure in handles list");
+		else
+		{
+			MQTTAsyncs* m = (MQTTAsyncs*)(found->content);
+
+			if (m->ma)
+				rc = MQTTAsync_deliverMessage(m, publish->topic, publish->topiclen, mm);
+		} 
+	}
+
+	if (rc == 0) /* if message was not delivered, queue it up */
+	{
+		qEntry* qe = malloc(sizeof(qEntry));	
+		qe->msg = mm;
+		qe->topicName = publish->topic;
+		qe->topicLen = publish->topiclen;
+		ListAppend(client->messageQueue, qe, sizeof(qe) + sizeof(mm) + mm->payloadlen + strlen(qe->topicName)+1);
+#if !defined(NO_PERSISTENCE)
+		if (client->persistence)
+			MQTTAsync_persistQueueEntry(client, qe);
+#endif
+	}
+	publish->topic = NULL;	
+	FUNC_EXIT;
+}
+
+
+int MQTTAsync_connect(MQTTAsync handle, MQTTAsync_connectOptions* options)
+{
+	MQTTAsyncs* m = handle;
+	int rc = MQTTASYNC_SUCCESS;
+	MQTTAsync_queuedCommand* conn;
+
+	FUNC_ENTRY;
+	if (options == NULL)
+	{
+		rc = MQTTASYNC_NULL_PARAMETER;
+		goto exit;
+	}
+
+	if (strncmp(options->struct_id, "MQTC", 4) != 0 || 
+		(options->struct_version != 0 && options->struct_version != 1 && options->struct_version != 2))
+	{
+		rc = MQTTASYNC_BAD_STRUCTURE;
+		goto exit;
+	}
+	if (options->will) /* check validity of will options structure */
+	{
+		if (strncmp(options->will->struct_id, "MQTW", 4) != 0 || options->will->struct_version != 0)
+		{
+			rc = MQTTASYNC_BAD_STRUCTURE;
+			goto exit;
+		}
+		if (options->will->qos < 0 || options->will->qos > 2)
+		{
+			rc = MQTTASYNC_BAD_QOS;
+			goto exit;
+		}
+	}
+	if (options->struct_version != 0 && options->ssl) /* check validity of SSL options structure */
+	{
+		if (strncmp(options->ssl->struct_id, "MQTS", 4) != 0 || options->ssl->struct_version != 0)
+		{
+			rc = MQTTASYNC_BAD_STRUCTURE;
+			goto exit;
+		}
+	}
+	if ((options->username && !UTF8_validateString(options->username)) ||
+		(options->password && !UTF8_validateString(options->password)))
+	{
+		rc = MQTTASYNC_BAD_UTF8_STRING;
+		goto exit;
+	}
+
+	m->connect.onSuccess = options->onSuccess;
+	m->connect.onFailure = options->onFailure;
+	m->connect.context = options->context;
+	
+	tostop = 0;
+	if (sendThread_state != STARTING && sendThread_state != RUNNING)
+	{
+		MQTTAsync_lock_mutex(mqttasync_mutex);
+		sendThread_state = STARTING;
+		Thread_start(MQTTAsync_sendThread, NULL);
+		MQTTAsync_unlock_mutex(mqttasync_mutex);
+	}
+	if (receiveThread_state != STARTING && receiveThread_state != RUNNING)
+	{
+		MQTTAsync_lock_mutex(mqttasync_mutex);
+		receiveThread_state = STARTING;
+		Thread_start(MQTTAsync_receiveThread, handle);
+		MQTTAsync_unlock_mutex(mqttasync_mutex);
+	}
+
+	m->c->keepAliveInterval = options->keepAliveInterval;
+	m->c->cleansession = options->cleansession;
+	m->c->maxInflightMessages = options->maxInflight;
+
+	if (m->c->will)
+	{
+		free(m->c->will->msg);
+		free(m->c->will->topic);
+		free(m->c->will);
+		m->c->will = NULL;
+	}
+	
+	if (options->will && options->will->struct_version == 0)
+	{
+		m->c->will = malloc(sizeof(willMessages));
+		m->c->will->msg = malloc(strlen(options->will->message) + 1); 
+		strcpy(m->c->will->msg, options->will->message);
+		m->c->will->qos = options->will->qos;
+		m->c->will->retained = options->will->retained;
+		m->c->will->topic = malloc(strlen(options->will->topicName) + 1);
+		strcpy(m->c->will->topic, options->will->topicName);
+	}
+	
+#if defined(OPENSSL)
+	if (m->c->sslopts)
+	{
+		if (m->c->sslopts->trustStore)
+			free(m->c->sslopts->trustStore);
+		if (m->c->sslopts->keyStore)
+			free(m->c->sslopts->keyStore);
+		if (m->c->sslopts->privateKey)
+			free(m->c->sslopts->privateKey);
+		if (m->c->sslopts->privateKeyPassword)
+			free(m->c->sslopts->privateKeyPassword);
+		if (m->c->sslopts->enabledCipherSuites)
+			free(m->c->sslopts->enabledCipherSuites);
+		free(m->c->sslopts);
+		m->c->sslopts = NULL;
+	}
+
+	if (options->struct_version != 0 && options->ssl)
+	{
+		m->c->sslopts = malloc(sizeof(MQTTClient_SSLOptions));
+		memset(m->c->sslopts, '\0', sizeof(MQTTClient_SSLOptions));
+		if (options->ssl->trustStore)
+		{
+			m->c->sslopts->trustStore = malloc(strlen(options->ssl->trustStore) + 1);
+			strcpy(m->c->sslopts->trustStore, options->ssl->trustStore); 
+		}
+		if (options->ssl->keyStore)
+		{
+			m->c->sslopts->keyStore = malloc(strlen(options->ssl->keyStore) + 1);
+			strcpy(m->c->sslopts->keyStore, options->ssl->keyStore);
+		}
+		if (options->ssl->privateKey)
+		{
+			m->c->sslopts->privateKey = malloc(strlen(options->ssl->privateKey) + 1);
+			strcpy(m->c->sslopts->privateKey, options->ssl->privateKey);
+		}
+		if (options->ssl->privateKeyPassword)
+		{
+			m->c->sslopts->privateKeyPassword = malloc(strlen(options->ssl->privateKeyPassword) + 1);
+			strcpy(m->c->sslopts->privateKeyPassword, options->ssl->privateKeyPassword);
+		}
+		if (options->ssl->enabledCipherSuites)
+		{
+			m->c->sslopts->enabledCipherSuites = malloc(strlen(options->ssl->enabledCipherSuites) + 1);
+			strcpy(m->c->sslopts->enabledCipherSuites, options->ssl->enabledCipherSuites);
+		}
+		m->c->sslopts->enableServerCertAuth = options->ssl->enableServerCertAuth;
+	}
+#endif
+
+	m->c->username = options->username;
+	m->c->password = options->password;
+	m->c->retryInterval = options->retryInterval;
+	
+	/* Add connect request to operation queue */
+	conn = malloc(sizeof(MQTTAsync_queuedCommand));
+	memset(conn, '\0', sizeof(MQTTAsync_queuedCommand));
+	conn->client = m;
+	if (options)
+	{
+		conn->command.onSuccess = options->onSuccess;
+		conn->command.onFailure = options->onFailure;
+		conn->command.context = options->context;
+		conn->command.details.conn.timeout = options->connectTimeout;
+			
+		if (options->struct_version >= 2 && options->serverURIcount > 0)
+		{
+			int i;
+			
+			conn->command.details.conn.serverURIcount = options->serverURIcount;
+			conn->command.details.conn.serverURIs = malloc(options->serverURIcount * sizeof(char*));
+			for (i = 0; i < options->serverURIcount; ++i)
+			{
+				conn->command.details.conn.serverURIs[i] = malloc(strlen(options->serverURIs[i]) + 1);
+				strcpy(conn->command.details.conn.serverURIs[i], options->serverURIs[i]);
+			}
+			conn->command.details.conn.currentURI = 0;
+		}
+	}
+	conn->command.type = CONNECT;
+	rc = MQTTAsync_addCommand(conn, sizeof(conn));
+
+exit:
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTAsync_disconnect1(MQTTAsync handle, MQTTAsync_disconnectOptions* options, int internal)
+{
+	MQTTAsyncs* m = handle;
+	int rc = MQTTASYNC_SUCCESS;
+	MQTTAsync_queuedCommand* dis;
+
+	FUNC_ENTRY;
+	if (m == NULL || m->c == NULL)
+	{
+		rc = MQTTASYNC_FAILURE;
+		goto exit;
+	}
+	if (m->c->connected == 0)
+	{
+		rc = MQTTASYNC_DISCONNECTED;
+		goto exit;
+	}
+	
+	/* Add disconnect request to operation queue */
+	dis = malloc(sizeof(MQTTAsync_queuedCommand));
+	memset(dis, '\0', sizeof(MQTTAsync_queuedCommand));
+	dis->client = m;
+	if (options)
+	{
+		dis->command.onSuccess = options->onSuccess;
+		dis->command.onFailure = options->onFailure;
+		dis->command.context = options->context;
+		dis->command.details.dis.timeout = options->timeout;
+	}
+	dis->command.type = DISCONNECT;
+	dis->command.details.dis.internal = internal;
+	rc = MQTTAsync_addCommand(dis, sizeof(dis));
+	
+exit:
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTAsync_disconnect_internal(MQTTAsync handle, int timeout)
+{
+	MQTTAsync_disconnectOptions options = MQTTAsync_disconnectOptions_initializer;
+	
+	options.timeout = timeout;
+	return MQTTAsync_disconnect1(handle, &options, 1);
+}
+
+
+void MQTTProtocol_closeSession(Clients* c, int sendwill)
+{
+	MQTTAsync_disconnect_internal((MQTTAsync)c->context, 0);
+}
+
+
+int MQTTAsync_disconnect(MQTTAsync handle, MQTTAsync_disconnectOptions* options)
+{	
+	return MQTTAsync_disconnect1(handle, options, 0);
+}
+
+
+int MQTTAsync_isConnected(MQTTAsync handle)
+{
+	MQTTAsyncs* m = handle;
+	int rc = 0;
+
+	FUNC_ENTRY;
+	MQTTAsync_lock_mutex(mqttasync_mutex);
+	if (m && m->c)
+		rc = m->c->connected;
+	MQTTAsync_unlock_mutex(mqttasync_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTAsync_subscribeMany(MQTTAsync handle, int count, char** topic, int* qos, MQTTAsync_responseOptions* response)
+{
+	MQTTAsyncs* m = handle;
+	int i = 0;
+	int rc = MQTTASYNC_FAILURE;
+	MQTTAsync_queuedCommand* sub;
+
+	FUNC_ENTRY;
+	if (m == NULL || m->c == NULL)
+	{
+		rc = MQTTASYNC_FAILURE;
+		goto exit;
+	}
+	if (m->c->connected == 0)
+	{
+		rc = MQTTASYNC_DISCONNECTED;
+		goto exit;
+	}
+	if (m->c->outboundMsgs->count >= MAX_MSG_ID - 1)
+	{
+		rc = MQTTASYNC_NO_MORE_MSGIDS;
+		goto exit;
+	}
+	for (i = 0; i < count; i++)
+	{
+		if (!UTF8_validateString(topic[i]))
+		{
+			rc = MQTTASYNC_BAD_UTF8_STRING;
+			goto exit;
+		}
+		if (qos[i] < 0 || qos[i] > 2)
+		{
+			rc = MQTTASYNC_BAD_QOS;
+			goto exit;
+		}
+	}
+
+	/* Add subscribe request to operation queue */
+	sub = malloc(sizeof(MQTTAsync_queuedCommand));
+	memset(sub, '\0', sizeof(MQTTAsync_queuedCommand));
+	sub->client = m;
+	if (response)
+	{
+		sub->command.onSuccess = response->onSuccess;
+		sub->command.onFailure = response->onFailure;
+		sub->command.context = response->context;
+	}
+	sub->command.type = SUBSCRIBE;
+	sub->command.details.sub.count = count;
+	sub->command.details.sub.topics = malloc(sizeof(char*) * count);
+	sub->command.details.sub.qoss = malloc(sizeof(int) * count);
+	for (i = 0; i < count; ++i)
+	{
+		sub->command.details.sub.topics[i] = malloc(strlen(topic[i]) + 1);
+		strcpy(sub->command.details.sub.topics[i], topic[i]);
+		sub->command.details.sub.qoss[i] = qos[i];	
+	}
+	rc = MQTTAsync_addCommand(sub, sizeof(sub));
+
+exit:
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTAsync_subscribe(MQTTAsync handle, char* topic, int qos, MQTTAsync_responseOptions* response)
+{
+	int rc = 0;
+
+	FUNC_ENTRY;
+	rc = MQTTAsync_subscribeMany(handle, 1, &topic, &qos, response);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTAsync_unsubscribeMany(MQTTAsync handle, int count, char** topic, MQTTAsync_responseOptions* response)
+{
+	MQTTAsyncs* m = handle;
+	int i = 0;
+	int rc = SOCKET_ERROR;
+	MQTTAsync_queuedCommand* unsub;
+
+	FUNC_ENTRY;
+	if (m == NULL || m->c == NULL)
+	{
+		rc = MQTTASYNC_FAILURE;
+		goto exit;
+	}
+	if (m->c->connected == 0)
+	{
+		rc = MQTTASYNC_DISCONNECTED;
+		goto exit;
+	}
+	if (m->c->outboundMsgs->count >= MAX_MSG_ID - 1)
+	{
+		rc = MQTTASYNC_NO_MORE_MSGIDS;
+		goto exit;
+	}
+	for (i = 0; i < count; i++)
+	{
+		if (!UTF8_validateString(topic[i]))
+		{
+			rc = MQTTASYNC_BAD_UTF8_STRING;
+			goto exit;
+		}
+	}
+	
+	/* Add unsubscribe request to operation queue */
+	unsub = malloc(sizeof(MQTTAsync_queuedCommand));
+	memset(unsub, '\0', sizeof(MQTTAsync_queuedCommand));
+	unsub->client = m;
+	unsub->command.type = UNSUBSCRIBE;
+	if (response)
+	{
+		unsub->command.onSuccess = response->onSuccess;
+		unsub->command.onFailure = response->onFailure;
+		unsub->command.context = response->context;
+	}
+	unsub->command.details.unsub.count = count;
+	unsub->command.details.unsub.topics = malloc(sizeof(char*) * count);
+	for (i = 0; i < count; ++i)
+	{
+		unsub->command.details.unsub.topics[i] = malloc(strlen(topic[i]) + 1);
+		strcpy(unsub->command.details.unsub.topics[i], topic[i]);
+	}
+	rc = MQTTAsync_addCommand(unsub, sizeof(unsub));
+
+exit:
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTAsync_unsubscribe(MQTTAsync handle, char* topic, MQTTAsync_responseOptions* response)
+{
+	int rc = 0;
+
+	FUNC_ENTRY;
+	rc = MQTTAsync_unsubscribeMany(handle, 1, &topic, response);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTAsync_send(MQTTAsync handle, char* destinationName, int payloadlen, void* payload,
+							 int qos, int retained, MQTTAsync_responseOptions* response)
+{
+	int rc = MQTTASYNC_SUCCESS;
+	MQTTAsyncs* m = handle;
+	MQTTAsync_queuedCommand* pub;
+
+	FUNC_ENTRY;
+	if (m == NULL || m->c == NULL)
+		rc = MQTTASYNC_FAILURE;
+	else if (m->c->connected == 0)
+		rc = MQTTASYNC_DISCONNECTED;
+	else if (!UTF8_validateString(destinationName))
+		rc = MQTTASYNC_BAD_UTF8_STRING;
+	else if (qos < 0 || qos > 2)
+		rc = MQTTASYNC_BAD_QOS;
+	else if (m->c->outboundMsgs->count >= MAX_MSG_ID - 1)
+		rc = MQTTASYNC_NO_MORE_MSGIDS;
+
+	if (rc != MQTTASYNC_SUCCESS)
+		goto exit;
+	
+	/* Add publish request to operation queue */
+	pub = malloc(sizeof(MQTTAsync_queuedCommand));
+	memset(pub, '\0', sizeof(MQTTAsync_queuedCommand));
+	pub->client = m;
+	pub->command.type = PUBLISH;
+	if (response)
+	{
+		pub->command.onSuccess = response->onSuccess;
+		pub->command.onFailure = response->onFailure;
+		pub->command.context = response->context;
+	}
+	pub->command.details.pub.destinationName = malloc(strlen(destinationName) + 1);
+	strcpy(pub->command.details.pub.destinationName, destinationName);
+	pub->command.details.pub.payloadlen = payloadlen;
+	pub->command.details.pub.payload = malloc(payloadlen);
+	memcpy(pub->command.details.pub.payload, payload, payloadlen);
+	pub->command.details.pub.qos = qos;
+	pub->command.details.pub.retained = retained;
+	rc = MQTTAsync_addCommand(pub, sizeof(pub));
+
+exit:
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+
+int MQTTAsync_sendMessage(MQTTAsync handle, char* destinationName, MQTTAsync_message* message,
+													 MQTTAsync_responseOptions* response)
+{
+	int rc = MQTTASYNC_SUCCESS;
+
+	FUNC_ENTRY;
+	if (message == NULL)
+	{
+		rc = MQTTASYNC_NULL_PARAMETER;
+		goto exit;
+	}
+	if (strncmp(message->struct_id, "MQTM", 4) != 0 || message->struct_version != 0)
+	{
+		rc = MQTTASYNC_BAD_STRUCTURE;
+		goto exit;
+	}
+
+	rc = MQTTAsync_send(handle, destinationName, message->payloadlen, message->payload,
+								message->qos, message->retained, response);
+exit:
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+void MQTTAsync_retry(void)
+{
+	static time_t last = 0L;
+	time_t now;
+
+	FUNC_ENTRY;
+	time(&(now));
+	if (difftime(now, last) > 5)
+	{
+		time(&(last));
+		MQTTProtocol_keepalive(now);
+		MQTTProtocol_retry(now, 1);
+	}
+	else
+		MQTTProtocol_retry(now, 0);
+	FUNC_EXIT;
+}
+
+
+int MQTTAsync_connecting(MQTTAsyncs* m)
+{
+	int rc = -1;
+
+	FUNC_ENTRY;
+	if (m->c->connect_state == 1) /* TCP connect started - check for completion */
+	{
+		int error;
+		socklen_t len = sizeof(error);
+
+		if ((rc = getsockopt(m->c->net.socket, SOL_SOCKET, SO_ERROR, (char*)&error, &len)) == 0)
+			rc = error;
+
+		if (rc != 0)
+			goto exit;
+			
+		Socket_clearPendingWrite(m->c->net.socket);
+
+#if defined(OPENSSL)
+		if (m->ssl)
+		{
+			if (SSLSocket_setSocketForSSL(&m->c->net, m->c->sslopts) != MQTTASYNC_SUCCESS)
+			{
+				if (m->c->session != NULL)
+					if ((rc = SSL_set_session(m->c->net.ssl, m->c->session)) != 1)
+						Log(TRACE_MIN, -1, "Failed to set SSL session with stored data, non critical");
+				rc = SSLSocket_connect(m->c->net.ssl, m->c->net.socket);
+				if (rc == -1)
+					m->c->connect_state = 2;
+				else if (rc == SSL_FATAL)
+				{
+					rc = SOCKET_ERROR;
+					goto exit;
+				}
+				else if (rc == 1) {
+					rc = MQTTCLIENT_SUCCESS;
+					m->c->connect_state = 3;
+					if (MQTTPacket_send_connect(m->c) == SOCKET_ERROR)
+					{
+						rc = SOCKET_ERROR;
+						goto exit;
+					}
+					if(!m->c->cleansession && m->c->session == NULL)
+						m->c->session = SSL_get1_session(m->c->net.ssl);
+				}
+			}
+			else
+			{
+				rc = SOCKET_ERROR;
+				goto exit;
+			}
+		}
+		else
+		{
+#endif
+			m->c->connect_state = 3; /* TCP/SSL connect completed, in which case send the MQTT connect packet */
+			if ((rc = MQTTPacket_send_connect(m->c)) == SOCKET_ERROR)
+				goto exit;
+#if defined(OPENSSL)
+		}
+#endif
+	}
+#if defined(OPENSSL)
+	else if (m->c->connect_state == 2) /* SSL connect sent - wait for completion */
+	{
+		if ((rc = SSLSocket_connect(m->c->net.ssl, m->c->net.socket)) != 1)
+			goto exit;
+
+		if(!m->c->cleansession && m->c->session == NULL)
+			m->c->session = SSL_get1_session(m->c->net.ssl);
+		m->c->connect_state = 3; /* SSL connect completed, in which case send the MQTT connect packet */
+		if ((rc = MQTTPacket_send_connect(m->c)) == SOCKET_ERROR)
+			goto exit;
+	}
+#endif
+
+exit:
+	if ((rc != 0 && m->c->connect_state != 2) || (rc == SSL_FATAL))
+	{
+		if (m->connect.details.conn.currentURI < m->connect.details.conn.serverURIcount)
+		{
+			MQTTAsync_queuedCommand* conn;
+				
+			MQTTAsync_closeOnly(m->c);
+			/* put the connect command back to the head of the command queue, using the next serverURI */
+			conn = malloc(sizeof(MQTTAsync_queuedCommand));
+			memset(conn, '\0', sizeof(MQTTAsync_queuedCommand));
+			conn->client = m;
+			conn->command = m->connect; 
+			Log(TRACE_MIN, -1, "Connect failed, now trying %s", 
+				m->connect.details.conn.serverURIs[m->connect.details.conn.currentURI]);
+			MQTTAsync_addCommand(conn, sizeof(m->connect));
+		}
+		else
+		{
+			MQTTAsync_closeSession(m->c);
+			MQTTAsync_freeConnect(m->connect);
+			if (m->connect.onFailure)
+			{
+				Log(TRACE_MIN, -1, "Calling connect failure for client %s", m->c->clientID);
+				(*(m->connect.onFailure))(m->connect.context, NULL);
+			}
+		}
+	}
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+MQTTPacket* MQTTAsync_cycle(int* sock, unsigned long timeout, int* rc)
+{
+	struct timeval tp = {0L, 0L};
+	static Ack ack;
+	MQTTPacket* pack = NULL;
+	static int nosockets_count = 0;
+
+	FUNC_ENTRY;
+	if (timeout > 0L)
+	{
+		tp.tv_sec = timeout / 1000;
+		tp.tv_usec = (timeout % 1000) * 1000; /* this field is microseconds! */
+	}
+
+#if defined(OPENSSL)
+	if ((*sock = SSLSocket_getPendingRead()) == -1)
+	{
+#endif
+		/* 0 from getReadySocket indicates no work to do, -1 == error, but can happen normally */
+		*sock = Socket_getReadySocket(0, &tp);
+		if (!tostop && *sock == 0 && (tp.tv_sec > 0L || tp.tv_usec > 0L))
+		{
+			MQTTAsync_sleep(100L);
+			if (s.clientsds->count == 0)
+			{
+				if (++nosockets_count == 50) /* 5 seconds with no sockets */
+					tostop = 1;
+			}
+		}
+		else
+			nosockets_count = 0;
+#if defined(OPENSSL)
+	}
+#endif
+	MQTTAsync_lock_mutex(mqttasync_mutex);
+	if (*sock > 0)
+	{
+		MQTTAsyncs* m = NULL;
+		if (ListFindItem(handles, sock, clientSockCompare) != NULL)
+			m = (MQTTAsync)(handles->current->content);
+		if (m != NULL)
+		{
+			if (m->c->connect_state == 1 || m->c->connect_state == 2)
+				*rc = MQTTAsync_connecting(m);
+			else
+				pack = MQTTPacket_Factory(&m->c->net, rc);
+			if ((m->c->connect_state == 3) && (*rc == SOCKET_ERROR))
+			{
+				Log(TRACE_MINIMUM, -1, "CONNECT sent but MQTTPacket_Factory has returned SOCKET_ERROR");
+				if (m->connect.details.conn.currentURI < m->connect.details.conn.serverURIcount)
+				{
+					MQTTAsync_queuedCommand* conn;
+				
+					MQTTAsync_closeOnly(m->c);
+					/* put the connect command back to the head of the command queue, using the next serverURI */
+					conn = malloc(sizeof(MQTTAsync_queuedCommand));
+					memset(conn, '\0', sizeof(MQTTAsync_queuedCommand));
+					conn->client = m;
+					conn->command = m->connect; 
+					Log(TRACE_MIN, -1, "Connect failed, now trying %s", 
+						m->connect.details.conn.serverURIs[m->connect.details.conn.currentURI]);
+					MQTTAsync_addCommand(conn, sizeof(m->connect));
+				}
+				else
+				{
+					MQTTAsync_closeSession(m->c);
+					MQTTAsync_freeConnect(m->connect);
+					if (m->connect.onFailure)
+					{
+						Log(TRACE_MIN, -1, "Calling connect failure for client %s", m->c->clientID);
+						(*(m->connect.onFailure))(m->connect.context, NULL);
+					}
+				}
+			}
+		}
+		if (pack)
+		{
+			int freed = 1;
+
+			/* Note that these handle... functions free the packet structure that they are dealing with */
+			if (pack->header.bits.type == PUBLISH)
+				*rc = MQTTProtocol_handlePublishes(pack, *sock);
+			else if (pack->header.bits.type == PUBACK || pack->header.bits.type == PUBCOMP)
+			{
+				int msgid;
+
+				ack = (pack->header.bits.type == PUBCOMP) ? *(Pubcomp*)pack : *(Puback*)pack;
+				msgid = ack.msgId;
+				*rc = (pack->header.bits.type == PUBCOMP) ?
+						MQTTProtocol_handlePubcomps(pack, *sock) : MQTTProtocol_handlePubacks(pack, *sock);
+				if (!m)
+					Log(LOG_ERROR, -1, "PUBCOMP or PUBACK received for no client, msgid %d", msgid);
+				if (m)
+				{
+					ListElement* current = NULL;
+					
+					if (m->dc)
+					{
+						Log(TRACE_MIN, -1, "Calling deliveryComplete for client %s, msgid %d", m->c->clientID, msgid);
+						(*(m->dc))(m->context, msgid);
+					}
+					/* use the msgid to find the callback to be called */
+					while (ListNextElement(m->responses, &current))
+					{
+						MQTTAsync_queuedCommand* command = (MQTTAsync_queuedCommand*)(current->content);
+						if (command->command.token == msgid)
+						{		
+							if (!ListDetach(m->responses, command)) /* then remove the response from the list */
+								Log(LOG_ERROR, -1, "Publish command not removed from command list");
+							if (command->command.onSuccess)
+							{
+								MQTTAsync_successData data;
+								
+								data.token = command->command.token;
+								data.alt.pub.destinationName = command->command.details.pub.destinationName;
+								data.alt.pub.message.payload = command->command.details.pub.payload;
+								data.alt.pub.message.payloadlen = command->command.details.pub.payloadlen;
+								data.alt.pub.message.qos = command->command.details.pub.qos;
+								data.alt.pub.message.retained = command->command.details.pub.retained;
+								Log(TRACE_MIN, -1, "Calling publish success for client %s", m->c->clientID);
+								(*(command->command.onSuccess))(command->command.context, &data);
+							}
+							MQTTAsync_freeCommand(command);
+							break;
+						}
+					}
+				}
+			}
+			else if (pack->header.bits.type == PUBREC)
+				*rc = MQTTProtocol_handlePubrecs(pack, *sock);
+			else if (pack->header.bits.type == PUBREL)
+				*rc = MQTTProtocol_handlePubrels(pack, *sock);
+			else if (pack->header.bits.type == PINGRESP)
+				*rc = MQTTProtocol_handlePingresps(pack, *sock);
+			else
+				freed = 0;
+			if (freed)
+				pack = NULL;
+		}
+	}
+	MQTTAsync_retry();
+	MQTTAsync_unlock_mutex(mqttasync_mutex);
+	FUNC_EXIT_RC(*rc);
+	return pack;
+}
+
+
+int pubCompare(void* a, void* b)
+{
+	Messages* msg = (Messages*)a;
+	return msg->publish == (Publications*)b;
+}
+
+
+int MQTTAsync_getPendingTokens(MQTTAsync handle, MQTTAsync_token **tokens)
+{
+	int rc = MQTTASYNC_SUCCESS;
+	MQTTAsyncs* m = handle;
+	*tokens = NULL;
+
+	FUNC_ENTRY;
+	MQTTAsync_lock_mutex(mqttasync_mutex);
+
+	if (m == NULL)
+	{
+		rc = MQTTASYNC_FAILURE;
+		goto exit;
+	}
+
+	if (m->c && m->c->outboundMsgs->count > 0)
+	{
+		ListElement* current = NULL;
+		int count = 0;
+
+		*tokens = malloc(sizeof(MQTTAsync_token) * (m->c->outboundMsgs->count + 1));
+		while (ListNextElement(m->c->outboundMsgs, &current))
+		{
+			Messages* m = (Messages*)(current->content);
+			(*tokens)[count++] = m->msgid;
+		}
+		(*tokens)[count] = -1;
+	}
+
+exit:
+	MQTTAsync_unlock_mutex(mqttasync_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+
+void MQTTAsync_setTraceLevel(enum MQTTASYNC_TRACE_LEVELS level)
+{
+	Log_setTraceLevel(level);
+}
+
+
+void MQTTAsync_setTraceCallback(MQTTAsync_traceCallback* callback)
+{
+	Log_setTraceCallback((Log_traceCallback*)callback);
+}
+
+
+MQTTAsync_nameValue* MQTTAsync_getVersionInfo()
+{
+	#define MAX_INFO_STRINGS 8
+	static MQTTAsync_nameValue libinfo[MAX_INFO_STRINGS + 1];
+	int i = 0; 
+	
+	libinfo[i].name = "Product name";
+	libinfo[i++].value = "Paho Asynchronous MQTT C Client Library";
+	
+	libinfo[i].name = "Version";
+	libinfo[i++].value = CLIENT_VERSION;
+	
+	libinfo[i].name = "Build level";
+	libinfo[i++].value = BUILD_TIMESTAMP;
+#if defined(OPENSSL)
+	libinfo[i].name = "OpenSSL version";
+	libinfo[i++].value = SSLeay_version(SSLEAY_VERSION);
+		
+	libinfo[i].name = "OpenSSL flags";
+	libinfo[i++].value = SSLeay_version(SSLEAY_CFLAGS);
+	
+	libinfo[i].name = "OpenSSL build timestamp";	
+	libinfo[i++].value = SSLeay_version(SSLEAY_BUILT_ON);
+	
+	libinfo[i].name = "OpenSSL platform";
+	libinfo[i++].value = SSLeay_version(SSLEAY_PLATFORM);
+	
+	libinfo[i].name = "OpenSSL directory";
+	libinfo[i++].value = SSLeay_version(SSLEAY_DIR);
+#endif
+	libinfo[i].name = NULL;
+	libinfo[i].value = NULL;
+	return libinfo;
+}

src/MQTTClient.c

@@ -19,6 +19,7 @@
  *    Ian Craggs - fix for bug 413429 - connectionLost not called
  *    Ian Craggs - fix for bug 421103 - trying to write to same socket, in publish/retries
  *    Ian Craggs - fix for bug 419233 - mutexes not reporting errors
+ *    Ian Craggs - fix for bug #420851
  *******************************************************************************/
 
 /**
@@ -1539,15 +1540,15 @@ MQTTPacket* MQTTClient_waitfor(MQTTClient handle, int packet_type, int* rc, long
 	{
 		if (packet_type == CONNECT)
 		{
-			if ((*rc = Thread_wait_sem(m->connect_sem)) == 0)
+			if ((*rc = Thread_wait_sem(m->connect_sem, timeout)) == 0)
 				*rc = m->rc;
 		}
 		else if (packet_type == CONNACK)
-			*rc = Thread_wait_sem(m->connack_sem);
+			*rc = Thread_wait_sem(m->connack_sem, timeout);
 		else if (packet_type == SUBACK)
-			*rc = Thread_wait_sem(m->suback_sem);
+			*rc = Thread_wait_sem(m->suback_sem, timeout);
 		else if (packet_type == UNSUBACK)
-			*rc = Thread_wait_sem(m->unsuback_sem);
+			*rc = Thread_wait_sem(m->unsuback_sem, timeout);
 		if (*rc == 0 && packet_type != CONNECT && m->pack == NULL)
 			Log(TRACE_MIN, -1, "waitfor unexpectedly is NULL for client %s, packet_type %d", m->c->clientID, packet_type);
 		pack = m->pack;

src/MQTTClient.c~

+/*******************************************************************************
+ * 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 - bug 384016 - segv setting will message
+ *    Ian Craggs - bug 384053 - v1.0.0.7 - stop MQTTClient_receive on socket error 
+ *    Ian Craggs, Allan Stockdill-Mander - add ability to connect with SSL
+ *    Ian Craggs - multiple server connection support
+ *    Ian Craggs - fix for bug 413429 - connectionLost not called
+ *    Ian Craggs - fix for bug 421103 - trying to write to same socket, in publish/retries
+ *    Ian Craggs - fix for bug 419233 - mutexes not reporting errors
+ *******************************************************************************/
+
+/**
+ * @file
+ * \brief Synchronous API implementation
+ *
+ */
+
+#define _GNU_SOURCE /* for pthread_mutexattr_settype */
+#include <stdlib.h>
+#if !defined(WIN32)
+	#include <sys/time.h>
+#endif
+
+#if !defined(NO_PERSISTENCE)
+#include "MQTTPersistence.h"
+#endif
+#include "MQTTClient.h"
+#include "utf-8.h"
+#include "MQTTProtocol.h"
+#include "MQTTProtocolOut.h"
+#include "Thread.h"
+#include "SocketBuffer.h"
+#include "StackTrace.h"
+#include "Heap.h"
+
+#if defined(OPENSSL)
+#include <openssl/ssl.h>
+#endif
+
+#define URI_TCP "tcp://"
+
+#define BUILD_TIMESTAMP "##MQTTCLIENT_BUILD_TAG##"
+#define CLIENT_VERSION  "##MQTTCLIENT_VERSION_TAG##" 
+
+char* client_timestamp_eye = "MQTTClientV3_Timestamp " BUILD_TIMESTAMP;
+char* client_version_eye = "MQTTClientV3_Version " CLIENT_VERSION;
+
+static ClientStates ClientState =
+{
+	CLIENT_VERSION, /* version */
+	NULL /* client list */
+};
+
+ClientStates* bstate = &ClientState;
+
+MQTTProtocol state;
+
+#if defined(WIN32)
+static mutex_type mqttclient_mutex = NULL;
+extern mutex_type stack_mutex;
+extern mutex_type heap_mutex;
+extern mutex_type log_mutex;
+BOOL APIENTRY DllMain(HANDLE hModule,
+					  DWORD  ul_reason_for_call,
+					  LPVOID lpReserved)
+{
+	switch (ul_reason_for_call)
+	{
+		case DLL_PROCESS_ATTACH:
+			Log(TRACE_MAX, -1, "DLL process attach");
+			if (mqttclient_mutex == NULL)
+			{
+				mqttclient_mutex = CreateMutex(NULL, 0, NULL);
+				stack_mutex = CreateMutex(NULL, 0, NULL);
+				heap_mutex = CreateMutex(NULL, 0, NULL);
+				log_mutex = CreateMutex(NULL, 0, NULL);
+			}
+		case DLL_THREAD_ATTACH:
+			Log(TRACE_MAX, -1, "DLL thread attach");
+		case DLL_THREAD_DETACH:
+			Log(TRACE_MAX, -1, "DLL thread detach");
+		case DLL_PROCESS_DETACH:
+			Log(TRACE_MAX, -1, "DLL process detach");
+	}
+	return TRUE;
+}
+#else
+static pthread_mutex_t mqttclient_mutex_store = PTHREAD_MUTEX_INITIALIZER;
+static mutex_type mqttclient_mutex = &mqttclient_mutex_store;
+
+void MQTTClient_init()
+{
+	pthread_mutexattr_t attr;
+	int rc;
+
+	pthread_mutexattr_init(&attr);
+	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
+	if ((rc = pthread_mutex_init(mqttclient_mutex, &attr)) != 0)
+		printf("MQTTAsync: error %d initializing client_mutex\n", rc);
+}
+
+#define WINAPI
+#endif
+
+static volatile int initialized = 0;
+static List* handles = NULL;
+static time_t last;
+static int running = 0;
+static int tostop = 0;
+static thread_id_type run_id = 0;
+
+MQTTPacket* MQTTClient_waitfor(MQTTClient handle, int packet_type, int* rc, long timeout);
+MQTTPacket* MQTTClient_cycle(int* sock, unsigned long timeout, int* rc);
+int MQTTClient_cleanSession(Clients* client);
+void MQTTClient_stop();
+int MQTTClient_disconnect_internal(MQTTClient handle, int timeout);
+void MQTTClient_writeComplete(int socket);
+
+typedef struct
+{
+	MQTTClient_message* msg;
+	char* topicName;
+	int topicLen;
+} qEntry;
+
+
+typedef struct
+{
+	char* serverURI;
+#if defined(OPENSSL)
+	int ssl;
+#endif
+	Clients* c;
+	MQTTClient_connectionLost* cl;
+	MQTTClient_messageArrived* ma;
+	MQTTClient_deliveryComplete* dc;
+	void* context;
+
+	sem_type connect_sem;
+	int rc; /* getsockopt return code in connect */
+	sem_type connack_sem;
+	sem_type suback_sem;
+	sem_type unsuback_sem;
+	MQTTPacket* pack;
+
+} MQTTClients;
+
+void MQTTClient_sleep(long milliseconds)
+{
+	FUNC_ENTRY;
+#if defined(WIN32)
+	Sleep(milliseconds);
+#else
+	usleep(milliseconds*1000);
+#endif
+	FUNC_EXIT;
+}
+
+
+#if defined(WIN32)
+#define START_TIME_TYPE DWORD
+START_TIME_TYPE MQTTClient_start_clock(void)
+{
+	return GetTickCount();
+}
+#elif defined(AIX)
+#define START_TIME_TYPE struct timespec
+START_TIME_TYPE MQTTClient_start_clock(void)
+{
+	static struct timespec start;
+	clock_gettime(CLOCK_REALTIME, &start);
+	return start;
+}
+#else
+#define START_TIME_TYPE struct timeval
+START_TIME_TYPE MQTTClient_start_clock(void)
+{
+	static struct timeval start;
+	gettimeofday(&start, NULL);
+	return start;
+}
+#endif
+
+
+#if defined(WIN32)
+long MQTTClient_elapsed(DWORD milliseconds)
+{
+	return GetTickCount() - milliseconds;
+}
+#elif defined(AIX)
+#define assert(a)
+long MQTTClient_elapsed(struct timespec start)
+{
+	struct timespec now, res;
+
+	clock_gettime(CLOCK_REALTIME, &now);
+	ntimersub(now, start, res);
+	return (res.tv_sec)*1000L + (res.tv_nsec)/1000000L;
+}
+#else
+long MQTTClient_elapsed(struct timeval start)
+{
+	struct timeval now, res;
+
+	gettimeofday(&now, NULL);
+	timersub(&now, &start, &res);
+	return (res.tv_sec)*1000 + (res.tv_usec)/1000;
+}
+#endif
+
+
+int MQTTClient_create(MQTTClient* handle, char* serverURI, char* clientId,
+		int persistence_type, void* persistence_context)
+{
+	int rc = 0;
+	MQTTClients *m = NULL;
+
+	FUNC_ENTRY;
+	rc = Thread_lock_mutex(mqttclient_mutex);
+
+	if (serverURI == NULL || clientId == NULL)
+	{
+		rc = MQTTCLIENT_NULL_PARAMETER;
+		goto exit;
+	}
+
+	if (!UTF8_validateString(clientId))
+	{
+		rc = MQTTCLIENT_BAD_UTF8_STRING;
+		goto exit;
+	}
+
+	if (!initialized)
+	{
+		#if defined(HEAP_H)
+			Heap_initialize();
+		#endif
+		Log_initialize((Log_nameValue*)MQTTClient_getVersionInfo());
+		bstate->clients = ListInitialize();
+		Socket_outInitialize();
+		Socket_setWriteCompleteCallback(MQTTClient_writeComplete);
+		handles = ListInitialize();
+#if defined(OPENSSL)
+		SSLSocket_initialize();
+#endif
+		initialized = 1;
+	}
+	m = malloc(sizeof(MQTTClients));
+	*handle = m;
+	memset(m, '\0', sizeof(MQTTClients));
+	if (strncmp(URI_TCP, serverURI, strlen(URI_TCP)) == 0)
+		serverURI += strlen(URI_TCP);
+#if defined(OPENSSL)
+	else if (strncmp(URI_SSL, serverURI, strlen(URI_SSL)) == 0)
+	{
+		serverURI += strlen(URI_SSL);
+		m->ssl = 1;
+	}
+#endif
+	m->serverURI = malloc(strlen(serverURI)+1);
+	strcpy(m->serverURI, serverURI);
+	ListAppend(handles, m, sizeof(MQTTClients));
+
+	m->c = malloc(sizeof(Clients));
+	memset(m->c, '\0', sizeof(Clients));
+	m->c->context = m;
+	m->c->outboundMsgs = ListInitialize();
+	m->c->inboundMsgs = ListInitialize();
+	m->c->messageQueue = ListInitialize();
+	m->c->clientID = malloc(strlen(clientId)+1);
+	strcpy(m->c->clientID, clientId);
+	m->connect_sem = Thread_create_sem();
+	m->connack_sem = Thread_create_sem();
+	m->suback_sem = Thread_create_sem();
+	m->unsuback_sem = Thread_create_sem();
+
+#if !defined(NO_PERSISTENCE)
+	rc = MQTTPersistence_create(&(m->c->persistence), persistence_type, persistence_context);
+	if (rc == 0)
+		rc = MQTTPersistence_initialize(m->c, m->serverURI);
+#endif
+	ListAppend(bstate->clients, m->c, sizeof(Clients) + 3*sizeof(List));
+
+exit:
+	Thread_unlock_mutex(mqttclient_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+void MQTTClient_terminate(void)
+{
+	FUNC_ENTRY;
+	MQTTClient_stop();
+	if (initialized)
+	{
+		ListFree(bstate->clients);
+		ListFree(handles);
+		handles = NULL;
+		Socket_outTerminate();
+#if defined(OPENSSL)
+		SSLSocket_terminate();
+#endif
+		#if defined(HEAP_H)
+			Heap_terminate();
+		#endif
+		Log_terminate();
+		initialized = 0;
+	}
+	FUNC_EXIT;
+}
+
+
+void MQTTClient_emptyMessageQueue(Clients* client)
+{
+	FUNC_ENTRY;
+	/* empty message queue */
+	if (client->messageQueue->count > 0)
+	{
+		ListElement* current = NULL;
+		while (ListNextElement(client->messageQueue, &current))
+		{
+			qEntry* qe = (qEntry*)(current->content);
+			free(qe->topicName);
+			free(qe->msg->payload);
+			free(qe->msg);
+		}
+		ListEmpty(client->messageQueue);
+	}
+	FUNC_EXIT;
+}
+
+
+void MQTTClient_destroy(MQTTClient* handle)
+{
+	MQTTClients* m = *handle;
+
+	FUNC_ENTRY;
+	Thread_lock_mutex(mqttclient_mutex);
+
+	if (m == NULL)
+		goto exit;
+
+	if (m->c)
+	{
+		int saved_socket = m->c->net.socket;
+		char* saved_clientid = malloc(strlen(m->c->clientID)+1);
+		strcpy(saved_clientid, m->c->clientID);
+#if !defined(NO_PERSISTENCE)
+		MQTTPersistence_close(m->c);
+#endif
+		MQTTClient_emptyMessageQueue(m->c);
+		MQTTProtocol_freeClient(m->c);
+		if (!ListRemove(bstate->clients, m->c))
+			Log(LOG_ERROR, 0, NULL);
+		else
+			Log(TRACE_MIN, 1, NULL, saved_clientid, saved_socket);
+		free(saved_clientid);
+	}
+	if (m->serverURI)
+		free(m->serverURI);
+	Thread_destroy_sem(m->connect_sem);
+	Thread_destroy_sem(m->connack_sem);
+	Thread_destroy_sem(m->suback_sem);
+	Thread_destroy_sem(m->unsuback_sem);
+	if (!ListRemove(handles, m))
+		Log(LOG_ERROR, -1, "free error");
+	*handle = NULL;
+	if (bstate->clients->count == 0)
+		MQTTClient_terminate();
+
+exit:
+	Thread_unlock_mutex(mqttclient_mutex);
+	FUNC_EXIT;
+}
+
+
+void MQTTClient_freeMessage(MQTTClient_message** message)
+{
+	FUNC_ENTRY;
+	free((*message)->payload);
+	free(*message);
+	*message = NULL;
+	FUNC_EXIT;
+}
+
+
+void MQTTClient_free(void* memory)
+{
+	FUNC_ENTRY;
+	free(memory);
+	FUNC_EXIT;
+}
+
+
+int MQTTClient_deliverMessage(int rc, MQTTClients* m, char** topicName, int* topicLen, MQTTClient_message** message)
+{
+	qEntry* qe = (qEntry*)(m->c->messageQueue->first->content);
+
+	FUNC_ENTRY;
+	*message = qe->msg;
+	*topicName = qe->topicName;
+	*topicLen = qe->topicLen;
+	if (strlen(*topicName) != *topicLen)
+		rc = MQTTCLIENT_TOPICNAME_TRUNCATED;
+	ListRemove(m->c->messageQueue, m->c->messageQueue->first->content);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+/**
+ * List callback function for comparing clients by socket
+ * @param a first integer value
+ * @param b second integer value
+ * @return boolean indicating whether a and b are equal
+ */
+int clientSockCompare(void* a, void* b)
+{
+	MQTTClients* m = (MQTTClients*)a;
+	return m->c->net.socket == *(int*)b;
+}
+
+
+/**
+ * Wrapper function to call connection lost on a separate thread.  A separate thread is needed to allow the
+ * connectionLost function to make API calls (e.g. connect)
+ * @param context a pointer to the relevant client
+ * @return thread_return_type standard thread return value - not used here
+ */
+thread_return_type WINAPI connectionLost_call(void* context)
+{
+	MQTTClients* m = (MQTTClients*)context;
+
+	(*(m->cl))(m->context, NULL);
+	return 0;
+}
+
+
+/* This is the thread function that handles the calling of callback functions if set */
+thread_return_type WINAPI MQTTClient_run(void* n)
+{
+	long timeout = 10L; /* first time in we have a small timeout.  Gets things started more quickly */
+
+	FUNC_ENTRY;
+	running = 1;
+	run_id = Thread_getid();
+
+	Thread_lock_mutex(mqttclient_mutex);
+	while (!tostop)
+	{
+		int rc = SOCKET_ERROR;
+		int sock = -1;
+		MQTTClients* m = NULL;
+		MQTTPacket* pack = NULL;
+
+		Thread_unlock_mutex(mqttclient_mutex);
+		pack = MQTTClient_cycle(&sock, timeout, &rc);
+		Thread_lock_mutex(mqttclient_mutex);
+		if (tostop)
+			break;
+		timeout = 1000L;
+
+		/* find client corresponding to socket */
+		if (ListFindItem(handles, &sock, clientSockCompare) == NULL)
+		{
+			/* assert: should not happen */
+			continue;
+		}
+		m = (MQTTClient)(handles->current->content);
+		if (m == NULL)
+		{
+			/* assert: should not happen */
+			continue;
+		}
+		if (rc == SOCKET_ERROR)
+		{
+			Thread_unlock_mutex(mqttclient_mutex);
+			MQTTClient_disconnect_internal(m, 0);
+			Thread_lock_mutex(mqttclient_mutex);
+		}
+		else
+		{
+			if (m->c->messageQueue->count > 0)
+			{
+				qEntry* qe = (qEntry*)(m->c->messageQueue->first->content);
+				int topicLen = qe->topicLen;
+
+				if (strlen(qe->topicName) == topicLen)
+					topicLen = 0;
+
+				Log(TRACE_MIN, -1, "Calling messageArrived for client %s, queue depth %d",
+					m->c->clientID, m->c->messageQueue->count);
+				Thread_unlock_mutex(mqttclient_mutex);
+				rc = (*(m->ma))(m->context, qe->topicName, topicLen, qe->msg);
+				Thread_lock_mutex(mqttclient_mutex);
+				/* if 0 (false) is returned by the callback then it failed, so we don't remove the message from
+				 * the queue, and it will be retried later.  If 1 is returned then the message data may have been freed,
+				 * so we must be careful how we use it.
+				 */
+				if (rc)
+					ListRemove(m->c->messageQueue, qe);
+				else
+					Log(TRACE_MIN, -1, "False returned from messageArrived for client %s, message remains on queue",
+						m->c->clientID);
+			}
+			if (pack)
+			{
+				if (pack->header.bits.type == CONNACK)
+				{
+					Log(TRACE_MIN, -1, "Posting connack semaphore for client %s", m->c->clientID);
+					m->pack = pack;
+					Thread_post_sem(m->connack_sem);
+				}
+				else if (pack->header.bits.type == SUBACK)
+				{
+					Log(TRACE_MIN, -1, "Posting suback semaphore for client %s", m->c->clientID);
+					m->pack = pack;
+					Thread_post_sem(m->suback_sem);
+				}
+				else if (pack->header.bits.type == UNSUBACK)
+				{
+					Log(TRACE_MIN, -1, "Posting unsuback semaphore for client %s", m->c->clientID);
+					m->pack = pack;
+					Thread_post_sem(m->unsuback_sem);
+				}
+			}
+			else if (m->c->connect_state == 1 && !Thread_check_sem(m->connect_sem))
+			{
+				int error;
+				socklen_t len = sizeof(error);
+
+				if ((m->rc = getsockopt(m->c->net.socket, SOL_SOCKET, SO_ERROR, (char*)&error, &len)) == 0)
+					m->rc = error;
+				Log(TRACE_MIN, -1, "Posting connect semaphore for client %s rc %d", m->c->clientID, m->rc);
+				Thread_post_sem(m->connect_sem);
+			}
+#if defined(OPENSSL)
+			else if (m->c->connect_state == 2 && !Thread_check_sem(m->connect_sem))
+			{			
+				rc = SSLSocket_connect(m->c->net.ssl, m->c->net.socket);
+				if (rc == 1 || rc == SSL_FATAL)
+				{
+					if (rc == 1 && !m->c->cleansession && m->c->session == NULL)
+						m->c->session = SSL_get1_session(m->c->net.ssl);
+					m->rc = rc;
+					Log(TRACE_MIN, -1, "Posting connect semaphore for SSL client %s rc %d", m->c->clientID, m->rc);
+					Thread_post_sem(m->connect_sem);
+				}
+			}
+#endif
+		}
+	}
+	run_id = 0;
+	running = tostop = 0;
+	Thread_unlock_mutex(mqttclient_mutex);
+	FUNC_EXIT;
+	return 0;
+}
+
+
+void MQTTClient_stop()
+{
+	int rc = 0;
+
+	FUNC_ENTRY;
+	if (running == 1 && tostop == 0)
+	{
+		int conn_count = 0;
+		ListElement* current = NULL;
+
+		if (handles != NULL)
+		{
+			/* find out how many handles are still connected */
+			while (ListNextElement(handles, &current))
+			{
+				if (((MQTTClients*)(current->content))->c->connect_state > 0 ||
+						((MQTTClients*)(current->content))->c->connected)
+					++conn_count;
+			}
+		}
+		Log(TRACE_MIN, -1, "Conn_count is %d", conn_count);
+		/* stop the background thread, if we are the last one to be using it */
+		if (conn_count == 0)
+		{
+			int count = 0;
+			tostop = 1;
+			if (Thread_getid() != run_id)
+			{
+				while (running && ++count < 100)
+				{
+					Thread_unlock_mutex(mqttclient_mutex);
+					Log(TRACE_MIN, -1, "sleeping");
+					MQTTClient_sleep(100L);
+					Thread_lock_mutex(mqttclient_mutex);
+				}
+			}
+			rc = 1;
+		}
+	}
+	FUNC_EXIT_RC(rc);
+}
+
+
+int MQTTClient_setCallbacks(MQTTClient handle, void* context, MQTTClient_connectionLost* cl,
+														MQTTClient_messageArrived* ma, MQTTClient_deliveryComplete* dc)
+{
+	int rc = MQTTCLIENT_SUCCESS;
+	MQTTClients* m = handle;
+
+	FUNC_ENTRY;
+	Thread_lock_mutex(mqttclient_mutex);
+
+	if (m == NULL || ma == NULL || m->c->connect_state != 0)
+		rc = MQTTCLIENT_FAILURE;
+	else
+	{
+		m->context = context;
+		m->cl = cl;
+		m->ma = ma;
+		m->dc = dc;
+	}
+
+	Thread_unlock_mutex(mqttclient_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+void MQTTClient_closeSession(Clients* client)
+{
+	FUNC_ENTRY;
+	client->good = 0;
+	client->ping_outstanding = 0;
+	if (client->net.socket > 0)
+	{
+		if (client->connected || client->connect_state)
+		{
+			MQTTPacket_send_disconnect(&client->net, client->clientID);
+			client->connected = 0;
+			client->connect_state = 0;
+		}
+#if defined(OPENSSL)
+		SSLSocket_close(&client->net);
+#endif
+		Socket_close(client->net.socket);
+		client->net.socket = 0;
+#if defined(OPENSSL)
+		client->net.ssl = NULL;
+#endif
+	}
+
+	if (client->cleansession)
+		MQTTClient_cleanSession(client);
+	FUNC_EXIT;
+}
+
+
+int MQTTClient_cleanSession(Clients* client)
+{
+	int rc = 0;
+
+	FUNC_ENTRY;
+#if !defined(NO_PERSISTENCE)
+	rc = MQTTPersistence_clear(client);
+#endif
+	MQTTProtocol_emptyMessageList(client->inboundMsgs);
+	MQTTProtocol_emptyMessageList(client->outboundMsgs);
+	MQTTClient_emptyMessageQueue(client);
+	client->msgID = 0;
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+void Protocol_processPublication(Publish* publish, Clients* client)
+{
+	qEntry* qe = NULL;
+	MQTTClient_message* mm = NULL;
+
+	FUNC_ENTRY;
+	qe = malloc(sizeof(qEntry));
+	mm = malloc(sizeof(MQTTClient_message));
+
+	qe->msg = mm;
+
+	qe->topicName = publish->topic;
+	qe->topicLen = publish->topiclen;
+	publish->topic = NULL;
+
+	/* If the message is QoS 2, then we have already stored the incoming payload
+	 * in an allocated buffer, so we don't need to copy again.
+	 */
+	if (publish->header.bits.qos == 2)
+		mm->payload = publish->payload;
+	else
+	{
+		mm->payload = malloc(publish->payloadlen);
+		memcpy(mm->payload, publish->payload, publish->payloadlen);
+	}
+
+	mm->payloadlen = publish->payloadlen;
+	mm->qos = publish->header.bits.qos;
+	mm->retained = publish->header.bits.retain;
+	if (publish->header.bits.qos == 2)
+		mm->dup = 0;  /* ensure that a QoS2 message is not passed to the application with dup = 1 */
+	else
+		mm->dup = publish->header.bits.dup;
+	mm->msgid = publish->msgId;
+
+	ListAppend(client->messageQueue, qe, sizeof(qe) + sizeof(mm) + mm->payloadlen + strlen(qe->topicName)+1);
+	FUNC_EXIT;
+}
+
+
+int MQTTClient_connectURI(MQTTClient handle, MQTTClient_connectOptions* options, char* serverURI)
+{
+	MQTTClients* m = handle;
+	START_TIME_TYPE start;
+	long millisecsTimeout = 30000L;
+	int rc = SOCKET_ERROR;
+
+	FUNC_ENTRY;
+	millisecsTimeout = options->connectTimeout * 1000;
+	start = MQTTClient_start_clock();
+	if (m->ma && !running)
+	{
+		Thread_start(MQTTClient_run, handle);
+		if (MQTTClient_elapsed(start) >= millisecsTimeout)
+		{
+			rc = SOCKET_ERROR;
+			goto exit;
+		}
+		MQTTClient_sleep(100L);
+	}
+
+	m->c->keepAliveInterval = options->keepAliveInterval;
+	m->c->cleansession = options->cleansession;
+	m->c->maxInflightMessages = (options->reliable) ? 1 : 10;
+
+	if (m->c->will)
+	{
+		free(m->c->will->msg);
+		free(m->c->will->topic);
+		free(m->c->will);
+		m->c->will = NULL;
+	}
+
+	if (options->will && options->will->struct_version == 0)
+	{
+		m->c->will = malloc(sizeof(willMessages));
+		m->c->will->msg = malloc(strlen(options->will->message) + 1); 
+		strcpy(m->c->will->msg, options->will->message);
+		m->c->will->qos = options->will->qos;
+		m->c->will->retained = options->will->retained;
+		m->c->will->topic = malloc(strlen(options->will->topicName) + 1);
+		strcpy(m->c->will->topic, options->will->topicName);
+	}
+	
+#if defined(OPENSSL)
+	if (m->c->sslopts)
+	{
+		if (m->c->sslopts->trustStore)
+			free(m->c->sslopts->trustStore);
+		if (m->c->sslopts->keyStore)
+			free(m->c->sslopts->keyStore);
+		if (m->c->sslopts->privateKey)
+			free(m->c->sslopts->privateKey);
+		if (m->c->sslopts->privateKeyPassword)
+			free(m->c->sslopts->privateKeyPassword);
+		if (m->c->sslopts->enabledCipherSuites)
+			free(m->c->sslopts->enabledCipherSuites);
+		free(m->c->sslopts);
+		m->c->sslopts = NULL;
+	}
+
+	if (options->struct_version != 0 && options->ssl)
+	{
+		m->c->sslopts = malloc(sizeof(MQTTClient_SSLOptions));
+		memset(m->c->sslopts, '\0', sizeof(MQTTClient_SSLOptions));
+		if (options->ssl->trustStore)
+		{
+			m->c->sslopts->trustStore = malloc(strlen(options->ssl->trustStore) + 1);
+			strcpy(m->c->sslopts->trustStore, options->ssl->trustStore); 
+		}
+		if (options->ssl->keyStore)
+		{
+			m->c->sslopts->keyStore = malloc(strlen(options->ssl->keyStore) + 1);
+			strcpy(m->c->sslopts->keyStore, options->ssl->keyStore);
+		}
+		if (options->ssl->privateKey)
+		{
+			m->c->sslopts->privateKey = malloc(strlen(options->ssl->privateKey) + 1);
+			strcpy(m->c->sslopts->privateKey, options->ssl->privateKey);
+		}
+		if (options->ssl->privateKeyPassword)
+		{
+			m->c->sslopts->privateKeyPassword = malloc(strlen(options->ssl->privateKeyPassword) + 1);
+			strcpy(m->c->sslopts->privateKeyPassword, options->ssl->privateKeyPassword);
+		}
+		if (options->ssl->enabledCipherSuites)
+		{
+			m->c->sslopts->enabledCipherSuites = malloc(strlen(options->ssl->enabledCipherSuites) + 1);
+			strcpy(m->c->sslopts->enabledCipherSuites, options->ssl->enabledCipherSuites);
+		}
+		m->c->sslopts->enableServerCertAuth = options->ssl->enableServerCertAuth;
+	}
+#endif
+
+	m->c->username = options->username;
+	m->c->password = options->password;
+	m->c->retryInterval = options->retryInterval;
+
+	Log(TRACE_MIN, -1, "Connecting to serverURI %s", serverURI);
+#if defined(OPENSSL)
+	rc = MQTTProtocol_connect(serverURI, m->c, m->ssl);
+#else
+	rc = MQTTProtocol_connect(serverURI, m->c);
+#endif
+	if (rc == SOCKET_ERROR)
+		goto exit;
+
+	if (m->c->connect_state == 0)
+	{
+		rc = SOCKET_ERROR;
+		goto exit;
+	}
+
+	if (m->c->connect_state == 1) /* TCP connect started - wait for completion */
+	{
+		Thread_unlock_mutex(mqttclient_mutex);
+		MQTTClient_waitfor(handle, CONNECT, &rc, millisecsTimeout - MQTTClient_elapsed(start));
+		Thread_lock_mutex(mqttclient_mutex);
+		if (rc != 0)
+		{
+			rc = SOCKET_ERROR;
+			goto exit;
+		}
+		
+#if defined(OPENSSL)
+		if (m->ssl)
+		{
+			if (SSLSocket_setSocketForSSL(&m->c->net, m->c->sslopts) != MQTTCLIENT_SUCCESS)
+			{
+				if (m->c->session != NULL)
+					if ((rc = SSL_set_session(m->c->net.ssl, m->c->session)) != 1)
+						Log(TRACE_MIN, -1, "Failed to set SSL session with stored data, non critical");
+				rc = SSLSocket_connect(m->c->net.ssl, m->c->net.socket);
+				if (rc == -1)
+					m->c->connect_state = 2;
+				else if (rc == SSL_FATAL)
+				{
+					rc = SOCKET_ERROR;
+					goto exit;
+				}
+				else if (rc == 1) {
+					rc = MQTTCLIENT_SUCCESS;
+					m->c->connect_state = 3;
+					if (MQTTPacket_send_connect(m->c) == SOCKET_ERROR)
+					{
+						rc = SOCKET_ERROR;
+						goto exit;
+					}
+					if(!m->c->cleansession && m->c->session == NULL)
+						m->c->session = SSL_get1_session(m->c->net.ssl);
+				}
+			}
+			else
+			{
+				rc = SOCKET_ERROR;
+				goto exit;
+			}
+		}
+		else
+		{
+#endif
+			m->c->connect_state = 3; /* TCP connect completed, in which case send the MQTT connect packet */
+			if (MQTTPacket_send_connect(m->c) == SOCKET_ERROR)
+			{
+				rc = SOCKET_ERROR;
+				goto exit;
+			}
+#if defined(OPENSSL)
+		}
+#endif
+	}
+	
+#if defined(OPENSSL)
+	if (m->c->connect_state == 2) /* SSL connect sent - wait for completion */
+	{
+		Thread_unlock_mutex(mqttclient_mutex);
+		MQTTClient_waitfor(handle, CONNECT, &rc, millisecsTimeout - MQTTClient_elapsed(start));
+		Thread_lock_mutex(mqttclient_mutex);
+		if (rc != 1)
+		{
+			rc = SOCKET_ERROR;
+			goto exit;
+		}
+		if(!m->c->cleansession && m->c->session == NULL)
+			m->c->session = SSL_get1_session(m->c->net.ssl);
+		m->c->connect_state = 3; /* TCP connect completed, in which case send the MQTT connect packet */
+		if (MQTTPacket_send_connect(m->c) == SOCKET_ERROR)
+		{
+			rc = SOCKET_ERROR;
+			goto exit;
+		}
+	}
+#endif
+
+	if (m->c->connect_state == 3) /* MQTT connect sent - wait for CONNACK */
+	{
+		MQTTPacket* pack = NULL;
+
+		Thread_unlock_mutex(mqttclient_mutex);
+		pack = MQTTClient_waitfor(handle, CONNACK, &rc, millisecsTimeout - MQTTClient_elapsed(start));
+		Thread_lock_mutex(mqttclient_mutex);
+		if (pack == NULL)
+			rc = SOCKET_ERROR;
+		else
+		{
+			Connack* connack = (Connack*)pack;
+			Log(LOG_PROTOCOL, 1, NULL, m->c->net.socket, m->c->clientID, connack->rc);
+			if ((rc = connack->rc) == MQTTCLIENT_SUCCESS)
+			{
+				m->c->connected = 1;
+				m->c->good = 1;
+				m->c->connect_state = 0;
+				if (m->c->cleansession)
+					rc = MQTTClient_cleanSession(m->c);
+				if (m->c->outboundMsgs->count > 0)
+				{
+					ListElement* outcurrent = NULL;
+
+					while (ListNextElement(m->c->outboundMsgs, &outcurrent))
+					{
+						Messages* m = (Messages*)(outcurrent->content);
+						m->lastTouch = 0;
+					}
+					MQTTProtocol_retry(m->c->net.lastContact, 1);
+					if (m->c->connected != 1)
+						rc = MQTTCLIENT_DISCONNECTED;
+				}
+			}
+			free(connack);
+			m->pack = NULL;
+		}
+	}
+
+exit:
+	if (rc != MQTTCLIENT_SUCCESS)
+	{
+		Thread_unlock_mutex(mqttclient_mutex);
+		MQTTClient_disconnect(handle, 0); /* not "internal" because we don't want to call connection lost */
+		Thread_lock_mutex(mqttclient_mutex);
+	}
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTClient_connect(MQTTClient handle, MQTTClient_connectOptions* options)
+{
+	MQTTClients* m = handle;
+	int rc = SOCKET_ERROR;
+
+	FUNC_ENTRY;
+	Thread_lock_mutex(mqttclient_mutex);
+
+	if (options == NULL)
+	{
+		rc = MQTTCLIENT_NULL_PARAMETER;
+		goto exit;
+	}
+
+	if (strncmp(options->struct_id, "MQTC", 4) != 0 || 
+		(options->struct_version != 0 && options->struct_version != 1 && options->struct_version != 2))
+	{
+		rc = MQTTCLIENT_BAD_STRUCTURE;
+		goto exit;
+	}
+
+	if (options->will) /* check validity of will options structure */
+	{
+		if (strncmp(options->will->struct_id, "MQTW", 4) != 0 || options->will->struct_version != 0)
+		{
+			rc = MQTTCLIENT_BAD_STRUCTURE;
+			goto exit;
+		}
+	}
+	
+#if defined(OPENSSL)
+	if (options->struct_version != 0 && options->ssl) /* check validity of SSL options structure */
+	{
+		if (strncmp(options->ssl->struct_id, "MQTS", 4) != 0 || options->ssl->struct_version != 0)
+		{
+			rc = MQTTCLIENT_BAD_STRUCTURE;
+			goto exit;
+		}
+	}
+#endif
+
+	if ((options->username && !UTF8_validateString(options->username)) ||
+		(options->password && !UTF8_validateString(options->password)))
+	{
+		rc = MQTTCLIENT_BAD_UTF8_STRING;
+		goto exit;
+	}
+
+	if (options->struct_version < 2 || options->serverURIcount == 0)
+		rc = MQTTClient_connectURI(handle, options, m->serverURI);
+	else
+	{
+		int i;
+		
+		for (i = 0; i < options->serverURIcount; ++i)
+		{
+			char* serverURI = options->serverURIs[i];
+			
+			if (strncmp(URI_TCP, serverURI, strlen(URI_TCP)) == 0)
+				serverURI += strlen(URI_TCP);
+#if defined(OPENSSL)
+			else if (strncmp(URI_SSL, serverURI, strlen(URI_SSL)) == 0)
+			{
+				serverURI += strlen(URI_SSL);
+				m->ssl = 1;
+			}
+#endif
+			if ((rc = MQTTClient_connectURI(handle, options, serverURI)) == MQTTCLIENT_SUCCESS)
+				break;
+		}	
+	}
+
+exit:
+	if (m->c->will)
+	{
+		free(m->c->will);
+		m->c->will = NULL;
+	}
+	Thread_unlock_mutex(mqttclient_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTClient_disconnect1(MQTTClient handle, int timeout, int internal)
+{
+	MQTTClients* m = handle;
+	START_TIME_TYPE start;
+	int rc = MQTTCLIENT_SUCCESS;
+	int was_connected = 0;
+
+	FUNC_ENTRY;
+	Thread_lock_mutex(mqttclient_mutex);
+
+	if (m == NULL || m->c == NULL)
+	{
+		rc = MQTTCLIENT_FAILURE;
+		goto exit;
+	}
+	if (m->c->connected == 0 && m->c->connect_state == 0)
+	{
+		rc = MQTTCLIENT_DISCONNECTED;
+		goto exit;
+	}
+	was_connected = m->c->connected; /* should be 1 */
+	if (m->c->connected != 0)
+	{
+		start = MQTTClient_start_clock();
+		m->c->connect_state = -2; /* indicate disconnecting */
+		while (m->c->inboundMsgs->count > 0 || m->c->outboundMsgs->count > 0)
+		{ /* wait for all inflight message flows to finish, up to timeout */
+			if (MQTTClient_elapsed(start) >= timeout)
+				break;
+			Thread_unlock_mutex(mqttclient_mutex);
+			MQTTClient_yield();
+			Thread_lock_mutex(mqttclient_mutex);
+		}
+	}
+
+	MQTTClient_closeSession(m->c);
+
+	if (Thread_check_sem(m->connect_sem))
+		Thread_post_sem(m->connect_sem);
+	if (Thread_check_sem(m->connack_sem))
+		Thread_post_sem(m->connack_sem);
+	if (Thread_check_sem(m->suback_sem))
+		Thread_post_sem(m->suback_sem);
+	if (Thread_check_sem(m->unsuback_sem))
+		Thread_post_sem(m->unsuback_sem);
+
+exit:
+	MQTTClient_stop();
+	if (internal && m->cl && was_connected)
+	{
+		Log(TRACE_MIN, -1, "Calling connectionLost for client %s", m->c->clientID);
+		Thread_start(connectionLost_call, m);
+	}
+	Thread_unlock_mutex(mqttclient_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTClient_disconnect_internal(MQTTClient handle, int timeout)
+{
+	return MQTTClient_disconnect1(handle, timeout, 1);
+}
+
+
+void MQTTProtocol_closeSession(Clients* c, int sendwill)
+{
+	MQTTClient_disconnect_internal((MQTTClient)c->context, 0);
+}
+
+
+int MQTTClient_disconnect(MQTTClient handle, int timeout)
+{
+	return MQTTClient_disconnect1(handle, timeout, 0);
+}
+
+
+int MQTTClient_isConnected(MQTTClient handle)
+{
+	MQTTClients* m = handle;
+	int rc = 0;
+
+	FUNC_ENTRY;
+	Thread_lock_mutex(mqttclient_mutex);
+	if (m && m->c)
+		rc = m->c->connected;
+	Thread_unlock_mutex(mqttclient_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTClient_subscribeMany(MQTTClient handle, int count, char** topic, int* qos)
+{
+	MQTTClients* m = handle;
+	List* topics = ListInitialize();
+	List* qoss = ListInitialize();
+	int i = 0;
+	int rc = MQTTCLIENT_FAILURE;
+
+	FUNC_ENTRY;
+	Thread_lock_mutex(mqttclient_mutex);
+
+	if (m == NULL || m->c == NULL)
+	{
+		rc = MQTTCLIENT_FAILURE;
+		goto exit;
+	}
+	if (m->c->connected == 0)
+	{
+		rc = MQTTCLIENT_DISCONNECTED;
+		goto exit;
+	}
+	for (i = 0; i < count; i++)
+	{
+		if (!UTF8_validateString(topic[i]))
+		{
+			rc = MQTTCLIENT_BAD_UTF8_STRING;
+			goto exit;
+		}
+		
+		if(qos[i] < 0 || qos[i] > 2)
+		{
+			rc = MQTTCLIENT_BAD_QOS;
+			goto exit;
+		}
+	}
+
+	for (i = 0; i < count; i++)
+	{
+		ListAppend(topics, topic[i], strlen(topic[i]));
+		ListAppend(qoss, &qos[i], sizeof(int));
+	}
+	rc = MQTTProtocol_subscribe(m->c, topics, qoss);
+	ListFreeNoContent(topics);
+	ListFreeNoContent(qoss);
+
+	if (rc == TCPSOCKET_COMPLETE)
+	{
+		MQTTPacket* pack = NULL;
+
+		Thread_unlock_mutex(mqttclient_mutex);
+		pack = MQTTClient_waitfor(handle, SUBACK, &rc, 10000L);
+		Thread_lock_mutex(mqttclient_mutex);
+		if (pack != NULL)
+		{
+			rc = MQTTProtocol_handleSubacks(pack, m->c->net.socket);
+			m->pack = NULL;
+		}
+		else
+			rc = SOCKET_ERROR;
+	}
+
+	if (rc == SOCKET_ERROR)
+	{
+		Thread_unlock_mutex(mqttclient_mutex);
+		MQTTClient_disconnect_internal(handle, 0);
+		Thread_lock_mutex(mqttclient_mutex);
+	}
+	else if (rc == TCPSOCKET_COMPLETE)
+		rc = MQTTCLIENT_SUCCESS;
+
+exit:
+	Thread_unlock_mutex(mqttclient_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTClient_subscribe(MQTTClient handle, char* topic, int qos)
+{
+	int rc = 0;
+
+	FUNC_ENTRY;
+	rc = MQTTClient_subscribeMany(handle, 1, &topic, &qos);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTClient_unsubscribeMany(MQTTClient handle, int count, char** topic)
+{
+	MQTTClients* m = handle;
+	List* topics = ListInitialize();
+	int i = 0;
+	int rc = SOCKET_ERROR;
+
+	FUNC_ENTRY;
+	Thread_lock_mutex(mqttclient_mutex);
+
+	if (m == NULL || m->c == NULL)
+	{
+		rc = MQTTCLIENT_FAILURE;
+		goto exit;
+	}
+	if (m->c->connected == 0)
+	{
+		rc = MQTTCLIENT_DISCONNECTED;
+		goto exit;
+	}
+
+	for (i = 0; i < count; i++)
+	{
+		if (!UTF8_validateString(topic[i]))
+		{
+			rc = MQTTCLIENT_BAD_UTF8_STRING;
+			goto exit;
+		}
+	}
+
+	for (i = 0; i < count; i++)
+		ListAppend(topics, topic[i], strlen(topic[i]));
+	rc = MQTTProtocol_unsubscribe(m->c, topics);
+	ListFreeNoContent(topics);
+
+	if (rc == TCPSOCKET_COMPLETE)
+	{
+		MQTTPacket* pack = NULL;
+
+		Thread_unlock_mutex(mqttclient_mutex);
+		pack = MQTTClient_waitfor(handle, UNSUBACK, &rc, 10000L);
+		Thread_lock_mutex(mqttclient_mutex);
+		if (pack != NULL)
+		{
+			rc = MQTTProtocol_handleUnsubacks(pack, m->c->net.socket);
+			m->pack = NULL;
+		}
+		else
+			rc = SOCKET_ERROR;
+	}
+
+	if (rc == SOCKET_ERROR)
+	{
+		Thread_unlock_mutex(mqttclient_mutex);
+		MQTTClient_disconnect_internal(handle, 0);
+		Thread_lock_mutex(mqttclient_mutex);
+	}
+
+exit:
+	Thread_unlock_mutex(mqttclient_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTClient_unsubscribe(MQTTClient handle, char* topic)
+{
+	int rc = 0;
+
+	FUNC_ENTRY;
+	rc = MQTTClient_unsubscribeMany(handle, 1, &topic);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTClient_publish(MQTTClient handle, char* topicName, int payloadlen, void* payload,
+							 int qos, int retained, MQTTClient_deliveryToken* deliveryToken)
+{
+	int rc = MQTTCLIENT_SUCCESS;
+	MQTTClients* m = handle;
+	Messages* msg = NULL;
+	Publish* p = NULL;
+	int blocked = 0;
+
+	FUNC_ENTRY;
+	Thread_lock_mutex(mqttclient_mutex);
+
+	if (m == NULL || m->c == NULL)
+		rc = MQTTCLIENT_FAILURE;
+	else if (m->c->connected == 0)
+		rc = MQTTCLIENT_DISCONNECTED;
+	else if (!UTF8_validateString(topicName))
+		rc = MQTTCLIENT_BAD_UTF8_STRING;
+	if (rc != MQTTCLIENT_SUCCESS)
+		goto exit;
+
+	/* If outbound queue is full, block until it is not */
+	while (m->c->outboundMsgs->count >= m->c->maxInflightMessages || 
+         Socket_noPendingWrites(m->c->net.socket) == 0) /* wait until the socket is free of large packets being written */
+	{
+		if (blocked == 0)
+		{
+			blocked = 1;
+			Log(TRACE_MIN, -1, "Blocking publish on queue full for client %s", m->c->clientID);
+		}
+		Thread_unlock_mutex(mqttclient_mutex);
+		MQTTClient_yield();
+		Thread_lock_mutex(mqttclient_mutex);
+		if (m->c->connected == 0)
+		{
+			rc = MQTTCLIENT_FAILURE;
+			goto exit;
+		}
+	}
+	if (blocked == 1)
+		Log(TRACE_MIN, -1, "Resuming publish now queue not full for client %s", m->c->clientID);
+
+	p = malloc(sizeof(Publish));
+
+	p->payload = payload;
+	p->payloadlen = payloadlen;
+	p->topic = topicName;
+	p->msgId = -1;
+
+	rc = MQTTProtocol_startPublish(m->c, p, qos, retained, &msg);
+
+	/* If the packet was partially written to the socket, wait for it to complete.
+	 * However, if the client is disconnected during this time and qos is not 0, still return success, as
+	 * the packet has already been written to persistence and assigned a message id so will
+	 * be sent when the client next connects.
+	 */
+	if (rc == TCPSOCKET_INTERRUPTED)
+	{
+		while (m->c->connected == 1 && SocketBuffer_getWrite(m->c->net.socket))
+		{
+			Thread_unlock_mutex(mqttclient_mutex);
+			MQTTClient_yield();
+			Thread_lock_mutex(mqttclient_mutex);
+		}
+		rc = (qos > 0 || m->c->connected == 1) ? MQTTCLIENT_SUCCESS : MQTTCLIENT_FAILURE;
+	}
+
+	if (deliveryToken && qos > 0)
+		*deliveryToken = msg->msgid;
+
+	free(p);
+
+	if (rc == SOCKET_ERROR)
+	{
+		Thread_unlock_mutex(mqttclient_mutex);
+		MQTTClient_disconnect_internal(handle, 0);
+		Thread_lock_mutex(mqttclient_mutex);
+		/* Return success for qos > 0 as the send will be retried automatically */
+		rc = (qos > 0) ? MQTTCLIENT_SUCCESS : MQTTCLIENT_FAILURE;
+	}
+
+exit:
+	Thread_unlock_mutex(mqttclient_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+
+int MQTTClient_publishMessage(MQTTClient handle, char* topicName, MQTTClient_message* message,
+															 MQTTClient_deliveryToken* deliveryToken)
+{
+	int rc = MQTTCLIENT_SUCCESS;
+
+	FUNC_ENTRY;
+	if (message == NULL)
+	{
+		rc = MQTTCLIENT_NULL_PARAMETER;
+		goto exit;
+	}
+
+	if (strncmp(message->struct_id, "MQTM", 4) != 0 || message->struct_version != 0)
+	{
+		rc = MQTTCLIENT_BAD_STRUCTURE;
+		goto exit;
+	}
+
+	rc = MQTTClient_publish(handle, topicName, message->payloadlen, message->payload,
+								message->qos, message->retained, deliveryToken);
+exit:
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+void MQTTClient_retry(void)
+{
+	time_t now;
+
+	FUNC_ENTRY;
+	time(&(now));
+	if (difftime(now, last) > 5)
+	{
+		time(&(last));
+		MQTTProtocol_keepalive(now);
+		MQTTProtocol_retry(now, 1);
+	}
+	else
+		MQTTProtocol_retry(now, 0);
+	FUNC_EXIT;
+}
+
+
+MQTTPacket* MQTTClient_cycle(int* sock, unsigned long timeout, int* rc)
+{
+	struct timeval tp = {0L, 0L};
+	static Ack ack;
+	MQTTPacket* pack = NULL;
+
+	FUNC_ENTRY;
+	if (timeout > 0L)
+	{
+		tp.tv_sec = timeout / 1000;
+		tp.tv_usec = (timeout % 1000) * 1000; /* this field is microseconds! */
+	}
+
+#if defined(OPENSSL)
+	if ((*sock = SSLSocket_getPendingRead()) == -1)
+	{
+		/* 0 from getReadySocket indicates no work to do, -1 == error, but can happen normally */
+#endif
+		*sock = Socket_getReadySocket(0, &tp);
+#if defined(OPENSSL)
+	}
+#endif
+	Thread_lock_mutex(mqttclient_mutex);
+	if (*sock > 0)
+	{
+		MQTTClients* m = NULL;
+		if (ListFindItem(handles, sock, clientSockCompare) != NULL)
+			m = (MQTTClient)(handles->current->content);
+		if (m != NULL)
+		{
+			if (m->c->connect_state == 1 || m->c->connect_state == 2)
+				*rc = 0;  /* waiting for connect state to clear */
+			else
+			{
+				pack = MQTTPacket_Factory(&m->c->net, rc);
+				if (*rc == TCPSOCKET_INTERRUPTED)
+					*rc = 0;
+			}
+		}
+		if (pack)
+		{
+			int freed = 1;
+
+			/* Note that these handle... functions free the packet structure that they are dealing with */
+			if (pack->header.bits.type == PUBLISH)
+				*rc = MQTTProtocol_handlePublishes(pack, *sock);
+			else if (pack->header.bits.type == PUBACK || pack->header.bits.type == PUBCOMP)
+			{
+				int msgid;
+
+				ack = (pack->header.bits.type == PUBCOMP) ? *(Pubcomp*)pack : *(Puback*)pack;
+				msgid = ack.msgId;
+				*rc = (pack->header.bits.type == PUBCOMP) ?
+						MQTTProtocol_handlePubcomps(pack, *sock) : MQTTProtocol_handlePubacks(pack, *sock);
+				if (m && m->dc)
+				{
+					Log(TRACE_MIN, -1, "Calling deliveryComplete for client %s, msgid %d", m->c->clientID, msgid);
+					(*(m->dc))(m->context, msgid);
+				}
+			}
+			else if (pack->header.bits.type == PUBREC)
+				*rc = MQTTProtocol_handlePubrecs(pack, *sock);
+			else if (pack->header.bits.type == PUBREL)
+				*rc = MQTTProtocol_handlePubrels(pack, *sock);
+			else if (pack->header.bits.type == PINGRESP)
+				*rc = MQTTProtocol_handlePingresps(pack, *sock);
+			else
+				freed = 0;
+			if (freed)
+				pack = NULL;
+		}
+	}
+	MQTTClient_retry();
+	Thread_unlock_mutex(mqttclient_mutex);
+	FUNC_EXIT_RC(*rc);
+	return pack;
+}
+
+
+MQTTPacket* MQTTClient_waitfor(MQTTClient handle, int packet_type, int* rc, long timeout)
+{
+	MQTTPacket* pack = NULL;
+	MQTTClients* m = handle;
+	START_TIME_TYPE start = MQTTClient_start_clock();
+
+	FUNC_ENTRY;
+	if (((MQTTClients*)handle) == NULL)
+	{
+		*rc = MQTTCLIENT_FAILURE;
+		goto exit;
+	}
+
+	if (running)
+	{
+		if (packet_type == CONNECT)
+		{
+			if ((*rc = Thread_wait_sem(m->connect_sem, timeout)) == 0)
+				*rc = m->rc;
+		}
+		else if (packet_type == CONNACK)
+			*rc = Thread_wait_sem(m->connack_sem, timeout);
+		else if (packet_type == SUBACK)
+			*rc = Thread_wait_sem(m->suback_sem, timeout);
+		else if (packet_type == UNSUBACK)
+			*rc = Thread_wait_sem(m->unsuback_sem, timeout);
+		if (*rc == 0 && packet_type != CONNECT && m->pack == NULL)
+			Log(TRACE_MIN, -1, "waitfor unexpectedly is NULL for client %s, packet_type %d", m->c->clientID, packet_type);
+		pack = m->pack;
+	}
+	else
+	{
+		*rc = TCPSOCKET_COMPLETE;
+		while (1)
+		{
+			int sock = -1;
+			pack = MQTTClient_cycle(&sock, 100L, rc);
+			if (sock == m->c->net.socket)
+			{
+				if (pack && (pack->header.bits.type == packet_type))
+					break;
+				if (m->c->connect_state == 1)
+				{
+					int error;
+					socklen_t len = sizeof(error);
+
+					if ((*rc = getsockopt(m->c->net.socket, SOL_SOCKET, SO_ERROR, (char*)&error, &len)) == 0)
+						*rc = error;
+					break;
+				}
+#if defined(OPENSSL)
+				else if (m->c->connect_state == 2)
+				{
+					*rc = SSLSocket_connect(m->c->net.ssl, sock);
+					if (*rc == SSL_FATAL)
+						break;
+					else if (*rc == 1) /* rc == 1 means SSL connect has finished and succeeded */
+					{
+						if (!m->c->cleansession && m->c->session == NULL)
+							m->c->session = SSL_get1_session(m->c->net.ssl);
+						break;
+					}
+				}
+#endif
+				else if (m->c->connect_state == 3)
+				{
+					int error;
+					socklen_t len = sizeof(error);
+
+					if (getsockopt(m->c->net.socket, SOL_SOCKET, SO_ERROR, (char*)&error, &len) == 0)
+					{
+						if (error)
+						{
+							*rc = error;
+							break;
+						}
+					}
+				}
+			}
+			if (MQTTClient_elapsed(start) > timeout)
+			{
+				pack = NULL;
+				break;
+			}
+		}
+	}
+
+exit:
+	FUNC_EXIT_RC(*rc);
+	return pack;
+}
+
+
+int MQTTClient_receive(MQTTClient handle, char** topicName, int* topicLen, MQTTClient_message** message,
+											 unsigned long timeout)
+{
+	int rc = TCPSOCKET_COMPLETE;
+	START_TIME_TYPE start = MQTTClient_start_clock();
+	unsigned long elapsed = 0L;
+	MQTTClients* m = handle;
+
+	FUNC_ENTRY;
+	if (m == NULL || m->c == NULL)
+	{
+		rc = MQTTCLIENT_FAILURE;
+		goto exit;
+	}
+	if (m->c->connected == 0)
+	{
+		rc = MQTTCLIENT_DISCONNECTED;
+		goto exit;
+	}
+
+	*topicName = NULL;
+	*message = NULL;
+
+	/* if there is already a message waiting, don't hang around but still do some packet handling */
+	if (m->c->messageQueue->count > 0)
+		timeout = 0L;
+
+	elapsed = MQTTClient_elapsed(start);
+	do
+	{
+		int sock = 0;
+		MQTTClient_cycle(&sock, (timeout > elapsed) ? timeout - elapsed : 0L, &rc);
+		
+		if (rc == SOCKET_ERROR)
+		{
+			if (ListFindItem(handles, &sock, clientSockCompare) && 	/* find client corresponding to socket */
+			  (MQTTClient)(handles->current->content) == handle)
+				break; /* there was an error on the socket we are interested in */
+		}
+		elapsed = MQTTClient_elapsed(start);
+	}
+	while (elapsed < timeout && m->c->messageQueue->count == 0);
+
+	if (m->c->messageQueue->count > 0)
+		rc = MQTTClient_deliverMessage(rc, m, topicName, topicLen, message);
+
+	if (rc == SOCKET_ERROR)
+		MQTTClient_disconnect_internal(handle, 0);
+
+exit:
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+void MQTTClient_yield(void)
+{
+	START_TIME_TYPE start = MQTTClient_start_clock();
+	unsigned long elapsed = 0L;
+	unsigned long timeout = 100L;
+	int rc = 0;
+
+	FUNC_ENTRY;
+	if (running)
+	{
+		MQTTClient_sleep(timeout);
+		goto exit;
+	}
+
+	elapsed = MQTTClient_elapsed(start);
+	do
+	{
+		int sock = -1;
+		MQTTClient_cycle(&sock, (timeout > elapsed) ? timeout - elapsed : 0L, &rc);
+		if (rc == SOCKET_ERROR && ListFindItem(handles, &sock, clientSockCompare))
+		{
+			MQTTClients* m = (MQTTClient)(handles->current->content);
+			if (m->c->connect_state != -2)
+				MQTTClient_disconnect_internal(m, 0);
+		}
+		elapsed = MQTTClient_elapsed(start);
+	}
+	while (elapsed < timeout);
+exit:
+	FUNC_EXIT;
+}
+
+
+int pubCompare(void* a, void* b)
+{
+	Messages* msg = (Messages*)a;
+	return msg->publish == (Publications*)b;
+}
+
+
+int MQTTClient_waitForCompletion(MQTTClient handle, MQTTClient_deliveryToken mdt, unsigned long timeout)
+{
+	int rc = MQTTCLIENT_FAILURE;
+	START_TIME_TYPE start = MQTTClient_start_clock();
+	unsigned long elapsed = 0L;
+	MQTTClients* m = handle;
+
+	FUNC_ENTRY;
+	Thread_lock_mutex(mqttclient_mutex);
+
+	if (m == NULL || m->c == NULL)
+	{
+		rc = MQTTCLIENT_FAILURE;
+		goto exit;
+	}
+	if (m->c->connected == 0)
+	{
+		rc = MQTTCLIENT_DISCONNECTED;
+		goto exit;
+	}
+
+	if (ListFindItem(m->c->outboundMsgs, &mdt, messageIDCompare) == NULL)
+	{
+		rc = MQTTCLIENT_SUCCESS; /* well we couldn't find it */
+		goto exit;
+	}
+
+	elapsed = MQTTClient_elapsed(start);
+	while (elapsed < timeout)
+	{
+		Thread_unlock_mutex(mqttclient_mutex);
+		MQTTClient_yield();
+		Thread_lock_mutex(mqttclient_mutex);
+		if (ListFindItem(m->c->outboundMsgs, &mdt, messageIDCompare) == NULL)
+		{
+			rc = MQTTCLIENT_SUCCESS; /* well we couldn't find it */
+			goto exit;
+		}
+		elapsed = MQTTClient_elapsed(start);
+	}
+
+exit:
+	Thread_unlock_mutex(mqttclient_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+int MQTTClient_getPendingDeliveryTokens(MQTTClient handle, MQTTClient_deliveryToken **tokens)
+{
+	int rc = MQTTCLIENT_SUCCESS;
+	MQTTClients* m = handle;
+	*tokens = NULL;
+
+	FUNC_ENTRY;
+	Thread_lock_mutex(mqttclient_mutex);
+
+	if (m == NULL)
+	{
+		rc = MQTTCLIENT_FAILURE;
+		goto exit;
+	}
+
+	if (m->c && m->c->outboundMsgs->count > 0)
+	{
+		ListElement* current = NULL;
+		int count = 0;
+
+		*tokens = malloc(sizeof(MQTTClient_deliveryToken) * (m->c->outboundMsgs->count + 1));
+		/*Heap_unlink(__FILE__, __LINE__, *tokens);*/
+		while (ListNextElement(m->c->outboundMsgs, &current))
+		{
+			Messages* m = (Messages*)(current->content);
+			(*tokens)[count++] = m->msgid;
+		}
+		(*tokens)[count] = -1;
+	}
+
+exit:
+	Thread_unlock_mutex(mqttclient_mutex);
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+MQTTClient_nameValue* MQTTClient_getVersionInfo()
+{
+	#define MAX_INFO_STRINGS 8
+	static MQTTClient_nameValue libinfo[MAX_INFO_STRINGS + 1];
+	int i = 0;
+
+	libinfo[i].name = "Product name";
+	libinfo[i++].value = "Paho Synchronous MQTT C Client Library";
+
+	libinfo[i].name = "Version";
+	libinfo[i++].value = CLIENT_VERSION;
+
+	libinfo[i].name = "Build level";
+	libinfo[i++].value = BUILD_TIMESTAMP;
+#if defined(OPENSSL)
+	libinfo[i].name = "OpenSSL version";
+	libinfo[i++].value = SSLeay_version(SSLEAY_VERSION);
+
+	libinfo[i].name = "OpenSSL flags";
+	libinfo[i++].value = SSLeay_version(SSLEAY_CFLAGS);
+
+	libinfo[i].name = "OpenSSL build timestamp";
+	libinfo[i++].value = SSLeay_version(SSLEAY_BUILT_ON);
+
+	libinfo[i].name = "OpenSSL platform";
+	libinfo[i++].value = SSLeay_version(SSLEAY_PLATFORM);
+
+	libinfo[i].name = "OpenSSL directory";
+	libinfo[i++].value = SSLeay_version(SSLEAY_DIR);
+#endif
+	libinfo[i].name = NULL;
+	libinfo[i].value = NULL;
+	return libinfo;
+}
+
+
+/**
+ * See if any pending writes have been completed, and cleanup if so.
+ * Cleaning up means removing any publication data that was stored because the write did
+ * not originally complete.
+ */
+void MQTTProtocol_checkPendingWrites()
+{
+	FUNC_ENTRY;
+	if (state.pending_writes.count > 0)
+	{
+		ListElement* le = state.pending_writes.first;
+		while (le)
+		{
+			if (Socket_noPendingWrites(((pending_write*)(le->content))->socket))
+			{
+				MQTTProtocol_removePublication(((pending_write*)(le->content))->p);
+				state.pending_writes.current = le;
+				ListRemove(&(state.pending_writes), le->content); /* does NextElement itself */
+				le = state.pending_writes.current;
+			}
+			else
+				ListNextElement(&(state.pending_writes), &le);
+		}
+	}
+	FUNC_EXIT;
+}
+
+
+void MQTTClient_writeComplete(int socket)				
+{
+	ListElement* found = NULL;
+	
+	FUNC_ENTRY;
+	/* a partial write is now complete for a socket - this will be on a publish*/
+	
+	MQTTProtocol_checkPendingWrites();
+	
+	/* find the client using this socket */
+	if ((found = ListFindItem(handles, &socket, clientSockCompare)) != NULL)
+	{
+		MQTTClients* m = (MQTTClients*)(found->content);
+		
+		time(&(m->c->net.lastContact));			
+	}
+	FUNC_EXIT;
+}

src/Thread.c

@@ -14,6 +14,7 @@
  *    Ian Craggs - initial implementation
  *    Ian Craggs, Allan Stockdill-Mander - async client updates
  *    Ian Craggs - bug #415042 - start Linux thread as disconnected
+ *    Ian Craggs - fix for bug #420851
  *******************************************************************************/
 
 /**
@@ -239,10 +240,10 @@ sem_type Thread_create_sem()
 /**
  * Wait for a semaphore to be posted, or timeout.
  * @param sem the semaphore
- * @param timeout the maximum time to wait, in seconds
+ * @param timeout the maximum time to wait, in milliseconds
  * @return completion code
  */
-int Thread_wait_sem_timeout(sem_type sem, int timeout)
+int Thread_wait_sem(sem_type sem, int timeout)
 {
 /* sem_timedwait is the obvious call to use, but seemed not to work on the Viper,
  * so I've used trywait in a loop instead. Ian Craggs 23/7/2010
@@ -252,8 +253,8 @@ int Thread_wait_sem_timeout(sem_type sem, int timeout)
 #define USE_TRYWAIT
 #if defined(USE_TRYWAIT)
 	int i = 0;
-	int interval = 10000;
-	int count = (1000000 / interval) * timeout;
+	int interval = 10000; /* 10000 microseconds: 10 milliseconds */
+	int count = (1000 / interval) * timeout; /* how many intervals in timeout period */
 #else
 	struct timespec ts;
 #endif
@@ -261,7 +262,7 @@ int Thread_wait_sem_timeout(sem_type sem, int timeout)
 
 	FUNC_ENTRY;
 	#if defined(WIN32)
-		rc = WaitForSingleObject(sem, timeout*1000L);
+		rc = WaitForSingleObject(sem, timeout);
 	#elif defined(USE_TRYWAIT)
 		while (++i < count && (rc = sem_trywait(sem)) != 0)
 		{
@@ -285,17 +286,6 @@ int Thread_wait_sem_timeout(sem_type sem, int timeout)
 }
 
 
-/**
- * Wait for a semaphore to be posted, or timeout after 10 seconds.
- * @param sem the semaphore
- * @return completion code
- */
-int Thread_wait_sem(sem_type sem)
-{
-	return Thread_wait_sem_timeout(sem, 10);
-}
-
-
 /**
  * Check to see if a semaphore has been posted, without waiting.
  * @param sem the semaphore
@@ -407,7 +397,7 @@ int Thread_signal_cond(cond_type condvar)
  * Wait with a timeout (seconds) for condition variable
  * @return completion code
  */
-int Thread_wait_cond_timeout(cond_type condvar, int timeout)
+int Thread_wait_cond(cond_type condvar, int timeout)
 {
 	FUNC_ENTRY;
 	int rc = 0;

src/Thread.c~

+/*******************************************************************************
+ * 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
+ *    Ian Craggs, Allan Stockdill-Mander - async client updates
+ *    Ian Craggs - bug #415042 - start Linux thread as disconnected
+ *******************************************************************************/
+
+/**
+ * @file
+ * \brief Threading related functions
+ *
+ * Used to create platform independent threading functions
+ */
+
+
+#include "Thread.h"
+#if defined(THREAD_UNIT_TESTS)
+#define NOSTACKTRACE
+#endif
+#include "StackTrace.h"
+
+#undef malloc
+#undef realloc
+#undef free
+
+#if !defined(WIN32)
+#include <errno.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <limits.h>
+#endif
+#include <memory.h>
+#include <stdlib.h>
+
+/**
+ * Start a new thread
+ * @param fn the function to run, must be of the correct signature
+ * @param parameter pointer to the function parameter, can be NULL
+ * @return the new thread
+ */
+thread_type Thread_start(thread_fn fn, void* parameter)
+{
+#if defined(WIN32)
+	thread_type thread = NULL;
+#else
+	thread_type thread = 0;
+	pthread_attr_t attr;
+#endif
+
+	FUNC_ENTRY;
+#if defined(WIN32)
+	thread = CreateThread(NULL, 0, fn, parameter, 0, NULL);
+#else
+	pthread_attr_init(&attr);
+	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+	if (pthread_create(&thread, &attr, fn, parameter) != 0)
+		thread = 0;
+	pthread_attr_destroy(&attr);
+#endif
+	FUNC_EXIT;
+	return thread;
+}
+
+
+/**
+ * Create a new mutex
+ * @return the new mutex
+ */
+mutex_type Thread_create_mutex()
+{
+	mutex_type mutex = NULL;
+	int rc = 0;
+
+	FUNC_ENTRY;
+	#if defined(WIN32)
+		mutex = CreateMutex(NULL, 0, NULL);
+	#else
+		mutex = malloc(sizeof(pthread_mutex_t));
+		rc = pthread_mutex_init(mutex, NULL);
+	#endif
+	FUNC_EXIT_RC(rc);
+	return mutex;
+}
+
+
+/**
+ * Lock a mutex which has already been created, block until ready
+ * @param mutex the mutex
+ * @return completion code, 0 is success
+ */
+int Thread_lock_mutex(mutex_type mutex)
+{
+	int rc = -1;
+
+	/* don't add entry/exit trace points as the stack log uses mutexes - recursion beckons */
+	#if defined(WIN32)
+		/* WaitForSingleObject returns WAIT_OBJECT_0 (0), on success */
+		rc = WaitForSingleObject(mutex, INFINITE);
+	#else
+		rc = pthread_mutex_lock(mutex);
+	#endif
+
+	return rc;
+}
+
+
+/**
+ * Unlock a mutex which has already been locked
+ * @param mutex the mutex
+ * @return completion code, 0 is success
+ */
+int Thread_unlock_mutex(mutex_type mutex)
+{
+	int rc = -1;
+
+	/* don't add entry/exit trace points as the stack log uses mutexes - recursion beckons */
+	#if defined(WIN32)
+		/* if ReleaseMutex fails, the return value is 0 */
+		if (ReleaseMutex(mutex) == 0)
+			rc = GetLastError();
+		else
+			rc = 0;
+	#else
+		rc = pthread_mutex_unlock(mutex);
+	#endif
+
+	return rc;
+}
+
+
+/**
+ * Destroy a mutex which has already been created
+ * @param mutex the mutex
+ */
+void Thread_destroy_mutex(mutex_type mutex)
+{
+	int rc = 0;
+
+	FUNC_ENTRY;
+	#if defined(WIN32)
+		rc = CloseHandle(mutex);
+	#else
+		rc = pthread_mutex_destroy(mutex);
+		free(mutex);
+	#endif
+	FUNC_EXIT_RC(rc);
+}
+
+
+/**
+ * Get the thread id of the thread from which this function is called
+ * @return thread id, type varying according to OS
+ */
+thread_id_type Thread_getid()
+{
+	#if defined(WIN32)
+		return GetCurrentThreadId();
+	#else
+		return pthread_self();
+	#endif
+}
+
+
+#if defined(USE_NAMED_SEMAPHORES)
+#define MAX_NAMED_SEMAPHORES 10
+
+static int named_semaphore_count = 0;
+
+static struct 
+{
+	sem_type sem;
+	char name[NAME_MAX-4];
+} named_semaphores[MAX_NAMED_SEMAPHORES];
+ 
+#endif
+
+
+/**
+ * Create a new semaphore
+ * @return the new condition variable
+ */
+sem_type Thread_create_sem()
+{
+	sem_type sem = NULL;
+	int rc = 0;
+
+	FUNC_ENTRY;
+	#if defined(WIN32)
+		sem = CreateEvent(
+		        NULL,               // default security attributes
+		        FALSE,              // manual-reset event?
+		        FALSE,              // initial state is nonsignaled
+		        NULL                // object name
+		        );
+    #elif defined(USE_NAMED_SEMAPHORES)
+    	if (named_semaphore_count == 0)
+    		memset(named_semaphores, '\0', sizeof(named_semaphores));
+    	char* name = &(strrchr(tempnam("/", "MQTT"), '/'))[1]; /* skip first slash of name */
+    	if ((sem = sem_open(name, O_CREAT, S_IRWXU, 0)) == SEM_FAILED)
+    		rc = -1;
+    	else
+    	{
+    		int i;
+    		
+    		named_semaphore_count++;
+    		for (i = 0; i < MAX_NAMED_SEMAPHORES; ++i)
+    		{
+    			if (named_semaphores[i].name[0] == '\0')
+    			{ 
+    				named_semaphores[i].sem = sem;
+    				strcpy(named_semaphores[i].name, name);	
+    				break;
+    			}
+    		}
+    	}
+	#else
+		sem = malloc(sizeof(sem_t));
+		rc = sem_init(sem, 0, 0);
+	#endif
+	FUNC_EXIT_RC(rc);
+	return sem;
+}
+
+
+/**
+ * Wait for a semaphore to be posted, or timeout.
+ * @param sem the semaphore
+ * @param timeout the maximum time to wait, in milliseconds
+ * @return completion code
+ */
+int Thread_wait_sem(sem_type sem, int timeout)
+{
+/* sem_timedwait is the obvious call to use, but seemed not to work on the Viper,
+ * so I've used trywait in a loop instead. Ian Craggs 23/7/2010
+ */
+	int rc = -1;
+#if !defined(WIN32)
+#define USE_TRYWAIT
+#if defined(USE_TRYWAIT)
+	int i = 0;
+	int interval = 10000; /* 10000 microseconds: 10 milliseconds */
+	int count = (1000 / interval) * timeout; /* how many intervals in timeout period */
+#else
+	struct timespec ts;
+#endif
+#endif
+
+	FUNC_ENTRY;
+	#if defined(WIN32)
+		rc = WaitForSingleObject(sem, timeout);
+	#elif defined(USE_TRYWAIT)
+		while (++i < count && (rc = sem_trywait(sem)) != 0)
+		{
+			if (rc == -1 && ((rc = errno) != EAGAIN))
+			{
+				rc = 0;
+				break;
+			}
+			usleep(interval); /* microseconds - .1 of a second */
+		}
+	#else
+		if (clock_gettime(CLOCK_REALTIME, &ts) != -1)
+		{
+			ts.tv_sec += timeout;
+			rc = sem_timedwait(sem, &ts);
+		}
+	#endif
+
+ 	FUNC_EXIT_RC(rc);
+ 	return rc;
+}
+
+
+/**
+ * Check to see if a semaphore has been posted, without waiting.
+ * @param sem the semaphore
+ * @return 0 (false) or 1 (true)
+ */
+int Thread_check_sem(sem_type sem)
+{
+#if defined(WIN32)
+	return WaitForSingleObject(sem, 0) == WAIT_OBJECT_0;
+#else
+	int semval = -1;
+	sem_getvalue(sem, &semval);
+	return semval > 0;
+#endif
+}
+
+
+/**
+ * Post a semaphore
+ * @param sem the semaphore
+ * @return completion code
+ */
+int Thread_post_sem(sem_type sem)
+{
+	int rc = 0;
+
+	FUNC_ENTRY;
+	#if defined(WIN32)
+		if (SetEvent(sem) == 0)
+			rc = GetLastError();
+	#else
+		if (sem_post(sem) == -1)
+			rc = errno;
+	#endif
+
+ 	FUNC_EXIT_RC(rc);
+  return rc;
+}
+
+
+/**
+ * Destroy a semaphore which has already been created
+ * @param sem the semaphore
+ */
+int Thread_destroy_sem(sem_type sem)
+{
+	int rc = 0;
+
+	FUNC_ENTRY;
+	#if defined(WIN32)
+		rc = CloseHandle(sem);
+    #elif defined(USE_NAMED_SEMAPHORES)
+    	int i;
+    	rc = sem_close(sem);
+    	for (i = 0; i < MAX_NAMED_SEMAPHORES; ++i)
+    	{
+    		if (named_semaphores[i].sem == sem)
+    		{ 
+    			rc = sem_unlink(named_semaphores[i].name);
+    			named_semaphores[i].name[0] = '\0';	
+    			break;
+    		}
+    	}
+    	named_semaphore_count--;
+	#else
+		rc = sem_destroy(sem);
+		free(sem);
+	#endif
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+
+#if !defined(WIN32)
+/**
+ * Create a new condition variable
+ * @return the condition variable struct
+ */
+cond_type Thread_create_cond()
+{
+	cond_type condvar = NULL;
+	int rc = 0;
+
+	FUNC_ENTRY;
+	condvar = malloc(sizeof(cond_type_struct));
+	rc = pthread_cond_init(&condvar->cond, NULL);
+	rc = pthread_mutex_init(&condvar->mutex, NULL);
+
+	FUNC_EXIT_RC(rc);
+	return condvar;
+}
+
+/**
+ * Signal a condition variable
+ * @return completion code
+ */
+int Thread_signal_cond(cond_type condvar)
+{
+	int rc = 0;
+
+	pthread_mutex_lock(&condvar->mutex);
+	rc = pthread_cond_signal(&condvar->cond);
+	pthread_mutex_unlock(&condvar->mutex);
+
+	return rc;
+}
+
+/**
+ * Wait with a timeout (seconds) for condition variable
+ * @return completion code
+ */
+int Thread_wait_cond(cond_type condvar, int timeout)
+{
+	FUNC_ENTRY;
+	int rc = 0;
+	struct timespec cond_timeout;
+	struct timeval cur_time;
+
+	gettimeofday(&cur_time, NULL);
+
+	cond_timeout.tv_sec = cur_time.tv_sec + timeout;
+	cond_timeout.tv_nsec = cur_time.tv_usec * 1000;
+
+	pthread_mutex_lock(&condvar->mutex);
+	rc = pthread_cond_timedwait(&condvar->cond, &condvar->mutex, &cond_timeout);
+	pthread_mutex_unlock(&condvar->mutex);
+
+	FUNC_EXIT_RC(rc);
+	return rc;
+}
+
+/**
+ * Destroy a condition variable
+ * @return completion code
+ */
+int Thread_destroy_cond(cond_type condvar)
+{
+	int rc = 0;
+
+	rc = pthread_mutex_destroy(&condvar->mutex);
+	rc = pthread_cond_destroy(&condvar->cond);
+	free(condvar);
+
+	return rc;
+}
+#endif
+
+
+#if defined(THREAD_UNIT_TESTS)
+
+#include <stdio.h>
+
+thread_return_type secondary(void* n)
+{
+	int rc = 0;
+
+	/*
+	cond_type cond = n;
+
+	printf("Secondary thread about to wait\n");
+	rc = Thread_wait_cond(cond);
+	printf("Secondary thread returned from wait %d\n", rc);*/
+
+	sem_type sem = n;
+
+	printf("Secondary thread about to wait\n");
+	rc = Thread_wait_sem(sem);
+	printf("Secondary thread returned from wait %d\n", rc);
+
+	printf("Secondary thread about to wait\n");
+	rc = Thread_wait_sem(sem);
+	printf("Secondary thread returned from wait %d\n", rc);
+	printf("Secondary check sem %d\n", Thread_check_sem(sem));
+
+	return 0;
+}
+
+
+int main(int argc, char *argv[])
+{
+	int rc = 0;
+
+	sem_type sem = Thread_create_sem();
+
+	printf("check sem %d\n", Thread_check_sem(sem));
+
+	printf("post secondary\n");
+	rc = Thread_post_sem(sem);
+	printf("posted secondary %d\n", rc);
+
+	printf("check sem %d\n", Thread_check_sem(sem));
+
+	printf("Starting secondary thread\n");
+	Thread_start(secondary, (void*)sem);
+
+	sleep(3);
+	printf("check sem %d\n", Thread_check_sem(sem));
+
+	printf("post secondary\n");
+	rc = Thread_post_sem(sem);
+	printf("posted secondary %d\n", rc);
+
+	sleep(3);
+
+	printf("Main thread ending\n");
+}
+
+#endif

src/Thread.h

@@ -13,6 +13,7 @@
  * Contributors:
  *    Ian Craggs - initial implementation
  *    Ian Craggs, Allan Stockdill-Mander - async client updates
+ *    Ian Craggs - fix for bug #420851
  *******************************************************************************/
 
 #if !defined(THREAD_H)
@@ -41,7 +42,7 @@
 
 	cond_type Thread_create_cond();
 	int Thread_signal_cond(cond_type);
-	int Thread_wait_cond_timeout(cond_type condvar, int timeout);
+	int Thread_wait_cond(cond_type condvar, int timeout);
 	int Thread_destroy_cond(cond_type);
 #endif
 
@@ -55,8 +56,7 @@ void Thread_destroy_mutex(mutex_type);
 thread_id_type Thread_getid();
 
 sem_type Thread_create_sem();
-int Thread_wait_sem(sem_type sem);
-int Thread_wait_sem_timeout(sem_type sem, int timeout);
+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);

src/Thread.h~

+/*******************************************************************************
+ * 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
+ *    Ian Craggs, Allan Stockdill-Mander - async client updates
+ *******************************************************************************/
+
+#if !defined(THREAD_H)
+#define THREAD_H
+
+#if defined(WIN32)
+	#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>
+	#include <semaphore.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;
+	typedef sem_t *sem_type;
+
+	cond_type Thread_create_cond();
+	int Thread_signal_cond(cond_type);
+	int Thread_wait_cond(cond_type condvar, int timeout);
+	int Thread_destroy_cond(cond_type);
+#endif
+
+thread_type Thread_start(thread_fn, void*);
+
+mutex_type Thread_create_mutex();
+int Thread_lock_mutex(mutex_type);
+int Thread_unlock_mutex(mutex_type);
+void Thread_destroy_mutex(mutex_type);
+
+thread_id_type Thread_getid();
+
+sem_type Thread_create_sem();
+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

src/samples/stdoutsub.c~

+/*******************************************************************************
+ * 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
+ *******************************************************************************/
+
+/*
+ 
+ stdout subscriber
+ 
+ compulsory parameters:
+ 
+  --topic topic to subscribe to
+ 
+ defaulted parameters:
+ 
+	--host localhost
+	--port 1883
+	--qos 2
+	--delimiter \n
+	--clientid stdout_subscriber
+	
+	--userid none
+	--password none
+ 
+*/
+#include "MQTTClient.h"
+#include "MQTTClientPersistence.h"
+
+#include <stdio.h>
+#include <signal.h>
+#include <memory.h>
+
+
+#if defined(WIN32)
+#include <Windows.h>
+#define sleep Sleep
+#else
+#include <sys/time.h>
+#include <stdlib.h>
+#endif
+
+
+volatile int toStop = 0;
+
+
+void usage()
+{
+	printf("MQTT stdout subscriber\n");
+	printf("Usage: stdoutsub topicname <options>, where options are:\n");
+	printf("  --host <hostname> (default is localhost)\n");
+	printf("  --port <port> (default is 1883)\n");
+	printf("  --qos <qos> (default is 2)\n");
+	printf("  --delimiter <delim> (default is \\n)\n");
+	printf("  --clientid <clientid> (default is hostname+timestamp)\n");
+	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");
+	exit(-1);
+}
+
+
+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(-1);	
+	}
+}
+
+
+void cfinish(int sig)
+{
+	signal(SIGINT, NULL);
+	toStop = 1;
+}
+
+
+struct opts_struct
+{
+	char* clientid;
+  int nodelimiter;
+	char* delimiter;
+	int qos;
+	char* username;
+	char* password;
+	char* host;
+	char* port;
+  int showtopics;
+} opts =
+{
+	"stdout-subscriber", 0, "\n", 2, NULL, NULL, "localhost", "1883", 0
+};
+
+void getopts(int argc, char** argv);
+
+int main(int argc, char** argv)
+{
+	MQTTClient client;
+	MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
+	char* topic = NULL;
+	int rc = 0;
+	char url[100];
+	
+	if (argc < 2)
+		usage();
+	
+	topic = argv[1];
+
+  if (strchr(topic, '#') || strchr(topic, '+'))
+		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 = 10;
+	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);
+      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 0;
+}
+
+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();
+		}
+		count++;
+	}
+	
+}