23 files changed, 196 insertions, 297 deletions

diff --git a/src/OSSupport/BlockingTCPLink.cpp b/src/OSSupport/BlockingTCPLink.cpp
deleted file mode 100644
index 07f48b955..000000000
--- a/src/OSSupport/BlockingTCPLink.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-
-#include "BlockingTCPLink.h"
-#include "Errors.h"
-
-
-
-
-cBlockingTCPLink::cBlockingTCPLink(void)
-{
-}
-
-
-
-
-
-cBlockingTCPLink::~cBlockingTCPLink()
-{
-	CloseSocket();
-}
-
-
-
-
-
-void cBlockingTCPLink::CloseSocket()
-{
-	if (!m_Socket.IsValid())
-	{
-		m_Socket.CloseSocket();
-	}
-}
-
-
-
-
-
-bool cBlockingTCPLink::Connect(const char * iAddress, unsigned int iPort)
-{
-	ASSERT(!m_Socket.IsValid());
-	if (m_Socket.IsValid())
-	{
-		LOGWARN("WARNING: cTCPLink Connect() called while still connected.");
-		m_Socket.CloseSocket();
-	}
-
-	struct hostent *hp;
-	unsigned int addr;
-	struct sockaddr_in server;
-
-	m_Socket = socket(AF_INET, SOCK_STREAM, 0);
-	if (!m_Socket.IsValid())
-	{
-		LOGERROR("cTCPLink: Cannot create a socket");
-		return false;
-	}
-
-	addr = inet_addr(iAddress);
-	hp = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET);
-	if (hp == NULL)
-	{
-		//LOGWARN("cTCPLink: gethostbyaddr returned NULL");
-		hp = gethostbyname(iAddress);
-		if (hp == NULL)
-		{
-			LOGWARN("cTCPLink: Could not resolve %s", iAddress);
-			CloseSocket();
-			return false;
-		}
-	}
-
-	memcpy(&server.sin_addr.s_addr,hp->h_addr, hp->h_length);
-	server.sin_family = AF_INET;
-	server.sin_port = htons( (unsigned short)iPort);
-	if (connect(m_Socket, (struct sockaddr *)&server, sizeof(server)))
-	{
-		LOGWARN("cTCPLink: Connection to \"%s:%d\" failed (%s)", iAddress, iPort,GetOSErrorString( cSocket::GetLastError() ).c_str() );
-		CloseSocket();
-		return false;
-	}
-
-	return true;
-}
-
-
-
-
-
-int cBlockingTCPLink::Send(char * a_Data, unsigned int a_Size, int a_Flags /* = 0 */ )
-{
-	UNUSED(a_Flags);
-	
-	ASSERT(m_Socket.IsValid());
-	if (!m_Socket.IsValid())
-	{
-		LOGERROR("cBlockingTCPLink: Trying to send data without a valid connection!");
-		return -1;
-	}
-	return m_Socket.Send(a_Data, a_Size);
-}
-
-
-
-
-
-int cBlockingTCPLink::SendMessage( const char* a_Message, int a_Flags /* = 0 */ )
-{
-	UNUSED(a_Flags);
-	
-	ASSERT(m_Socket.IsValid());
-	if (!m_Socket.IsValid())
-	{
-		LOGWARN("cBlockingTCPLink: Trying to send message without a valid connection!");
-		return -1;
-	}
-	return m_Socket.Send(a_Message, strlen(a_Message));
-}
-
-
-
-
-
-void cBlockingTCPLink::ReceiveData(AString & oData)
-{
-	ASSERT(m_Socket.IsValid());
-	if (!m_Socket.IsValid())
-	{
-		return;
-	}
-
-	int Received = 0;
-	char Buffer[256];
-	while ((Received = recv(m_Socket, Buffer, sizeof(Buffer), 0)) > 0)
-	{
-		oData.append(Buffer, Received);
-	}
-}
-
-
-
-
diff --git a/src/OSSupport/BlockingTCPLink.h b/src/OSSupport/BlockingTCPLink.h
deleted file mode 100644
index cb5f9e3f4..000000000
--- a/src/OSSupport/BlockingTCPLink.h
+++ /dev/null
@@ -1,28 +0,0 @@
-
-#pragma once
-
-#include "Socket.h"
-
-
-
-
-
-class cBlockingTCPLink															// tolua_export
-{																				// tolua_export
-public:																			// tolua_export
-	cBlockingTCPLink(void);															// tolua_export
-	~cBlockingTCPLink();														// tolua_export
-
-	bool Connect( const char* a_Address, unsigned int a_Port );					// tolua_export
-	int Send( char* a_Data, unsigned int a_Size, int a_Flags = 0 );				// tolua_export
-	int SendMessage( const char* a_Message, int a_Flags = 0 );					// tolua_export
-	void CloseSocket();															// tolua_export
-	void ReceiveData(AString & oData);													// tolua_export
-protected:
-
-	cSocket m_Socket;
-};	// tolua_export
-
-
-
-
diff --git a/src/OSSupport/CMakeLists.txt b/src/OSSupport/CMakeLists.txt
index dee60b450..a42fcbed4 100644
--- a/src/OSSupport/CMakeLists.txt
+++ b/src/OSSupport/CMakeLists.txt
@@ -3,13 +3,42 @@ cmake_minimum_required (VERSION 2.6)
 project (MCServer)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
