LoggerClient.m

/*
 * LoggerClient.m
 *
 * version 1.9.7 09-JAN-2019
 *
 * Main implementation of the NSLogger client side code
 * Part of NSLogger (client side)
 * https://github.com/fpillet/NSLogger
 *
 * BSD license follows (http://www.opensource.org/licenses/bsd-license.php)
 * 
 * Copyright (c) 2010-2018 Florent Pillet All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * Redistributions of  source code  must retain  the above  copyright notice,
 * this list of  conditions and the following  disclaimer. Redistributions in
 * binary  form must  reproduce  the  above copyright  notice,  this list  of
 * conditions and the following disclaimer  in the documentation and/or other
 * materials  provided with  the distribution.  Neither the  name of  Florent
 * Pillet nor the names of its contributors may be used to endorse or promote
 * products  derived  from  this  software  without  specific  prior  written
 * permission.  THIS  SOFTWARE  IS  PROVIDED BY  THE  COPYRIGHT  HOLDERS  AND
 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
 * NOT LIMITED TO, THE IMPLIED  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A  PARTICULAR PURPOSE  ARE DISCLAIMED.  IN  NO EVENT  SHALL THE  COPYRIGHT
 * HOLDER OR  CONTRIBUTORS BE  LIABLE FOR  ANY DIRECT,  INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY,  OR CONSEQUENTIAL DAMAGES (INCLUDING,  BUT NOT LIMITED
 * TO, PROCUREMENT  OF SUBSTITUTE GOODS  OR SERVICES;  LOSS OF USE,  DATA, OR
 * PROFITS; OR  BUSINESS INTERRUPTION)  HOWEVER CAUSED AND  ON ANY  THEORY OF
 * LIABILITY,  WHETHER  IN CONTRACT,  STRICT  LIABILITY,  OR TORT  (INCLUDING
 * NEGLIGENCE  OR OTHERWISE)  ARISING  IN ANY  WAY  OUT OF  THE  USE OF  THIS
 * SOFTWARE,   EVEN  IF   ADVISED  OF   THE  POSSIBILITY   OF  SUCH   DAMAGE.
 * 
 */
#import <sys/time.h>
#import <arpa/inet.h>
#import <stdlib.h>

#import "LoggerClient.h"
#import "LoggerCommon.h"

#import <sys/types.h>
#import <sys/sysctl.h>
#import <sys/utsname.h>
#import <dlfcn.h>
#import <fcntl.h>
#import <stdatomic.h>

#if TARGET_OS_IPHONE
#import <UIKit/UIDevice.h>
#endif

/* --------------------------------------------------------------------------------
 * IMPLEMENTATION NOTES:
 *
 * The logger runs in a separate thread. You can start
 * logging very early (as soon as your code starts running), logs will be
 * buffered and sent to the log viewer as soon as a connection is acquired.
 * This makes the logger suitable for use in conditions where you usually
 * don't have a connection to a remote machine yet (early wakeup, network
 * down, etc).
 *
 * When you call one of the public logging functions, the logger is designed
 * to return to your application as fast as possible. It enqueues logs to
 * send for processing by its own thread, while your application keeps running.
 *
 * The logger does buffer logs while not connected to a desktop
 * logger. It uses Bonjour to find a logger on the local network, and can
 * optionally connect to a remote logger identified by an IP address / port
 * or a Host Name / port.
 *
 * The logger can optionally output its logs to the console, like NSLog().
 *
 * The logger can optionally buffer its logs to a file for which you specify the
 * full path. Upon connection to the desktop viewer, the file contents are
 * transmitted to the viewer prior to sending new logs. When the whole file
 * content has been transmitted, it is emptied.
 *
 * Multiple loggers can coexist at the same time. You can perfectly use a
 * logger for your debug traces, and another that connects remotely to help
 * diagnose issues while the application runs on your user's device.
 *
 * The logger can optionally capture stdout and stderr. When running an
 * application from the IDE, this will automatically capture everything that
 * goes into the debugger console log, and insert it in the stream of logs
 * sent to the viewer.
 *
 * Using the logger's flexible packet format, you can customize logging by
 * creating your own log types, and customize the desktop viewer to display
 * runtime information panels for your application.
 * --------------------------------------------------------------------------------
 */

/* Logger internal debug flags */
// Set to 0 to disable internal debug completely
// Set to 1 to activate console logs when running the logger itself
// Set to 2 to see every logging call issued by the app, too
#define LOGGER_DEBUG 0
#ifdef NSLog
	#undef NSLog
#endif

// Internal debugging stuff for the logger itself
#if LOGGER_DEBUG
	#define LOGGERDBG LoggerDbg
	#if LOGGER_DEBUG > 1
		#define LOGGERDBG2 LoggerDbg
	#else
		#define LOGGERDBG2(format, ...) do{}while(0)
	#endif
	// Internal logging function prototype
	static void LoggerDbg(CFStringRef format, ...);
#else
	#define LOGGERDBG(format, ...) do{}while(0)
	#define LOGGERDBG2(format, ...) do{}while(0)
#endif

#if defined(__has_feature) && __has_feature(objc_arc)
#error LoggerClient.m must be compiled without Objective-C Automatic Reference Counting (CLANG_ENABLE_OBJC_ARC=NO)
#endif

struct Logger
{
	CFStringRef bufferFile;                         // If non-NULL, all buffering is done to the specified file instead of in-memory
	CFStringRef host;                               // Viewer host to connect to (instead of using Bonjour)
	UInt32 port;                                    // port on the viewer host
	
	CFMutableArrayRef bonjourServiceBrowsers;       // Active service browsers
	CFMutableArrayRef bonjourServices;              // Services being tried
	NSNetServiceBrowser *bonjourDomainBrowser;      // Domain browser
	CFMutableArrayRef logQueue;                     // Message queue
	pthread_mutex_t logQueueMutex;					// A mutex we use to protect access to the log queue and some critical variables
	pthread_cond_t logQueueEmpty;
	
	dispatch_once_t workerThreadInit;               // Use this to ensure creation of the worker thread is ever done only once for a given logger
	pthread_t workerThread;                         // The worker thread responsible for Bonjour resolution, connection and logs transmission
	CFRunLoopSourceRef messagePushedSource;         // A message source that fires on the worker thread when messages are available for send
	CFRunLoopSourceRef bufferFileChangedSource;     // A message source that fires on the worker thread when the buffer file configuration changes
	CFRunLoopSourceRef remoteOptionsChangedSource;  // A message source that fires when option changes imply a networking strategy change (switch to/from Bonjour, direct host or file streaming)
	
	CFWriteStreamRef logStream;                     // The connected stream we're writing to
	CFWriteStreamRef bufferWriteStream;             // If bufferFile not NULL and we're not connected, points to a stream for writing log data
	CFReadStreamRef bufferReadStream;               // If bufferFile not NULL, points to a read stream that will be emptied prior to sending the rest of in-memory messages
	
	SCNetworkReachabilityRef reachability;          // The reachability object we use to determine when the target host becomes reachable
	SCNetworkReachabilityFlags reachabilityFlags;   // Last known reachability flags - we use these to detect network transitions without network loss
	CFRunLoopTimerRef reconnectTimer;               // A timer to regularly check connection to the defined host, along with reachability for added reliability
	
	uint8_t *sendBuffer;                            // data waiting to be sent
	NSUInteger sendBufferSize;
	NSUInteger sendBufferUsed;                      // number of bytes of the send buffer currently in use
	NSUInteger sendBufferOffset;                    // offset in sendBuffer to start sending at
	
	_Atomic(int32_t) messageSeq;                    // sequential message number (added to each message sent)
	
	// settings
	uint32_t options;                               // Flags, see enum above
	CFStringRef bonjourServiceType;                 // leave NULL to use the default
	CFStringRef bonjourServiceName;                 // leave NULL to use the first one available
	
	// internal state
	BOOL targetReachable;                           // Set to YES when the Reachability target (host or internet) is deemed reachable
	BOOL connected;                                 // Set to YES once the write stream declares the connection open
	volatile BOOL quit;                             // Set to YES to terminate the logger worker thread's runloop
	BOOL incompleteSendOfFirstItem;                 // set to YES if we are sending the first item in the queue and it's bigger than what the buffer can hold
};

/* Local prototypes */
static void LoggerFlushAllOnExit(void);
static void* LoggerWorkerThread(Logger *logger);
static void LoggerWriteMoreData(Logger *logger);
static void LoggerPushMessageToQueue(Logger *logger, CFDataRef message);

// Bonjour management
static void LoggerStartBonjourBrowsing(Logger *logger);
static void LoggerStopBonjourBrowsing(Logger *logger);
static void LoggerBrowseBonjourForServices(Logger *logger, CFStringRef domainName);
static void LoggerConnectToService(Logger *logger, NSNetService *service);
static void LoggerDisconnectFromService(Logger *logger, NSNetService *service);

@interface FPLLoggerBonjourDelegate : NSObject <NSNetServiceBrowserDelegate>
{
	Logger *_logger;
}
- (instancetype)initWithLogger:(Logger *)logger;
@end

// Reachability and reconnect timer
static void LoggerRemoteSettingsChanged(Logger *logger);
static void LoggerStartReachabilityChecking(Logger *logger);
static void LoggerStopReachabilityChecking(Logger *logger);
static void LoggerReachabilityCallBack(SCNetworkReachabilityRef target, SCNetworkReachabilityFlags flags, void *info);
static void LoggerStartReconnectTimer(Logger *logger);
static void LoggerStopReconnectTimer(Logger *logger);
static void LoggerTimedReconnectCallback(CFRunLoopTimerRef timer, void *info);

// Connection & stream management
static void LoggerTryConnect(Logger *logger);
static void LoggerWriteStreamTerminated(Logger *logger);
static void LoggerWriteStreamCallback(CFWriteStreamRef ws, CFStreamEventType event, void* info);

// File buffering
static void LoggerCreateBufferWriteStream(Logger *logger);
static void LoggerCreateBufferReadStream(Logger *logger);
static void LoggerEmptyBufferFile(Logger *logger);
static void LoggerFileBufferingOptionsChanged(Logger *logger);
static void LoggerFlushQueueToBufferStream(Logger *logger, BOOL firstEntryIsClientInfo);

// Encoding functions
static void	LoggerPushClientInfoToFrontOfQueue(Logger *logger);
static void LoggerMessageAddTimestampAndThreadID(CFMutableDataRef encoder);

static CFMutableDataRef LoggerMessageCreate(int32_t seq);
static void LoggerMessageAddInt32(CFMutableDataRef encoder, int32_t anInt, int key);
#if __LP64__
static void LoggerMessageAddInt64(CFMutableDataRef data, int64_t anInt, int key);
#endif
static void LoggerMessageAddString(CFMutableDataRef encoder, CFStringRef aString, int key);
static void LoggerMessageAddData(CFMutableDataRef encoder, CFDataRef theData, int key, int partType);
static uint32_t LoggerMessageGetSeq(CFDataRef message);

/* Static objects */
static CFMutableArrayRef sLoggersList;
static Logger* volatile sDefaultLogger = NULL;
static Boolean sAtexitFunctionSet = FALSE;
static pthread_mutex_t sLoggersListMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t sDefaultLoggerMutex = PTHREAD_MUTEX_INITIALIZER;

// Console logging
static void LoggerStartGrabbingConsole(Logger *logger);
static void LoggerStopGrabbingConsole(Logger *logger);
static Logger ** consoleGrabbersList = NULL;
static unsigned consoleGrabbersListLength = 0;
static unsigned numActiveConsoleGrabbers = 0;
static pthread_mutex_t consoleGrabbersMutex = PTHREAD_MUTEX_INITIALIZER;
static int sConsolePipes[4] = { -1, -1, -1, -1 };
static int sSTDOUT = -1, sSTDERR = -1;
static int sSTDOUThadSIGPIPE, sSTDERRhadSIGPIPE;
static pthread_t consoleGrabThread;

// -----------------------------------------------------------------------------
#pragma mark -
#pragma mark Default logger
// -----------------------------------------------------------------------------
void LoggerSetDefaultLogger(Logger *defaultLogger)
{
	pthread_mutex_lock(&sDefaultLoggerMutex);
	sDefaultLogger = defaultLogger;
	pthread_mutex_unlock(&sDefaultLoggerMutex);
}

Logger *LoggerGetDefaultLogger(void)
{
	Logger *l = sDefaultLogger;
	if (l == NULL)
	{
		pthread_mutex_lock(&sDefaultLoggerMutex);
		l = sDefaultLogger;
		if (l == NULL)
			l = LoggerInit();
		pthread_mutex_unlock(&sDefaultLoggerMutex);
	}
	return l;
}

Logger *LoggerCheckDefaultLogger(void)
{
	return sDefaultLogger;
}

// -----------------------------------------------------------------------------
#pragma mark -
#pragma mark Initialization and setup
// -----------------------------------------------------------------------------
Logger *LoggerInit(void)
{
	LOGGERDBG(CFSTR("LoggerInit defaultLogger=%p"), sDefaultLogger);
	
	Logger *logger = (Logger *)malloc(sizeof(Logger));
	bzero(logger, sizeof(Logger));

	logger->logQueue = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
	pthread_mutex_init(&logger->logQueueMutex, NULL);
	pthread_cond_init(&logger->logQueueEmpty, NULL);

	logger->bonjourServiceBrowsers = CFArrayCreateMutable(NULL, 4, &kCFTypeArrayCallBacks);
	logger->bonjourServices = CFArrayCreateMutable(NULL, 4, &kCFTypeArrayCallBacks);

	// for now we don't grow the send buffer, just use one page of memory which should be enouh
	// (bigger messages will be sent separately)
	logger->sendBuffer = (uint8_t *)malloc(4096);
	logger->sendBufferSize = 4096;
	
	logger->options = LOGGER_DEFAULT_OPTIONS;
#if LOGGER_DEBUG
	// when debugging NSLogger itself, don't hijack the system console
	// as we are sending messages to it for display
	logger->options &= ~kLoggerOption_CaptureSystemConsole;
#endif

	logger->quit = NO;

	// Add logger to the list of existing loggers
	// Set this logger as the default logger is none exist already
	pthread_mutex_lock(&sLoggersListMutex);
	if (sLoggersList == NULL)
	{
		CFArrayCallBacks callbacks;
		bzero(&callbacks, sizeof(callbacks));
		sLoggersList = CFArrayCreateMutable(NULL, 0, &callbacks);
	}
	CFArrayAppendValue(sLoggersList, (const void *)logger);
	if (sDefaultLogger == NULL)
		sDefaultLogger = logger;

	// Configure a low level exit() callback that will flush all connected loggers
	if (!sAtexitFunctionSet)
	{
		atexit(&LoggerFlushAllOnExit);
		sAtexitFunctionSet = TRUE;
	}
	pthread_mutex_unlock(&sLoggersListMutex);

	return logger;
}

void LoggerSetOptions(Logger *logger, uint32_t options)
{
	LOGGERDBG(CFSTR("LoggerSetOptions options=0x%08lx"), options);

	// If we choose to log to system console
	// make sure we are not configured to capture the system console
	// When debugging NSLogger itself, we never capture the system console either
	if (options & kLoggerOption_LogToConsole)
		options &= (uint32_t)~kLoggerOption_CaptureSystemConsole;

	if (logger == NULL)
		logger = LoggerGetDefaultLogger();
	if (logger != NULL)
		logger->options = options;
}

uint32_t LoggerGetOptions(Logger *logger)
{
	logger = logger ?: LoggerGetDefaultLogger();
	return logger ? logger->options : 0;
}

