diff --git a/winpr/include/winpr/print.h b/winpr/include/winpr/print.h
index c7ffecd5c..d10821d26 100644
--- a/winpr/include/winpr/print.h
+++ b/winpr/include/winpr/print.h
@@ -33,14 +33,14 @@
 extern "C" {
 #endif
 
-WINPR_API void winpr_HexDump(const BYTE* data, int length);
-WINPR_API void winpr_CArrayDump(const BYTE* data, int length, int width);
+	WINPR_API void winpr_HexDump(const char *tag, int lvl, const BYTE *data, int length);
+	WINPR_API void winpr_CArrayDump(const char *tag, int lvl, const BYTE *data, int length, int width);
 
-WINPR_API char* winpr_BinToHexString(const BYTE* data, int length, BOOL space);
+	WINPR_API char *winpr_BinToHexString(const BYTE *data, int length, BOOL space);
 
-WINPR_API int wprintfx(const char *fmt, ...);
-WINPR_API int wvprintfx(const char *fmt, va_list args);
-WINPR_API int wvsnprintfx(char *buffer, size_t bufferSize, const char* fmt, va_list args);
+	WINPR_API int wprintfx(const char *fmt, ...);
+	WINPR_API int wvprintfx(const char *fmt, va_list args);
+	WINPR_API int wvsnprintfx(char *buffer, size_t bufferSize, const char *fmt, va_list args);
 
 #ifdef __cplusplus
 }
diff --git a/winpr/include/winpr/wlog.h b/winpr/include/winpr/wlog.h
index 1139c98c5..b19d1dc1c 100644
--- a/winpr/include/winpr/wlog.h
+++ b/winpr/include/winpr/wlog.h
@@ -77,19 +77,19 @@ extern "C" {
 
 		/* Data Message */
 
-		void* Data;
+		void *Data;
 		int Length;
 
 		/* Image Message */
 
-		void* ImageData;
+		void *ImageData;
 		int ImageWidth;
 		int ImageHeight;
 		int ImageBpp;
 
 		/* Packet Message */
 
-		void* PacketData;
+		void *PacketData;
 		int PacketLength;
 		DWORD PacketFlags;
 	};