-file(GLOB SOURCE
-    "*.cpp"
-    "*.h"
-)
 
-add_library(OSSupport ${SOURCE})
+SET (SRCS
+	CriticalSection.cpp
+	Errors.cpp
+	Event.cpp
+	File.cpp
+	GZipFile.cpp
+	IsThread.cpp
+	ListenThread.cpp
+	Semaphore.cpp
+	Sleep.cpp
+	Socket.cpp
+	SocketThreads.cpp
+	Thread.cpp
+	Timer.cpp)
 
-if(UNIX)
-	target_link_libraries(OSSupport pthread)
+SET (HDRS
+	CriticalSection.h
+	Errors.h
+	Event.h
+	File.h
+	GZipFile.h
+	IsThread.h
+	ListenThread.h
+	Queue.h
+	Semaphore.h
+	Sleep.h
+	Socket.h
+	SocketThreads.h
+	Thread.h
+	Timer.h)
+
+if(NOT MSVC)
+	add_library(OSSupport ${SRCS} ${HDRS})
+
+	if(UNIX)
+		target_link_libraries(OSSupport pthread)
+	endif()
 endif()
diff --git a/src/OSSupport/CriticalSection.cpp b/src/OSSupport/CriticalSection.cpp
index bda97e3a1..5dfc8b5f9 100644
--- a/src/OSSupport/CriticalSection.cpp
+++ b/src/OSSupport/CriticalSection.cpp
@@ -6,7 +6,7 @@
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cCriticalSection:
 
 cCriticalSection::cCriticalSection()
@@ -105,10 +105,10 @@ bool cCriticalSection::IsLockedByCurrentThread(void)
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cCSLock
 