void LoggerSetupBonjour(Logger *logger, CFStringRef bonjourServiceType, CFStringRef bonjourServiceName)
{
	LOGGERDBG(CFSTR("LoggerSetupBonjour serviceType=%@ serviceName=%@"), bonjourServiceType, bonjourServiceName);

	if (logger == NULL)
		logger = LoggerGetDefaultLogger();
	if (logger != NULL)
	{
		pthread_mutex_lock(&logger->logQueueMutex);
		
		BOOL change = ((bonjourServiceName != NULL) != (logger->bonjourServiceName != NULL) ||
					   (bonjourServiceName != NULL && CFStringCompare(bonjourServiceName, logger->bonjourServiceName, 0) != kCFCompareEqualTo))
		||			((bonjourServiceType != NULL) != (logger->bonjourServiceType != NULL) ||
					 (bonjourServiceType != NULL && CFStringCompare(bonjourServiceType, logger->bonjourServiceType, 0) != kCFCompareEqualTo));
		
		if (bonjourServiceType != NULL)
			CFRetain(bonjourServiceType);
		if (bonjourServiceName != NULL)
			CFRetain(bonjourServiceName);
		
		if (logger->bonjourServiceType != NULL)
			CFRelease(logger->bonjourServiceType);
		if (logger->bonjourServiceName != NULL)
			CFRelease(logger->bonjourServiceName);
		
		logger->bonjourServiceType = bonjourServiceType;
		logger->bonjourServiceName = bonjourServiceName;

		if (change && logger->remoteOptionsChangedSource != NULL)
			CFRunLoopSourceSignal(logger->remoteOptionsChangedSource);
		
		pthread_mutex_unlock(&logger->logQueueMutex);
	}
}

CFStringRef LoggerGetBonjourServiceType(Logger *logger)
{
	logger = logger ?: LoggerGetDefaultLogger();
	pthread_mutex_lock(&logger->logQueueMutex);
	CFStringRef result = logger ? logger->bonjourServiceType : NULL;
	pthread_mutex_unlock(&logger->logQueueMutex);
	return result;
}

CFStringRef LoggerGetBonjourServiceName(Logger *logger)
{
	logger = logger ?: LoggerGetDefaultLogger();
	pthread_mutex_lock(&logger->logQueueMutex);
	CFStringRef result = logger ? logger->bonjourServiceName : NULL;
	pthread_mutex_unlock(&logger->logQueueMutex);
	return result;
}

/// Stringification, see this:
/// http://gcc.gnu.org/onlinedocs/cpp/Stringification.html
#define nslogger_xstr(s) nslogger_str(s)
#define nslogger_str(s) #s

void LoggerSetupBonjourForBuildUser()
{
    LoggerSetupBonjour(LoggerGetDefaultLogger(), NULL, CFSTR(nslogger_xstr(NSLOGGER_BUILD_USERNAME)));
}

void LoggerSetViewerHost(Logger *logger, CFStringRef hostName, UInt32 port)
{
	logger = logger ?: LoggerGetDefaultLogger();

	pthread_mutex_lock(&logger->logQueueMutex);
	
	CFStringRef previousHost = logger->host;
	UInt32 previousPort = logger->port;

	logger->host = NULL;

	if (hostName != NULL)
	{
		logger->host = CFStringCreateCopy(NULL, hostName);
		logger->port = port;
	}

	if (logger->remoteOptionsChangedSource != NULL &&
		(logger->port != previousPort ||
		 ((hostName == NULL) != (previousHost == NULL)) ||
		 (hostName != NULL && CFStringCompare(hostName, previousHost, kCFCompareCaseInsensitive) != kCFCompareEqualTo)))
		CFRunLoopSourceSignal(logger->remoteOptionsChangedSource);
		 
	if (previousHost != NULL)
		CFRelease(previousHost);

	pthread_mutex_unlock(&logger->logQueueMutex);
}

CFStringRef LoggerGetViewerHostName(Logger *logger)
{
	logger = logger ?: LoggerGetDefaultLogger();
	pthread_mutex_lock(&logger->logQueueMutex);
	CFStringRef result = logger ? logger->host : NULL;
	pthread_mutex_unlock(&logger->logQueueMutex);
	return result;
}

UInt32 LoggerGetViewerPort(Logger *logger)
{
	logger = logger ?: LoggerGetDefaultLogger();
	pthread_mutex_lock(&logger->logQueueMutex);
	UInt32 result = logger ? logger->port : 0;
	pthread_mutex_unlock(&logger->logQueueMutex);
	return result;
}

void LoggerSetBufferFile(Logger *logger, CFStringRef absolutePath)
{
	logger = logger ?: LoggerGetDefaultLogger();
	pthread_mutex_lock(&logger->logQueueMutex);
	
	BOOL change = ((logger->bufferFile != NULL && absolutePath == NULL) ||
				   (logger->bufferFile == NULL && absolutePath != NULL) ||
				   (logger->bufferFile != NULL && absolutePath != NULL && CFStringCompare(logger->bufferFile, absolutePath, (CFStringCompareFlags) 0) != kCFCompareEqualTo));
	if (change)
	{
		if (logger->bufferFile != NULL)
		{
			CFRelease(logger->bufferFile);
			logger->bufferFile = NULL;
		}
		if (absolutePath != NULL)
			logger->bufferFile = CFStringCreateCopy(NULL, absolutePath);

		if (logger->bufferFileChangedSource != NULL)
			CFRunLoopSourceSignal(logger->bufferFileChangedSource);
	}

	pthread_mutex_unlock(&logger->logQueueMutex);
}

CFStringRef LoggerGetBufferFile(Logger *logger)
{
	logger = logger ?: LoggerGetDefaultLogger();
	pthread_mutex_lock(&logger->logQueueMutex);
	CFStringRef result = logger ? logger->bufferFile : NULL;
	pthread_mutex_unlock(&logger->logQueueMutex);
	return result;
}

Logger *LoggerStart(Logger *logger)
{
	// will do nothing if logger is already started
	if (logger == NULL)
		logger = LoggerGetDefaultLogger();

    if (logger != NULL)
	{
		if (logger->workerThread == NULL)
        {
			dispatch_once(&logger->workerThreadInit, ^{
				// Start the work thread which performs the Bonjour search,
				// connects to the logging service and forwards the logs
				LOGGERDBG(CFSTR("LoggerStart logger=%p"), logger);
				pthread_create(&logger->workerThread, NULL, (void *(*)(void *))&LoggerWorkerThread, logger);
				
				// Grab console output if required
				if (logger->options & kLoggerOption_CaptureSystemConsole)
					LoggerStartGrabbingConsole(logger);
			});
        }
    }
    else
    {
        LOGGERDBG2(CFSTR("-> could not create logger"));
    }
	return logger;
}

void LoggerStop(Logger *logger)
{
	LOGGERDBG(CFSTR("LoggerStop"));

	pthread_mutex_lock(&sLoggersListMutex);
	if (logger == NULL || logger == sDefaultLogger)
	{
		logger = sDefaultLogger;
		sDefaultLogger = NULL;
	}
	if (sLoggersList != NULL && logger != NULL)
	{
		CFIndex where = CFArrayGetFirstIndexOfValue(sLoggersList, CFRangeMake(0, CFArrayGetCount(sLoggersList)), (void const *) logger);
		if (where != -1)
			CFArrayRemoveValueAtIndex(sLoggersList, where);
	}
	pthread_mutex_unlock(&sLoggersListMutex);

	if (logger != NULL)
	{
		if (logger->workerThread != NULL)
		{
            LoggerStopGrabbingConsole(logger);
			logger->quit = YES;
			pthread_join(logger->workerThread, NULL);
			logger->workerThread = NULL;
		}

		CFRelease(logger->bonjourServiceBrowsers);
		CFRelease(logger->bonjourServices);
		free(logger->sendBuffer);
		if (logger->host != NULL)
			CFRelease(logger->host);
		if (logger->bufferFile != NULL)
			CFRelease(logger->bufferFile);
		if (logger->bonjourServiceType != NULL)
			CFRelease(logger->bonjourServiceType);
		if (logger->bonjourServiceName != NULL)
			CFRelease(logger->bonjourServiceName);

		// to make sure potential errors are caught, set the whole structure
		// to a value that will make code crash if it tries using pointers to it.
		memset(logger, 0x55, sizeof(Logger));

		free(logger);
	}
}

static void LoggerFlushAllOnExit()
{
	// this function is automatically configured by NSLogger to flush all connected loggers
	// on exit. this guarantees that the developer sees the last messages issued by the application.
	// it is configured the first time a logger is initialized, so at the time we're being called
	// the loggers list is never NULL
	pthread_mutex_lock(&sLoggersListMutex);
	CFIndex numLoggers = CFArrayGetCount(sLoggersList);
	for (CFIndex i=0; i < numLoggers; i++)
		LoggerFlush((Logger *) CFArrayGetValueAtIndex(sLoggersList, i), NO);
	pthread_mutex_unlock(&sLoggersListMutex);
}

void LoggerFlush(Logger *logger, BOOL waitForConnection)
{
	// Special case: if nothing has ever been logged, don't bother
	if (logger == NULL && sDefaultLogger == NULL)
		return;
	if (logger == NULL)
		logger = LoggerGetDefaultLogger();
	if (logger != NULL &&
		pthread_self() != logger->workerThread &&
		(logger->connected || logger->bufferFile != NULL || waitForConnection))		// TODO: change this test
	{
		pthread_mutex_lock(&logger->logQueueMutex);
		if (CFArrayGetCount(logger->logQueue) > 0)
			pthread_cond_wait(&logger->logQueueEmpty, &logger->logQueueMutex);
		pthread_mutex_unlock(&logger->logQueueMutex);
	}
}

#if LOGGER_DEBUG
static void LoggerDbg(CFStringRef format, ...)
{
	// Internal debugging function
	// (what do you think, that we use the Logger to debug itself ??)
	if (format != NULL)
	{
		@autoreleasepool
		{
			va_list args;
			va_start(args, format);
			CFStringRef s = CFStringCreateWithFormatAndArguments(NULL, NULL, format, args);
			va_end(args);
			if (s != NULL)
			{
				CFShow(s);
				CFRelease(s);
			}
		}
	}
}
#endif

// -----------------------------------------------------------------------------
#pragma mark -
#pragma mark Main processing
// -----------------------------------------------------------------------------
static BOOL LoggerPrepareRunloopSource(Logger *logger, CFRunLoopSourceRef *outRef, void *callback)
{
	// first call will also create the thread's runloop
	CFRunLoopSourceContext context;
	bzero(&context, sizeof(context));
	context.info = logger;
	context.perform = callback;
	*outRef = CFRunLoopSourceCreate(NULL, 0, &context);
	if (*outRef == NULL)
	{
		// This NSLog is intentional as this failure MUST be logged to console
		NSLog(@"*** NSLogger: worker thread failed creating runloop source");
		return NO;
	}
	CFRunLoopAddSource(CFRunLoopGetCurrent(), *outRef, kCFRunLoopDefaultMode);
	return YES;
}

static void LoggerDisposeRunloopSource(CFRunLoopSourceRef *sourceRef)
{
	if (*sourceRef != NULL)
	{
		CFRunLoopSourceInvalidate(*sourceRef);
		CFRelease(*sourceRef);
		*sourceRef = NULL;
	}
}

static void *LoggerWorkerThread(Logger *logger)
{
	LOGGERDBG(CFSTR("Start LoggerWorkerThread"));

#if !TARGET_OS_IPHONE
	// Register thread with Garbage Collector on Mac OS X if we're running an OS version that has GC
    void (*registerThreadWithCollector_fn)(void);
    registerThreadWithCollector_fn = (void(*)(void)) dlsym(RTLD_NEXT, "objc_registerThreadWithCollector");
    if (registerThreadWithCollector_fn)
        (*registerThreadWithCollector_fn)();
#endif

	// access to the runloop sources is protected by our logQueue mutex
	pthread_mutex_lock(&logger->logQueueMutex);

	// Create the run loop source that signals when messages have been added to the runloop
	// this will directly trigger a WriteMoreData() call, which will or won't write depending
	// on whether we're connected and there's space available in the stream
	if (!LoggerPrepareRunloopSource(logger, &logger->messagePushedSource, &LoggerWriteMoreData))
	{
		// Failing to create the runloop source for pushing messages is a major failure.
		// This NSLog is intentional. We WANT console output in this case
		NSLog(@"*** NSLogger: switching to console logging.");
		logger->options |= kLoggerOption_LogToConsole;
		logger->workerThread = NULL;
		return NULL;
	}

	// Create the runloop source that lets us know when file buffering options change
	LoggerPrepareRunloopSource(logger, &logger->bufferFileChangedSource, &LoggerFileBufferingOptionsChanged);

	// Create the runloop source that lets us know when remote (host, Bonjour) settings change
	LoggerPrepareRunloopSource(logger, &logger->remoteOptionsChangedSource, &LoggerRemoteSettingsChanged);

	pthread_mutex_unlock(&logger->logQueueMutex);

	// Create the buffering stream if needed
	if (logger->bufferFile != NULL)
		LoggerCreateBufferWriteStream(logger);

	// Start Reachability (when needed), which determines when we take the next step
	// (once Reachability status is known, we'll decide to either start Bonjour browsing or
	// try connecting to a direct host)
	LoggerStartReachabilityChecking(logger);

	// Run logging thread until LoggerStop() is called
	NSTimeInterval timeout = 0.05;
	while (!logger->quit)
	{
		int result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, timeout, true);
		if (result == kCFRunLoopRunFinished || result == kCFRunLoopRunStopped)
			break;
		if (result == kCFRunLoopRunHandledSource)
            timeout = 0;
        else
            timeout = fmax(0.05, timeout+0.005);
	}

	// Cleanup
	LoggerStopBonjourBrowsing(logger);
	LoggerStopReachabilityChecking(logger);
	LoggerStopReconnectTimer(logger);

	if (logger->logStream != NULL)
	{
		CFWriteStreamSetClient(logger->logStream, 0, NULL, NULL);
		CFWriteStreamClose(logger->logStream);
		CFRelease(logger->logStream);
		logger->logStream = NULL;
	}

	if (logger->bufferWriteStream == NULL && logger->bufferFile != NULL)
	{
		// If there are messages in the queue and LoggerStop() was called and
		// a buffer file was set just before LoggerStop() was called, flush
		// the log queue to the buffer file
		pthread_mutex_lock(&logger->logQueueMutex);
		CFIndex outstandingMessages = CFArrayGetCount(logger->logQueue);
		pthread_mutex_unlock(&logger->logQueueMutex);
		if (outstandingMessages)
			LoggerCreateBufferWriteStream(logger);
	}

	if (logger->bufferWriteStream != NULL)
	{
		CFWriteStreamClose(logger->bufferWriteStream);
		CFRelease(logger->bufferWriteStream);
		logger->bufferWriteStream = NULL;
	}

	LoggerDisposeRunloopSource(&logger->messagePushedSource);
	LoggerDisposeRunloopSource(&logger->bufferFileChangedSource);
	LoggerDisposeRunloopSource(&logger->remoteOptionsChangedSource);

	// if the client ever tries to log again against us, make sure that logs at least
	// go to console
	logger->options |= kLoggerOption_LogToConsole;
	
	LOGGERDBG(CFSTR("Stop LoggerWorkerThread"));
	return NULL;
}