@@ -116,12 +116,12 @@ extern "C" {
 #define WLOG_PACKET_INBOUND	1
 #define WLOG_PACKET_OUTBOUND	2
 
-	typedef int (*WLOG_APPENDER_OPEN_FN)(wLog* log, wLogAppender* appender);
-	typedef int (*WLOG_APPENDER_CLOSE_FN)(wLog* log, wLogAppender* appender);
-	typedef int (*WLOG_APPENDER_WRITE_MESSAGE_FN)(wLog* log, wLogAppender* appender, wLogMessage* message);
-	typedef int (*WLOG_APPENDER_WRITE_DATA_MESSAGE_FN)(wLog* log, wLogAppender* appender, wLogMessage* message);
-	typedef int (*WLOG_APPENDER_WRITE_IMAGE_MESSAGE_FN)(wLog* log, wLogAppender* appender, wLogMessage* message);
-	typedef int (*WLOG_APPENDER_WRITE_PACKET_MESSAGE_FN)(wLog* log, wLogAppender* appender, wLogMessage* message);
+	typedef int (*WLOG_APPENDER_OPEN_FN)(wLog *log, wLogAppender *appender);
+	typedef int (*WLOG_APPENDER_CLOSE_FN)(wLog *log, wLogAppender *appender);
+	typedef int (*WLOG_APPENDER_WRITE_MESSAGE_FN)(wLog *log, wLogAppender *appender, wLogMessage *message);
+	typedef int (*WLOG_APPENDER_WRITE_DATA_MESSAGE_FN)(wLog *log, wLogAppender *appender, wLogMessage *message);
+	typedef int (*WLOG_APPENDER_WRITE_IMAGE_MESSAGE_FN)(wLog *log, wLogAppender *appender, wLogMessage *message);
+	typedef int (*WLOG_APPENDER_WRITE_PACKET_MESSAGE_FN)(wLog *log, wLogAppender *appender, wLogMessage *message);
 
 #define WLOG_APPENDER_COMMON() \
 	DWORD Type; \
@@ -161,10 +161,10 @@ extern "C" {
 	{
 		WLOG_APPENDER_COMMON();
 
-		char* FileName;
-		char* FilePath;
-		char* FullFileName;
-		FILE* FileDescriptor;
+		char *FileName;
+		char *FilePath;
+		char *FullFileName;
+		FILE *FileDescriptor;
 	};
 	typedef struct _wLogFileAppender wLogFileAppender;
 
@@ -172,10 +172,10 @@ extern "C" {
 	{
 		WLOG_APPENDER_COMMON();
 
-		char* FileName;
-		char* FilePath;
-		char* FullFileName;
-		FILE* FileDescriptor;
+		char *FileName;
+		char *FilePath;
+		char *FullFileName;
+		FILE *FileDescriptor;
 	};
 	typedef struct _wLogBinaryAppender wLogBinaryAppender;
 
@@ -186,7 +186,7 @@ extern "C" {
 	struct _wLogFilter
 	{
 		DWORD Level;
-		LPSTR* Names;
+		LPSTR *Names;
 		DWORD NameCount;
 	};
 	typedef struct _wLogFilter wLogFilter;
@@ -201,18 +201,18 @@ extern "C" {
 		DWORD Level;
 
 		BOOL IsRoot;
-		LPSTR* Names;
+		LPSTR *Names;
 		DWORD NameCount;
-		wLogAppender* Appender;
+		wLogAppender *Appender;
 
-		wLog* Parent;
-		wLog** Children;
+		wLog *Parent;
+		wLog **Children;
 		DWORD ChildrenCount;
 		DWORD ChildrenSize;
 	};
 
-	WINPR_API void WLog_PrintMessage(wLog* log, wLogMessage* message, ...);
-	WINPR_API int WLog_PrintMessageVA(wLog* log, wLogMessage* message, va_list args);
+	WINPR_API void WLog_PrintMessage(wLog *log, wLogMessage *message, ...);
+	WINPR_API int WLog_PrintMessageVA(wLog *log, wLogMessage *message, va_list args);
 
 #define WLog_Print(_log, _log_level, _fmt, ...) \
 	if (_log_level >= WLog_GetLogLevel(_log)) { \
@@ -277,25 +277,25 @@ extern "C" {
 #define WLog_IsLevelActive(_log, _log_level) \
 	(_log_level >= WLog_GetLogLevel(_log))
 
-	WINPR_API DWORD WLog_GetLogLevel(wLog* log);
-	WINPR_API void WLog_SetLogLevel(wLog* log, DWORD logLevel);
+	WINPR_API DWORD WLog_GetLogLevel(wLog *log);
+	WINPR_API void WLog_SetLogLevel(wLog *log, DWORD logLevel);
 
-	WINPR_API wLogAppender* WLog_GetLogAppender(wLog* log);
-	WINPR_API void WLog_SetLogAppenderType(wLog* log, DWORD logAppenderType);
+	WINPR_API wLogAppender *WLog_GetLogAppender(wLog *log);
+	WINPR_API void WLog_SetLogAppenderType(wLog *log, DWORD logAppenderType);
 
-	WINPR_API int WLog_OpenAppender(wLog* log);
-	WINPR_API int WLog_CloseAppender(wLog* log);
+	WINPR_API int WLog_OpenAppender(wLog *log);
+	WINPR_API int WLog_CloseAppender(wLog *log);
 
-	WINPR_API void WLog_ConsoleAppender_SetOutputStream(wLog* log, wLogConsoleAppender* appender, int outputStream);
+	WINPR_API void WLog_ConsoleAppender_SetOutputStream(wLog *log, wLogConsoleAppender *appender, int outputStream);
 
-	WINPR_API void WLog_FileAppender_SetOutputFileName(wLog* log, wLogFileAppender* appender, const char* filename);
-	WINPR_API void WLog_FileAppender_SetOutputFilePath(wLog* log, wLogFileAppender* appender, const char* filepath);
+	WINPR_API void WLog_FileAppender_SetOutputFileName(wLog *log, wLogFileAppender *appender, const char *filename);
+	WINPR_API void WLog_FileAppender_SetOutputFilePath(wLog *log, wLogFileAppender *appender, const char *filepath);
 
-	WINPR_API wLogLayout* WLog_GetLogLayout(wLog* log);
-	WINPR_API void WLog_Layout_SetPrefixFormat(wLog* log, wLogLayout* layout, const char* format);
+	WINPR_API wLogLayout *WLog_GetLogLayout(wLog *log);
+	WINPR_API void WLog_Layout_SetPrefixFormat(wLog *log, wLogLayout *layout, const char *format);
 
-	WINPR_API wLog* WLog_GetRoot(void);
-	WINPR_API wLog* WLog_Get(LPCSTR name);
+	WINPR_API wLog *WLog_GetRoot(void);
+	WINPR_API wLog *WLog_Get(LPCSTR name);
 
 	WINPR_API void WLog_Init(void);
 	WINPR_API void WLog_Uninit(void);
diff --git a/winpr/libwinpr/utils/print.c b/winpr/libwinpr/utils/print.c
index 9b0d6942b..5ad86dff0 100644
--- a/winpr/libwinpr/utils/print.c
+++ b/winpr/libwinpr/utils/print.c
@@ -24,46 +24,71 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdarg.h>
+#include <errno.h>
 
 #include <winpr/crt.h>
 #include <winpr/print.h>
 
 #include "trio.h"
 
-void winpr_HexDump(const BYTE* data, int length)
+#include "../log.h"
+
+void winpr_HexDump(const char *tag, int level, const BYTE *data, int length)
 {
-	const BYTE* p = data;
+	const BYTE *p = data;
 	int i, line, offset = 0;
+	const size_t llen = (length > WINPR_HEXDUMP_LINE_LENGTH) ? WINPR_HEXDUMP_LINE_LENGTH : length;
+	size_t blen = 5 + llen * 5;
+	size_t pos = 0;
+	char *buffer = malloc(blen);
+
+	if (!buffer)
+	{
+		WLog_ERR(tag, "malloc(%zd) failed with [%d] %s", blen, errno, strerror(errno));
+		return;
+	}
 
 	while (offset < length)
 	{
-		fprintf(stderr, "%04x ", offset);
-
+		pos += snprintf(&buffer[pos], blen - pos, "%04x ", offset);
 		line = length - offset;
 
 		if (line > WINPR_HEXDUMP_LINE_LENGTH)
 			line = WINPR_HEXDUMP_LINE_LENGTH;
 
 		for (i = 0; i < line; i++)
-			fprintf(stderr, "%02x ", p[i]);
+			pos += snprintf(&buffer[pos], blen - pos, "%02x ", p[i]);
 
 		for (; i < WINPR_HEXDUMP_LINE_LENGTH; i++)
-			fprintf(stderr, "   ");
+			pos += snprintf(&buffer[pos], blen - pos, "   ");
 
 		for (i = 0; i < line; i++)
-			fprintf(stderr, "%c", (p[i] >= 0x20 && p[i] < 0x7F) ? p[i] : '.');
-
-		fprintf(stderr, "\n");
+			pos += snprintf(&buffer[pos], blen - pos, "%c",
+							(p[i] >= 0x20 && p[i] < 0x7F) ? p[i] : '.');
 
+		pos += snprintf(&buffer[pos], blen - pos, "\n");
+		WLog_LVL(tag, level, "%s", buffer);
 		offset += line;
 		p += line;
+		pos = 0;
 	}
+
+	free(buffer);
 }
 
-void winpr_CArrayDump(const BYTE* data, int length, int width)
+void winpr_CArrayDump(const char *tag, int level, const BYTE *data, int length, int width)
 {
-	const BYTE* p = data;
+	const BYTE *p = data;
 	int i, line, offset = 0;
+	const size_t llen = ((length > width) ? width : length) * 4 + 1;
+	size_t pos;
+	char *buffer = malloc(llen);
+
+	if (!buffer)
+	{
+		WLog_ERR(tag, "malloc(%zd) failed with [%d] %s", llen, errno, strerror(errno));
+		return;
+	}
 
 	while (offset < length)
 	{
@@ -72,37 +97,33 @@ void winpr_CArrayDump(const BYTE* data, int length, int width)
 		if (line > width)
 			line = width;
 
-		printf("\t\"");
+		pos = 0;
 
 		for (i = 0; i < line; i++)
-			printf("\\x%02X", p[i]);
-
-		printf("\"\n");
+			pos += snprintf(&buffer[pos], llen - pos, "\\x%02X", p[i]);
 
+		WLog_LVL(tag, level, "%s", buffer);
 		offset += line;
 		p += line;
 	}
 
-	printf("\n");
+	free(buffer);
 }
 
-char* winpr_BinToHexString(const BYTE* data, int length, BOOL space)
+char *winpr_BinToHexString(const BYTE *data, int length, BOOL space)
 {
 	int i;
 	int n;
-	char* p;
+	char *p;
 	int ln, hn;
 	char bin2hex[] = "0123456789ABCDEF";
-
 	n = space ? 3 : 2;
-
-	p = (char*) malloc((length + 1) * n);
+	p = (char *) malloc((length + 1) * n);
 
 	for (i = 0; i < length; i++)
 	{
 		ln = data[i] & 0xF;
 		hn = (data[i] >> 4) & 0xF;
-
 		p[i * n] = bin2hex[hn];
 		p[(i * n) + 1] = bin2hex[ln];
 
@@ -111,7 +132,6 @@ char* winpr_BinToHexString(const BYTE* data, int length, BOOL space)
 	}
 
 	p[length * n] = '\0';
-
 	return p;
 }
 
@@ -124,15 +144,13 @@ int wprintfx(const char *fmt, ...)
 {
 	va_list args;
 	int status;
-
 	va_start(args, fmt);
 	status = trio_vprintf(fmt, args);
 	va_end(args);
-
 	return status;
 }
 
-int wvsnprintfx(char *buffer, size_t bufferSize, const char* fmt, va_list args)
+int wvsnprintfx(char *buffer, size_t bufferSize, const char *fmt, va_list args)
 {
 	return trio_vsnprintf(buffer, bufferSize, fmt, args);
 }
diff --git a/winpr/libwinpr/utils/ssl.c b/winpr/libwinpr/utils/ssl.c
index add22b12b..d8db157e4 100644
--- a/winpr/libwinpr/utils/ssl.c
+++ b/winpr/libwinpr/utils/ssl.c
@@ -26,8 +26,11 @@
 #include <openssl/ssl.h>
 #include <openssl/err.h>
 
+#include "../log.h"
+#define TAG "utils.ssl"
+
 static int g_winpr_openssl_num_locks = 0;
-static HANDLE* g_winpr_openssl_locks = NULL;
+static HANDLE *g_winpr_openssl_locks = NULL;
 static BOOL g_winpr_openssl_initialized_by_winpr = FALSE;
 
 struct CRYPTO_dynlock_value
@@ -58,9 +61,10 @@ static void _winpr_openssl_locking(int mode, int type, const char *file, int lin
 static struct CRYPTO_dynlock_value *_winpr_openssl_dynlock_create(const char *file, int line)
 {
 	struct CRYPTO_dynlock_value *dynlock = (struct CRYPTO_dynlock_value *)
-		malloc(sizeof(struct CRYPTO_dynlock_value));
+										   malloc(sizeof(struct CRYPTO_dynlock_value));
 
-	if (dynlock) {
+	if (dynlock)
+	{
 		dynlock->mutex = CreateMutex(NULL, FALSE, NULL);
 	}
 
@@ -93,16 +97,17 @@ static BOOL _winpr_openssl_initialize_locking(void)
 
 	if (CRYPTO_get_locking_callback())
 	{
-		fprintf(stderr, "%s: warning: OpenSSL static locking callback is already set\n", __FUNCTION__);
+		WLog_WARN(TAG, "OpenSSL static locking callback is already set");
 	}
 	else
 	{
 		if ((count = CRYPTO_num_locks()) > 0)
 		{
 			HANDLE *locks;
+
 			if (!(locks = calloc(count, sizeof(HANDLE))))
 			{
-				fprintf(stderr, "%s: error allocating lock table\n", __FUNCTION__);
+				WLog_ERR(TAG, "error allocating lock table");
 				return FALSE;
 			}
 
@@ -110,11 +115,13 @@ static BOOL _winpr_openssl_initialize_locking(void)
 			{
 				if (!(locks[i] = CreateMutex(NULL, FALSE, NULL)))
 				{
-					fprintf(stderr, "%s: error creating lock #%d\n", __FUNCTION__, i);
+					WLog_ERR(TAG, "error creating lock #%d", i);
+
 					while (i--)
 					{
 						CloseHandle(g_winpr_openssl_locks[i]);
 					}
+
 					free(locks);
 					return FALSE;
 				}
@@ -122,19 +129,17 @@ static BOOL _winpr_openssl_initialize_locking(void)
 
 			g_winpr_openssl_locks = locks;
 			g_winpr_openssl_num_locks = count;
-
 			CRYPTO_set_locking_callback(_winpr_openssl_locking);
 		}
 	}
 
-
 	/* OpenSSL dynamic locking */
 
 	if (CRYPTO_get_dynlock_create_callback() ||
-	    CRYPTO_get_dynlock_lock_callback()   ||
-	    CRYPTO_get_dynlock_destroy_callback())
+			CRYPTO_get_dynlock_lock_callback()   ||
+			CRYPTO_get_dynlock_destroy_callback())
 	{
-		fprintf(stderr, "%s: warning: dynamic locking callbacks are already set\n", __FUNCTION__);
+		WLog_WARN(TAG, "dynamic locking callbacks are already set");
 	}
 	else
 	{
@@ -143,31 +148,28 @@ static BOOL _winpr_openssl_initialize_locking(void)
 		CRYPTO_set_dynlock_destroy_callback(_winpr_openssl_dynlock_destroy);
 	}
 
-
 	/* Use the deprecated CRYPTO_get_id_callback() if building against OpenSSL < 1.0.0 */
-
 #if (OPENSSL_VERSION_NUMBER < 0x10000000L)
+
 	if (CRYPTO_get_id_callback())
 	{
-		fprintf(stderr, "%s: warning OpenSSL id_callback is already set\n", __FUNCTION__);
+		WLog_WARN(TAG, "OpenSSL id_callback is already set");
 	}
 	else
 	{
 		CRYPTO_set_id_callback(_winpr_openssl_id);
 	}
-#endif
 
+#endif
 	return TRUE;
 }
 
 static BOOL _winpr_openssl_cleanup_locking(void)
 {
 	/* undo our static locking modifications */
-
 	if (CRYPTO_get_locking_callback() == _winpr_openssl_locking)
 	{
 		int i;
-
 		CRYPTO_set_locking_callback(NULL);
 
 		for (i = 0; i < g_winpr_openssl_num_locks; i++)
@@ -180,7 +182,6 @@ static BOOL _winpr_openssl_cleanup_locking(void)
 		g_winpr_openssl_locks = NULL;
 	}
 
-
 	/* unset our dynamic locking callbacks */
 
 	if (CRYPTO_get_dynlock_create_callback() == _winpr_openssl_dynlock_create)
@@ -198,14 +199,14 @@ static BOOL _winpr_openssl_cleanup_locking(void)
 		CRYPTO_set_dynlock_destroy_callback(NULL);
 	}
 
-
 #if (OPENSSL_VERSION_NUMBER < 0x10000000L)
+
 	if (CRYPTO_get_id_callback() == _winpr_openssl_id)
 	{
 		CRYPTO_set_id_callback(NULL);
 	}
-#endif
 
+#endif
 	return TRUE;
 }
 
@@ -228,12 +229,9 @@ static BOOL CALLBACK _winpr_openssl_initialize(PINIT_ONCE once, PVOID param, PVO
 
 	/* SSL_load_error_strings() is void */
 	SSL_load_error_strings();
-
 	/* SSL_library_init() always returns "1" */
 	SSL_library_init();
-
 	g_winpr_openssl_initialized_by_winpr = TRUE;
-
 	return TRUE;
 }
 
@@ -252,9 +250,10 @@ BOOL winpr_CleanupSSL(DWORD flags)
 	{
 		if (!g_winpr_openssl_initialized_by_winpr)
 		{
-			fprintf(stderr, "%s: warning: ssl was not initialized by winpr\n", __FUNCTION__);
+			WLog_WARN(TAG, "ssl was not initialized by winpr");
 			return FALSE;
 		}
+
 		g_winpr_openssl_initialized_by_winpr = FALSE;
 		_winpr_openssl_cleanup_locking();
 		CRYPTO_cleanup_all_ex_data();
diff --git a/winpr/libwinpr/utils/wlog/DataMessage.c b/winpr/libwinpr/utils/wlog/DataMessage.c
index ded9f9af6..dbeaf07c0 100644
--- a/winpr/libwinpr/utils/wlog/DataMessage.c
+++ b/winpr/libwinpr/utils/wlog/DataMessage.c
@@ -25,21 +25,21 @@
 
 #include "wlog/DataMessage.h"
 
-int WLog_DataMessage_Write(char* filename, void* data, int length)
-{
-	FILE* fp;
+#include "../../log.h"
+#define TAG "utils.wlog"
 
+int WLog_DataMessage_Write(char *filename, void *data, int length)
+{
+	FILE *fp;
 	fp = fopen(filename, "w+b");
 
 	if (!fp)
 	{
-		fprintf(stderr, "failed to open file %s\n", filename);
+		WLog_ERR(TAG, "failed to open file %s\n", filename);
 		return -1;
 	}
 
 	fwrite(data, length, 1, fp);
-
 	fclose(fp);
-
 	return 0;
 }
diff --git a/winpr/libwinpr/utils/wlog/ImageMessage.c b/winpr/libwinpr/utils/wlog/ImageMessage.c
index 1866ed1de..fcfbbdbdc 100644
--- a/winpr/libwinpr/utils/wlog/ImageMessage.c
+++ b/winpr/libwinpr/utils/wlog/ImageMessage.c
@@ -23,8 +23,6 @@
 
 #include <winpr/wlog.h>
 
-#include <winpr/image.h>
-
 #include "wlog/ImageMessage.h"
 
 int WLog_ImageMessage_Write(char* filename, void* data, int width, int height, int bpp)
diff --git a/winpr/libwinpr/utils/wlog/PacketMessage.c b/winpr/libwinpr/utils/wlog/PacketMessage.c
index 9f7e5648e..b1db60de4 100644
--- a/winpr/libwinpr/utils/wlog/PacketMessage.c
+++ b/winpr/libwinpr/utils/wlog/PacketMessage.c
@@ -28,6 +28,9 @@
 #include <winpr/crt.h>
 #include <winpr/stream.h>
 
+#include "../../log.h"
+#define TAG WINPR_TAG("utils.wlog")
+
 #ifndef _WIN32
 #include <sys/time.h>
 #else
@@ -175,7 +178,7 @@ wPcap* Pcap_Open(char* name, BOOL write)
 
 	if (!pcap_fp)
 	{
-		perror("opening pcap file");
+		WLog_ERR(TAG,"opening pcap file");
 		return NULL;
 	}
 
diff --git a/winpr/libwinpr/utils/wlog/wlog.c b/winpr/libwinpr/utils/wlog/wlog.c
index 6c6205b1d..9ce8e619b 100644
--- a/winpr/libwinpr/utils/wlog/wlog.c
+++ b/winpr/libwinpr/utils/wlog/wlog.c
@@ -42,7 +42,7 @@
  * http://docs.python.org/2/library/logging.html
  */
 
-const char* WLOG_LEVELS[7] =
+const char *WLOG_LEVELS[7] =
 {
 	"TRACE",
 	"DEBUG",
@@ -54,12 +54,26 @@ const char* WLOG_LEVELS[7] =
 };
 
 static DWORD g_FilterCount = 0;
-static wLogFilter* g_Filters = NULL;
+static wLogFilter *g_Filters = NULL;
 
-int WLog_Write(wLog* log, wLogMessage* message)
+static void log_recursion(const char *file, const char *fkt, int line)
 {
-	int status;
-	wLogAppender* appender;
+	/* TODO: Stack trace here! */
+#if defined(ANDROID)
+	const char *tag = "com.winpr.utils.wlog";
+	level = ANDROID_LOG_FATAL;
+	__android_log_print(ANDROID_LOG_FATAL, tag, "Recursion detected!!!");
+	__android_log_print(ANDROID_LOG_FATAL, tag, "Check %s [%s:%d]", fkt, file, line);
+#else
+	fprintf(stderr, "[%s]: Recursion detected!\n", fkt);
+	fprintf(stderr, "[%s]: Check %s:%d\n", fkt, file, line);
+#endif
+}
+
+int WLog_Write(wLog *log, wLogMessage *message)
+{
+	int status = -1;
+	wLogAppender *appender;
 	appender = WLog_GetLogAppender(log);
 
 	if (!appender)
@@ -74,19 +88,22 @@ int WLog_Write(wLog* log, wLogMessage* message)
 	EnterCriticalSection(&appender->lock);
 
 	if (appender->recursive)
-		fprintf(stderr, "%s: Recursion detected!!!!", __FUNCTION__);
+		log_recursion(message->FileName, message->FunctionName, message->LineNumber);
+	else
+	{
+		appender->recursive = TRUE;
+		status = appender->WriteMessage(log, appender, message);
+		appender->recursive = FALSE;
+	}
 
-	appender->recursive = TRUE;
-	status = appender->WriteMessage(log, appender, message);
-	appender->recursive = FALSE;
 	LeaveCriticalSection(&appender->lock);
 	return status;
 }
 
-int WLog_WriteData(wLog* log, wLogMessage* message)
+int WLog_WriteData(wLog *log, wLogMessage *message)
 {
-	int status;
-	wLogAppender* appender;
+	int status = -1;
+	wLogAppender *appender;
 	appender = WLog_GetLogAppender(log);
 
 	if (!appender)
@@ -101,19 +118,22 @@ int WLog_WriteData(wLog* log, wLogMessage* message)
 	EnterCriticalSection(&appender->lock);
 
 	if (appender->recursive)
-		fprintf(stderr, "%s: Recursion detected!!!!", __FUNCTION__);
+		log_recursion(message->FileName, message->FunctionName, message->LineNumber);
+	else
+	{
+		appender->recursive = TRUE;
+		status = appender->WriteDataMessage(log, appender, message);
+		appender->recursive = FALSE;
+	}
 
-	appender->recursive = TRUE;
-	status = appender->WriteDataMessage(log, appender, message);
-	appender->recursive = FALSE;
 	LeaveCriticalSection(&appender->lock);
 	return status;
 }
 
-int WLog_WriteImage(wLog* log, wLogMessage* message)
+int WLog_WriteImage(wLog *log, wLogMessage *message)
 {
-	int status;
-	wLogAppender* appender;
+	int status = -1;
+	wLogAppender *appender;
 	appender = WLog_GetLogAppender(log);
 
 	if (!appender)
@@ -128,19 +148,22 @@ int WLog_WriteImage(wLog* log, wLogMessage* message)
 	EnterCriticalSection(&appender->lock);
 
 	if (appender->recursive)
-		fprintf(stderr, "%s: Recursion detected!!!!", __FUNCTION__);
+		log_recursion(message->FileName, message->FunctionName, message->LineNumber);
+	else
+	{
+		appender->recursive = TRUE;
+		status = appender->WriteImageMessage(log, appender, message);
+		appender->recursive = FALSE;
+	}
 
-	appender->recursive = TRUE;
-	status = appender->WriteImageMessage(log, appender, message);
-	appender->recursive = FALSE;
 	LeaveCriticalSection(&appender->lock);
 	return status;
 }
 
-int WLog_WritePacket(wLog* log, wLogMessage* message)
+int WLog_WritePacket(wLog *log, wLogMessage *message)
 {
-	int status;
-	wLogAppender* appender;
+	int status = -1;
+	wLogAppender *appender;
 	appender = WLog_GetLogAppender(log);
 
 	if (!appender)
@@ -155,16 +178,19 @@ int WLog_WritePacket(wLog* log, wLogMessage* message)
 	EnterCriticalSection(&appender->lock);
 
 	if (appender->recursive)
-		fprintf(stderr, "%s: Recursion detected!!!!", __FUNCTION__);
+		log_recursion(message->FileName, message->FunctionName, message->LineNumber);
+	else
+	{
+		appender->recursive = TRUE;
+		status = appender->WritePacketMessage(log, appender, message);
+		appender->recursive = FALSE;
+	}
 
-	appender->recursive = TRUE;
-	status = appender->WritePacketMessage(log, appender, message);
-	appender->recursive = FALSE;
 	LeaveCriticalSection(&appender->lock);
 	return status;
 }
 
-int WLog_PrintMessageVA(wLog* log, wLogMessage* message, va_list args)
+int WLog_PrintMessageVA(wLog *log, wLogMessage *message, va_list args)
 {
 	int status = -1;
 
@@ -185,13 +211,13 @@ int WLog_PrintMessageVA(wLog* log, wLogMessage* message, va_list args)
 	}
 	else if (message->Type == WLOG_MESSAGE_DATA)
 	{
-		message->Data = va_arg(args, void*);
+		message->Data = va_arg(args, void *);
 		message->Length = va_arg(args, int);
 		status = WLog_WriteData(log, message);
 	}
 	else if (message->Type == WLOG_MESSAGE_IMAGE)
 	{
-		message->ImageData = va_arg(args, void*);
+		message->ImageData = va_arg(args, void *);
 		message->ImageWidth = va_arg(args, int);
 		message->ImageHeight = va_arg(args, int);
 		message->ImageBpp = va_arg(args, int);
@@ -199,7 +225,7 @@ int WLog_PrintMessageVA(wLog* log, wLogMessage* message, va_list args)
 	}
 	else if (message->Type == WLOG_MESSAGE_PACKET)
 	{
-		message->PacketData = va_arg(args, void*);
+		message->PacketData = va_arg(args, void *);
 		message->PacketLength = va_arg(args, int);
 		message->PacketFlags = va_arg(args, int);
 		status = WLog_WritePacket(log, message);
@@ -208,7 +234,7 @@ int WLog_PrintMessageVA(wLog* log, wLogMessage* message, va_list args)
 	return status;
 }
 
-void WLog_PrintMessage(wLog* log, wLogMessage* message, ...)
+void WLog_PrintMessage(wLog *log, wLogMessage *message, ...)
 {
 	int status;
 	va_list args;
@@ -217,7 +243,7 @@ void WLog_PrintMessage(wLog* log, wLogMessage* message, ...)
 	va_end(args);
 }
 
-DWORD WLog_GetLogLevel(wLog* log)
+DWORD WLog_GetLogLevel(wLog *log)
 {
 	if (log->Level == WLOG_LEVEL_INHERIT)
 	{
@@ -229,7 +255,7 @@ DWORD WLog_GetLogLevel(wLog* log)
 	}
 }
 
-void WLog_SetLogLevel(wLog* log, DWORD logLevel)
+void WLog_SetLogLevel(wLog *log, DWORD logLevel)
 {
 	if ((logLevel > WLOG_OFF) && (logLevel != WLOG_LEVEL_INHERIT))
 	{
@@ -239,7 +265,7 @@ void WLog_SetLogLevel(wLog* log, DWORD logLevel)
 	log->Level = logLevel;
 }
 
-int WLog_ParseLogLevel(const char* level)
+int WLog_ParseLogLevel(const char *level)
 {
 	int iLevel = -1;
 
@@ -264,15 +290,15 @@ int WLog_ParseLogLevel(const char* level)
 	return iLevel;
 }
 
-int WLog_ParseFilter(wLogFilter* filter, LPCSTR name)
+int WLog_ParseFilter(wLogFilter *filter, LPCSTR name)
 {
-	char* p;
-	char* q;
+	char *p;
+	char *q;
 	int count;
 	LPSTR names;
 	int iLevel;
 	count = 1;
-	p = (char*) name;
+	p = (char *) name;
 
 	while ((p = strchr(p, '.')) != NULL)
 	{
@@ -282,10 +308,10 @@ int WLog_ParseFilter(wLogFilter* filter, LPCSTR name)
 
 	names = _strdup(name);
 	filter->NameCount = count;
-	filter->Names = (LPSTR*) malloc(sizeof(LPSTR) * (count + 1));
+	filter->Names = (LPSTR *) malloc(sizeof(LPSTR) * (count + 1));
 	filter->Names[count] = NULL;
 	count = 0;
-	p = (char*) names;
+	p = (char *) names;
 	filter->Names[count++] = p;
 	q = strrchr(p, ':');
 
@@ -313,12 +339,12 @@ int WLog_ParseFilter(wLogFilter* filter, LPCSTR name)
 
 int WLog_ParseFilters()
 {
-	char* p;
-	char* env;
+	char *p;
+	char *env;
 	DWORD count;
 	DWORD nSize;
 	int status;
-	char** strs;
+	char **strs;
 	nSize = GetEnvironmentVariableA("WLOG_FILTER", NULL, 0);
 
 	if (nSize < 1)
@@ -342,7 +368,7 @@ int WLog_ParseFilters()
 	g_FilterCount = count;
 	p = env;
 	count = 0;
-	strs = (char**) calloc(g_FilterCount, sizeof(char*));
+	strs = (char **) calloc(g_FilterCount, sizeof(char *));
 	strs[count++] = p;
 
 	while ((p = strchr(p, ',')) != NULL)
@@ -369,7 +395,7 @@ int WLog_ParseFilters()
 	return 0;
 }
 
-int WLog_GetFilterLogLevel(wLog* log)
+int WLog_GetFilterLogLevel(wLog *log)
 {
 	DWORD i, j;
 	int iLevel = -1;
@@ -410,13 +436,13 @@ int WLog_GetFilterLogLevel(wLog* log)
 	return iLevel;
 }
 
-int WLog_ParseName(wLog* log, LPCSTR name)
+int WLog_ParseName(wLog *log, LPCSTR name)
 {
-	char* p;
+	char *p;
 	int count;
 	LPSTR names;
 	count = 1;
-	p = (char*) name;
+	p = (char *) name;
 
 	while ((p = strchr(p, '.')) != NULL)
 	{
@@ -426,10 +452,10 @@ int WLog_ParseName(wLog* log, LPCSTR name)
 
 	names = _strdup(name);
 	log->NameCount = count;
-	log->Names = (LPSTR*) malloc(sizeof(LPSTR) * (count + 1));
+	log->Names = (LPSTR *) malloc(sizeof(LPSTR) * (count + 1));
 	log->Names[count] = NULL;
 	count = 0;
-	p = (char*) names;
+	p = (char *) names;
 	log->Names[count++] = p;
 
 	while ((p = strchr(p, '.')) != NULL)
@@ -442,13 +468,13 @@ int WLog_ParseName(wLog* log, LPCSTR name)
 	return 0;
 }
 
-wLog* WLog_New(LPCSTR name, wLog* rootLogger)
+wLog *WLog_New(LPCSTR name, wLog *rootLogger)
 {
-	wLog* log;
-	char* env;
+	wLog *log;
+	char *env;
 	DWORD nSize;
 	int iLevel;
-	log = (wLog*) calloc(1, sizeof(wLog));
+	log = (wLog *) calloc(1, sizeof(wLog));
 
 	if (log)
 	{
@@ -461,7 +487,7 @@ wLog* WLog_New(LPCSTR name, wLog* rootLogger)
 		log->Parent = rootLogger;
 		log->ChildrenCount = 0;
 		log->ChildrenSize = 16;
-		log->Children = (wLog**) calloc(log->ChildrenSize, sizeof(wLog*));
+		log->Children = (wLog **) calloc(log->ChildrenSize, sizeof(wLog *));
 
 		if (!log->Children)
 			return NULL;
@@ -499,7 +525,7 @@ wLog* WLog_New(LPCSTR name, wLog* rootLogger)
 	return log;
 }
 
-void WLog_Free(wLog* log)
+void WLog_Free(wLog *log)
 {
 	if (log)
 	{
@@ -517,11 +543,11 @@ void WLog_Free(wLog* log)
 	}
 }
 
-static wLog* g_RootLog = NULL;
+static wLog *g_RootLog = NULL;
 
-wLog* WLog_GetRoot()
+wLog *WLog_GetRoot()
 {
-	char* env;
+	char *env;
 	DWORD nSize;
 	DWORD logAppenderType;
 
@@ -557,12 +583,12 @@ wLog* WLog_GetRoot()
 	return g_RootLog;
 }
 
-int WLog_AddChild(wLog* parent, wLog* child)
+int WLog_AddChild(wLog *parent, wLog *child)
 {
 	if (parent->ChildrenCount >= parent->ChildrenSize)
 	{
 		parent->ChildrenSize *= 2;
-		parent->Children = (wLog**) realloc(parent->Children, sizeof(wLog*) * parent->ChildrenSize);
+		parent->Children = (wLog **) realloc(parent->Children, sizeof(wLog *) * parent->ChildrenSize);
 	}
 
 	parent->Children[parent->ChildrenCount++] = child;
@@ -570,11 +596,11 @@ int WLog_AddChild(wLog* parent, wLog* child)
 	return 0;
 }
 
-wLog* WLog_FindChild(LPCSTR name)
+wLog *WLog_FindChild(LPCSTR name)
 {
 	DWORD index;
-	wLog* root;
-	wLog* child = NULL;
+	wLog *root;
+	wLog *child = NULL;
 	BOOL found = FALSE;
 	root = WLog_GetRoot();
 
@@ -592,10 +618,10 @@ wLog* WLog_FindChild(LPCSTR name)
 	return (found) ? child : NULL;
 }
 
-wLog* WLog_Get(LPCSTR name)
+wLog *WLog_Get(LPCSTR name)
 {
-	wLog* log;
-	wLog* root;
+	wLog *log;
+	wLog *root;
 	root = WLog_GetRoot();
 	log = WLog_FindChild(name);
 
@@ -615,9 +641,9 @@ void WLog_Init()
 
 void WLog_Uninit()
 {
-	wLog* root = WLog_GetRoot();
+	wLog *root = WLog_GetRoot();
 	DWORD index;
-	wLog* child = NULL;
+	wLog *child = NULL;
 
 	for (index = 0; index < root->ChildrenCount; index++)
 	{