-cCSLock::cCSLock(cCriticalSection * a_CS) 
+cCSLock::cCSLock(cCriticalSection * a_CS)
 	: m_CS(a_CS)
 	, m_IsLocked(false)
 {
@@ -119,7 +119,7 @@ cCSLock::cCSLock(cCriticalSection * a_CS)
 
 
 
-cCSLock::cCSLock(cCriticalSection & a_CS) 
+cCSLock::cCSLock(cCriticalSection & a_CS)
 	: m_CS(&a_CS)
 	, m_IsLocked(false)
 {
@@ -165,7 +165,7 @@ void cCSLock::Unlock(void)
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cCSUnlock:
 
 cCSUnlock::cCSUnlock(cCSLock & a_Lock) :
diff --git a/src/OSSupport/CriticalSection.h b/src/OSSupport/CriticalSection.h
index 73a71f5e1..c3c6e57f0 100644
--- a/src/OSSupport/CriticalSection.h
+++ b/src/OSSupport/CriticalSection.h
@@ -47,7 +47,7 @@ class cCSLock
 	cCriticalSection * m_CS;
 
 	// Unlike a cCriticalSection, this object should be used from a single thread, therefore access to m_IsLocked is not threadsafe
-	// In Windows, it is an error to call cCriticalSection::Unlock() multiple times if the lock is not held, 
+	// In Windows, it is an error to call cCriticalSection::Unlock() multiple times if the lock is not held,
 	// therefore we need to check this value whether we are locked or not.
 	bool m_IsLocked;
 	
diff --git a/src/OSSupport/Errors.cpp b/src/OSSupport/Errors.cpp
index 6072b6ac6..9401ec257 100644
--- a/src/OSSupport/Errors.cpp
+++ b/src/OSSupport/Errors.cpp
@@ -3,7 +3,7 @@
 
 #include "Errors.h"
 
-AString GetOSErrorString( int a_ErrNo )
+AString GetOSErrorString( int a_ErrNo)
 {
 	char buffer[ 1024 ];
 	AString Out;
@@ -22,10 +22,10 @@ AString GetOSErrorString( int a_ErrNo )
 	
 	// According to http://linux.die.net/man/3/strerror_r there are two versions of strerror_r():
 	
-	#if !defined(__APPLE__) && ( _GNU_SOURCE ) && !defined(ANDROID_NDK)  // GNU version of strerror_r()
+	#if !defined(__APPLE__) && ( _GNU_SOURCE) && !defined(ANDROID_NDK)  // GNU version of strerror_r()
 	
-	char * res = strerror_r( errno, buffer, ARRAYCOUNT(buffer) );
-	if( res != NULL )
+	char * res = strerror_r( errno, buffer, ARRAYCOUNT(buffer));
+	if (res != NULL)
 	{
 		Printf(Out, "%d: %s", a_ErrNo, res);
 		return Out;
@@ -33,8 +33,8 @@ AString GetOSErrorString( int a_ErrNo )
 	
 	#else  // XSI version of strerror_r():
 	
-	int res = strerror_r( errno, buffer, ARRAYCOUNT(buffer) );
-	if( res == 0 )
+	int res = strerror_r( errno, buffer, ARRAYCOUNT(buffer));
+	if (res == 0)
 	{
 		Printf(Out, "%d: %s", a_ErrNo, buffer);
 		return Out;
diff --git a/src/OSSupport/Event.cpp b/src/OSSupport/Event.cpp
index 649a0a3cf..74f823216 100644
--- a/src/OSSupport/Event.cpp
+++ b/src/OSSupport/Event.cpp
@@ -18,7 +18,7 @@ cEvent::cEvent(void)
 	m_Event = CreateEvent(NULL, FALSE, FALSE, NULL);
 	if (m_Event == NULL)
 	{
-		LOGERROR("cEvent: cannot create event, GLE = %d. Aborting server.", GetLastError());
+		LOGERROR("cEvent: cannot create event, GLE = %u. Aborting server.", (unsigned)GetLastError());
 		abort();
 	}
 #else  // *nix
@@ -32,7 +32,7 @@ cEvent::cEvent(void)
 
 		AString EventName;
 		Printf(EventName, "cEvent%p", this);
-		m_Event = sem_open(EventName.c_str(), O_CREAT, 777, 0 );
+		m_Event = sem_open(EventName.c_str(), O_CREAT, 777, 0);
 		if (m_Event == SEM_FAILED)
 		{
 			AString error = GetOSErrorString(errno);
@@ -71,6 +71,7 @@ cEvent::~cEvent()
 	{
 		sem_destroy(m_Event);
 		delete m_Event;
+		m_Event = NULL;
 	}
 #endif
 }
@@ -85,11 +86,11 @@ void cEvent::Wait(void)
 		DWORD res = WaitForSingleObject(m_Event, INFINITE);
 		if (res != WAIT_OBJECT_0)
 		{
-			LOGWARN("cEvent: waiting for the event failed: %d, GLE = %d. Continuing, but server may be unstable.", res, GetLastError());
+			LOGWARN("cEvent: waiting for the event failed: %u, GLE = %u. Continuing, but server may be unstable.", (unsigned)res, (unsigned)GetLastError());
 		}
 	#else
 		int res = sem_wait(m_Event);
-		if (res != 0 )
+		if (res != 0)
 		{
 			AString error = GetOSErrorString(errno);
 			LOGWARN("cEvent: waiting for the event failed: %i, err = %s. Continuing, but server may be unstable.", res, error.c_str());
@@ -106,7 +107,7 @@ void cEvent::Set(void)
 	#ifdef _WIN32
 		if (!SetEvent(m_Event))
 		{
-			LOGWARN("cEvent: Could not set cEvent: GLE = %d", GetLastError());
+			LOGWARN("cEvent: Could not set cEvent: GLE = %u", (unsigned)GetLastError());
 		}
 	#else
 		int res = sem_post(m_Event);
diff --git a/src/OSSupport/File.cpp b/src/OSSupport/File.cpp
index f1b3bcf9e..ff6fb5898 100644
--- a/src/OSSupport/File.cpp
+++ b/src/OSSupport/File.cpp
@@ -7,6 +7,9 @@
 
 #include "File.h"
 #include <fstream>
+#ifdef _WIN32
+	#include <share.h>  // for _SH_DENYWRITE
+#endif  // _WIN32
 
 
 
@@ -75,10 +78,10 @@ bool cFile::Open(const AString & iFileName, eMode iMode)
 	}
 
 #ifdef _WIN32
-	fopen_s(&m_File, (FILE_IO_PREFIX + iFileName).c_str(), Mode);
+	m_File = _fsopen((FILE_IO_PREFIX + iFileName).c_str(), Mode, _SH_DENYWR);
 #else
 	m_File = fopen((FILE_IO_PREFIX + iFileName).c_str(), Mode);
-#endif // _WIN32
+#endif  // _WIN32
 
 	if ((m_File == NULL) && (iMode == fmReadWrite))
 	{
@@ -88,10 +91,10 @@ bool cFile::Open(const AString & iFileName, eMode iMode)
 		// Simply re-open for read-writing, erasing existing contents:
 
 #ifdef _WIN32
-		fopen_s(&m_File, (FILE_IO_PREFIX + iFileName).c_str(), "wb+");
+		m_File = _fsopen((FILE_IO_PREFIX + iFileName).c_str(), "wb+", _SH_DENYWR);
 #else
 		m_File = fopen((FILE_IO_PREFIX + iFileName).c_str(), "wb+");
-#endif // _WIN32
+#endif  // _WIN32
 
 	}
 	return (m_File != NULL);
@@ -143,7 +146,7 @@ bool cFile::IsEOF(void) const
 
 
 
-int cFile::Read (void * iBuffer, int iNumBytes)
+int cFile::Read (void * iBuffer, size_t iNumBytes)
 {
 	ASSERT(IsOpen());
 	
@@ -159,7 +162,7 @@ int cFile::Read (void * iBuffer, int iNumBytes)
 
 
 
-int cFile::Write(const void * iBuffer, int iNumBytes)
+int cFile::Write(const void * iBuffer, size_t iNumBytes)
 {
 	ASSERT(IsOpen());
 	
diff --git a/src/OSSupport/File.h b/src/OSSupport/File.h
index b394c5cb9..2a7ecf0ed 100644
--- a/src/OSSupport/File.h
+++ b/src/OSSupport/File.h
@@ -80,10 +80,10 @@ public:
 	bool IsEOF(void) const;
 	
 	/** Reads  up to iNumBytes bytes into iBuffer, returns the number of bytes actually read,    or -1 on failure; asserts if not open */
-	int Read (void * iBuffer,       int iNumBytes);
+	int Read (void * iBuffer,       size_t iNumBytes);
 	
 	/** Writes up to iNumBytes bytes from iBuffer, returns the number of bytes actually written, or -1 on failure; asserts if not open */
-	int Write(const void * iBuffer, int iNumBytes);
+	int Write(const void * iBuffer, size_t iNumBytes);
 	
 	/** Seeks to iPosition bytes from file start, returns old position or -1 for failure; asserts if not open */
 	int Seek (int iPosition);
diff --git a/src/OSSupport/IsThread.cpp b/src/OSSupport/IsThread.cpp
index 04fc818e4..1a436623a 100644
--- a/src/OSSupport/IsThread.cpp
+++ b/src/OSSupport/IsThread.cpp
@@ -60,6 +60,9 @@ static void SetThreadName(DWORD dwThreadID, const char * threadName)
 cIsThread::cIsThread(const AString & iThreadName) :
 	m_ShouldTerminate(false),
 	m_ThreadName(iThreadName),
+	#ifdef _WIN32
+		m_ThreadID(0),
+	#endif
 	m_Handle(NULL_HANDLE)
 {
 }
@@ -83,11 +86,11 @@ bool cIsThread::Start(void)
 	ASSERT(m_Handle == NULL_HANDLE);  // Has already started one thread?
 	#ifdef _WIN32
 		// Create the thread suspended, so that the mHandle variable is valid in the thread procedure
-		DWORD ThreadID = 0;
-		m_Handle = CreateThread(NULL, 0, thrExecute, this, CREATE_SUSPENDED, &ThreadID);
+		m_ThreadID = 0;
+		m_Handle = CreateThread(NULL, 0, thrExecute, this, CREATE_SUSPENDED, &m_ThreadID);
 		if (m_Handle == NULL)
 		{
-			LOGERROR("ERROR: Could not create thread \"%s\", GLE = %d!", m_ThreadName.c_str(), GetLastError());
+			LOGERROR("ERROR: Could not create thread \"%s\", GLE = %u!", m_ThreadName.c_str(), (unsigned)GetLastError());
 			return false;
 		}
 		ResumeThread(m_Handle);
@@ -96,7 +99,7 @@ bool cIsThread::Start(void)
 			// Thread naming is available only in MSVC
 			if (!m_ThreadName.empty())
 			{
-				SetThreadName(ThreadID, m_ThreadName.c_str());
+				SetThreadName(m_ThreadID, m_ThreadName.c_str());
 			}
 		#endif  // _DEBUG and _MSC_VER
 		
@@ -177,3 +180,15 @@ unsigned long cIsThread::GetCurrentID(void)
 
 
 
+bool cIsThread::IsCurrentThread(void) const
+{
+	#ifdef _WIN32
+		return (GetCurrentThreadId() == m_ThreadID);
+	#else
+		return (m_Handle == pthread_self());
+	#endif
+}
+
+
+
+
diff --git a/src/OSSupport/IsThread.h b/src/OSSupport/IsThread.h
index 57651a490..c20fc3e7e 100644
--- a/src/OSSupport/IsThread.h
+++ b/src/OSSupport/IsThread.h
@@ -48,6 +48,9 @@ public:
 	/// Returns the OS-dependent thread ID for the caller's thread
 	static unsigned long GetCurrentID(void);
 
+	/** Returns true if the thread calling this function is the thread contained within this object. */
+	bool IsCurrentThread(void) const;
+
 protected:
 	AString m_ThreadName;
 	
@@ -60,6 +63,7 @@ protected:
 
 	#ifdef _WIN32
 	
+		DWORD m_ThreadID;
 		HANDLE m_Handle;
 		
 		static DWORD __stdcall thrExecute(LPVOID a_Param)
diff --git a/src/OSSupport/ListenThread.cpp b/src/OSSupport/ListenThread.cpp
index ba3198764..02e98acfc 100644
--- a/src/OSSupport/ListenThread.cpp
+++ b/src/OSSupport/ListenThread.cpp
@@ -214,7 +214,7 @@ void cListenThread::Execute(void)
 		timeval tv;  // On Linux select() doesn't seem to wake up when socket is closed, so let's kinda busy-wait:
 		tv.tv_sec = 1;
 		tv.tv_usec = 0;
-		if (select(Highest + 1, &fdRead, NULL, NULL, &tv) == -1)
+		if (select((int)Highest + 1, &fdRead, NULL, NULL, &tv) == -1)
 		{
 			LOG("select(R) call failed in cListenThread: \"%s\"", cSocket::GetLastErrorString().c_str());
 			continue;
diff --git a/src/OSSupport/Queue.h b/src/OSSupport/Queue.h
index beb6a63f1..bf4d7f004 100644
--- a/src/OSSupport/Queue.h
+++ b/src/OSSupport/Queue.h
@@ -21,19 +21,19 @@ cQueueFuncs and is used as the default behavior.
 
 /// This empty struct allows for the callback functions to be inlined
 template<class T>
-struct cQueueFuncs 
+struct cQueueFuncs
 {
 public:
 
 	/// Called when an Item is deleted from the queue without being returned
-	static void Delete(T) {};
+	static void Delete(T) {}
 	
 	/// Called when an Item is inserted with EnqueueItemIfNotPresent and there is another equal value already inserted
 	static void Combine(T & a_existing, const T & a_new)
 	{
 		UNUSED(a_existing);
 		UNUSED(a_new);
-	};
+	}
 };
 
 
@@ -88,7 +88,7 @@ public:
 		cCSLock Lock(m_CS);
 		if (m_Contents.size() == 0)
 		{
-			return false; 
+			return false;
 		}
 		item = m_Contents.front();
 		m_Contents.pop_front();
diff --git a/src/OSSupport/Semaphore.cpp b/src/OSSupport/Semaphore.cpp
index 468de6858..c1fc7d9c7 100644
--- a/src/OSSupport/Semaphore.cpp
+++ b/src/OSSupport/Semaphore.cpp
@@ -5,9 +5,9 @@
 
 
 
-cSemaphore::cSemaphore( unsigned int a_MaxCount, unsigned int a_InitialCount /* = 0 */ )
+cSemaphore::cSemaphore( unsigned int a_MaxCount, unsigned int a_InitialCount /* = 0 */)
 #ifndef _WIN32
-	: m_bNamed( false )
+	: m_bNamed( false)
 #endif
 {
 #ifndef _WIN32
@@ -20,15 +20,15 @@ cSemaphore::cSemaphore( unsigned int a_MaxCount, unsigned int a_InitialCount /*
 		m_bNamed = true;
 
 		AString Name;
-		Printf(Name, "cSemaphore%p", this );
+		Printf(Name, "cSemaphore%p", this);
 		m_Handle = sem_open(Name.c_str(), O_CREAT, 777, a_InitialCount);
-		if( m_Handle == SEM_FAILED )
+		if (m_Handle == SEM_FAILED)
 		{
-			LOG("ERROR: Could not create Semaphore. (%i)", errno );
+			LOG("ERROR: Could not create Semaphore. (%i)", errno);
 		}
 		else
 		{
-			if( sem_unlink(Name.c_str()) != 0 )
+			if (sem_unlink(Name.c_str()) != 0)
 			{
 				LOG("ERROR: Could not unlink cSemaphore. (%i)", errno);
 			}
@@ -36,56 +36,72 @@ cSemaphore::cSemaphore( unsigned int a_MaxCount, unsigned int a_InitialCount /*
 	}
 #else
 	m_Handle = CreateSemaphore(
-		NULL, // security attribute
-		a_InitialCount, // initial count
-		a_MaxCount, // maximum count
-		0 // name (optional)
+		NULL,  // security attribute
+		a_InitialCount,  // initial count
+		a_MaxCount,  // maximum count
+		0  // name (optional)
 		);
 #endif
 }
 
+
+
+
+
 cSemaphore::~cSemaphore()
 {
 #ifdef _WIN32
-	CloseHandle( m_Handle );
+	CloseHandle( m_Handle);
 #else
-    if( m_bNamed )
-    {
-        if( sem_close( (sem_t*)m_Handle ) != 0 )
-        {
-            LOG("ERROR: Could not close cSemaphore. (%i)", errno);
-        }
-    }
-    else
-    {
-        sem_destroy( (sem_t*)m_Handle );
-        delete (sem_t*)m_Handle;
-    }
+	if (m_bNamed)
+	{
+		if (sem_close( (sem_t*)m_Handle) != 0)
+		{
+			LOG("ERROR: Could not close cSemaphore. (%i)", errno);
+		}
+	}
+	else
+	{
+		sem_destroy( (sem_t*)m_Handle);
+		delete (sem_t*)m_Handle;
+	}
 	m_Handle = 0;
 
 #endif
 }
 
+
+
+
+
 void cSemaphore::Wait()
 {
 #ifndef _WIN32
-    if( sem_wait( (sem_t*)m_Handle ) != 0)
-    {
-        LOG("ERROR: Could not wait for cSemaphore. (%i)", errno);
-    }
+	if (sem_wait( (sem_t*)m_Handle) != 0)
+	{
+		LOG("ERROR: Could not wait for cSemaphore. (%i)", errno);
+	}
 #else
 	WaitForSingleObject( m_Handle, INFINITE);
 #endif
 }
 
+
+
+
+
 void cSemaphore::Signal()
 {
 #ifndef _WIN32
-	if( sem_post( (sem_t*)m_Handle ) != 0 )
+	if (sem_post( (sem_t*)m_Handle) != 0)
 	{
-        LOG("ERROR: Could not signal cSemaphore. (%i)", errno);
+		LOG("ERROR: Could not signal cSemaphore. (%i)", errno);
 	}
 #else
-	ReleaseSemaphore( m_Handle, 1, NULL );
+	ReleaseSemaphore( m_Handle, 1, NULL);
 #endif
 }
+
+
+
+
diff --git a/src/OSSupport/Semaphore.h b/src/OSSupport/Semaphore.h
index fbe8907f1..adc531ed8 100644
--- a/src/OSSupport/Semaphore.h
+++ b/src/OSSupport/Semaphore.h
@@ -3,13 +3,13 @@
 class cSemaphore
 {
 public:
-	cSemaphore( unsigned int a_MaxCount, unsigned int a_InitialCount = 0 );
+	cSemaphore( unsigned int a_MaxCount, unsigned int a_InitialCount = 0);
 	~cSemaphore();
 
 	void Wait();
 	void Signal();
 private:
-	void* m_Handle; // HANDLE pointer
+	void* m_Handle;  // HANDLE pointer
 
 #ifndef _WIN32
 	bool m_bNamed;
diff --git a/src/OSSupport/Sleep.cpp b/src/OSSupport/Sleep.cpp
index 70fb06b40..297d668d7 100644
--- a/src/OSSupport/Sleep.cpp
+++ b/src/OSSupport/Sleep.cpp
@@ -9,11 +9,11 @@
 
 
 
-void cSleep::MilliSleep( unsigned int a_MilliSeconds )
+void cSleep::MilliSleep( unsigned int a_MilliSeconds)
 {
 #ifdef _WIN32
-	Sleep(a_MilliSeconds); // Don't tick too much
+	Sleep(a_MilliSeconds);  // Don't tick too much
 #else
-    usleep(a_MilliSeconds*1000);
+	usleep(a_MilliSeconds*1000);
 #endif
 }
diff --git a/src/OSSupport/Sleep.h b/src/OSSupport/Sleep.h
index 0ec0adf9d..57d29682c 100644
--- a/src/OSSupport/Sleep.h
+++ b/src/OSSupport/Sleep.h
@@ -3,5 +3,5 @@
 class cSleep
 {
 public:
-	static void MilliSleep( unsigned int a_MilliSeconds );
+	static void MilliSleep( unsigned int a_MilliSeconds);
 };
diff --git a/src/OSSupport/Socket.cpp b/src/OSSupport/Socket.cpp
index c29e495c3..c07d31c8b 100644
--- a/src/OSSupport/Socket.cpp
+++ b/src/OSSupport/Socket.cpp
@@ -25,15 +25,6 @@ cSocket::cSocket(xSocket a_Socket)
 
 
 
-cSocket::~cSocket()
-{
-	// Do NOT close the socket; this class is an API wrapper, not a RAII!
-}
-
-
-
-
-
 cSocket::operator cSocket::xSocket() const
 {
 	return m_Socket;
@@ -138,7 +129,7 @@ int cSocket::WSAStartup(void)
 #ifdef _WIN32
 	WSADATA wsaData;
 	memset(&wsaData, 0, sizeof(wsaData));
-	return ::WSAStartup(MAKEWORD(2, 2),&wsaData);
+	return ::WSAStartup(MAKEWORD(2, 2), &wsaData);
 #else
 	return 0;
 #endif
@@ -244,7 +235,7 @@ cSocket cSocket::AcceptIPv6(void)
 			// Windows XP doesn't have inet_ntop, so we need to improvise. And MSVC has different headers than GCC
 			#ifdef _MSC_VER
 				// MSVC version
-				Printf(SClient.m_IPString, "%x:%x:%x:%x:%x:%x:%x:%x", 
+				Printf(SClient.m_IPString, "%x:%x:%x:%x:%x:%x:%x:%x",
 					from.sin6_addr.u.Word[0],
 					from.sin6_addr.u.Word[1],
 					from.sin6_addr.u.Word[2],
@@ -256,7 +247,7 @@ cSocket cSocket::AcceptIPv6(void)
 				);
 			#else  // _MSC_VER
 				// MinGW
-				Printf(SClient.m_IPString, "%x:%x:%x:%x:%x:%x:%x:%x", 
+				Printf(SClient.m_IPString, "%x:%x:%x:%x:%x:%x:%x:%x",
 					from.sin6_addr.s6_addr16[0],
 					from.sin6_addr.s6_addr16[1],
 					from.sin6_addr.s6_addr16[2],
@@ -295,7 +286,7 @@ bool cSocket::ConnectToLocalhostIPv4(unsigned short a_Port)
 
 bool cSocket::ConnectIPv4(const AString & a_HostNameOrAddr, unsigned short a_Port)
 {
-	// First try IP Address string to hostent conversion, because it's faster
+	// First try IP Address string to hostent conversion, because it's faster and local:
 	unsigned long addr = inet_addr(a_HostNameOrAddr.c_str());
 	if (addr == INADDR_NONE)
 	{
@@ -307,10 +298,16 @@ bool cSocket::ConnectIPv4(const AString & a_HostNameOrAddr, unsigned short a_Por
 			CloseSocket();
 			return false;
 		}
-		// Should be optimised to a single word copy
 		memcpy(&addr, hp->h_addr, hp->h_length);
 	}
 
+	// If the socket is not created yet, create one:
+	if (!IsValid())
+	{
+		m_Socket = socket((int)IPv4, SOCK_STREAM, 0);
+	}
+	
+	// Connect the socket:
 	sockaddr_in server;
 	server.sin_addr.s_addr = addr;
 	server.sin_family = AF_INET;
@@ -322,18 +319,18 @@ bool cSocket::ConnectIPv4(const AString & a_HostNameOrAddr, unsigned short a_Por
 
 
 
-int cSocket::Receive(char * a_Buffer, unsigned int a_Length, unsigned int a_Flags)
+int cSocket::Receive(char * a_Buffer, size_t a_Length, unsigned int a_Flags)
 {
-	return recv(m_Socket, a_Buffer, a_Length, a_Flags);
+	return recv(m_Socket, a_Buffer, (int)a_Length, a_Flags);
 }
 
 
 
 
 
-int cSocket::Send(const char * a_Buffer, unsigned int a_Length)
+int cSocket::Send(const char * a_Buffer, size_t a_Length)
 {
-	return send(m_Socket, a_Buffer, a_Length, MSG_NOSIGNAL);
+	return send(m_Socket, a_Buffer, (int)a_Length, MSG_NOSIGNAL);
 }
 
 
diff --git a/src/OSSupport/Socket.h b/src/OSSupport/Socket.h
index bdc2babf5..e4ec895cb 100644
--- a/src/OSSupport/Socket.h
+++ b/src/OSSupport/Socket.h
@@ -41,7 +41,6 @@ public:
 
 	cSocket(void) : m_Socket(INVALID_SOCKET) {}
 	cSocket(xSocket a_Socket);
-	~cSocket();
 
 	bool IsValid(void) const { return IsValidSocket(m_Socket); }
 	void CloseSocket(void);
@@ -110,8 +109,8 @@ public:
 	/// Connects to the specified host or string IP address and port, using IPv4. Returns true if successful.
 	bool ConnectIPv4(const AString & a_HostNameOrAddr, unsigned short a_Port);
 	
-	int Receive(char * a_Buffer, unsigned int a_Length, unsigned int a_Flags);
-	int Send   (const char * a_Buffer, unsigned int a_Length);
+	int Receive(char * a_Buffer, size_t a_Length, unsigned int a_Flags);
+	int Send   (const char * a_Buffer, size_t a_Length);
 	
 	unsigned short GetPort(void) const;  // Returns 0 on failure
 
diff --git a/src/OSSupport/SocketThreads.cpp b/src/OSSupport/SocketThreads.cpp
index 0bc1d6b55..f436318a5 100644
--- a/src/OSSupport/SocketThreads.cpp
+++ b/src/OSSupport/SocketThreads.cpp
@@ -13,7 +13,7 @@
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cSocketThreads:
 
 cSocketThreads::cSocketThreads(void)
@@ -61,6 +61,7 @@ bool cSocketThreads::AddClient(const cSocket & a_Socket, cCallback * a_Client)
 		// There was an error launching the thread (but it was already logged along with the reason)
 		LOGERROR("A new cSocketThread failed to start");
 		delete Thread;
+		Thread = NULL;
 		return false;
 	}
 	Thread->AddClient(a_Socket, a_Client);
@@ -406,7 +407,7 @@ void cSocketThreads::cSocketThread::Execute(void)
 		timeval Timeout;
 		Timeout.tv_sec = 5;
 		Timeout.tv_usec = 0;
-		if (select(Highest + 1, &fdRead, &fdWrite, NULL, &Timeout) == -1)
+		if (select((int)Highest + 1, &fdRead, &fdWrite, NULL, &Timeout) == -1)
 		{
 			LOG("select() call failed in cSocketThread: \"%s\"", cSocket::GetLastErrorString().c_str());
 			continue;
diff --git a/src/OSSupport/SocketThreads.h b/src/OSSupport/SocketThreads.h
index 679e374e1..944f5f3bc 100644
--- a/src/OSSupport/SocketThreads.h
+++ b/src/OSSupport/SocketThreads.h
@@ -63,8 +63,10 @@ public:
 		// Force a virtual destructor in all subclasses:
 		virtual ~cCallback() {}
 		
-		/** Called when data is received from the remote party */
-		virtual void DataReceived(const char * a_Data, size_t a_Size) = 0;
+		/** Called when data is received from the remote party.
+		SocketThreads does not care about the return value, others can use it for their specific purpose -
+		for example HTTPServer uses it to signal if the connection was terminated as a result of the data received. */
+		virtual bool DataReceived(const char * a_Data, size_t a_Size) = 0;
 		
 		/** Called when data can be sent to remote party
 		The function is supposed to *set* outgoing data to a_Data (overwrite) */
diff --git a/src/OSSupport/Thread.cpp b/src/OSSupport/Thread.cpp
index 7a10ef8d2..faaccce96 100644
--- a/src/OSSupport/Thread.cpp
+++ b/src/OSSupport/Thread.cpp
@@ -47,13 +47,13 @@ static void SetThreadName(DWORD dwThreadID, const char * threadName)
 
 
 
-cThread::cThread( ThreadFunc a_ThreadFunction, void* a_Param, const char* a_ThreadName /* = 0 */ )
-	: m_ThreadFunction( a_ThreadFunction )
-	, m_Param( a_Param )
-	, m_Event( new cEvent() )
-	, m_StopEvent( 0 )
+cThread::cThread( ThreadFunc a_ThreadFunction, void* a_Param, const char* a_ThreadName /* = 0 */)
+	: m_ThreadFunction( a_ThreadFunction)
+	, m_Param( a_Param)
+	, m_Event( new cEvent())
+	, m_StopEvent( 0)
 {
-	if( a_ThreadName )
+	if (a_ThreadName)
 	{
 		m_ThreadName.assign(a_ThreadName);
 	}
@@ -66,11 +66,13 @@ cThread::cThread( ThreadFunc a_ThreadFunction, void* a_Param, const char* a_Thre
 cThread::~cThread()
 {
 	delete m_Event;
+	m_Event = NULL;
 	
-	if( m_StopEvent )
+	if (m_StopEvent)
 	{
 		m_StopEvent->Wait();
 		delete m_StopEvent;
+		m_StopEvent = NULL;
 	}
 }
 
@@ -78,24 +80,24 @@ cThread::~cThread()
 
 
 
-void cThread::Start( bool a_bWaitOnDelete /* = true */ )
+void cThread::Start( bool a_bWaitOnDelete /* = true */)
 {
-	if( a_bWaitOnDelete )
+	if (a_bWaitOnDelete)
 		m_StopEvent = new cEvent();
 
 #ifndef _WIN32
 	pthread_t SndThread;
-	if( pthread_create( &SndThread, NULL, MyThread, this) )
+	if (pthread_create( &SndThread, NULL, MyThread, this))
 		LOGERROR("ERROR: Could not create thread!");
 #else
 	DWORD ThreadID = 0;
-	HANDLE hThread = CreateThread(	0 // security
-		,0 // stack size
-		, (LPTHREAD_START_ROUTINE) MyThread // function name
-		,this // parameters
-		,0 // flags
-		,&ThreadID ); // thread id
-	CloseHandle( hThread );
+	HANDLE hThread = CreateThread(NULL  // security
+		, 0  // stack size
+		, (LPTHREAD_START_ROUTINE) MyThread  // function name
+		, this  // parameters
+		, 0  // flags
+		, &ThreadID);  // thread id
+	CloseHandle( hThread);
 
 	#ifdef _MSC_VER
 	if (!m_ThreadName.empty())
@@ -114,9 +116,9 @@ void cThread::Start( bool a_bWaitOnDelete /* = true */ )
 
 
 #ifdef _WIN32
-unsigned long cThread::MyThread(void* a_Param )
+unsigned long cThread::MyThread(void* a_Param)
 #else
-void *cThread::MyThread( void *a_Param )
+void *cThread::MyThread( void *a_Param)
 #endif
 {
 	cThread* self = (cThread*)a_Param;
@@ -128,8 +130,8 @@ void *cThread::MyThread( void *a_Param )
 	// Set event to let other thread know this thread has been created and it's safe to delete the cThread object
 	self->m_Event->Set();
 
-	ThreadFunction( ThreadParam );
+	ThreadFunction( ThreadParam);
 
-	if( StopEvent ) StopEvent->Set();
+	if (StopEvent) StopEvent->Set();
 	return 0;
 }
diff --git a/src/OSSupport/Thread.h b/src/OSSupport/Thread.h
index 4153b2427..7ee352c82 100644
--- a/src/OSSupport/Thread.h
+++ b/src/OSSupport/Thread.h
@@ -4,18 +4,18 @@ class cThread
 {
 public:
 	typedef void (ThreadFunc)(void*);
-	cThread( ThreadFunc a_ThreadFunction, void* a_Param, const char* a_ThreadName = 0 );
+	cThread( ThreadFunc a_ThreadFunction, void* a_Param, const char* a_ThreadName = 0);
 	~cThread();
 
-	void Start( bool a_bWaitOnDelete = true );
+	void Start( bool a_bWaitOnDelete = true);
 	void WaitForThread();
 private:
 	ThreadFunc* m_ThreadFunction;
 
 #ifdef _WIN32
-	static unsigned long MyThread(void* a_Param );
+	static unsigned long MyThread(void* a_Param);
 #else
-	static void *MyThread( void *lpParam );
+	static void *MyThread( void *lpParam);
 #endif
 
 	void* m_Param;