static CFStringRef LoggerCreateStringRepresentationFromBinaryData(CFDataRef data)
{
	CFMutableStringRef s = CFStringCreateMutable(NULL, 0);
	unsigned int offset = 0;
	unsigned int dataLen = (unsigned int)CFDataGetLength(data);
	char buffer[1+6+16*3+1+16+1+1+1];
	buffer[0] = '\0';
	const unsigned char *q = (unsigned char *)CFDataGetBytePtr(data);
	if (dataLen == 1)
		CFStringAppend(s, CFSTR("Raw data, 1 byte:\n"));
	else
		CFStringAppendFormat(s, NULL, CFSTR("Raw data, %u bytes:\n"), dataLen);
	while (dataLen)
	{
		int i, j, b = sprintf(buffer," %04x: ", offset);
		for (i=0; i < 16 && i < (int)dataLen; i++)
			sprintf(&buffer[b+3*i], "%02x ", (int)q[i]);
		for (j=i; j < 16; j++)
			strncat(buffer, "   ", 3);
		
		b = (int)strlen(buffer);
		buffer[b++] = '\'';
		for (i=0; i < 16 && i < (int)dataLen; i++, q++)
		{
			if (*q >= 32 && *q < 128)
				buffer[b++] = (char)*q;
			else
				buffer[b++] = ' ';
		}
		for (j=i; j < 16; j++)
			buffer[b++] = ' ';
		buffer[b++] = '\'';
		buffer[b++] = '\n';
		buffer[b] = 0;
		
		CFStringRef bufferStr = CFStringCreateWithBytesNoCopy(NULL, (const UInt8 *)buffer, (CFIndex)strlen(buffer), kCFStringEncodingISOLatin1, false, kCFAllocatorNull);
		CFStringAppend(s, bufferStr);
		CFRelease(bufferStr);
		
		dataLen -= (unsigned int)i;
		offset += (unsigned int)i;
	}
	return s;
}

static void LoggerLogToConsole(CFDataRef data)
{
	// Decode and log a message to the console. Doing this from the worker thread
	// allow us to serialize logging, which is a benefit that NSLog() doesn't have.
	// Only drawback is that we have to decode our own message, but that is a minor hassle.
	if (data == NULL)
	{
		CFShow(CFSTR("LoggerLogToConsole: data is NULL"));
		return;
	}
	struct timeval timestamp;
	bzero(&timestamp, sizeof(timestamp));
	int type = LOGMSG_TYPE_LOG, contentsType = PART_TYPE_STRING;
	int imgWidth=0, imgHeight=0;
	CFStringRef message = NULL;
	CFStringRef thread = NULL;

	// decode message contents
	uint8_t *p = (uint8_t *)CFDataGetBytePtr(data) + 4;
	uint16_t partCount;
	memcpy(&partCount, p, 2);
	partCount = ntohs(partCount);
	p += 2;
	while (partCount--)
	{
		uint8_t partKey = *p++;
		uint8_t partType = *p++;
		uint32_t partSize;
		if (partType == PART_TYPE_INT16)
			partSize = 2;
		else if (partType == PART_TYPE_INT32)
			partSize = 4;
		else if (partType == PART_TYPE_INT64)
			partSize = 8;
		else
		{
			memcpy(&partSize, p, 4);
			p += 4;
			partSize = ntohl(partSize);
		}
		CFTypeRef part = NULL;
		uint32_t value32 = 0;
		uint64_t value64 = 0;
		if (partSize > 0)
		{
			if (partType == PART_TYPE_STRING)
			{
				// trim whitespace and newline at both ends of the string
				uint8_t *q = p;
				uint32_t l = partSize;
                while (l && (*q == ' ' || *q == '\t' || *q == '\n' || *q == '\r')) {
                    q++;
                    l--;
                }
				uint8_t *r = q + l - 1;
                while (l && (*r == ' ' || *r == '\t' || *r == '\n' || *r == '\r')) {
                    r--;
                    l--;
                }
				part = CFStringCreateWithBytesNoCopy(NULL, q, (CFIndex)l, kCFStringEncodingUTF8, false, kCFAllocatorNull);
			}
			else if (partType == PART_TYPE_BINARY)
			{
				part = CFDataCreateWithBytesNoCopy(NULL, p, (CFIndex)partSize, kCFAllocatorNull);
			}
			else if (partType == PART_TYPE_IMAGE)
			{
				// ignore image data, we can't log it to console
			}
			else if (partType == PART_TYPE_INT16)
			{
				value32 = ((uint32_t)p[0]) << 8 | (uint32_t)p[1];
			}
			else if (partType == PART_TYPE_INT32)
			{
				memcpy(&value32, p, 4);
				value32 = ntohl(value32);
			}
			else if (partType == PART_TYPE_INT64)
			{
				memcpy(&value64, p, 8);
				value64 = CFSwapInt64BigToHost(value64);
			}
			p += partSize;
		}
		switch (partKey)
		{
			case PART_KEY_MESSAGE_TYPE:
				type = (int)value32;
				break;
			case PART_KEY_TIMESTAMP_S:			// timestamp with seconds-level resolution
				timestamp.tv_sec = (partType == PART_TYPE_INT64) ? (__darwin_time_t)value64 : (__darwin_time_t)value32;
				break;
			case PART_KEY_TIMESTAMP_MS:			// millisecond part of the timestamp (optional)
				timestamp.tv_usec = ((partType == PART_TYPE_INT64) ? (__darwin_suseconds_t)value64 : (__darwin_suseconds_t)value32) * 1000;
				break;
			case PART_KEY_TIMESTAMP_US:			// microsecond part of the timestamp (optional)
				timestamp.tv_usec = (partType == PART_TYPE_INT64) ? (__darwin_suseconds_t)value64 : (__darwin_suseconds_t)value32;
				break;
			case PART_KEY_THREAD_ID:
				if (thread == NULL)				// useless test, we know what we're doing but clang analyzer doesn't...
				{
					if (partType == PART_TYPE_INT32)
						thread = CFStringCreateWithFormat(NULL, NULL, CFSTR("thread 0x%08x"), value32);
					else if (partType == PART_TYPE_INT64)
						thread = CFStringCreateWithFormat(NULL, NULL, CFSTR("thread 0x%qx"), value64);
					else if (partType == PART_TYPE_STRING && part != NULL)
						thread = CFRetain(part);
				}
				break;
			case PART_KEY_MESSAGE:
				if (part != NULL)
				{
					if (partType == PART_TYPE_STRING)
						message = CFRetain(part);
					else if (partType == PART_TYPE_BINARY)
						message = LoggerCreateStringRepresentationFromBinaryData(part);
				}
				contentsType = partType;
				break;
			case PART_KEY_IMAGE_WIDTH:
				imgWidth = (partType == PART_TYPE_INT32 ? (int)value32 : (int)value64);
				break;
			case PART_KEY_IMAGE_HEIGHT:
				imgHeight = (partType == PART_TYPE_INT32 ? (int)value32 : (int)value64);
				break;
			default:
				break;
		}
		if (part != NULL)
			CFRelease(part);
	}

	// Prepare the final representation and log to console
	CFMutableStringRef s = CFStringCreateMutable(NULL, 0);

	char buf[32];
	struct tm t;
	gmtime_r(&timestamp.tv_sec, &t);
	strftime(buf, sizeof(buf)-1, "%T", &t);
	CFStringRef ts = CFStringCreateWithBytesNoCopy(
                                                   NULL,
                                                   (const UInt8 *)buf,
                                                   (CFIndex)strlen(buf),
                                                   kCFStringEncodingASCII,
                                                   false,
                                                   kCFAllocatorNull);
	CFStringAppend(s, ts);
	CFRelease(ts);

	if (contentsType == PART_TYPE_IMAGE)
		message = CFStringCreateWithFormat(NULL, NULL, CFSTR("<image width=%d height=%d>"), imgWidth, imgHeight);

	buf[0] = 0;
	if (thread != NULL && CFStringGetLength(thread) < 16)
	{
		int n = 16 - (int)CFStringGetLength(thread);
		memset(buf, ' ', (size_t)n);
		buf[n] = 0;
	}
	CFStringAppendFormat(s, NULL, CFSTR(".%04d %s%@ | %@"),
						 (int)(timestamp.tv_usec / 1000),
						 buf, (thread == NULL) ? CFSTR("") : thread,
						 (message != NULL) ? message : CFSTR(""));

	if (thread != NULL)
		CFRelease(thread);
	if (message != NULL)
		CFRelease(message);

	if (type == LOGMSG_TYPE_LOG || type == LOGMSG_TYPE_MARK)
		CFShow(s);

	CFRelease(s);
}

static void LoggerWriteMoreData(Logger *logger)
{
    BOOL logToConsole = (logger->options & (kLoggerOption_LogToConsole | kLoggerOption_CaptureSystemConsole)) == kLoggerOption_LogToConsole;
	
	if (!logger->connected)
	{
		if (logToConsole)
		{
			pthread_mutex_lock(&logger->logQueueMutex);
			while (CFArrayGetCount(logger->logQueue))
			{
				LoggerLogToConsole((CFDataRef)CFArrayGetValueAtIndex(logger->logQueue, 0));
				CFArrayRemoveValueAtIndex(logger->logQueue, 0);
			}
			pthread_mutex_unlock(&logger->logQueueMutex);
			pthread_cond_broadcast(&logger->logQueueEmpty);
		}
		else if (logger->bufferWriteStream != NULL)
		{
			LoggerFlushQueueToBufferStream(logger, NO);
		}
        else if (!(logger->options & kLoggerOption_BufferLogsUntilConnection))
        {
            /* No client connected
             * User don't want to log to console
             * User don't want to log to file
             * and user don't want us to buffer it in memory
             * So let's just sack the whole queue
             */
			pthread_mutex_lock(&logger->logQueueMutex);
			while (CFArrayGetCount(logger->logQueue))
			{
				CFArrayRemoveValueAtIndex(logger->logQueue, 0);
			}
			pthread_mutex_unlock(&logger->logQueueMutex);
			pthread_cond_broadcast(&logger->logQueueEmpty);
        }
		return;
	}
	
	if (CFWriteStreamCanAcceptBytes(logger->logStream))
	{
		// prepare archived data with log queue contents, unblock the queue as soon as possible
		CFMutableDataRef sendFirstItem = NULL;
		if (logger->sendBufferUsed == 0)
		{
			// pull more data from the log queue
			pthread_mutex_lock(&logger->logQueueMutex);
			if (logger->bufferReadStream != NULL)
			{
				if (!CFReadStreamHasBytesAvailable(logger->bufferReadStream))
				{
					CFReadStreamClose(logger->bufferReadStream);
					CFRelease(logger->bufferReadStream);
					logger->bufferReadStream = NULL;
					LoggerEmptyBufferFile(logger);
				}
				else
				{
					logger->sendBufferUsed = (NSUInteger)CFReadStreamRead(logger->bufferReadStream, logger->sendBuffer, (CFIndex)logger->sendBufferSize);
				}
			}
			else
			{
				while (CFArrayGetCount(logger->logQueue))
				{
					CFDataRef d = (CFDataRef)CFArrayGetValueAtIndex(logger->logQueue, 0);
					CFIndex dsize = CFDataGetLength(d);
					if ((logger->sendBufferUsed + (NSUInteger)dsize) > logger->sendBufferSize)
						break;
					memcpy(logger->sendBuffer + logger->sendBufferUsed, CFDataGetBytePtr(d), (size_t)dsize);
					logger->sendBufferUsed += (NSUInteger)dsize;
					if (logToConsole)
						LoggerLogToConsole(d);
					CFArrayRemoveValueAtIndex(logger->logQueue, 0);
					logger->incompleteSendOfFirstItem = NO;
				}
			}
			if (logger->sendBufferUsed == 0) 
			{
				// are we done yet?
				if (CFArrayGetCount(logger->logQueue) == 0)
				{
					pthread_cond_broadcast(&logger->logQueueEmpty);
					pthread_mutex_unlock(&logger->logQueueMutex);
					return;
				}

				// first item is too big to fit in a single packet, send it separately
				sendFirstItem = (CFMutableDataRef)CFArrayGetValueAtIndex(logger->logQueue, 0);
				logger->incompleteSendOfFirstItem = YES;
				logger->sendBufferOffset = 0;
			}
			pthread_mutex_unlock(&logger->logQueueMutex);
		}

		// send data over the socket. We try hard to be failsafe and if we have to send
		// data in fragments, we make sure that in case a disconnect occurs we restart
		// sending the whole message(s)
		if (logger->sendBufferUsed != 0)
		{
			CFIndex written = CFWriteStreamWrite(logger->logStream,
												 logger->sendBuffer + logger->sendBufferOffset,
												 (CFIndex)(logger->sendBufferUsed - logger->sendBufferOffset));
			if (written < 0)
			{
				// We'll get an event if the stream closes on error. Don't discard the data,
				// it will be sent as soon as a connection is re-acquired.
				LOGGERDBG(CFSTR("CFWriteStreamWrite got %d result"),written);
				return;
			}
			if ((logger->sendBufferOffset + (NSUInteger)written) < logger->sendBufferUsed)
			{
				// everything couldn't be sent at once
				logger->sendBufferOffset += (NSUInteger)written;
			}
			else
			{
				logger->sendBufferUsed = 0;
				logger->sendBufferOffset = 0;
			}
		}
		else if (sendFirstItem)
		{
			CFIndex length = CFDataGetLength(sendFirstItem) - (CFIndex)logger->sendBufferOffset;
			CFIndex written = CFWriteStreamWrite(logger->logStream,
												 CFDataGetBytePtr(sendFirstItem) + logger->sendBufferOffset,
												 length);
			if (written < 0)
			{
				// We'll get an event if the stream closes on error
				return;
			}
			if (written < length)
			{
				// The output pipe is full, and the first item has not been sent completely
				// We need to reduce the remaining data on the first item so it can be taken
				// care of at the next iteration. We take advantage of the fact that each item
				// in the queue is actually a mutable data block
				// TODO: IF WE GET DISCONNECTED WHILE DOING THIS, THINGS WILL GO WRONG - NEED TO UPDATE THIS LOGIC
				LOGGERDBG(CFSTR("Output pipe is full"));
				CFDataReplaceBytes((CFMutableDataRef)sendFirstItem, CFRangeMake(0, written), NULL, 0);
				return;
			}
			
			// we are done sending the first item in the queue, remove it now
			pthread_mutex_lock(&logger->logQueueMutex);
			CFArrayRemoveValueAtIndex(logger->logQueue, 0);
			logger->incompleteSendOfFirstItem = NO;
			logger->sendBufferOffset = 0;
			pthread_mutex_unlock(&logger->logQueueMutex);
		}
		
		pthread_mutex_lock(&logger->logQueueMutex);
		CFIndex remainingMsgs = CFArrayGetCount(logger->logQueue);
		if (remainingMsgs == 0)
			pthread_cond_broadcast(&logger->logQueueEmpty);
		pthread_mutex_unlock(&logger->logQueueMutex);
	}
}

// -----------------------------------------------------------------------------
#pragma mark -
#pragma mark Console logs redirection support
// -----------------------------------------------------------------------------
static void LoggerLogFromConsole(CFStringRef tag, int fd, int outfd, CFMutableDataRef data)
{
	// protected by `consoleGrabbersMutex`

	const int BUFSIZE = 1000;
	size_t prognameLength = strlen(getprogname());

	UInt8 buf[BUFSIZE];
	ssize_t bytes_read = 0;
	while ((bytes_read = read(fd, buf, BUFSIZE-1)) >= 0)
	{
		if (bytes_read == 0)
			continue;

		CFDataAppendBytes(data, buf, bytes_read);

		if (outfd != -1)
		{
			// output received data to the original fd (so as to keep output in the Xcode console etc)
			//write(outfd, "##", 2); // internal debug stuff to visualize stdout/stderr fragmentation
			write(outfd, buf, (size_t)bytes_read);
		}
		
		for(;;)
		{
			// locate newline, group multiple lines in the same log string
			const unsigned char *bytes = CFDataGetMutableBytePtr(data);
			if (bytes == NULL)	// pointer may be null if data is empty
				break;
			
			NSInteger pos = 0, maxPos = CFDataGetLength(data), lineBreak = -1;
			while (pos < maxPos)
			{
				if (bytes[pos] == '\n')
					lineBreak = pos;
				pos++;
			}
			if (lineBreak == -1)
				break;
			pos = lineBreak;
			
			// detect and remove NSLog header if any
			NSUInteger offset = 0;
			if (pos > 24 + prognameLength + 2)
			{
				// "yyyy-mm-dd HH:MM:ss.SSS progname[:] "
				if ((bytes[4] == '-') && (bytes[7] == '-') && (bytes[10] == ' ') && (bytes[13] == ':') && (bytes[16] == ':') && (bytes[19] == '.'))
				{
					if ((bytes[23] == ' ') &&  (bytes[24 + prognameLength] == '['))
					{
						const char* found = strnstr((const char *)&bytes[24 + prognameLength + 1], "] ", maxPos - (24 + prognameLength + 1));
						if (found)
						{
							offset = found - (const char *)bytes + 2;
						}
					}
				}
			}
			
			// output message to grabbers
			CFStringRef message = CFStringCreateWithBytes(NULL, bytes+offset, pos-offset, kCFStringEncodingUTF8, false);
			if (message != NULL)
			{
				for (unsigned i = 0; i < consoleGrabbersListLength; i++)
				{
					if (consoleGrabbersList[i] != NULL)
						LogMessageRawToF(consoleGrabbersList[i], NULL, 0, NULL, (NSString *)tag, 0, (NSString *)message);
				}
				CFRelease(message);
			}
			else
			{
				LOGGERDBG(CFSTR("failed extracting string of length %d from fd %d"), pos-offset, fd);
			}
			
			// drop all newlines and move on
			while (++pos < maxPos && (bytes[pos] == '\n' || bytes[pos] == '\r'))
				;
			CFDataDeleteBytes(data, CFRangeMake(0, pos));
		}
	}
}

static void *LoggerConsoleGrabThread(void *context)
{
#pragma unused (context)
	pthread_mutex_lock(&consoleGrabbersMutex);

	int fdout = sConsolePipes[0];
	fcntl(fdout, F_SETFL, fcntl(fdout, F_GETFL, 0) | O_NONBLOCK);
	
	int fderr = sConsolePipes[2];
	fcntl(fderr, F_SETFL, fcntl(fderr, F_GETFL, 0) | O_NONBLOCK);
	
	CFMutableDataRef stdoutData = CFDataCreateMutable(NULL, 0);
	CFMutableDataRef stderrData = CFDataCreateMutable(NULL, 0);

	unsigned activeGrabbers = numActiveConsoleGrabbers;
	
	pthread_mutex_unlock(&consoleGrabbersMutex);
	
	while (activeGrabbers != 0)
	{
		fd_set set;
		FD_ZERO(&set);
		FD_SET(fdout, &set);
		FD_SET(fderr, &set);
		
		int ret = select(fderr + 1, &set, NULL, NULL, NULL);
		
		if (ret <= 0)
		{
			// ==0: time expired without activity
			// < 0: error occurred
			break;
		}

		pthread_mutex_lock(&consoleGrabbersMutex);
		
		activeGrabbers = numActiveConsoleGrabbers;
		if (activeGrabbers != 0)
		{
			if (FD_ISSET(fdout, &set))
				LoggerLogFromConsole(CFSTR("stdout"), fdout, sSTDOUT, stdoutData);
			if (FD_ISSET(fderr, &set ))
				LoggerLogFromConsole(CFSTR("stderr"), fderr, sSTDERR, stderrData);
		}

		pthread_mutex_unlock(&consoleGrabbersMutex);
	}
	
	CFRelease(stdoutData);
	CFRelease(stderrData);
	return NULL;
}

static void LoggerStartConsoleRedirection()
{
	// protected by `consoleGrabbersMutex`
	
	// keep the original pipes so we can still forward everything
	// (i.e. to the running IDE that needs to display or interpret console messages)
	// and remember the SIGPIPE settings, as we are going to clear them to prevent
	// the app from exiting when we close the pipes
	if (sSTDOUT == -1)
	{
		sSTDOUThadSIGPIPE = fcntl(STDOUT_FILENO, F_GETNOSIGPIPE);
		sSTDOUT = dup(STDOUT_FILENO);
		sSTDERRhadSIGPIPE = fcntl(STDERR_FILENO, F_GETNOSIGPIPE);
		sSTDERR = dup(STDERR_FILENO);
	}
	
	// create the pipes
	if (sConsolePipes[0] == -1)
	{
		if (pipe(sConsolePipes) != -1)
		{
			fcntl(sConsolePipes[0], F_SETNOSIGPIPE, 1);
			fcntl(sConsolePipes[1], F_SETNOSIGPIPE, 1);
			dup2(sConsolePipes[1], STDOUT_FILENO);
		}
	}
	
	if (sConsolePipes[2] == -1)
	{
		if (pipe(&sConsolePipes[2]) != -1)
		{
			fcntl(sConsolePipes[0], F_SETNOSIGPIPE, 1);
			fcntl(sConsolePipes[1], F_SETNOSIGPIPE, 1);
			dup2(sConsolePipes[3], STDERR_FILENO);
		}
	}
	
	pthread_create(&consoleGrabThread, NULL, &LoggerConsoleGrabThread, NULL);
}

static void LoggerStopConsoleRedirection()
{
	// protected by consoleGrabbersMutex (see below)

	// close the pipes - will force exiting the console logger thread
	// assume the console grabber mutex has been acquired
	dup2(sSTDOUT, STDOUT_FILENO);
	dup2(sSTDERR, STDERR_FILENO);
	
	close(sSTDOUT);
	close(sSTDERR);
	
	sSTDOUT = -1;
	sSTDERR = -1;
	
	// restore sigpipe flag on standard streams
	fcntl(STDOUT_FILENO, F_SETNOSIGPIPE, &sSTDOUThadSIGPIPE);
	fcntl(STDERR_FILENO, F_SETNOSIGPIPE, &sSTDERRhadSIGPIPE);
	
	// close pipes, this will trigger an error in select() and a console grab thread exit
	if (sConsolePipes[0] != -1)
	{
		close(sConsolePipes[0]);
		close(sConsolePipes[1]);
		sConsolePipes[0] = -1;
	}
	if (sConsolePipes[2] != -1)
	{
		close(sConsolePipes[2]);
		close(sConsolePipes[1]);
	}
	sConsolePipes[0] = sConsolePipes[1] = sConsolePipes[2] = sConsolePipes[3] = -1;
	numActiveConsoleGrabbers = 0;

	pthread_mutex_unlock(&consoleGrabbersMutex);
	pthread_join(consoleGrabThread, NULL);
	pthread_mutex_lock(&consoleGrabbersMutex);
}

static void LoggerStartGrabbingConsole(Logger *logger)
{
	if (!(logger->options & kLoggerOption_CaptureSystemConsole))
		return;
	
	pthread_mutex_lock(&consoleGrabbersMutex);
	
	Boolean added = FALSE;
	for (unsigned i = 0; i < numActiveConsoleGrabbers; i++)
	{
		if (consoleGrabbersList[i] == NULL)
		{
			consoleGrabbersList[i] = logger;
			numActiveConsoleGrabbers++;
			added = TRUE;
			break;
		}
	}
	if (!added)
	{
		consoleGrabbersList = realloc(consoleGrabbersList, ++consoleGrabbersListLength * sizeof(Logger *));
		consoleGrabbersList[numActiveConsoleGrabbers++] = logger;
	}
	
	LoggerStartConsoleRedirection(); // Start redirection if necessary
	
	pthread_mutex_unlock(&consoleGrabbersMutex);
}

static void LoggerStopGrabbingConsole(Logger *logger)
{
	pthread_mutex_lock(&consoleGrabbersMutex);
	
	if (numActiveConsoleGrabbers != 0)
	{
		for (unsigned grabberIndex = 0; grabberIndex < consoleGrabbersListLength; grabberIndex++)
		{
			if (consoleGrabbersList[grabberIndex] == logger)
			{
				consoleGrabbersList[grabberIndex] = NULL;
				if (--numActiveConsoleGrabbers == 0)
				{
					consoleGrabbersListLength = 0;
					free(consoleGrabbersList);
					consoleGrabbersList = NULL;
					LoggerStopConsoleRedirection();
				}
				break;
			}
		}
	}
	
	pthread_mutex_unlock(&consoleGrabbersMutex);
}

// -----------------------------------------------------------------------------
#pragma mark -
#pragma mark File buffering functions
// -----------------------------------------------------------------------------
static void LoggerCreateBufferWriteStream(Logger *logger)
{
	LOGGERDBG(CFSTR("LoggerCreateBufferWriteStream to file %@"), logger->bufferFile);
	CFURLRef fileURL = CFURLCreateWithFileSystemPath(NULL, logger->bufferFile, kCFURLPOSIXPathStyle, false);
	if (fileURL != NULL)
	{
		// Create write stream to file
		logger->bufferWriteStream = CFWriteStreamCreateWithFile(NULL, fileURL);
		CFRelease(fileURL);
		if (logger->bufferWriteStream != NULL)
		{
			// Set flag to append new data to buffer file
			CFWriteStreamSetProperty(logger->bufferWriteStream, kCFStreamPropertyAppendToFile, kCFBooleanTrue);

			// Open the buffer stream for writing
			if (!CFWriteStreamOpen(logger->bufferWriteStream))
			{
				CFRelease(logger->bufferWriteStream);
				logger->bufferWriteStream = NULL;
			}
			else
			{
				// Write client info and flush the queue contents to buffer file
				LoggerPushClientInfoToFrontOfQueue(logger);
				LoggerFlushQueueToBufferStream(logger, YES);
			}
		}
	}
	if (logger->bufferWriteStream == NULL)
	{
		CFShow(CFSTR("NSLogger Warning: failed opening buffer file for writing:"));
		CFShow(logger->bufferFile);
	}
}

static void LoggerCreateBufferReadStream(Logger *logger)
{
	LOGGERDBG(CFSTR("LoggerCreateBufferReadStream from file %@"), logger->bufferFile);
	CFURLRef fileURL = CFURLCreateWithFileSystemPath(NULL, logger->bufferFile, kCFURLPOSIXPathStyle, false);
	if (fileURL != NULL)
	{
		// Create read stream from file
		logger->bufferReadStream = CFReadStreamCreateWithFile(NULL, fileURL);
		CFRelease(fileURL);
		if (logger->bufferReadStream != NULL)
		{
			if (!CFReadStreamOpen(logger->bufferReadStream))
			{
				CFRelease(logger->bufferReadStream);
				logger->bufferReadStream = NULL;
			}
		}
	}
}

static void LoggerEmptyBufferFile(Logger *logger)
{
	// completely remove the buffer file from storage
	LOGGERDBG(CFSTR("LoggerEmptyBufferFile %@"), logger->bufferFile);
	if (logger->bufferFile != NULL)
	{
		CFIndex bufferSize = 1 + CFStringGetLength(logger->bufferFile) * 3;
		char *buffer = (char *)malloc((size_t)bufferSize);
		if (buffer != NULL)
		{
			if (CFStringGetFileSystemRepresentation(logger->bufferFile, buffer, bufferSize))
			{
				// remove file
				unlink(buffer);
			}
			free(buffer);
		}
	}
}

static void LoggerFileBufferingOptionsChanged(Logger *logger)
{
	// File buffering options changed (callback called on logger thread):
	// - close the current buffer file stream, if any
	// - create a new one, if needed
	LOGGERDBG(CFSTR("LoggerFileBufferingOptionsChanged bufferFile=%@"), logger->bufferFile);
	if (logger->bufferWriteStream != NULL)
	{
		CFWriteStreamClose(logger->bufferWriteStream);
		CFRelease(logger->bufferWriteStream);
		logger->bufferWriteStream = NULL;
	}
	if (logger->bufferFile  != NULL)
		LoggerCreateBufferWriteStream(logger);
}

static void LoggerFlushQueueToBufferStream(Logger *logger, BOOL firstEntryIsClientInfo)
{
	LOGGERDBG(CFSTR("LoggerFlushQueueToBufferStream"));
	pthread_mutex_lock(&logger->logQueueMutex);
	if (logger->incompleteSendOfFirstItem)
	{
		// drop anything being sent
		logger->sendBufferUsed = 0;
		logger->sendBufferOffset = 0;
	}
	logger->incompleteSendOfFirstItem = NO;

	// Write outstanding messages to the buffer file (streams don't detect disconnection
	// until the next write, where we could lose one or more messages)
	if (!firstEntryIsClientInfo && logger->sendBufferUsed)
		CFWriteStreamWrite(logger->bufferWriteStream, logger->sendBuffer + logger->sendBufferOffset, (CFIndex)(logger->sendBufferUsed - logger->sendBufferOffset));
	
	int n = 0;
	while (CFArrayGetCount(logger->logQueue))
	{
		CFDataRef data = CFArrayGetValueAtIndex(logger->logQueue, 0);
		CFIndex dataLength = CFDataGetLength(data);
		CFIndex written = CFWriteStreamWrite(logger->bufferWriteStream, CFDataGetBytePtr(data), dataLength);
		if (written != dataLength)
		{
			// couldn't write all data to file, maybe storage run out of space?
			CFShow(CFSTR("NSLogger Error: failed flushing the whole queue to buffer file:"));
			CFShow(logger->bufferFile);
			break;
		}
		CFArrayRemoveValueAtIndex(logger->logQueue, 0);
		if (n == 0 && firstEntryIsClientInfo && logger->sendBufferUsed)
		{
			// try hard: write any outstanding messages to the buffer file, after the client info
			CFWriteStreamWrite(logger->bufferWriteStream, logger->sendBuffer + logger->sendBufferOffset, (CFIndex)(logger->sendBufferUsed - logger->sendBufferOffset));
		}
		n++;
	}
	logger->sendBufferUsed = 0;
	logger->sendBufferOffset = 0;
	pthread_mutex_unlock(&logger->logQueueMutex);
	pthread_cond_broadcast(&logger->logQueueEmpty);
}

// -----------------------------------------------------------------------------
#pragma mark -
#pragma mark Bonjour browsing
// -----------------------------------------------------------------------------
static void LoggerStartBonjourBrowsing(Logger *logger)
{
	if (!logger->targetReachable ||
		logger->bonjourDomainBrowser != NULL ||
		!(logger->options & kLoggerOption_BrowseBonjour))
		return;

	LOGGERDBG(CFSTR("LoggerStartBonjourBrowsing"));
	
	if (logger->options & kLoggerOption_BrowseOnlyLocalDomain)
	{
		LOGGERDBG(CFSTR("Logger configured to search only the local domain, searching for services on: local."));
		LoggerBrowseBonjourForServices(logger, CFSTR("local."));
	}
	else
	{
		LOGGERDBG(CFSTR("Logger configured to search all domains, browsing for domains first"));
		NSNetServiceBrowser *browser = [NSNetServiceBrowser new];
		browser.delegate = [[FPLLoggerBonjourDelegate alloc] initWithLogger:logger];
		[browser searchForBrowsableDomains];
		logger->bonjourDomainBrowser = browser;
	}
}

static void LoggerStopBonjourBrowsing(Logger *logger)
{
	LOGGERDBG(CFSTR("LoggerStopBonjourBrowsing"));
	
	// stop browsing for domains
	if (logger->bonjourDomainBrowser != NULL)
	{
		[logger->bonjourDomainBrowser stop];
		[logger->bonjourDomainBrowser.delegate release];
		[logger->bonjourDomainBrowser release];
		logger->bonjourDomainBrowser = NULL;
	}
	
	// stop browsing for services
	CFIndex idx;
	for (idx = 0; idx < CFArrayGetCount(logger->bonjourServiceBrowsers); idx++)
	{
		NSNetServiceBrowser *browser = CFArrayGetValueAtIndex(logger->bonjourServiceBrowsers, idx);
		[browser stop];
		[browser.delegate release];
	}
	CFArrayRemoveAllValues(logger->bonjourServiceBrowsers);
	
	// Forget all services
	CFArrayRemoveAllValues(logger->bonjourServices);
}

static void LoggerBrowseBonjourForServices(Logger *logger, CFStringRef domainName)
{
	NSNetServiceBrowser *browser;
	browser = [NSNetServiceBrowser new];
	browser.includesPeerToPeer = (logger->options & kLoggerOption_BrowsePeerToPeer) == kLoggerOption_BrowsePeerToPeer;
	browser.delegate = [[FPLLoggerBonjourDelegate alloc] initWithLogger:logger];

	// try to use the user-specfied service type if any, fallback on our
	// default service type
	CFStringRef serviceType = logger->bonjourServiceType;
	if (serviceType == NULL)
	{
		if (logger->options & kLoggerOption_UseSSL)
			serviceType = LOGGER_SERVICE_TYPE_SSL;
		else
			serviceType = LOGGER_SERVICE_TYPE;
	}
	
	[browser searchForServicesOfType:(__bridge NSString *)serviceType inDomain:(__bridge NSString *)domainName];
	LOGGERDBG(CFSTR("Logger started search for services of type %@ in domain %@"), serviceType, domainName);
	CFArrayAppendValue(logger->bonjourServiceBrowsers, browser);
	[browser release];
}

static void LoggerConnectToService(Logger *logger, NSNetService *service)
{
	// a service has been found
	LOGGERDBG(CFSTR("Logger found service: %@"), service);
	if (service == NULL)
		return;
	
	// if the user has specified that Logger shall only connect to the specified
	// Bonjour service name, check it now. This makes things easier in a teamwork
	// environment where multiple instances of NSLogger viewer may run on the
	// same network
	CFStringRef serviceName = (__bridge CFStringRef)service.name;
	if (logger->bonjourServiceName != NULL)
	{
		LOGGERDBG(CFSTR("-> looking for services of name %@"), logger->bonjourServiceName);
		if (serviceName == NULL || kCFCompareEqualTo != CFStringCompare(serviceName, logger->bonjourServiceName, kCFCompareCaseInsensitive | kCFCompareDiacriticInsensitive))
		{
			LOGGERDBG(CFSTR("-> service name %@ does not match requested service name, ignoring."), serviceName);
			return;
		}
	}
	else
	{
		// If the desktop viewer we found requested that only clients looking for its name can connect,
		// honor the request and do not connect. This helps with teams having multiple devices and multiple
		// desktops with NSLogger installed to avoid unwanted logs coming to a specific viewer
		// To indicate that the desktop only wants clients that are looking for its specific name,
		// the desktop sets the TXT record to be a dictionary containing the @"filterClients" key with value @"1"
		CFDataRef txtData = (__bridge CFDataRef)service.TXTRecordData;
		if (txtData != NULL)
		{
			CFDictionaryRef txtDict = CFNetServiceCreateDictionaryWithTXTData(NULL, txtData);
			if (txtDict != NULL)
			{
				const void *value = CFDictionaryGetValue(txtDict, CFSTR("filterClients"));
				Boolean mismatch = (value != NULL &&
									CFGetTypeID((CFTypeRef)value) == CFStringGetTypeID() &&
									CFStringCompare((CFStringRef)value, CFSTR("1"), 0) != kCFCompareEqualTo);
				CFRelease(txtDict);
				if (mismatch)
				{
					LOGGERDBG(CFSTR("-> service %@ requested that only clients looking for it do connect."), serviceName);
					return;
				}
			}
		}
	}
	CFArrayAppendValue(logger->bonjourServices, service);
	LoggerTryConnect(logger);
}

static void LoggerDisconnectFromService(Logger *logger, NSNetService *service)
{
	CFIndex idx = CFArrayGetFirstIndexOfValue(logger->bonjourServices, CFRangeMake(0, CFArrayGetCount(logger->bonjourServices)), service);
	if (idx == -1)
		return;
	
	[service stop];
	
	CFArrayRemoveValueAtIndex(logger->bonjourServices, idx);
}

@implementation FPLLoggerBonjourDelegate

- (instancetype)initWithLogger:(Logger *)logger;
{
	if (!(self = [super init]))
		return nil;
	
	_logger = logger;
	
	return self;
}

- (void)netServiceBrowser:(NSNetServiceBrowser *)browser didNotSearch:(NSDictionary<NSString *, NSNumber *> *)errorDict
{
	LOGGERDBG(CFSTR("netServiceBrowser:%@ didNotSearch:%@"), browser, errorDict);
	
	if (browser == self->_logger->bonjourDomainBrowser)
	{
		// An error occurred, revert to console logging if there is no remote host
		LOGGERDBG(CFSTR("*** Logger: could not browse for domains, reverting to console logging. ***"));
		CFRelease(self->_logger->bonjourDomainBrowser);
		self->_logger->bonjourDomainBrowser = NULL;
		if (self->_logger->host == NULL)
			self->_logger->options |= kLoggerOption_LogToConsole;
	}
	else if (self->_logger->host == NULL)
	{
		LOGGERDBG(CFSTR("*** Logger: could not browse for services, no remote host configured: reverting to console logging. ***"));
		self->_logger->options |= kLoggerOption_LogToConsole;
	}
}

- (void)netServiceBrowser:(NSNetServiceBrowser *)browser didFindDomain:(NSString *)domain moreComing:(BOOL)moreComing
{
	LoggerBrowseBonjourForServices(self->_logger, (__bridge CFStringRef)domain);
}

- (void)netServiceBrowser:(NSNetServiceBrowser *)browser didFindService:(NSNetService *)service moreComing:(BOOL)moreComing
{
	LoggerConnectToService(self->_logger, service);
}

- (void)netServiceBrowser:(NSNetServiceBrowser *)browser didRemoveService:(NSNetService *)service moreComing:(BOOL)moreComing
{
	LoggerDisconnectFromService(self->_logger, service);
}

@end

// -----------------------------------------------------------------------------
#pragma mark -
#pragma mark Reachability & Connectivity Management
// -----------------------------------------------------------------------------
static void LoggerRemoteSettingsChanged(Logger *logger)
{
	// this is a callback for a runloop source, called on the logger thread
	
	// Always terminate any ongoing connection first
	LoggerWriteStreamTerminated(logger);

	LoggerStopBonjourBrowsing(logger);
	LoggerStopReconnectTimer(logger);
	LoggerStopReachabilityChecking(logger);

	if (logger->host == NULL && !(logger->options & kLoggerOption_BrowseBonjour))
	{
		// developer doesn't want any network connection
	}
	else
	{
		// we may already have Reachability or Bonjour browsing running,
		// the calls do nothing if they are not needed
		LoggerStartReachabilityChecking(logger);
		if (logger->targetReachable)
		{
			if (logger->options & kLoggerOption_BrowseBonjour)
				LoggerStartBonjourBrowsing(logger);
		}
		LoggerTryConnect(logger);
	}
}

static void LoggerStartReachabilityChecking(Logger *logger)
{
	if (logger->reachability == NULL)
	{
		// start reachability only when network will be required, which is at least one of:
		// - Bonjour is being used
		// - A target host has been specified
		if (logger->host == NULL && !(logger->options & kLoggerOption_BrowseBonjour))
			return;

		if (logger->host != NULL)
		{
			// reachability targeted to the configured host
			LOGGERDBG(CFSTR("Starting SCNetworkReachability to wait for host %@ to be reachable"), logger->host);
			CFIndex length = CFStringGetLength(logger->host) * 3;
			char *buffer = (char *)malloc((size_t)length + 1);
			CFStringGetBytes(logger->host, CFRangeMake(0, CFStringGetLength(logger->host)), kCFStringEncodingUTF8, '?', false, (UInt8 *)buffer, length, &length);
			buffer[length] = 0;

			logger->reachability = SCNetworkReachabilityCreateWithName(NULL, buffer);

			free(buffer);
		}
		else
		{
			// reachability for generic connection to the internet
			LOGGERDBG(CFSTR("Starting SCNetworkReachability to wait for internet to be reachable"));
			struct sockaddr_in addr;
			bzero(&addr, sizeof(addr));
			addr.sin_len = (__uint8_t) sizeof(addr);
			addr.sin_family = AF_INET;

			logger->reachability = SCNetworkReachabilityCreateWithAddress(NULL, (const struct sockaddr *)&addr);
		}
		
		SCNetworkReachabilityContext context = {0, logger, NULL, NULL, NULL};
		SCNetworkReachabilitySetCallback(logger->reachability, &LoggerReachabilityCallBack, &context);
		SCNetworkReachabilityScheduleWithRunLoop(logger->reachability, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);

		// arm the callback
		if (SCNetworkReachabilityGetFlags(logger->reachability, &logger->reachabilityFlags))
			LoggerReachabilityCallBack(logger->reachability, logger->reachabilityFlags, logger);
	}
}

static void LoggerStopReachabilityChecking(Logger *logger)
{
	if (logger->reachability != NULL)
	{
		LOGGERDBG(CFSTR("Stopping SCNetworkReachability"));
		SCNetworkReachabilityUnscheduleFromRunLoop(logger->reachability, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
		CFRelease((CFTypeRef)logger->reachability);
		logger->reachability = NULL;
	}
	LoggerStopReconnectTimer(logger);
	logger->targetReachable = NO;
}

static void LoggerReachabilityCallBack(SCNetworkReachabilityRef target, SCNetworkReachabilityFlags flags, void *info)
{
#pragma unused (target)
	Logger *logger = (Logger *)info;

	LOGGERDBG(CFSTR("LoggerReachabilityCallBack called with flags=0x%08lx"), flags);

	SCNetworkReachabilityFlags oldFlags = logger->reachabilityFlags;
	logger->reachabilityFlags = flags;
	
	bool isReachable = flags & kSCNetworkReachabilityFlagsReachable;
	if (!isReachable && (logger->connected || logger->logStream != NULL))
	{
		// lost internet connecton. Force a disconnect, we'll wait for the connection to become
		// available again
		LOGGERDBG(CFSTR("-> target became unreachable"));
		logger->targetReachable = NO;
		if (flags != oldFlags && logger->logStream != NULL)
			LoggerWriteStreamTerminated(logger);
		LoggerStopBonjourBrowsing(logger);
		LoggerStopReconnectTimer(logger);
	}
	else
	{
		if (isReachable)
			LOGGERDBG(CFSTR("-> target became reachable"));
		else
			LOGGERDBG(CFSTR("-> target is not reachable, let's pretend it is and try to connect anyway"));
		
		logger->targetReachable = YES;
		
		// in the event a network transition occurred without network loss (i.e. WiFi -> 3G),
		// preemptively disconnect. In many cases, if the network stays up, we will never receive
		// a disconnection (possibly due to SSH ?)
		if (flags != oldFlags && logger->logStream != NULL)
			LoggerWriteStreamTerminated(logger);
		else
			LoggerTryConnect(logger);			// will start Bonjour browsing if needed
	}
}

static void LoggerStartReconnectTimer(Logger *logger)
{
	// start a timer that will try to reconnect every 5 seconds
	if (logger->reconnectTimer == NULL && (logger->host != NULL || (logger->options & kLoggerOption_BrowseBonjour)))
	{
		LOGGERDBG(CFSTR("Starting the reconnect timer"));
		CFRunLoopTimerContext timerCtx = {
			.version = 0,
			.info = logger,
			.retain = NULL,
			.release = NULL,
			.copyDescription = NULL
		};
		logger->reconnectTimer = CFRunLoopTimerCreate(NULL,
													  CFAbsoluteTimeGetCurrent() + 5,
													  5, // reconnect interval
													  0,
													  0,
													  &LoggerTimedReconnectCallback,
													  &timerCtx);
		if (logger->reconnectTimer != NULL)
		{
			LOGGERDBG(CFSTR("Starting the TimedReconnect timer to regularly retry the connection"));
			CFRunLoopAddTimer(CFRunLoopGetCurrent(), logger->reconnectTimer, kCFRunLoopCommonModes);
		}
	}
}

static void LoggerStopReconnectTimer(Logger *logger)
{
	if (logger->reconnectTimer != NULL)
	{
		LOGGERDBG(CFSTR("Stopping the reconnect timer"));
		CFRunLoopTimerInvalidate(logger->reconnectTimer);
		CFRunLoopRemoveTimer(CFRunLoopGetCurrent(), logger->reconnectTimer, kCFRunLoopCommonModes);
		CFRelease(logger->reconnectTimer);
		logger->reconnectTimer = NULL;
	}
}

static void LoggerTimedReconnectCallback(CFRunLoopTimerRef timer, void *info)
{
#pragma unused (timer)
	Logger *logger = (Logger *)info;
	assert(logger != NULL);
	LOGGERDBG(CFSTR("LoggerTimedReconnectCallback"));
	if (logger->logStream == NULL)
	{
		LOGGERDBG(CFSTR("-> trying to reconnect to host %@"), logger->host);
		LoggerTryConnect(logger);
	}
	else
	{
		LOGGERDBG(CFSTR("-> timer not needed anymore, removing it form runloop"));
		LoggerStopReconnectTimer(logger);
	}
}

// -----------------------------------------------------------------------------
#pragma mark -
#pragma mark Stream management
// -----------------------------------------------------------------------------
static BOOL LoggerConfigureAndOpenStream(Logger *logger)
{
	// configure and open stream
	LOGGERDBG(CFSTR("LoggerConfigureAndOpenStream configuring and opening log stream"));
	CFStreamClientContext context = {0, (void *)logger, NULL, NULL, NULL};
	if (CFWriteStreamSetClient(logger->logStream,
							   (kCFStreamEventOpenCompleted |
								kCFStreamEventCanAcceptBytes |
								kCFStreamEventErrorOccurred |
								kCFStreamEventEndEncountered),
							   &LoggerWriteStreamCallback,
							   &context))
	{
		if (logger->options & kLoggerOption_UseSSL)
		{
			// Configure stream to require a SSL connection
			LOGGERDBG(CFSTR("-> configuring SSL"));
			const void *SSLKeys[] = {
				kCFStreamSSLLevel,
				kCFStreamSSLValidatesCertificateChain,
				kCFStreamSSLIsServer,
				kCFStreamSSLPeerName
			};
			const void *SSLValues[] = {
				kCFStreamSocketSecurityLevelNegotiatedSSL,
				kCFBooleanFalse,			// no certificate chain validation (we use a self-signed certificate)
				kCFBooleanFalse,			// not a server
				kCFNull
			};
			
			CFDictionaryRef SSLDict = CFDictionaryCreate(NULL, SSLKeys, SSLValues, 4, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
			CFWriteStreamSetProperty(logger->logStream, kCFStreamPropertySSLSettings, SSLDict);
			CFRelease(SSLDict);
		}

		CFWriteStreamScheduleWithRunLoop(logger->logStream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
		
		if (CFWriteStreamOpen(logger->logStream))
		{
			LOGGERDBG(CFSTR("-> stream open attempt, waiting for open completion"));
			return YES;
		}

		LOGGERDBG(CFSTR("-> stream open failed."));
		
		CFWriteStreamSetClient(logger->logStream, kCFStreamEventNone, NULL, NULL);
		if (CFWriteStreamGetStatus(logger->logStream) == kCFStreamStatusOpen)
			CFWriteStreamClose(logger->logStream);
		CFWriteStreamUnscheduleFromRunLoop(logger->logStream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
	}
	else
	{
		LOGGERDBG(CFSTR("-> stream set client failed."));
	}
	CFRelease(logger->logStream);
	logger->logStream = NULL;
	return NO;
}

static void LoggerTryConnect(Logger *logger)
{
	// Core function that attempts connection to found Bonjour services and configured Host
	LOGGERDBG(CFSTR("LoggerTryConnect, %d services registered, current stream=%@"), CFArrayGetCount(logger->bonjourServices), logger->logStream);
	
	// If we already have a connection established or being attempted, stop here
	if (logger->logStream != NULL)
	{
		LOGGERDBG(CFSTR("-> another connection is opened or in progress, giving up for now"));
		return;
	}
	
	// If reachability status is not known yet, just wait
	if (logger->targetReachable == NO)
	{
		LOGGERDBG(CFSTR("-> not sure target is reachable, let's wait and see"));
		return;
	}

	// If there are discovered Bonjour services, try them now
	while (CFArrayGetCount(logger->bonjourServices))
	{
		NSNetService *service = CFArrayGetValueAtIndex(logger->bonjourServices, 0);
		LOGGERDBG(CFSTR("-> Trying to open write stream to service %@"), service);
		NSOutputStream *outputStream;
		[service getInputStream:NULL outputStream:&outputStream];
		logger->logStream = (CFWriteStreamRef)outputStream;
		CFArrayRemoveValueAtIndex(logger->bonjourServices, 0);
		if (logger->logStream == NULL)
		{
			// create pair failed
			LOGGERDBG(CFSTR("-> failed."));
		}
		else if (LoggerConfigureAndOpenStream(logger))
		{
			// open is now in progress
			return;
		}
	}

	// If there is a host to directly connect to, try it now (this will happen before
	// Bonjour kicks in, Bonjour being handled as a fallback solution if direct Host
	// fails)
	if (logger->host != NULL)
	{
		LOGGERDBG(CFSTR("-> Trying to open direct connection to host %@ port %u"), logger->host, logger->port);
		CFStreamCreatePairWithSocketToHost(NULL, logger->host, logger->port, NULL, &logger->logStream);
		if (logger->logStream == NULL)
		{
			// Create stream failed
			LOGGERDBG(CFSTR("-> failed."));
			if (logger->logStream != NULL)
			{
				CFRelease(logger->logStream);
				logger->logStream = NULL;
			}
		}
		else if (LoggerConfigureAndOpenStream(logger))
		{
			// open is now in progress
			return;
		}
		LoggerStartReconnectTimer(logger);
	}
	
	// Finally, if Bonjour is enabled and not started yet, start it now.
	if (logger->options & kLoggerOption_BrowseBonjour)
	{
		if (logger->bonjourDomainBrowser == NULL || CFArrayGetCount(logger->bonjourServiceBrowsers) == 0)
		{
			LoggerStopBonjourBrowsing(logger);
			LoggerStartBonjourBrowsing(logger);
		}
	}
}

static void LoggerWriteStreamTerminated(Logger *logger)
{
	LOGGERDBG(CFSTR("LoggerWriteStreamTerminated called"));

	if (logger->connected)
	{
		LOGGERDBG(CFSTR("-> Logger DISCONNECTED"));
		logger->connected = NO;
	}

	if (logger->logStream != NULL)
	{
		LOGGERDBG(CFSTR("-> disposing the write stream"));
		CFWriteStreamSetClient(logger->logStream, 0, NULL, NULL);
		CFWriteStreamUnscheduleFromRunLoop(logger->logStream, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
		CFWriteStreamClose(logger->logStream);
		
		CFRelease(logger->logStream);
		logger->logStream = NULL;
	}

	if (logger->bufferReadStream != NULL)
	{
		// In the case the connection drops before we have flushed the
		// whole contents of the file, we choose to keep it integrally
		// and retransmit it when reconnecting to the viewer. The reason
		// of this choice is that we may have transmitted only part of
		// a message, and this may cause errors on the desktop side.
		LOGGERDBG(CFSTR("-> closing the bufferReadStream"));
		CFReadStreamClose(logger->bufferReadStream);
		CFRelease(logger->bufferReadStream);
		logger->bufferReadStream = NULL;
	}

	if (logger->bufferFile != NULL && logger->bufferWriteStream == NULL)
		LoggerCreateBufferWriteStream(logger);

	// ensure that any current block on LoggerFlush() gets unblocked
	pthread_cond_broadcast(&logger->logQueueEmpty);

	// tryConnect will take care of setting up the reconnect timer if needed
	if (logger->targetReachable &&
		(logger->host != NULL || (logger->options & kLoggerOption_BrowseBonjour)))
		LoggerTryConnect(logger);
}

static void LoggerWriteStreamCallback(CFWriteStreamRef ws, CFStreamEventType event, void* info)
{
	Logger *logger = (Logger *)info;
	assert(ws == logger->logStream);
	switch (event)
	{
		case kCFStreamEventOpenCompleted:
			// A stream open was complete. Cancel all bonjour browsing,
			// service resolution and connection attempts, and try to
			// write existing buffer contents
			LOGGERDBG(CFSTR("Logger CONNECTED"));
			logger->connected = YES;
			LoggerStopBonjourBrowsing(logger);
			LoggerStopReconnectTimer(logger);
			if (logger->bufferWriteStream != NULL)
			{
				// now that a connection is acquired, we can stop logging to a file
				CFWriteStreamClose(logger->bufferWriteStream);
				CFRelease(logger->bufferWriteStream);
				logger->bufferWriteStream = NULL;
			}
			if (logger->bufferFile != NULL)
			{
				// if a buffer file was defined, try to read its contents
				LoggerCreateBufferReadStream(logger);
			}
			LoggerPushClientInfoToFrontOfQueue(logger);
			LoggerWriteMoreData(logger);
			break;
			
		case kCFStreamEventCanAcceptBytes:
			LoggerWriteMoreData(logger);
			break;
			
		case kCFStreamEventErrorOccurred: {
			CFErrorRef error = CFWriteStreamCopyError(ws);
			LOGGERDBG(CFSTR("Logger stream error: %@"), error);
			CFRelease(error);
			// Fall-thru
		}
			
		case kCFStreamEventEndEncountered:
			LoggerWriteStreamTerminated(logger);
			break;

		// avoid warnings when building; cover all enum cases.
        case kCFStreamEventNone:
        case kCFStreamEventHasBytesAvailable:
            break;
	}
}

// -----------------------------------------------------------------------------
#pragma mark -
#pragma mark Internal encoding functions
// -----------------------------------------------------------------------------

#define WRITE_MISALIGNED_INT32(p,n) { \
	uint32_t i32 = (uint32_t)(n); \
	uint8_t *q32 = (uint8_t *)(p) + 3; \
	*q32-- = (uint8_t)i32; i32 >>= 8; \
	*q32-- = (uint8_t)i32; i32 >>= 8; \
	*q32-- = (uint8_t)i32; i32 >>= 8; \
	*q32 = (uint8_t)i32; \
}

#if __LP64__
#define WRITE_MISALIGNED_INT64(p,n) { \
	uint32_t i = (uint32_t)(n); \
	uint8_t *q = (uint8_t *)(p) + 7; \
	*q-- = (uint8_t)i; i >>= 8; \
	*q-- = (uint8_t)i; i >>= 8; \
	*q-- = (uint8_t)i; i >>= 8; \
	*q-- = (uint8_t)i; i >>= 8; \
	*q-- = (uint8_t)i; i >>= 8; \
	*q-- = (uint8_t)i; i >>= 8; \
	*q-- = (uint8_t)i; i >>= 8; \
	*q = (uint8_t)i; \
}
#endif

static uint8_t *LoggerMessagePrepareForPart(CFMutableDataRef encoder, uint32_t requiredExtraBytes)
{
	// Ensure a data block has the required storage capacity, update the total size and part count
	// then return a pointer for fast storage of the data
	uint8_t *p = CFDataGetMutableBytePtr(encoder);
	CFIndex size = CFDataGetLength(encoder);
	uint32_t oldSize = ntohl(*(uint32_t *)p);
	uint32_t newSize = oldSize + requiredExtraBytes;
	if ((newSize + 4) > (uint32_t)size)
	{
		// grow by 64 bytes chunks
		CFDataSetLength(encoder, (newSize + 4 + 64) & ~63);
		p = CFDataGetMutableBytePtr(encoder);
	}
	*((uint32_t *)p) = htonl(newSize);
	p += 4;
	*((uint16_t *)p) = htons(ntohs(*(uint16_t *)p) + 1);

	// return a pointer to where new data must be put
	return p + oldSize;
}

static void LoggerMessageAddTimestamp(CFMutableDataRef encoder)
{
	struct timeval t;
	if (gettimeofday(&t, NULL) == 0)
	{
#if __LP64__
		LoggerMessageAddInt64(encoder, t.tv_sec, PART_KEY_TIMESTAMP_S);
		LoggerMessageAddInt64(encoder, t.tv_usec, PART_KEY_TIMESTAMP_US);
#else
		LoggerMessageAddInt32(encoder, t.tv_sec, PART_KEY_TIMESTAMP_S);
		LoggerMessageAddInt32(encoder, t.tv_usec, PART_KEY_TIMESTAMP_US);
#endif
	}
	else
	{
		time_t ts = time(NULL);
#if __LP64__
		LoggerMessageAddInt64(encoder, ts, PART_KEY_TIMESTAMP_S);
#else
		LoggerMessageAddInt32(encoder, ts, PART_KEY_TIMESTAMP_S);
#endif
	}
}

static void LoggerMessageAddTimestampAndThreadID(CFMutableDataRef encoder)
{
	LoggerMessageAddTimestamp(encoder);

	BOOL hasThreadName = NO;
	// Getting the thread number is tedious, to say the least. Since there is
	// no direct way to get it, we have to do it sideways. Note that it can be dangerous
	// to use any Cocoa call when in a multithreaded application that only uses non-Cocoa threads
	// and for which Cocoa's multithreading has not been activated. We test for this case.
	BOOL inMainThread = [NSThread isMainThread];
	if (inMainThread)
	{
		hasThreadName = YES;
		LoggerMessageAddString(encoder, CFSTR("Main thread"), PART_KEY_THREAD_ID);
	}
	else if ([NSThread isMultiThreaded])
	{
		NSThread *thread = [NSThread currentThread];
		NSString *name = [thread name];
		if (![name length])
		{
			// use the thread dictionary to store and retrieve the computed thread name
			NSMutableDictionary *threadDict = [thread threadDictionary];
			name = [threadDict objectForKey:@"__$NSLoggerThreadName$__"];
			if (name == nil)
			{
				@autoreleasepool {
					// optimize CPU use by computing the thread name once and storing it back
					// in the thread dictionary
					name = [thread description];
                    NSArray *threadNumberPrefixes = @[@"num = ", @"number = "];
                    NSRange range = NSMakeRange(NSNotFound, 0);
                    
                    for (NSString *threadNumberPrefix in threadNumberPrefixes)
                    {
                        range = [name rangeOfString:threadNumberPrefix];
                        
                        if (range.location != NSNotFound)
                            break;
                    }
					
					if (range.location != NSNotFound)
					{
						// iOS and OS X now add a "name = (null)" when thread name unknown. Suppress it.
						NSRange noNameRange = [name rangeOfString:@", name = (null)" options:(NSLiteralSearch | NSBackwardsSearch)];
						if (noNameRange.location != NSNotFound)
						{
							name = [NSString stringWithFormat:@"Thread %@",
									[name substringWithRange:NSMakeRange(range.location + range.length,
																		 noNameRange.location - range.location - range.length)]];
						}
						else
						{
							name = [NSString stringWithFormat:@"Thread %@",
									[name substringWithRange:NSMakeRange(range.location + range.length,
																		 [name length] - range.location - range.length - 1)]];
						}
						[threadDict setObject:name forKey:@"__$NSLoggerThreadName$__"];
					}
                    else
                    {
                        name = nil;
                    }
				}
			}
		}
		if (name != nil)
		{
			LoggerMessageAddString(encoder, (CFStringRef)name, PART_KEY_THREAD_ID);
			hasThreadName = YES;
		}
	}
	if (!hasThreadName)
	{
#if __LP64__
		LoggerMessageAddInt64(encoder, (int64_t)pthread_self(), PART_KEY_THREAD_ID);
#else
		LoggerMessageAddInt32(encoder, (int32_t)pthread_self(), PART_KEY_THREAD_ID);
#endif
	}
}

static CFMutableDataRef LoggerMessageCreate(int32_t seq)
{
	CFMutableDataRef encoder = CFDataCreateMutable(NULL, 0);
	if (encoder != NULL)
	{
		CFDataIncreaseLength(encoder, 64);
		uint8_t *p = CFDataGetMutableBytePtr(encoder);
		if (p != NULL)
		{
			// directly write the sequence number as first part of the message
			// so we find it quickly when inserting new messages in the queue
			if (seq)
			{
				p[3] = 8;		// size 0x00000008 in big endian
				p[5] = 1;		// part count 0x0001
				p[6] = (uint8_t)PART_KEY_MESSAGE_SEQ;
				p[7] = (uint8_t)PART_TYPE_INT32;
				*(uint32_t *)(p + 8) = htonl(seq);
			}
			else
			{
				// empty message with a 0 part count
				p[3] = 2;
			}
		}
		LoggerMessageAddTimestampAndThreadID(encoder);
	}
	return encoder;
}

static void LoggerMessageFinalize(CFMutableDataRef encoder)
{
	// Finalize a message by reducing the CFData size to the actual used size
	if (encoder != NULL)
	{
		uint32_t *p = (uint32_t *)CFDataGetBytePtr(encoder);
		if (p != NULL)
			CFDataSetLength(encoder, ntohl(*p) + 4);
	}
}

static void LoggerMessageAddInteger(CFMutableDataRef encoder, NSInteger anInt, int key) {
#if __LP64__
    LoggerMessageAddInt64(encoder, anInt, key);
#else
    LoggerMessageAddInt32(encoder, anInt, key);
#endif
}

static void LoggerMessageAddInt32(CFMutableDataRef encoder, int32_t anInt, int key)
{
	uint8_t *p = LoggerMessagePrepareForPart(encoder, 6);
	if (p != NULL)
	{
		*p++ = (uint8_t)key;
		*p++ = (uint8_t)PART_TYPE_INT32;
		WRITE_MISALIGNED_INT32(p, anInt);
	}
}

#if __LP64__
static void LoggerMessageAddInt64(CFMutableDataRef encoder, int64_t anInt, int key)
{
	uint8_t *p = LoggerMessagePrepareForPart(encoder, 10);
	if (p != NULL)
	{
		*p++ = (uint8_t)key;
		*p++ = (uint8_t)PART_TYPE_INT64;
		WRITE_MISALIGNED_INT64(p, anInt)
	}
}
#endif

static void LoggerMessageAddCString(CFMutableDataRef data, const char *aString, int key)
{
	if (aString == NULL || *aString == 0)
		return;
	
	// convert to UTF-8
	int len = (int)strlen(aString);
	uint8_t *buf = malloc((size_t)(2 * len));
	if (buf != NULL)
	{
		int i, n = 0;
		for (i = 0; i < len; i++)
		{
			uint8_t c = (uint8_t)(*aString++);
			if (c < 0x80)
				buf[n++] = c;
			else {
				buf[n++] = 0xC0 | (c >> 6);
				buf[n++] = (c & 0x6F) | 0x80;
			}
		}
		if (n)
		{
			uint8_t *p = LoggerMessagePrepareForPart(data, (uint32_t)n+6);
			if (p != NULL)
			{
				*p++ = (uint8_t)key;
				*p++ = (uint8_t)PART_TYPE_STRING;
				WRITE_MISALIGNED_INT32(p, n)
				memcpy(p + 4, buf, (size_t)n);
			}
		}
		free(buf);
	}
}

static void LoggerMessageAddString(CFMutableDataRef encoder, CFStringRef aString, int key)
{
	if (aString == NULL)
		aString = CFSTR("");

	// All strings are UTF-8 encoded
	uint32_t partSize = 0;
	uint8_t *bytes = NULL;
	
	CFIndex stringLength = CFStringGetLength(aString);
	CFIndex bytesLength = stringLength * 4;
	if (stringLength)
	{
		bytes = (uint8_t *)malloc((size_t)bytesLength + 4);
		if (bytes != NULL)
		{
			CFStringGetBytes(aString, CFRangeMake(0, stringLength), kCFStringEncodingUTF8, '?', false, bytes, bytesLength, &bytesLength);
			partSize = (uint32_t)bytesLength;
		}
	}

	uint8_t *p = LoggerMessagePrepareForPart(encoder, 6 + partSize);
	if (p != NULL)
	{
		*p++ = (uint8_t)key;
		*p++ = (uint8_t)PART_TYPE_STRING;
		WRITE_MISALIGNED_INT32(p, partSize)
		if (partSize && bytes != NULL)
			memcpy(p + 4, bytes, (size_t)partSize);
	}

	if (bytes != NULL)
		free(bytes);
}

static void LoggerMessageAddData(CFMutableDataRef encoder, CFDataRef theData, int key, int partType)
{
	if (theData != NULL)
	{
		CFIndex dataLength = CFDataGetLength(theData);
		uint8_t *p = LoggerMessagePrepareForPart(encoder, (uint32_t)dataLength + 6);
		if (p != NULL)
		{
			*p++ = (uint8_t)key;
			*p++ = (uint8_t)partType;
			WRITE_MISALIGNED_INT32(p, dataLength)
			if (dataLength)
				memcpy(p + 4, CFDataGetBytePtr(theData), (size_t)dataLength);
		}
	}
}

static uint32_t LoggerMessageGetSeq(CFDataRef message)
{
	// Extract the sequence number from a message. When pushing messages to the queue,
	// we use this to guarantee the logging order according to the seq#
	// Since we now store the seq as first component, we only have to check whether
	// the first part is the sequence number, and extract it.
	uint8_t *p = (uint8_t *)CFDataGetBytePtr(message) + 4;
	uint16_t partCount = ntohs(*(uint16_t *)p);
	if (partCount)
	{
		if (p[2] == PART_KEY_MESSAGE_SEQ)
			return ntohl(*(uint32_t *)(p+4));		// ARMv6 and later, x86 processors do just fine with unaligned accesses
	}
	return 0;
}

// -----------------------------------------------------------------------------
#pragma mark -
#pragma mark Private logging functions
// -----------------------------------------------------------------------------
static void	LoggerPushClientInfoToFrontOfQueue(Logger *logger)
{
	// Extract client information from the main bundle, as well as platform info,
	// and assemble it to a message that will be put in front of the queue
	// Helps desktop viewer display who's talking to it
	// Note that we must be called from the logger work thread, as we don't
	// run through the message port to transmit this message to the queue
	CFBundleRef bundle = CFBundleGetMainBundle();
	if (bundle == NULL)
		return;
	CFMutableDataRef encoder = LoggerMessageCreate(0);
	if (encoder != NULL)
	{
		LoggerMessageAddInt32(encoder, LOGMSG_TYPE_CLIENTINFO, PART_KEY_MESSAGE_TYPE);

		CFStringRef version = (CFStringRef)CFBundleGetValueForInfoDictionaryKey(bundle, kCFBundleVersionKey);
		if (version != NULL && CFGetTypeID(version) == CFStringGetTypeID())
			LoggerMessageAddString(encoder, version, PART_KEY_CLIENT_VERSION);
		CFStringRef name = (CFStringRef)CFBundleGetValueForInfoDictionaryKey(bundle, kCFBundleNameKey);
		if (name != NULL)
			LoggerMessageAddString(encoder, name, PART_KEY_CLIENT_NAME);

#if TARGET_OS_IPHONE
		if ([NSThread isMultiThreaded] || [NSThread isMainThread])
		{
			@autoreleasepool
			{
				UIDevice *device = [UIDevice currentDevice];
				LoggerMessageAddString(encoder, (CFStringRef)device.name, PART_KEY_UNIQUEID);
				LoggerMessageAddString(encoder, (CFStringRef)device.systemVersion, PART_KEY_OS_VERSION);
				LoggerMessageAddString(encoder, (CFStringRef)device.systemName, PART_KEY_OS_NAME);
				LoggerMessageAddString(encoder, (CFStringRef)device.model, PART_KEY_CLIENT_MODEL);
			}
		}
#elif TARGET_OS_MAC
		CFStringRef osName = NULL, osVersion = NULL;
		// Read the OS version without using deprecated Gestalt calls
		@autoreleasepool
		{
			@try
			{
				NSString* versionString = [[NSDictionary dictionaryWithContentsOfFile: @"/System/Library/CoreServices/SystemVersion.plist"] objectForKey: @"ProductVersion"];
				if ([versionString length])
				{
					osName = CFSTR("Mac OS X");
					osVersion = CFRetain((CFStringRef)versionString);
				}
			}
			@catch (NSException *exc)
			{
			}
		}
		if (osVersion == NULL)
		{
			// Not allowed to call into Cocoa ? use the Darwin version string
			struct utsname u;
			if (uname(&u) == 0)
			{
				osName = CFStringCreateWithCString(NULL, u.sysname, kCFStringEncodingUTF8);
				osVersion = CFStringCreateWithCString(NULL, u.release, kCFStringEncodingUTF8);
			}
			else
			{
				osName = CFSTR("Mac OS X");
				osVersion = CFSTR("");
			}
		}
		LoggerMessageAddString(encoder, osVersion, PART_KEY_OS_VERSION);
		LoggerMessageAddString(encoder, osName, PART_KEY_OS_NAME);
		CFRelease(osVersion);
		CFRelease(osName);

		char buf[64];
		size_t len;
		int ncpu = 0;
		bzero(buf, sizeof(buf));
		len = sizeof(buf)-1;
		sysctlbyname("hw.model", buf, &len, NULL, 0);
		len = sizeof(ncpu);
		sysctlbyname("hw.ncpu", &ncpu, &len, NULL, 0);
		sprintf(buf+strlen(buf), " - %d * ", ncpu);
		len = sizeof(buf)-strlen(buf)-1;
		sysctlbyname("hw.machine", buf+strlen(buf), &len, NULL, 0);
		
		CFStringRef s = CFStringCreateWithCString(NULL, buf, kCFStringEncodingASCII);
		LoggerMessageAddString(encoder, s, PART_KEY_CLIENT_MODEL);
		CFRelease(s);
#endif
		LoggerMessageFinalize(encoder);

		pthread_mutex_lock(&logger->logQueueMutex);
		CFArrayInsertValueAtIndex(logger->logQueue, logger->incompleteSendOfFirstItem ? 1 : 0, encoder);
		pthread_mutex_unlock(&logger->logQueueMutex);

		CFRelease(encoder);
	}
}

static void LoggerPushMessageToQueue(Logger *logger, CFDataRef message)
{
	// Add the message to the log queue and signal the runLoop source that will trigger
	// a send on the worker thread.
	pthread_mutex_lock(&logger->logQueueMutex);
	CFIndex idx = CFArrayGetCount(logger->logQueue);
	if (idx)
	{
		// to prevent out-of-order messages (as much as possible), we try to transmit messages in the
		// order their sequence number was generated. Since the seq is generated first-thing,
		// we can provide fine-grained ordering that gives a reasonable idea of the order
		// the logging calls were made (useful for precise information about multithreading code)
		uint32_t lastSeq, seq = LoggerMessageGetSeq(message);
		do {
			lastSeq = LoggerMessageGetSeq(CFArrayGetValueAtIndex(logger->logQueue, idx-1));
		} while (lastSeq > seq && --idx > 0);
	}
	if (idx >= 0)
		CFArrayInsertValueAtIndex(logger->logQueue, idx, message);
	else
		CFArrayAppendValue(logger->logQueue, message);
	
	if (logger->messagePushedSource != NULL)
	{
		// One case where the pushed source may be NULL is if the client code
		// immediately starts logging without initializing the logger first.
		// In this case, the worker thread has not completed startup, so we don't need
		// to fire the runLoop source
		CFRunLoopSourceSignal(logger->messagePushedSource);
	}
	else if (logger->workerThread == NULL && (logger->options & kLoggerOption_LogToConsole) && !(logger->options & kLoggerOption_CaptureSystemConsole))
	{
		// In this case, a failure creating the message runLoop source forces us
		// to always log to console
		while (CFArrayGetCount(logger->logQueue))
		{
			LoggerLogToConsole(CFArrayGetValueAtIndex(logger->logQueue, 0));
			CFArrayRemoveValueAtIndex(logger->logQueue, 0);
		}
		pthread_cond_broadcast(&logger->logQueueEmpty);		// in case other threads are waiting for a flush
	}
	pthread_mutex_unlock(&logger->logQueueMutex);
}

static void LogMessageRawTo_internal(Logger *logger,
								  const char *filename,
								  int lineNumber,
								  const char *functionName,
								  NSString *domain,
								  int level,
								  NSString *message)
{
	// Variant of the LogMessage function that doesn't perform any variable arguments formatting
	logger = LoggerStart(logger);	// start if needed
    if (logger != NULL)
	{
        int32_t seq = atomic_fetch_add(&logger->messageSeq, 1);
        LOGGERDBG2(CFSTR("%ld LogMessage"), seq);

        CFMutableDataRef encoder = LoggerMessageCreate(seq);
        if (encoder != NULL)
        {
            LoggerMessageAddInt32(encoder, LOGMSG_TYPE_LOG, PART_KEY_MESSAGE_TYPE);
            if (domain != nil && [domain length])
                LoggerMessageAddString(encoder, (CFStringRef)domain, PART_KEY_TAG);
            if (level)
                LoggerMessageAddInt32(encoder, level, PART_KEY_LEVEL);
            if (filename != NULL)
                LoggerMessageAddCString(encoder, filename, PART_KEY_FILENAME);
            if (lineNumber)
                LoggerMessageAddInt32(encoder, lineNumber, PART_KEY_LINENUMBER);
            if (functionName != NULL)
                LoggerMessageAddCString(encoder, functionName, PART_KEY_FUNCTIONNAME);
            if (message != nil)
                LoggerMessageAddString(encoder, (CFStringRef)message, PART_KEY_MESSAGE);
			else
				LoggerMessageAddString(encoder, CFSTR(""), PART_KEY_MESSAGE);

			LoggerMessageFinalize(encoder);
            LoggerPushMessageToQueue(logger, encoder);
            CFRelease(encoder);
        }
        else
        {
            LOGGERDBG2(CFSTR("-> failed creating encoder"));
        }
    }
}

static void LogMessageTo_internal(Logger *logger,
								  const char *filename,
								  int lineNumber,
								  const char *functionName,
								  NSString *domain,
								  int level,
								  NSString *format,
								  va_list args)
{
	logger = LoggerStart(logger);	// start if needed
    if (logger != NULL)
	{
        int32_t seq = atomic_fetch_add(&logger->messageSeq, 1);
        LOGGERDBG2(CFSTR("%ld LogMessage"), seq);

        CFMutableDataRef encoder = LoggerMessageCreate(seq);
        if (encoder != NULL)
        {
            LoggerMessageAddInt32(encoder, LOGMSG_TYPE_LOG, PART_KEY_MESSAGE_TYPE);
            if (domain != nil && [domain length])
                LoggerMessageAddString(encoder, (CFStringRef)domain, PART_KEY_TAG);
            if (level)
                LoggerMessageAddInt32(encoder, level, PART_KEY_LEVEL);
            if (filename != NULL)
                LoggerMessageAddCString(encoder, filename, PART_KEY_FILENAME);
            if (lineNumber)
                LoggerMessageAddInt32(encoder, lineNumber, PART_KEY_LINENUMBER);
            if (functionName != NULL)
                LoggerMessageAddCString(encoder, functionName, PART_KEY_FUNCTIONNAME);

            NSString *msgString = [[NSString alloc] initWithFormat:format arguments:args];
            if (msgString != nil)
            {
                LoggerMessageAddString(encoder, (CFStringRef)msgString, PART_KEY_MESSAGE);
                [msgString release];
            }

			LoggerMessageFinalize(encoder);
            LoggerPushMessageToQueue(logger, encoder);
            CFRelease(encoder);
        }
        else
        {
            LOGGERDBG2(CFSTR("-> failed creating encoder"));
        }
    }
}

void LogMessage_noFormat(NSString *filename,
                         NSInteger lineNumber,
                         NSString *functionName,
                         NSString *domain,
                         NSInteger level,
                         NSString *message)
{
    Logger *logger = LoggerStart(NULL);	// start if needed
    if (logger != NULL)
    {
        int32_t seq = atomic_fetch_add(&logger->messageSeq, 1);
        LOGGERDBG2(CFSTR("%ld LogMessage"), seq);
        
        CFMutableDataRef encoder = LoggerMessageCreate(seq);
        if (encoder != NULL)
        {
            LoggerMessageAddInt32(encoder, LOGMSG_TYPE_LOG, PART_KEY_MESSAGE_TYPE);
            if (domain != nil && [domain length])
                LoggerMessageAddString(encoder, (CFStringRef)domain, PART_KEY_TAG);
            if (level)
                LoggerMessageAddInteger(encoder, level, PART_KEY_LEVEL);
            if (filename != NULL)
                LoggerMessageAddString(encoder, (CFStringRef)filename, PART_KEY_FILENAME);
            if (lineNumber)
                LoggerMessageAddInteger(encoder, lineNumber, PART_KEY_LINENUMBER);
            if (functionName != NULL)
                LoggerMessageAddString(encoder, (CFStringRef)functionName, PART_KEY_FUNCTIONNAME);
            
            LoggerMessageAddString(encoder, (CFStringRef)message, PART_KEY_MESSAGE);
            
            LoggerMessageFinalize(encoder);
            LoggerPushMessageToQueue(logger, encoder);
            CFRelease(encoder);
        }
        else
        {
            LOGGERDBG2(CFSTR("-> failed creating encoder"));
        }
    }
}

static void LogImageTo_internal(Logger *logger,
								const char *filename,
								int lineNumber,
								const char *functionName,
								NSString *domain,
								int level,
								int width,
								int height,
								NSData *data)
{
	logger = LoggerStart(logger);		// start if needed
	if (logger != NULL)
	{
		int32_t seq = atomic_fetch_add(&logger->messageSeq, 1);
		LOGGERDBG2(CFSTR("%ld LogImage"), seq);

		CFMutableDataRef encoder = LoggerMessageCreate(seq);
		if (encoder != NULL)
		{
			LoggerMessageAddInt32(encoder, LOGMSG_TYPE_LOG, PART_KEY_MESSAGE_TYPE);
			if (domain != nil && [domain length])
				LoggerMessageAddString(encoder, (CFStringRef)domain, PART_KEY_TAG);
			if (level)
				LoggerMessageAddInt32(encoder, level, PART_KEY_LEVEL);
			if (width && height)
			{
				LoggerMessageAddInt32(encoder, width, PART_KEY_IMAGE_WIDTH);
				LoggerMessageAddInt32(encoder, height, PART_KEY_IMAGE_HEIGHT);
			}
			if (filename != NULL)
				LoggerMessageAddCString(encoder, filename, PART_KEY_FILENAME);
			if (lineNumber)
				LoggerMessageAddInt32(encoder, lineNumber, PART_KEY_LINENUMBER);
			if (functionName != NULL)
				LoggerMessageAddCString(encoder, functionName, PART_KEY_FUNCTIONNAME);
			LoggerMessageAddData(encoder, (CFDataRef)data, PART_KEY_MESSAGE, PART_TYPE_IMAGE);

			LoggerMessageFinalize(encoder);
			LoggerPushMessageToQueue(logger, encoder);
			CFRelease(encoder);
		}
		else
		{
			LOGGERDBG2(CFSTR("-> failed creating encoder"));
		}
	}
}

void LogImage_noFormat(NSString *filename,
                       NSInteger lineNumber,
                       NSString *functionName,
                       NSString *domain,
                       NSInteger level,
                       NSInteger width,
                       NSInteger height,
                       NSData *data)
{
    Logger *logger = LoggerStart(NULL);		// start if needed
    if (logger != NULL)
    {
        int32_t seq = atomic_fetch_add(&logger->messageSeq, 1);
        LOGGERDBG2(CFSTR("%ld LogImage"), seq);
        
        CFMutableDataRef encoder = LoggerMessageCreate(seq);
        if (encoder != NULL)
        {
            LoggerMessageAddInt32(encoder, LOGMSG_TYPE_LOG, PART_KEY_MESSAGE_TYPE);
            if (domain != nil && [domain length])
                LoggerMessageAddString(encoder, (CFStringRef)domain, PART_KEY_TAG);
            if (level)
                LoggerMessageAddInteger(encoder, level, PART_KEY_LEVEL);
            if (width && height)
            {
                LoggerMessageAddInteger(encoder, width, PART_KEY_IMAGE_WIDTH);
                LoggerMessageAddInteger(encoder, height, PART_KEY_IMAGE_HEIGHT);
            }
            if (filename != NULL)
                LoggerMessageAddString(encoder, (CFStringRef)filename, PART_KEY_FILENAME);
            if (lineNumber)
                LoggerMessageAddInteger(encoder, lineNumber, PART_KEY_LINENUMBER);
            if (functionName != NULL)
                LoggerMessageAddString(encoder, (CFStringRef)functionName, PART_KEY_FUNCTIONNAME);
            LoggerMessageAddData(encoder, (CFDataRef)data, PART_KEY_MESSAGE, PART_TYPE_IMAGE);
            
            LoggerMessageFinalize(encoder);
            LoggerPushMessageToQueue(logger, encoder);
            CFRelease(encoder);
        }
        else
        {
            LOGGERDBG2(CFSTR("-> failed creating encoder"));
        }
    }
}

static void LogDataTo_internal(Logger *logger,
							   const char *filename,
							   int lineNumber,
							   const char *functionName,
							   NSString *domain,
							   int level, NSData *data)
{
	logger = LoggerStart(logger);		// start if needed
    if (logger != NULL)
    {
        int32_t seq = atomic_fetch_add(&logger->messageSeq, 1);
        LOGGERDBG2(CFSTR("%ld LogData"), seq);

        CFMutableDataRef encoder = LoggerMessageCreate(seq);
        if (encoder != NULL)
        {
            LoggerMessageAddInt32(encoder, LOGMSG_TYPE_LOG, PART_KEY_MESSAGE_TYPE);
            if (domain != nil && [domain length])
                LoggerMessageAddString(encoder, (CFStringRef)domain, PART_KEY_TAG);
            if (level)
                LoggerMessageAddInt32(encoder, level, PART_KEY_LEVEL);
            if (filename != NULL)
                LoggerMessageAddCString(encoder, filename, PART_KEY_FILENAME);
            if (lineNumber)
                LoggerMessageAddInt32(encoder, lineNumber, PART_KEY_LINENUMBER);
            if (functionName != NULL)
                LoggerMessageAddCString(encoder, functionName, PART_KEY_FUNCTIONNAME);
            LoggerMessageAddData(encoder, (CFDataRef)data, PART_KEY_MESSAGE, PART_TYPE_BINARY);

			LoggerMessageFinalize(encoder);
            LoggerPushMessageToQueue(logger, encoder);
            CFRelease(encoder);
        }
        else
        {
            LOGGERDBG2(CFSTR("-> failed creating encoder"));
        }
    }
}

void LogData_noFormat(NSString *filename,
                      NSInteger lineNumber,
                      NSString *functionName,
                      NSString *domain,
                      NSInteger level,
                      NSData *data)
{
    Logger *logger = LoggerStart(NULL);		// start if needed
    if (logger != NULL)
    {
        int32_t seq = atomic_fetch_add(&logger->messageSeq, 1);
        LOGGERDBG2(CFSTR("%ld LogData"), seq);
        
        CFMutableDataRef encoder = LoggerMessageCreate(seq);
        if (encoder != NULL)
        {
            LoggerMessageAddInt32(encoder, LOGMSG_TYPE_LOG, PART_KEY_MESSAGE_TYPE);
            if (domain != nil && [domain length])
                LoggerMessageAddString(encoder, (CFStringRef)domain, PART_KEY_TAG);
            if (level)
                LoggerMessageAddInteger(encoder, level, PART_KEY_LEVEL);
            if (filename != NULL)
                LoggerMessageAddString(encoder, (CFStringRef)filename, PART_KEY_FILENAME);
            if (lineNumber)
                LoggerMessageAddInteger(encoder, lineNumber, PART_KEY_LINENUMBER);
            if (functionName != NULL)
                LoggerMessageAddString(encoder, (CFStringRef)functionName, PART_KEY_FUNCTIONNAME);
            LoggerMessageAddData(encoder, (CFDataRef)data, PART_KEY_MESSAGE, PART_TYPE_BINARY);
            
            LoggerMessageFinalize(encoder);
            LoggerPushMessageToQueue(logger, encoder);
            CFRelease(encoder);
        }
        else
        {
            LOGGERDBG2(CFSTR("-> failed creating encoder"));
        }
    }
}

static void LogStartBlockTo_internal(Logger *logger, NSString *format, va_list args)
{
	logger = LoggerStart(logger);		// start if needed
	if (logger)
	{
		int32_t seq = atomic_fetch_add(&logger->messageSeq, 1);
		LOGGERDBG2(CFSTR("%ld LogStartBlock"), seq);

		CFMutableDataRef encoder = LoggerMessageCreate(seq);
		if (encoder != NULL)
		{
			LoggerMessageAddInt32(encoder, LOGMSG_TYPE_BLOCKSTART, PART_KEY_MESSAGE_TYPE);
			if (format != nil)
			{
				CFStringRef msgString = CFStringCreateWithFormatAndArguments(NULL, NULL, (CFStringRef)format, args);
				if (msgString != NULL)
				{
					LoggerMessageAddString(encoder, msgString, PART_KEY_MESSAGE);
					CFRelease(msgString);
				}
			}
		
			LoggerMessageFinalize(encoder);
			LoggerPushMessageToQueue(logger, encoder);
			CFRelease(encoder);
		}
	}
}

// -----------------------------------------------------------------------------
#pragma mark -
#pragma mark Public logging functions
// -----------------------------------------------------------------------------
void LogMessageRaw(NSString *message)
{
	LogMessageRawTo_internal(NULL, NULL, 0, NULL, nil, 0, message);
}

void LogMessageRawF(const char *filename, int lineNumber, const char *functionName, NSString *domain, int level, NSString *message)
{
	LogMessageRawTo_internal(NULL, filename, lineNumber, functionName, domain, level, message);
}

void LogMessageRawToF(Logger *logger, const char *filename, int lineNumber, const char *functionName, NSString *domain, int level, NSString *message)
{
	LogMessageRawTo_internal(logger, filename, lineNumber, functionName, domain, level, message);
}

void LogMessageCompat(NSString *format, ...)
{
	va_list args;
	va_start(args, format);
	LogMessageTo_internal(NULL, NULL, 0, NULL, nil, 0, format, args);
	va_end(args);
}

void LogMessageTo(Logger *logger, NSString *domain, int level, NSString *format, ...)
{
	va_list args;
	va_start(args, format);
	LogMessageTo_internal(logger, NULL, 0, NULL, domain, level, format, args);
	va_end(args);
}

void LogMessageToF(Logger *logger, const char *filename, int lineNumber, const char *functionName, NSString *domain, int level, NSString *format, ...)
{
	va_list args;
	va_start(args, format);
	LogMessageTo_internal(logger, filename, lineNumber, functionName, domain, level, format, args);
	va_end(args);
}

void LogMessageTo_va(Logger *logger, NSString *domain, int level, NSString *format, va_list args)
{
	LogMessageTo_internal(logger, NULL, 0, NULL, domain, level, format, args);
}

void LogMessageToF_va(Logger *logger, const char *filename, int lineNumber, const char *functionName, NSString *domain, int level, NSString *format, va_list args)
{
	LogMessageTo_internal(logger, filename, lineNumber, functionName, domain, level, format, args);
}

void LogMessage(NSString *domain, int level, NSString *format, ...)
{
	va_list args;
	va_start(args, format);
	LogMessageTo_internal(NULL, NULL, 0, NULL, domain, level, format, args);
	va_end(args);
}

void LogMessageF(const char *filename, int lineNumber, const char *functionName, NSString *domain, int level, NSString *format, ...)
{
	va_list args;
	va_start(args, format);
	LogMessageTo_internal(NULL, filename, lineNumber, functionName, domain, level, format, args);
	va_end(args);
}

void LogMessage_va(NSString *domain, int level, NSString *format, va_list args)
{
	LogMessageTo_internal(NULL, NULL, 0, NULL, domain, level, format, args);
}

void LogMessageF_va(const char *filename, int lineNumber, const char *functionName, NSString *domain, int level, NSString *format, va_list args)
{
	LogMessageTo_internal(NULL, filename, lineNumber, functionName, domain, level, format, args);
}

void LogData(NSString *domain, int level, NSData *data)
{
	LogDataTo_internal(NULL, NULL, 0, NULL, domain, level, data);
}

void LogDataF(const char *filename, int lineNumber, const char *functionName, NSString *domain, int level, NSData *data)
{
	LogDataTo_internal(NULL, filename, lineNumber, functionName, domain, level, data);
}

void LogDataTo(Logger *logger, NSString *domain, int level, NSData *data)
{
	LogDataTo_internal(logger, NULL, 0, NULL, domain, level, data);
}

void LogDataToF(Logger *logger, const char *filename, int lineNumber, const char *functionName, NSString *domain, int level, NSData *data)
{
	LogDataTo_internal(logger, filename, lineNumber, functionName, domain, level, data);
}

void LogImageData(NSString *domain, int level, int width, int height, NSData *data)
{
	LogImageTo_internal(NULL, NULL, 0, NULL, domain, level, width, height, data);
}

void LogImageDataF(const char *filename, int lineNumber, const char *functionName, NSString *domain, int level, int width, int height, NSData *data)
{
	LogImageTo_internal(NULL, filename, lineNumber, functionName, domain, level, width, height, data);
}

void LogImageDataTo(Logger *logger, NSString *domain, int level, int width, int height, NSData *data)
{
	LogImageTo_internal(logger, NULL, 0, NULL, domain, level, width, height, data);
}

void LogImageDataToF(Logger *logger, const char *filename, int lineNumber, const char *functionName, NSString *domain, int level, int width, int height, NSData *data)
{
	LogImageTo_internal(logger, filename, lineNumber, functionName, domain, level, width, height, data);
}

void LogStartBlock(NSString *format, ...)
{
	va_list args;
	va_start(args, format);
	LogStartBlockTo_internal(NULL, format, args);
	va_end(args);
}

void LogStartBlockTo(Logger *logger, NSString *format, ...)
{
	va_list args;
	va_start(args, format);
	LogStartBlockTo_internal(logger, format, args);
	va_end(args);
}

void LogEndBlockTo(Logger *logger)
{
	logger = LoggerStart(logger);
    if (logger)
    {
        if (logger->options & kLoggerOption_LogToConsole)
            return;

        int32_t seq = atomic_fetch_add(&logger->messageSeq, 1);
        LOGGERDBG2(CFSTR("%ld LogEndBlock"), seq);

        CFMutableDataRef encoder = LoggerMessageCreate(seq);
        if (encoder != NULL)
        {
            LoggerMessageAddInt32(encoder, LOGMSG_TYPE_BLOCKEND, PART_KEY_MESSAGE_TYPE);
			LoggerMessageFinalize(encoder);
            LoggerPushMessageToQueue(logger, encoder);
            CFRelease(encoder);
        }
        else
        {
            LOGGERDBG2(CFSTR("-> failed creating encoder"));
        }
    }
}

void LogEndBlock(void)
{
	LogEndBlockTo(NULL);
}

void LogMarkerTo(Logger *logger, NSString *text)
{
	logger = LoggerStart(logger);		// start if needed
	if (logger != NULL)
	{
		int32_t seq = atomic_fetch_add(&logger->messageSeq, 1);
		LOGGERDBG2(CFSTR("%ld LogMarker"), seq);

		CFMutableDataRef encoder = LoggerMessageCreate(seq);
		if (encoder != NULL)
		{
			LoggerMessageAddInt32(encoder, LOGMSG_TYPE_MARK, PART_KEY_MESSAGE_TYPE);
			if (text == nil)
			{
				CFDateFormatterRef df = CFDateFormatterCreate(NULL, NULL, kCFDateFormatterShortStyle, kCFDateFormatterMediumStyle);
				CFStringRef str = CFDateFormatterCreateStringWithAbsoluteTime(NULL, df, CFAbsoluteTimeGetCurrent());
				CFRelease(df);
				if (str != NULL)
				{
					LoggerMessageAddString(encoder, str, PART_KEY_MESSAGE);
					CFRelease(str);
				}
			}
			else
			{
				LoggerMessageAddString(encoder, (CFStringRef)text, PART_KEY_MESSAGE);
			}
			LoggerMessageFinalize(encoder);
			LoggerPushMessageToQueue(logger, encoder);
			CFRelease(encoder);
		}
		else
		{
			LOGGERDBG2(CFSTR("-> failed creating encoder"));
		}
	}
}

void LogMarker(NSString *text)
{
	LogMarkerTo(NULL, text);
}