Replace tabs with spaces in more files.

--HG--
branch : trunk

18 files changed, 5086 insertions, 5086 deletions

diff --git a/dep/src/sockets/Base64.cpp b/dep/src/sockets/Base64.cpp
index b8cf1237175..95b91555beb 100644
--- a/dep/src/sockets/Base64.cpp
+++ b/dep/src/sockets/Base64.cpp
@@ -1,6 +1,6 @@
 /** \file Base64.cpp
- **	\date  2004-02-13
- **	\author grymse@alhem.net
+ ** \date  2004-02-13
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2004-2007  Anders Hedstrom
@@ -8,7 +8,7 @@ Copyright (C) 2004-2007  Anders Hedstrom
 This library is made available under the terms of the GNU GPL.
 
 If you would like to use this library in a closed-source application,
-a separate license agreement is available. For information about 
+a separate license agreement is available. For information about
 the closed-source license agreement for the C++ sockets library,
 please visit http://www.alhem.net/Sockets/license.html and/or
 email license@alhem.net.
@@ -35,20 +35,20 @@ namespace SOCKETS_NAMESPACE {
 
 
 const char *Base64::bstr =
-	"ABCDEFGHIJKLMNOPQ"
-	"RSTUVWXYZabcdefgh"
-	"ijklmnopqrstuvwxy"
-	"z0123456789+/";
+    "ABCDEFGHIJKLMNOPQ"
+    "RSTUVWXYZabcdefgh"
+    "ijklmnopqrstuvwxy"
+    "z0123456789+/";
 
 const char Base64::rstr[] = {
-	  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
-	  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
-	  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  62,   0,   0,   0,  63, 
-	 52,  53,  54,  55,  56,  57,  58,  59,  60,  61,   0,   0,   0,   0,   0,   0, 
-	  0,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14, 
-	 15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,   0,   0,   0,   0,   0, 
-	  0,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40, 
-	 41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,   0,   0,   0,   0,   0};
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  62,   0,   0,   0,  63,
+     52,  53,  54,  55,  56,  57,  58,  59,  60,  61,   0,   0,   0,   0,   0,   0,
+      0,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,
+     15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,   0,   0,   0,   0,   0,
+      0,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,
+     41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,   0,   0,   0,   0,   0};
 
 
 Base64::Base64()
@@ -58,210 +58,210 @@ Base64::Base64()
 
 void Base64::encode(FILE *fil, std::string& output, bool add_crlf)
 {
-	size_t remain;
-	size_t i = 0;
-	size_t o = 0;
-	char input[4];
-
-	output = "";
-	remain = fread(input,1,3,fil);
-	while (remain > 0)
-	{
-		if (add_crlf && o && o % 76 == 0)
-			output += "\n";
-		switch (remain)
-		{
-		case 1:
-			output += bstr[ ((input[i] >> 2) & 0x3f) ];
-			output += bstr[ ((input[i] << 4) & 0x30) ];
-			output += "==";
-			break;
-		case 2:
-			output += bstr[ ((input[i] >> 2) & 0x3f) ];
-			output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
-			output += bstr[ ((input[i + 1] << 2) & 0x3c) ];
-			output += "=";
-			break;
-		default:
-			output += bstr[ ((input[i] >> 2) & 0x3f) ];
-			output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
-			output += bstr[ ((input[i + 1] << 2) & 0x3c) + ((input[i + 2] >> 6) & 0x03) ];
-			output += bstr[ (input[i + 2] & 0x3f) ];
-		}
-		o += 4;
-		//
-		remain = fread(input,1,3,fil);
-	}
+    size_t remain;
+    size_t i = 0;
+    size_t o = 0;
+    char input[4];
+
+    output = "";
+    remain = fread(input,1,3,fil);
+    while (remain > 0)
+    {
+        if (add_crlf && o && o % 76 == 0)
+            output += "\n";
+        switch (remain)
+        {
+        case 1:
+            output += bstr[ ((input[i] >> 2) & 0x3f) ];
+            output += bstr[ ((input[i] << 4) & 0x30) ];
+            output += "==";
+            break;
+        case 2:
+            output += bstr[ ((input[i] >> 2) & 0x3f) ];
+            output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
+            output += bstr[ ((input[i + 1] << 2) & 0x3c) ];
+            output += "=";
+            break;
+        default:
+            output += bstr[ ((input[i] >> 2) & 0x3f) ];
+            output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
+            output += bstr[ ((input[i + 1] << 2) & 0x3c) + ((input[i + 2] >> 6) & 0x03) ];
+            output += bstr[ (input[i + 2] & 0x3f) ];
+        }
+        o += 4;
+        //
+        remain = fread(input,1,3,fil);
+    }
 }
 
 
 void Base64::encode(const std::string& str_in, std::string& str_out, bool add_crlf)
 {
-	encode(str_in.c_str(), str_in.size(), str_out, add_crlf);
+    encode(str_in.c_str(), str_in.size(), str_out, add_crlf);
 }
 
 
 void Base64::encode(const char* input,size_t l,std::string& output, bool add_crlf)
 {
-	size_t i = 0;
-	size_t o = 0;
-	
-	output = "";
-	while (i < l)
-	{
-		size_t remain = l - i;
-		if (add_crlf && o && o % 76 == 0)
-			output += "\n";
-		switch (remain)
-		{
-		case 1:
-			output += bstr[ ((input[i] >> 2) & 0x3f) ];
-			output += bstr[ ((input[i] << 4) & 0x30) ];
-			output += "==";
-			break;
-		case 2:
-			output += bstr[ ((input[i] >> 2) & 0x3f) ];
-			output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
-			output += bstr[ ((input[i + 1] << 2) & 0x3c) ];
-			output += "=";
-			break;
-		default:
-			output += bstr[ ((input[i] >> 2) & 0x3f) ];
-			output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
-			output += bstr[ ((input[i + 1] << 2) & 0x3c) + ((input[i + 2] >> 6) & 0x03) ];
-			output += bstr[ (input[i + 2] & 0x3f) ];
-		}
-		o += 4;
-		i += 3;
-	}
+    size_t i = 0;
+    size_t o = 0;
+
+    output = "";
+    while (i < l)
+    {
+        size_t remain = l - i;
+        if (add_crlf && o && o % 76 == 0)
+            output += "\n";
+        switch (remain)
+        {
+        case 1:
+            output += bstr[ ((input[i] >> 2) & 0x3f) ];
+            output += bstr[ ((input[i] << 4) & 0x30) ];
+            output += "==";
+            break;
+        case 2:
+            output += bstr[ ((input[i] >> 2) & 0x3f) ];
+            output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
+            output += bstr[ ((input[i + 1] << 2) & 0x3c) ];
+            output += "=";
+            break;
+        default:
+            output += bstr[ ((input[i] >> 2) & 0x3f) ];
+            output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
+            output += bstr[ ((input[i + 1] << 2) & 0x3c) + ((input[i + 2] >> 6) & 0x03) ];
+            output += bstr[ (input[i + 2] & 0x3f) ];
+        }
+        o += 4;
+        i += 3;
+    }
 }
 
 
 void Base64::encode(const unsigned char* input,size_t l,std::string& output,bool add_crlf)
 {
-	size_t i = 0;
-	size_t o = 0;
-	
-	output = "";
-	while (i < l)
-	{
-		size_t remain = l - i;
-		if (add_crlf && o && o % 76 == 0)
-			output += "\n";
-		switch (remain)
-		{
-		case 1:
-			output += bstr[ ((input[i] >> 2) & 0x3f) ];
-			output += bstr[ ((input[i] << 4) & 0x30) ];
-			output += "==";
-			break;
-		case 2:
-			output += bstr[ ((input[i] >> 2) & 0x3f) ];
-			output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
-			output += bstr[ ((input[i + 1] << 2) & 0x3c) ];
-			output += "=";
-			break;
-		default:
-			output += bstr[ ((input[i] >> 2) & 0x3f) ];
-			output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
-			output += bstr[ ((input[i + 1] << 2) & 0x3c) + ((input[i + 2] >> 6) & 0x03) ];
-			output += bstr[ (input[i + 2] & 0x3f) ];
-		}
-		o += 4;
-		i += 3;
-	}
+    size_t i = 0;
+    size_t o = 0;
+
+    output = "";
+    while (i < l)
+    {
+        size_t remain = l - i;
+        if (add_crlf && o && o % 76 == 0)
+            output += "\n";
+        switch (remain)
+        {
+        case 1:
+            output += bstr[ ((input[i] >> 2) & 0x3f) ];
+            output += bstr[ ((input[i] << 4) & 0x30) ];
+            output += "==";
+            break;
+        case 2:
+            output += bstr[ ((input[i] >> 2) & 0x3f) ];
+            output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
+            output += bstr[ ((input[i + 1] << 2) & 0x3c) ];
+            output += "=";
+            break;
+        default:
+            output += bstr[ ((input[i] >> 2) & 0x3f) ];
+            output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
+            output += bstr[ ((input[i + 1] << 2) & 0x3c) + ((input[i + 2] >> 6) & 0x03) ];
+            output += bstr[ (input[i + 2] & 0x3f) ];
+        }
+        o += 4;
+        i += 3;
+    }
 }
 
 
 void Base64::decode(const std::string& input,std::string& output)
 {
-	size_t i = 0;
-	size_t l = input.size();
-	
-	output = "";
-	while (i < l)
-	{
-		while (i < l && (input[i] == 13 || input[i] == 10))
-			i++;
-		if (i < l)
-		{
-			char b1 = (char)((rstr[(int)input[i]] << 2 & 0xfc) +
-					(rstr[(int)input[i + 1]] >> 4 & 0x03));
-			output += b1;
-			if (input[i + 2] != '=')
-			{
-				char b2 = (char)((rstr[(int)input[i + 1]] << 4 & 0xf0) +
-						(rstr[(int)input[i + 2]] >> 2 & 0x0f));
-				output += b2;
-			}
-			if (input[i + 3] != '=')
-			{
-				char b3 = (char)((rstr[(int)input[i + 2]] << 6 & 0xc0) +
-						rstr[(int)input[i + 3]]);
-				output += b3;
-			}
-			i += 4;
-		}
-	}
+    size_t i = 0;
+    size_t l = input.size();
+
+    output = "";
+    while (i < l)
+    {
+        while (i < l && (input[i] == 13 || input[i] == 10))
+            i++;
+        if (i < l)
+        {
+            char b1 = (char)((rstr[(int)input[i]] << 2 & 0xfc) +
+                    (rstr[(int)input[i + 1]] >> 4 & 0x03));
+            output += b1;
+            if (input[i + 2] != '=')
+            {
+                char b2 = (char)((rstr[(int)input[i + 1]] << 4 & 0xf0) +
+                        (rstr[(int)input[i + 2]] >> 2 & 0x0f));
+                output += b2;
+            }
+            if (input[i + 3] != '=')
+            {
+                char b3 = (char)((rstr[(int)input[i + 2]] << 6 & 0xc0) +
+                        rstr[(int)input[i + 3]]);
+                output += b3;
+            }
+            i += 4;
+        }
+    }
 }
 
 
 void Base64::decode(const std::string& input, unsigned char *output, size_t& sz)
 {
-	size_t i = 0;
-	size_t l = input.size();
-	size_t j = 0;
-	
-	while (i < l)
-	{
-		while (i < l && (input[i] == 13 || input[i] == 10))
-			i++;
-		if (i < l)
-		{
-			unsigned char b1 = (unsigned char)((rstr[(int)input[i]] << 2 & 0xfc) +
-					(rstr[(int)input[i + 1]] >> 4 & 0x03));
-			if (output)
-			{
-				output[j] = b1;
-			}
-			j++;
-			if (input[i + 2] != '=')
-			{
-				unsigned char b2 = (unsigned char)((rstr[(int)input[i + 1]] << 4 & 0xf0) +
-						(rstr[(int)input[i + 2]] >> 2 & 0x0f));
-				if (output)
-				{
-					output[j] = b2;
-				}
-				j++;
-			}
-			if (input[i + 3] != '=')
-			{
-				unsigned char b3 = (unsigned char)((rstr[(int)input[i + 2]] << 6 & 0xc0) +
-						rstr[(int)input[i + 3]]);
-				if (output)
-				{
-					output[j] = b3;
-				}
-				j++;
-			}
-			i += 4;
-		}
-	}
-	sz = j;
+    size_t i = 0;
+    size_t l = input.size();
+    size_t j = 0;
+
+    while (i < l)
+    {
+        while (i < l && (input[i] == 13 || input[i] == 10))
+            i++;
+        if (i < l)
+        {
+            unsigned char b1 = (unsigned char)((rstr[(int)input[i]] << 2 & 0xfc) +
+                    (rstr[(int)input[i + 1]] >> 4 & 0x03));
+            if (output)
+            {
+                output[j] = b1;
+            }
+            j++;
+            if (input[i + 2] != '=')
+            {
+                unsigned char b2 = (unsigned char)((rstr[(int)input[i + 1]] << 4 & 0xf0) +
+                        (rstr[(int)input[i + 2]] >> 2 & 0x0f));
+                if (output)
+                {
+                    output[j] = b2;
+                }
+                j++;
+            }
+            if (input[i + 3] != '=')
+            {
+                unsigned char b3 = (unsigned char)((rstr[(int)input[i + 2]] << 6 & 0xc0) +
+                        rstr[(int)input[i + 3]]);
+                if (output)
+                {
+                    output[j] = b3;
+                }
+                j++;
+            }
+            i += 4;
+        }
+    }
+    sz = j;
 }
 
 
 size_t Base64::decode_length(const std::string& str64)
 {
-	if (str64.empty() || str64.size() % 4)
-		return 0;
-	size_t l = 3 * (str64.size() / 4 - 1) + 1;
-	if (str64[str64.size() - 2] != '=')
-		l++;
-	if (str64[str64.size() - 1] != '=')
-		l++;
-	return l;
+    if (str64.empty() || str64.size() % 4)
+        return 0;
+    size_t l = 3 * (str64.size() / 4 - 1) + 1;
+    if (str64[str64.size() - 2] != '=')
+        l++;
+    if (str64[str64.size() - 1] != '=')
+        l++;
+    return l;
 }
 
 
diff --git a/dep/src/sockets/Exception.cpp b/dep/src/sockets/Exception.cpp
index a005669e4c9..b3844982c0f 100644
--- a/dep/src/sockets/Exception.cpp
+++ b/dep/src/sockets/Exception.cpp
@@ -1,7 +1,7 @@
 /**
- **	\file Exception.cpp
- **	\date  2007-09-28
- **	\author grymse@alhem.net
+ ** \file Exception.cpp
+ ** \date  2007-09-28
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2007  Anders Hedstrom
@@ -38,7 +38,7 @@ Exception::Exception(const std::string& description) : m_description(description
 
 const std::string Exception::ToString() const
 {
-	return m_description;
+    return m_description;
 }
 
 
diff --git a/dep/src/sockets/Ipv4Address.cpp b/dep/src/sockets/Ipv4Address.cpp
index 58f25e53b83..88a7d33fb63 100644
--- a/dep/src/sockets/Ipv4Address.cpp
+++ b/dep/src/sockets/Ipv4Address.cpp
@@ -1,7 +1,7 @@
 /**
- **	\file Ipv4Address.cpp
- **	\date  2006-09-21
- **	\author grymse@alhem.net
+ ** \file Ipv4Address.cpp
+ ** \date  2006-09-21
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2007  Anders Hedstrom
@@ -36,50 +36,50 @@ namespace SOCKETS_NAMESPACE {
 
 Ipv4Address::Ipv4Address(port_t port) : m_valid(true)
 {
-	memset(&m_addr, 0, sizeof(m_addr));
-	m_addr.sin_family = AF_INET;
-	m_addr.sin_port = htons( port );
+    memset(&m_addr, 0, sizeof(m_addr));
+    m_addr.sin_family = AF_INET;
+    m_addr.sin_port = htons( port );
 }
 
 
 Ipv4Address::Ipv4Address(ipaddr_t a,port_t port) : m_valid(true)
 {
-	memset(&m_addr, 0, sizeof(m_addr));
-	m_addr.sin_family = AF_INET;
-	m_addr.sin_port = htons( port );
-	memcpy(&m_addr.sin_addr, &a, sizeof(struct in_addr));
+    memset(&m_addr, 0, sizeof(m_addr));
+    m_addr.sin_family = AF_INET;
+    m_addr.sin_port = htons( port );
+    memcpy(&m_addr.sin_addr, &a, sizeof(struct in_addr));
 }
 
 
 Ipv4Address::Ipv4Address(struct in_addr& a,port_t port) : m_valid(true)
 {
-	memset(&m_addr, 0, sizeof(m_addr));
-	m_addr.sin_family = AF_INET;
-	m_addr.sin_port = htons( port );
-	m_addr.sin_addr = a;
+    memset(&m_addr, 0, sizeof(m_addr));
+    m_addr.sin_family = AF_INET;
+    m_addr.sin_port = htons( port );
+    m_addr.sin_addr = a;
 }
 
 
 Ipv4Address::Ipv4Address(const std::string& host,port_t port) : m_valid(false)
 {
-	memset(&m_addr, 0, sizeof(m_addr));
-	m_addr.sin_family = AF_INET;
-	m_addr.sin_port = htons( port );
-	{
-		ipaddr_t a;
-		if (Utility::u2ip(host, a))
-		{
-			memcpy(&m_addr.sin_addr, &a, sizeof(struct in_addr));
-			m_valid = true;
-		}
-	}
+    memset(&m_addr, 0, sizeof(m_addr));
+    m_addr.sin_family = AF_INET;
+    m_addr.sin_port = htons( port );
+    {
+        ipaddr_t a;
+        if (Utility::u2ip(host, a))
+        {
+            memcpy(&m_addr.sin_addr, &a, sizeof(struct in_addr));
+            m_valid = true;
+        }
+    }
 }
 
 
 Ipv4Address::Ipv4Address(struct sockaddr_in& sa)
 {
-	m_addr = sa;
-	m_valid = sa.sin_family == AF_INET;
+    m_addr = sa;
+    m_valid = sa.sin_family == AF_INET;
 }
 
 
@@ -90,121 +90,121 @@ Ipv4Address::~Ipv4Address()
 
 Ipv4Address::operator struct sockaddr *()
 {
-	return (struct sockaddr *)&m_addr;
+    return (struct sockaddr *)&m_addr;
 }
 
 
 Ipv4Address::operator socklen_t()
 {
-	return sizeof(struct sockaddr_in);
+    return sizeof(struct sockaddr_in);
 }
 
 
 void Ipv4Address::SetPort(port_t port)
 {
-	m_addr.sin_port = htons( port );
+    m_addr.sin_port = htons( port );
 }
 
 
 port_t Ipv4Address::GetPort()
 {
-	return ntohs( m_addr.sin_port );
+    return ntohs( m_addr.sin_port );
 }
 
 
 bool Ipv4Address::Resolve(const std::string& hostname,struct in_addr& a)
 {
-	struct sockaddr_in sa;
-	memset(&a, 0, sizeof(a));
-	if (Utility::isipv4(hostname))
-	{
-		if (!Utility::u2ip(hostname, sa, AI_NUMERICHOST))
-			return false;
-		a = sa.sin_addr;
-		return true;
-	}
-	if (!Utility::u2ip(hostname, sa))
-		return false;
-	a = sa.sin_addr;
-	return true;
+    struct sockaddr_in sa;
+    memset(&a, 0, sizeof(a));
+    if (Utility::isipv4(hostname))
+    {
+        if (!Utility::u2ip(hostname, sa, AI_NUMERICHOST))
+            return false;
+        a = sa.sin_addr;
+        return true;
+    }
+    if (!Utility::u2ip(hostname, sa))
+        return false;
+    a = sa.sin_addr;
+    return true;
 }
 
 
 bool Ipv4Address::Reverse(struct in_addr& a,std::string& name)
 {
-	struct sockaddr_in sa;
-	memset(&sa, 0, sizeof(sa));
-	sa.sin_family = AF_INET;
-	sa.sin_addr = a;
-	return Utility::reverse((struct sockaddr *)&sa, sizeof(sa), name);
+    struct sockaddr_in sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sin_family = AF_INET;
+    sa.sin_addr = a;
+    return Utility::reverse((struct sockaddr *)&sa, sizeof(sa), name);
 }
 
 
 std::string Ipv4Address::Convert(bool include_port)
 {
-	if (include_port)
-		return Convert(m_addr.sin_addr) + ":" + Utility::l2string(GetPort());
-	return Convert(m_addr.sin_addr);
+    if (include_port)
+        return Convert(m_addr.sin_addr) + ":" + Utility::l2string(GetPort());
+    return Convert(m_addr.sin_addr);
 }
 
 
 std::string Ipv4Address::Convert(struct in_addr& a)
 {
-	struct sockaddr_in sa;
-	memset(&sa, 0, sizeof(sa));
-	sa.sin_family = AF_INET;
-	sa.sin_addr = a;
-	std::string name;
-	Utility::reverse((struct sockaddr *)&sa, sizeof(sa), name, NI_NUMERICHOST);
-	return name;
+    struct sockaddr_in sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sin_family = AF_INET;
+    sa.sin_addr = a;
+    std::string name;
+    Utility::reverse((struct sockaddr *)&sa, sizeof(sa), name, NI_NUMERICHOST);
+    return name;
 }
 
 
 void Ipv4Address::SetAddress(struct sockaddr *sa)
 {
-	memcpy(&m_addr, sa, sizeof(struct sockaddr_in));
+    memcpy(&m_addr, sa, sizeof(struct sockaddr_in));
 }
 
 
 int Ipv4Address::GetFamily()
 {
-	return m_addr.sin_family;
+    return m_addr.sin_family;
 }
 
 
 bool Ipv4Address::IsValid()
 {
-	return m_valid;
+    return m_valid;
 }
 
 
 bool Ipv4Address::operator==(SocketAddress& a)
 {
-	if (a.GetFamily() != GetFamily())
-		return false;
-	if ((socklen_t)a != sizeof(m_addr))
-		return false;
-	struct sockaddr *sa = a;
-	struct sockaddr_in *p = (struct sockaddr_in *)sa;
-	if (p -> sin_port != m_addr.sin_port)
-		return false;
-	if (memcmp(&p -> sin_addr, &m_addr.sin_addr, 4))
-		return false;
-	return true;
+    if (a.GetFamily() != GetFamily())
+        return false;
+    if ((socklen_t)a != sizeof(m_addr))
+        return false;
+    struct sockaddr *sa = a;
+    struct sockaddr_in *p = (struct sockaddr_in *)sa;
+    if (p -> sin_port != m_addr.sin_port)
+        return false;
+    if (memcmp(&p -> sin_addr, &m_addr.sin_addr, 4))
+        return false;
+    return true;
 }
 
 
 std::auto_ptr<SocketAddress> Ipv4Address::GetCopy()
 {
-	return std::auto_ptr<SocketAddress>(new Ipv4Address(m_addr));
+    return std::auto_ptr<SocketAddress>(new Ipv4Address(m_addr));
 }
 
 
 std::string Ipv4Address::Reverse()
 {
-	std::string tmp;
-	Reverse(m_addr.sin_addr, tmp);
-	return tmp;
+    std::string tmp;
+    Reverse(m_addr.sin_addr, tmp);
+    return tmp;
 }
 
 
diff --git a/dep/src/sockets/Ipv6Address.cpp b/dep/src/sockets/Ipv6Address.cpp
index 2e0f1e9acf3..c6f1443af2e 100644
--- a/dep/src/sockets/Ipv6Address.cpp
+++ b/dep/src/sockets/Ipv6Address.cpp
@@ -1,7 +1,7 @@
 /**
- **	\file Ipv6Address.cpp
- **	\date  2006-09-21
- **	\author grymse@alhem.net
+ ** \file Ipv6Address.cpp
+ ** \date  2006-09-21
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2007  Anders Hedstrom
@@ -37,41 +37,41 @@ namespace SOCKETS_NAMESPACE {
 
 Ipv6Address::Ipv6Address(port_t port) : m_valid(true)
 {
-	memset(&m_addr, 0, sizeof(m_addr));
-	m_addr.sin6_family = AF_INET6;
-	m_addr.sin6_port = htons( port );
+    memset(&m_addr, 0, sizeof(m_addr));
+    m_addr.sin6_family = AF_INET6;
+    m_addr.sin6_port = htons( port );
 }
 
 
 Ipv6Address::Ipv6Address(struct in6_addr& a,port_t port) : m_valid(true)
 {
-	memset(&m_addr, 0, sizeof(m_addr));
-	m_addr.sin6_family = AF_INET6;
-	m_addr.sin6_port = htons( port );
-	m_addr.sin6_addr = a;
+    memset(&m_addr, 0, sizeof(m_addr));
+    m_addr.sin6_family = AF_INET6;
+    m_addr.sin6_port = htons( port );
+    m_addr.sin6_addr = a;
 }
 
 
 Ipv6Address::Ipv6Address(const std::string& host,port_t port) : m_valid(false)
 {
-	memset(&m_addr, 0, sizeof(m_addr));
-	m_addr.sin6_family = AF_INET6;
-	m_addr.sin6_port = htons( port );
-	{
-		struct in6_addr a;
-		if (Utility::u2ip(host, a))
-		{
-			m_addr.sin6_addr = a;
-			m_valid = true;
-		}
-	}
+    memset(&m_addr, 0, sizeof(m_addr));
+    m_addr.sin6_family = AF_INET6;
+    m_addr.sin6_port = htons( port );
+    {
+        struct in6_addr a;
+        if (Utility::u2ip(host, a))
+        {
+            m_addr.sin6_addr = a;
+            m_valid = true;
+        }
+    }
 }
 
 
 Ipv6Address::Ipv6Address(struct sockaddr_in6& sa)
 {
-	m_addr = sa;
-	m_valid = sa.sin6_family == AF_INET6;
+    m_addr = sa;
+    m_valid = sa.sin6_family == AF_INET6;
 }
 
 
@@ -82,183 +82,183 @@ Ipv6Address::~Ipv6Address()
 
 Ipv6Address::operator struct sockaddr *()
 {
-	return (struct sockaddr *)&m_addr;
+    return (struct sockaddr *)&m_addr;
 }
 
 
 Ipv6Address::operator socklen_t()
 {
-	return sizeof(struct sockaddr_in6);
+    return sizeof(struct sockaddr_in6);
 }
 
 
 void Ipv6Address::SetPort(port_t port)
 {
-	m_addr.sin6_port = htons( port );
+    m_addr.sin6_port = htons( port );
 }
 
 
 port_t Ipv6Address::GetPort()
 {
-	return ntohs( m_addr.sin6_port );
+    return ntohs( m_addr.sin6_port );
 }
 
 
 bool Ipv6Address::Resolve(const std::string& hostname,struct in6_addr& a)
 {
-	struct sockaddr_in6 sa;
-	memset(&a, 0, sizeof(a));
-	if (Utility::isipv6(hostname))
-	{
-		if (!Utility::u2ip(hostname, sa, AI_NUMERICHOST))
-			return false;
-		a = sa.sin6_addr;
-		return true;
-	}
-	if (!Utility::u2ip(hostname, sa))
-		return false;
-	a = sa.sin6_addr;
-	return true;
+    struct sockaddr_in6 sa;
+    memset(&a, 0, sizeof(a));
+    if (Utility::isipv6(hostname))
+    {
+        if (!Utility::u2ip(hostname, sa, AI_NUMERICHOST))
+            return false;
+        a = sa.sin6_addr;
+        return true;
+    }
+    if (!Utility::u2ip(hostname, sa))
+        return false;
+    a = sa.sin6_addr;
+    return true;
 }
 
 
 bool Ipv6Address::Reverse(struct in6_addr& a,std::string& name)
 {
-	struct sockaddr_in6 sa;
-	memset(&sa, 0, sizeof(sa));
-	sa.sin6_family = AF_INET6;
-	sa.sin6_addr = a;
-	return Utility::reverse((struct sockaddr *)&sa, sizeof(sa), name);
+    struct sockaddr_in6 sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sin6_family = AF_INET6;
+    sa.sin6_addr = a;
+    return Utility::reverse((struct sockaddr *)&sa, sizeof(sa), name);
 }
 
 
 std::string Ipv6Address::Convert(bool include_port)
 {
-	if (include_port)
-		return Convert(m_addr.sin6_addr) + ":" + Utility::l2string(GetPort());
-	return Convert(m_addr.sin6_addr);
+    if (include_port)
+        return Convert(m_addr.sin6_addr) + ":" + Utility::l2string(GetPort());
+    return Convert(m_addr.sin6_addr);
 }
 
 
 std::string Ipv6Address::Convert(struct in6_addr& a,bool mixed)
 {
-	char slask[100]; // l2ip temporary
-	*slask = 0;
-	unsigned int prev = 0;
-	bool skipped = false;
-	bool ok_to_skip = true;
-	if (mixed)
-	{
-		unsigned short x;
-		unsigned short addr16[8];
-		memcpy(addr16, &a, sizeof(addr16));
-		for (size_t i = 0; i < 6; i++)
-		{
-			x = ntohs(addr16[i]);
-			if (*slask && (x || !ok_to_skip || prev))
-				strcat(slask,":");
-			if (x || !ok_to_skip)
-			{
-				sprintf(slask + strlen(slask),"%x", x);
-				if (x && skipped)
-					ok_to_skip = false;
-			}
-			else
-			{
-				skipped = true;
-			}
-			prev = x;
-		}
-		x = ntohs(addr16[6]);
-		sprintf(slask + strlen(slask),":%u.%u",x / 256,x & 255);
-		x = ntohs(addr16[7]);
-		sprintf(slask + strlen(slask),".%u.%u",x / 256,x & 255);
-	}
-	else
-	{
-		struct sockaddr_in6 sa;
-		memset(&sa, 0, sizeof(sa));
-		sa.sin6_family = AF_INET6;
-		sa.sin6_addr = a;
-		std::string name;
-		Utility::reverse((struct sockaddr *)&sa, sizeof(sa), name, NI_NUMERICHOST);
-		return name;
-	}
-	return slask;
+    char slask[100]; // l2ip temporary
+    *slask = 0;
+    unsigned int prev = 0;
+    bool skipped = false;
+    bool ok_to_skip = true;
+    if (mixed)
+    {
+        unsigned short x;
+        unsigned short addr16[8];
+        memcpy(addr16, &a, sizeof(addr16));
+        for (size_t i = 0; i < 6; i++)
+        {
+            x = ntohs(addr16[i]);
+            if (*slask && (x || !ok_to_skip || prev))
+                strcat(slask,":");
+            if (x || !ok_to_skip)
+            {
+                sprintf(slask + strlen(slask),"%x", x);
+                if (x && skipped)
+                    ok_to_skip = false;
+            }
+            else
+            {
+                skipped = true;
+            }
+            prev = x;
+        }
+        x = ntohs(addr16[6]);
+        sprintf(slask + strlen(slask),":%u.%u",x / 256,x & 255);
+        x = ntohs(addr16[7]);
+        sprintf(slask + strlen(slask),".%u.%u",x / 256,x & 255);
+    }
+    else
+    {
+        struct sockaddr_in6 sa;
+        memset(&sa, 0, sizeof(sa));
+        sa.sin6_family = AF_INET6;
+        sa.sin6_addr = a;
+        std::string name;
+        Utility::reverse((struct sockaddr *)&sa, sizeof(sa), name, NI_NUMERICHOST);
+        return name;
+    }
+    return slask;
 }
 
 
 void Ipv6Address::SetAddress(struct sockaddr *sa)
 {
-	memcpy(&m_addr, sa, sizeof(struct sockaddr_in6));
+    memcpy(&m_addr, sa, sizeof(struct sockaddr_in6));
 }
 
 
 int Ipv6Address::GetFamily()
 {
-	return m_addr.sin6_family;
+    return m_addr.sin6_family;
 }
 
 
 void Ipv6Address::SetFlowinfo(uint32_t x)
 {
-	m_addr.sin6_flowinfo = x;
+    m_addr.sin6_flowinfo = x;
 }
 
 
 uint32_t Ipv6Address::GetFlowinfo()
 {
-	return m_addr.sin6_flowinfo;
+    return m_addr.sin6_flowinfo;
 }
 
 
 #ifndef _WIN32
 void Ipv6Address::SetScopeId(uint32_t x)
 {
-	m_addr.sin6_scope_id = x;
+    m_addr.sin6_scope_id = x;
 }
 
 
 uint32_t Ipv6Address::GetScopeId()
 {
-	return m_addr.sin6_scope_id;
+    return m_addr.sin6_scope_id;
 }
 #endif
 
 
 bool Ipv6Address::IsValid()
 {
-	return m_valid;
+    return m_valid;
 }
 
 
 bool Ipv6Address::operator==(SocketAddress& a)
 {
-	if (a.GetFamily() != GetFamily())
-		return false;
-	if ((socklen_t)a != sizeof(m_addr))
-		return false;
-	struct sockaddr *sa = a;
-	struct sockaddr_in6 *p = (struct sockaddr_in6 *)sa;
-	if (p -> sin6_port != m_addr.sin6_port)
-		return false;
-	if (memcmp(&p -> sin6_addr, &m_addr.sin6_addr, sizeof(struct in6_addr)))
-		return false;
-	return true;
+    if (a.GetFamily() != GetFamily())
+        return false;
+    if ((socklen_t)a != sizeof(m_addr))
+        return false;
+    struct sockaddr *sa = a;
+    struct sockaddr_in6 *p = (struct sockaddr_in6 *)sa;
+    if (p -> sin6_port != m_addr.sin6_port)
+        return false;
+    if (memcmp(&p -> sin6_addr, &m_addr.sin6_addr, sizeof(struct in6_addr)))
+        return false;
+    return true;
 }
 
 
 std::auto_ptr<SocketAddress> Ipv6Address::GetCopy()
 {
-	return std::auto_ptr<SocketAddress>(new Ipv6Address(m_addr));
+    return std::auto_ptr<SocketAddress>(new Ipv6Address(m_addr));
 }
 
 
 std::string Ipv6Address::Reverse()
 {
-	std::string tmp;
-	Reverse(m_addr.sin6_addr, tmp);
-	return tmp;
+    std::string tmp;
+    Reverse(m_addr.sin6_addr, tmp);
+    return tmp;
 }
 
 
diff --git a/dep/src/sockets/Lock.cpp b/dep/src/sockets/Lock.cpp
index 3f7902e232b..3f7ad87b2ba 100644
--- a/dep/src/sockets/Lock.cpp
+++ b/dep/src/sockets/Lock.cpp
@@ -1,6 +1,6 @@
 /** \file Lock.cpp
- **	\date  2005-08-22
- **	\author grymse@alhem.net
+ ** \date  2005-08-22
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2005,2007  Anders Hedstrom
@@ -8,7 +8,7 @@ Copyright (C) 2005,2007  Anders Hedstrom
 This library is made available under the terms of the GNU GPL.
 
 If you would like to use this library in a closed-source application,
-a separate license agreement is available. For information about 
+a separate license agreement is available. For information about
 the closed-source license agreement for the C++ sockets library,
 please visit http://www.alhem.net/Sockets/license.html and/or
 email license@alhem.net.
@@ -37,13 +37,13 @@ namespace SOCKETS_NAMESPACE {
 
 Lock::Lock(Mutex& m) : m_mutex(m)
 {
-	m_mutex.Lock();
+    m_mutex.Lock();
 }
 
 
 Lock::~Lock()
 {
-	m_mutex.Unlock();
+    m_mutex.Unlock();
 }
 
 
diff --git a/dep/src/sockets/Mutex.cpp b/dep/src/sockets/Mutex.cpp
index f7a03c7d990..8284fefacd8 100644
--- a/dep/src/sockets/Mutex.cpp
+++ b/dep/src/sockets/Mutex.cpp
@@ -1,6 +1,6 @@
 /** \file Mutex.cpp
- **	\date  2004-10-30
- **	\author grymse@alhem.net
+ ** \date  2004-10-30
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2004-2007  Anders Hedstrom
@@ -8,7 +8,7 @@ Copyright (C) 2004-2007  Anders Hedstrom
 This library is made available under the terms of the GNU GPL.
 
 If you would like to use this library in a closed-source application,
-a separate license agreement is available. For information about 
+a separate license agreement is available. For information about
 the closed-source license agreement for the C++ sockets library,
 please visit http://www.alhem.net/Sockets/license.html and/or
 email license@alhem.net.
@@ -37,9 +37,9 @@ namespace SOCKETS_NAMESPACE {
 Mutex::Mutex()
 {
 #ifdef _WIN32
-	m_mutex = ::CreateMutex(NULL, FALSE, NULL);
+    m_mutex = ::CreateMutex(NULL, FALSE, NULL);
 #else
-	pthread_mutex_init(&m_mutex, NULL);
+    pthread_mutex_init(&m_mutex, NULL);
 #endif
 }
 
@@ -47,9 +47,9 @@ Mutex::Mutex()
 Mutex::~Mutex()
 {
 #ifdef _WIN32
-	::CloseHandle(m_mutex);
+    ::CloseHandle(m_mutex);
 #else
-	pthread_mutex_destroy(&m_mutex);
+    pthread_mutex_destroy(&m_mutex);
 #endif
 }
 
@@ -57,10 +57,10 @@ Mutex::~Mutex()
 void Mutex::Lock()
 {
 #ifdef _WIN32
-	/*DWORD d =*/ WaitForSingleObject(m_mutex, INFINITE);
-	/// \todo check 'd' for result
+    /*DWORD d =*/ WaitForSingleObject(m_mutex, INFINITE);
+    /// \todo check 'd' for result
 #else
-	pthread_mutex_lock(&m_mutex);
+    pthread_mutex_lock(&m_mutex);
 #endif
 }
 
@@ -68,9 +68,9 @@ void Mutex::Lock()
 void Mutex::Unlock()
 {
 #ifdef _WIN32
-	::ReleaseMutex(m_mutex);
+    ::ReleaseMutex(m_mutex);
 #else
-	pthread_mutex_unlock(&m_mutex);
+    pthread_mutex_unlock(&m_mutex);
 #endif
 }
 
diff --git a/dep/src/sockets/Parse.cpp b/dep/src/sockets/Parse.cpp
index 58122c0c96e..4d4dd99cd98 100644
--- a/dep/src/sockets/Parse.cpp
+++ b/dep/src/sockets/Parse.cpp
@@ -1,6 +1,6 @@
 /** \file Parse.cpp - parse a string
  **
- **	Written: 1999-Feb-10 grymse@alhem.net
+ ** Written: 1999-Feb-10 grymse@alhem.net
  **/
 
 /*
@@ -9,7 +9,7 @@ Copyright (C) 1999-2007  Anders Hedstrom
 This library is made available under the terms of the GNU GPL.
 
 If you would like to use this library in a closed-source application,
-a separate license agreement is available. For information about 
+a separate license agreement is available. For information about
 the closed-source license agreement for the C++ sockets library,
 please visit http://www.alhem.net/Sockets/license.html and/or
 email license@alhem.net.
@@ -102,214 +102,214 @@ Parse::~Parse()
 
 short Parse::issplit(const char c)
 {
-	for (size_t i = 0; i < pa_splits.size(); i++)
-		if (pa_splits[i] == c)
-			return 1;
-	return 0;
+    for (size_t i = 0; i < pa_splits.size(); i++)
+        if (pa_splits[i] == c)
+            return 1;
+    return 0;
 }
 
 void Parse::getsplit()
 {
-	size_t x;
-
-	if (C == '=')
-	{
-		x = pa_the_ptr++;
-	} else
-	{
-		while (C && (issplit(C)))
-			pa_the_ptr++;
-		x = pa_the_ptr;
-		while (C && !issplit(C) && C != '=')
-			pa_the_ptr++;
-	}
-	if (x == pa_the_ptr && C == '=')
-		pa_the_ptr++;
-	pa_ord = (x < pa_the_str.size()) ? pa_the_str.substr(x,pa_the_ptr - x) : "";
+    size_t x;
+
+    if (C == '=')
+    {
+        x = pa_the_ptr++;
+    } else
+    {
+        while (C && (issplit(C)))
+            pa_the_ptr++;
+        x = pa_the_ptr;
+        while (C && !issplit(C) && C != '=')
+            pa_the_ptr++;
+    }
+    if (x == pa_the_ptr && C == '=')
+        pa_the_ptr++;
+    pa_ord = (x < pa_the_str.size()) ? pa_the_str.substr(x,pa_the_ptr - x) : "";
 }
 
 std::string Parse::getword()
 {
-	size_t x;
-	int disabled = 0;
-	int quote = 0;
-	int rem = 0;
-
-	if (pa_nospace)
-	{
-		while (C && issplit(C))
-			pa_the_ptr++;
-		x = pa_the_ptr;
-		while (C && !issplit(C) && (C != pa_breakchar || !pa_breakchar || disabled))
-		{
-			if (pa_breakchar && C == pa_disable)
-				disabled = 1;
-			if (pa_breakchar && C == pa_enable)
-				disabled = 0;
-			if (pa_quote && C == '"')
-				quote = 1;
-			pa_the_ptr++;
-			while (quote && C && C != '"')
-			{
-				pa_the_ptr++;
-			}
-			if (pa_quote && C == '"')
-			{
-				pa_the_ptr++;
-			}
-			quote = 0;
-		}
-	} else
-	{
-		if (C == pa_breakchar && pa_breakchar)
-		{
-			x = pa_the_ptr++;
-			rem = 1;
-		} else
-		{
-			while (C && (C == ' ' || C == 9 || C == 13 || C == 10 || issplit(C)))
-				pa_the_ptr++;
-			x = pa_the_ptr;
-			while (C && C != ' ' && C != 9 && C != 13 && C != 10 && !issplit(C) &&
-			 (C != pa_breakchar || !pa_breakchar || disabled))
-			{
-				if (pa_breakchar && C == pa_disable)
-					disabled = 1;
-				if (pa_breakchar && C == pa_enable)
-					disabled = 0;
-				if (pa_quote && C == '"')
-				{
-					quote = 1;
-				pa_the_ptr++;
-				while (quote && C && C != '"')
-				{
-					pa_the_ptr++;
-				}
-				if (pa_quote && C == '"')
-				{
-					pa_the_ptr++;
-				}
-				}
-				else
-					pa_the_ptr++;
-				quote = 0;
-			}
-			pa_the_ptr++;
-			rem = 1;
-		}
-		if (x == pa_the_ptr && C == pa_breakchar && pa_breakchar)
-			pa_the_ptr++;
-	}
-	if (x < pa_the_str.size())
-	{
-		pa_ord = pa_the_str.substr(x,pa_the_ptr - x - rem);
-	}
-	else
-	{
-		pa_ord = "";
-	}
-	return pa_ord;
+    size_t x;
+    int disabled = 0;
+    int quote = 0;
+    int rem = 0;
+
+    if (pa_nospace)
+    {
+        while (C && issplit(C))
+            pa_the_ptr++;
+        x = pa_the_ptr;
+        while (C && !issplit(C) && (C != pa_breakchar || !pa_breakchar || disabled))
+        {
+            if (pa_breakchar && C == pa_disable)
+                disabled = 1;
+            if (pa_breakchar && C == pa_enable)
+                disabled = 0;
+            if (pa_quote && C == '"')
+                quote = 1;
+            pa_the_ptr++;
+            while (quote && C && C != '"')
+            {
+                pa_the_ptr++;
+            }
+            if (pa_quote && C == '"')
+            {
+                pa_the_ptr++;
+            }
+            quote = 0;
+        }
+    } else
+    {
+        if (C == pa_breakchar && pa_breakchar)
+        {
+            x = pa_the_ptr++;
+            rem = 1;
+        } else
+        {
+            while (C && (C == ' ' || C == 9 || C == 13 || C == 10 || issplit(C)))
+                pa_the_ptr++;
+            x = pa_the_ptr;
+            while (C && C != ' ' && C != 9 && C != 13 && C != 10 && !issplit(C) &&
+             (C != pa_breakchar || !pa_breakchar || disabled))
+            {
+                if (pa_breakchar && C == pa_disable)
+                    disabled = 1;
+                if (pa_breakchar && C == pa_enable)
+                    disabled = 0;
+                if (pa_quote && C == '"')
+                {
+                    quote = 1;
+                pa_the_ptr++;
+                while (quote && C && C != '"')
+                {
+                    pa_the_ptr++;
+                }
+                if (pa_quote && C == '"')
+                {
+                    pa_the_ptr++;
+                }
+                }
+                else
+                    pa_the_ptr++;
+                quote = 0;
+            }
+            pa_the_ptr++;
+            rem = 1;
+        }
+        if (x == pa_the_ptr && C == pa_breakchar && pa_breakchar)
+            pa_the_ptr++;
+    }
+    if (x < pa_the_str.size())
+    {
+        pa_ord = pa_the_str.substr(x,pa_the_ptr - x - rem);
+    }
+    else
+    {
+        pa_ord = "";
+    }
+    return pa_ord;
 }
 
 void Parse::getword(std::string&s)
 {
-	s = Parse::getword();
+    s = Parse::getword();
 }
 
 void Parse::getsplit(std::string&s)
 {
-	Parse::getsplit();
-	s = pa_ord;
+    Parse::getsplit();
+    s = pa_ord;
 }
 
 void Parse::getword(std::string&s,std::string&fill,int l)
 {
-	Parse::getword();
-	s = "";
-	while (s.size() + pa_ord.size() < (size_t)l)
-		s += fill;
-	s += pa_ord;
+    Parse::getword();
+    s = "";
+    while (s.size() + pa_ord.size() < (size_t)l)
+        s += fill;
+    s += pa_ord;
 }
 
 std::string Parse::getrest()
 {
-	std::string s;
-	while (C && (C == ' ' || C == 9 || issplit(C)))
-		pa_the_ptr++;
-	s = (pa_the_ptr < pa_the_str.size()) ? pa_the_str.substr(pa_the_ptr) : "";
-	return s;
+    std::string s;
+    while (C && (C == ' ' || C == 9 || issplit(C)))
+        pa_the_ptr++;
+    s = (pa_the_ptr < pa_the_str.size()) ? pa_the_str.substr(pa_the_ptr) : "";
+    return s;
 }
 
 void Parse::getrest(std::string&s)
 {
-	while (C && (C == ' ' || C == 9 || issplit(C)))
-		pa_the_ptr++;
-	s = (pa_the_ptr < pa_the_str.size()) ? pa_the_str.substr(pa_the_ptr) : "";
+    while (C && (C == ' ' || C == 9 || issplit(C)))
+        pa_the_ptr++;
+    s = (pa_the_ptr < pa_the_str.size()) ? pa_the_str.substr(pa_the_ptr) : "";
 }
 
 long Parse::getvalue()
 {
-	Parse::getword();
-	return atol(pa_ord.c_str());
+    Parse::getword();
+    return atol(pa_ord.c_str());
 }
 
 void Parse::setbreak(const char c)
 {
-	pa_breakchar = c;
+    pa_breakchar = c;
 }
 
 int Parse::getwordlen()
 {
-	size_t x,y = pa_the_ptr,len;
-
-	if (C == pa_breakchar && pa_breakchar)
-	{
-		x = pa_the_ptr++;
-	} else
-	{
-		while (C && (C == ' ' || C == 9 || C == 13 || C == 10 || issplit(C)))
-			pa_the_ptr++;
-		x = pa_the_ptr;
-		while (C && C != ' ' && C != 9 && C != 13 && C != 10 && !issplit(C) && (C != pa_breakchar || !pa_breakchar))
-			pa_the_ptr++;
-	}
-	if (x == pa_the_ptr && C == pa_breakchar && pa_breakchar)
-		pa_the_ptr++;
-	len = pa_the_ptr - x;
-	pa_the_ptr = y;
-	return (int)len;
+    size_t x,y = pa_the_ptr,len;
+
+    if (C == pa_breakchar && pa_breakchar)
+    {
+        x = pa_the_ptr++;
+    } else
+    {
+        while (C && (C == ' ' || C == 9 || C == 13 || C == 10 || issplit(C)))
+            pa_the_ptr++;
+        x = pa_the_ptr;
+        while (C && C != ' ' && C != 9 && C != 13 && C != 10 && !issplit(C) && (C != pa_breakchar || !pa_breakchar))
+            pa_the_ptr++;
+    }
+    if (x == pa_the_ptr && C == pa_breakchar && pa_breakchar)
+        pa_the_ptr++;
+    len = pa_the_ptr - x;
+    pa_the_ptr = y;
+    return (int)len;
 }
 
 int Parse::getrestlen()
 {
-	size_t y = pa_the_ptr;
-	size_t len;
-
-	while (C && (C == ' ' || C == 9 || issplit(C)))
-		pa_the_ptr++;
-	len = strlen(pa_the_str.c_str() + pa_the_ptr);
-	pa_the_ptr = y;
-	return (int)len;
+    size_t y = pa_the_ptr;
+    size_t len;
+
+    while (C && (C == ' ' || C == 9 || issplit(C)))
+        pa_the_ptr++;
+    len = strlen(pa_the_str.c_str() + pa_the_ptr);
+    pa_the_ptr = y;
+    return (int)len;
 }
 
 void Parse::getline()
 {
-	size_t x;
-
-	x = pa_the_ptr;
-	while (C && C != 13 && C != 10)
-		pa_the_ptr++;
-	pa_ord = (x < pa_the_str.size()) ? pa_the_str.substr(x,pa_the_ptr - x) : "";
-	if (C == 13)
-		pa_the_ptr++;
-	if (C == 10)
-		pa_the_ptr++;
+    size_t x;
+
+    x = pa_the_ptr;
+    while (C && C != 13 && C != 10)
+        pa_the_ptr++;
+    pa_ord = (x < pa_the_str.size()) ? pa_the_str.substr(x,pa_the_ptr - x) : "";
+    if (C == 13)
+        pa_the_ptr++;
+    if (C == 10)
+        pa_the_ptr++;
 }
 
 void Parse::getline(std::string&s)
 {
-	getline();
-	s = pa_ord;
+    getline();
+    s = pa_ord;
 }
 
 /* end of implementation of class Parse */
diff --git a/dep/src/sockets/ResolvServer.cpp b/dep/src/sockets/ResolvServer.cpp
index 83f842b5343..3923df33079 100644
--- a/dep/src/sockets/ResolvServer.cpp
+++ b/dep/src/sockets/ResolvServer.cpp
@@ -1,6 +1,6 @@
 /** \file ResolvServer.cpp
- **	\date  2005-03-24
- **	\author grymse@alhem.net
+ ** \date  2005-03-24
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2004-2007  Anders Hedstrom
@@ -8,7 +8,7 @@ Copyright (C) 2004-2007  Anders Hedstrom
 This library is made available under the terms of the GNU GPL.
 
 If you would like to use this library in a closed-source application,
-a separate license agreement is available. For information about 
+a separate license agreement is available. For information about
 the closed-source license agreement for the C++ sockets library,
 please visit http://www.alhem.net/Sockets/license.html and/or
 email license@alhem.net.
@@ -58,34 +58,34 @@ ResolvServer::~ResolvServer()
 
 void ResolvServer::Run()
 {
-//	StdoutLog log;
-	SocketHandler h;
-	ListenSocket<ResolvSocket> l(h);
-
-	if (l.Bind("127.0.0.1", m_port))
-	{
-		return;
-	}
-	h.Add(&l);
-
-	m_ready = true;
-	while (!m_quit && IsRunning() )
-	{
-		h.Select(0, 500000);
-	}
-	SetRunning(false);
+//  StdoutLog log;
+    SocketHandler h;
+    ListenSocket<ResolvSocket> l(h);
+
+    if (l.Bind("127.0.0.1", m_port))
+    {
+        return;
+    }
+    h.Add(&l);
+
+    m_ready = true;
+    while (!m_quit && IsRunning() )
+    {
+        h.Select(0, 500000);
+    }
+    SetRunning(false);
 }
 
 
 void ResolvServer::Quit()
 {
-	m_quit = true;
+    m_quit = true;
 }
 
 
 bool ResolvServer::Ready()
 {
-	return m_ready;
+    return m_ready;
 }
 
 
diff --git a/dep/src/sockets/ResolvSocket.cpp b/dep/src/sockets/ResolvSocket.cpp
index 2d9d31d5a4f..6096dc89e37 100644
--- a/dep/src/sockets/ResolvSocket.cpp
+++ b/dep/src/sockets/ResolvSocket.cpp
@@ -1,6 +1,6 @@
 /** \file ResolvSocket.cpp
- **	\date  2005-03-24
- **	\author grymse@alhem.net
+ ** \date  2005-03-24
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2004-2007  Anders Hedstrom
@@ -69,7 +69,7 @@ ResolvSocket::ResolvSocket(ISocketHandler& h)
 #endif
 ,m_cached(false)
 {
-	SetLineProtocol();
+    SetLineProtocol();
 }
 
 
@@ -84,7 +84,7 @@ ResolvSocket::ResolvSocket(ISocketHandler& h, Socket *parent, const std::string&
 #endif
 ,m_cached(false)
 {
-	SetLineProtocol();
+    SetLineProtocol();
 }
 
 
@@ -99,7 +99,7 @@ ResolvSocket::ResolvSocket(ISocketHandler& h, Socket *parent, ipaddr_t a)
 #endif
 ,m_cached(false)
 {
-	SetLineProtocol();
+    SetLineProtocol();
 }
 
 
@@ -113,7 +113,7 @@ ResolvSocket::ResolvSocket(ISocketHandler& h, Socket *parent, in6_addr& a)
 ,m_resolv_address6(a)
 ,m_cached(false)
 {
-	SetLineProtocol();
+    SetLineProtocol();
 }
 #endif
 
@@ -125,145 +125,145 @@ ResolvSocket::~ResolvSocket()
 
 void ResolvSocket::OnLine(const std::string& line)
 {
-	Parse pa(line, ":");
-	if (m_bServer)
-	{
-		m_query = pa.getword();
-		m_data = pa.getrest();
-DEB(		fprintf(stderr, " *** ResolvSocket server; query=%s, data=%s\n", m_query.c_str(), m_data.c_str());)
-		// %! check cache
-		{
-			Lock lock(m_cache_mutex);
-			if (m_cache[m_query].find(m_data) != m_cache[m_query].end())
-			{
-				if (time(NULL) - m_cache_to[m_query][m_data] < 3600) // ttl
-				{
-					std::string result = m_cache[m_query][m_data];
+    Parse pa(line, ":");
+    if (m_bServer)
+    {
+        m_query = pa.getword();
+        m_data = pa.getrest();
+DEB(        fprintf(stderr, " *** ResolvSocket server; query=%s, data=%s\n", m_query.c_str(), m_data.c_str());)
+        // %! check cache
+        {
+            Lock lock(m_cache_mutex);
+            if (m_cache[m_query].find(m_data) != m_cache[m_query].end())
+            {
+                if (time(NULL) - m_cache_to[m_query][m_data] < 3600) // ttl
+                {
+                    std::string result = m_cache[m_query][m_data];
 DEB(fprintf(stderr, " *** Returning cache for [%s][%s] = '%s'\n", m_query.c_str(), m_data.c_str(), result.c_str());)
-					Send("Cached\n");
-					if (!result.size()) /* failed */
-					{
-						Send("Failed\n\n");
-						SetCloseAndDelete();
-						return;
-					}
-					else
-					if (m_query == "gethostbyname")
-					{
-						Send("A: " + result + "\n\n");
-						SetCloseAndDelete();
-						return;
-					}
-					else
+                    Send("Cached\n");
+                    if (!result.size()) /* failed */
+                    {
+                        Send("Failed\n\n");
+                        SetCloseAndDelete();
+                        return;
+                    }
+                    else
+                    if (m_query == "gethostbyname")
+                    {
+                        Send("A: " + result + "\n\n");
+                        SetCloseAndDelete();
+                        return;
+                    }
+                    else
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-					if (m_query == "gethostbyname2")
-					{
-						Send("AAAA: " + result + "\n\n");
-						SetCloseAndDelete();
-						return;
-					}
-					else
+                    if (m_query == "gethostbyname2")
+                    {
+                        Send("AAAA: " + result + "\n\n");
+                        SetCloseAndDelete();
+                        return;
+                    }
+                    else
 #endif
 #endif
-					if (m_query == "gethostbyaddr")
-					{
-						Send("Name: " + result + "\n\n");
-						SetCloseAndDelete();
-						return;
-					}
-				}
-			}
-		}
-		if (!Detach()) // detach failed?
-		{
-			SetCloseAndDelete();
-		}
-		return;
-	}
-	std::string key = pa.getword();
-	std::string value = pa.getrest();
-DEB(	fprintf(stderr, " *** ResolvSocket response;  %s: %s\n", key.c_str(), value.c_str());)
-
-	if (key == "Cached")
-	{
-		m_cached = true;
-	}
-	else
-	if (key == "Failed" && m_parent)
-	{
-DEB(		fprintf(stderr, " ************ Resolve failed\n");)
-		if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
-		{
-			m_parent -> OnResolveFailed(m_resolv_id);
-		}
-		// update cache
-		if (!m_cached)
-		{
-			Lock lock(m_cache_mutex);
+                    if (m_query == "gethostbyaddr")
+                    {
+                        Send("Name: " + result + "\n\n");
+                        SetCloseAndDelete();
+                        return;
+                    }
+                }
+            }
+        }
+        if (!Detach()) // detach failed?
+        {
+            SetCloseAndDelete();
+        }
+        return;
+    }
+    std::string key = pa.getword();
+    std::string value = pa.getrest();
+DEB(    fprintf(stderr, " *** ResolvSocket response;  %s: %s\n", key.c_str(), value.c_str());)
+
+    if (key == "Cached")
+    {
+        m_cached = true;
+    }
+    else
+    if (key == "Failed" && m_parent)
+    {
+DEB(        fprintf(stderr, " ************ Resolve failed\n");)
+        if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
+        {
+            m_parent -> OnResolveFailed(m_resolv_id);
+        }
+        // update cache
+        if (!m_cached)
+        {
+            Lock lock(m_cache_mutex);
 DEB(fprintf(stderr, " *** Update cache for [%s][%s] = '%s'\n", m_query.c_str(), m_data.c_str(), value.c_str());)
-			m_cache[m_query][m_data] = value;
-			m_cache_to[m_query][m_data] = time(NULL);
-		}
-		m_parent = NULL;
-	}
-	else
-	if (key == "Name" && !m_resolv_host.size() && m_parent)
-	{
-		if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
-		{
-			m_parent -> OnReverseResolved(m_resolv_id, value);
-		}
-		// update cache
-		if (!m_cached)
-		{
-			Lock lock(m_cache_mutex);
+            m_cache[m_query][m_data] = value;
+            m_cache_to[m_query][m_data] = time(NULL);
+        }
+        m_parent = NULL;
+    }
+    else
+    if (key == "Name" && !m_resolv_host.size() && m_parent)
+    {
+        if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
+        {
+            m_parent -> OnReverseResolved(m_resolv_id, value);
+        }
+        // update cache
+        if (!m_cached)
+        {
+            Lock lock(m_cache_mutex);
 DEB(fprintf(stderr, " *** Update cache for [%s][%s] = '%s'\n", m_query.c_str(), m_data.c_str(), value.c_str());)
-			m_cache[m_query][m_data] = value;
-			m_cache_to[m_query][m_data] = time(NULL);
-		}
-		m_parent = NULL;
-	}
-	else
-	if (key == "A" && m_parent)
-	{
-		if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
-		{
-			ipaddr_t l;
-			Utility::u2ip(value, l); // ip2ipaddr_t
-			m_parent -> OnResolved(m_resolv_id, l, m_resolv_port);
-		}
-		// update cache
-		if (!m_cached)
-		{
-			Lock lock(m_cache_mutex);
+            m_cache[m_query][m_data] = value;
+            m_cache_to[m_query][m_data] = time(NULL);
+        }
+        m_parent = NULL;
+    }
+    else
+    if (key == "A" && m_parent)
+    {
+        if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
+        {
+            ipaddr_t l;
+            Utility::u2ip(value, l); // ip2ipaddr_t
+            m_parent -> OnResolved(m_resolv_id, l, m_resolv_port);
+        }
+        // update cache
+        if (!m_cached)
+        {
+            Lock lock(m_cache_mutex);
 DEB(fprintf(stderr, " *** Update cache for [%s][%s] = '%s'\n", m_query.c_str(), m_data.c_str(), value.c_str());)
-			m_cache[m_query][m_data] = value;
-			m_cache_to[m_query][m_data] = time(NULL);
-		}
-		m_parent = NULL; // always use first ip in case there are several
-	}
+            m_cache[m_query][m_data] = value;
+            m_cache_to[m_query][m_data] = time(NULL);
+        }
+        m_parent = NULL; // always use first ip in case there are several
+    }
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	else
-	if (key == "AAAA" && m_parent)
-	{
-		if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
-		{
-			in6_addr a;
-			Utility::u2ip(value, a);
-			m_parent -> OnResolved(m_resolv_id, a, m_resolv_port);
-		}
-		// update cache
-		if (!m_cached)
-		{
-			Lock lock(m_cache_mutex);
+    else
+    if (key == "AAAA" && m_parent)
+    {
+        if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
+        {
+            in6_addr a;
+            Utility::u2ip(value, a);
+            m_parent -> OnResolved(m_resolv_id, a, m_resolv_port);
+        }
+        // update cache
+        if (!m_cached)
+        {
+            Lock lock(m_cache_mutex);
 DEB(fprintf(stderr, " *** Update cache for [%s][%s] = '%s'\n", m_query.c_str(), m_data.c_str(), value.c_str());)
-			m_cache[m_query][m_data] = value;
-			m_cache_to[m_query][m_data] = time(NULL);
-		}
-		m_parent = NULL;
-	}
+            m_cache[m_query][m_data] = value;
+            m_cache_to[m_query][m_data] = time(NULL);
+        }
+        m_parent = NULL;
+    }
 #endif
 #endif
 }
@@ -271,160 +271,160 @@ DEB(fprintf(stderr, " *** Update cache for [%s][%s] = '%s'\n", m_query.c_str(),
 
 void ResolvSocket::OnDetached()
 {
-DEB(	fprintf(stderr, " *** ResolvSocket::OnDetached(); query=%s, data=%s\n", m_query.c_str(), m_data.c_str());)
-	if (m_query == "gethostbyname")
-	{
-		struct sockaddr_in sa;
-		if (Utility::u2ip(m_data, sa))
-		{
-			std::string ip;
-			Utility::l2ip(sa.sin_addr, ip);
-			Send("A: " + ip + "\n");
-		}
-		else
-		{
-			Send("Failed\n");
-		}
-		Send("\n");
-	}
-	else
+DEB(    fprintf(stderr, " *** ResolvSocket::OnDetached(); query=%s, data=%s\n", m_query.c_str(), m_data.c_str());)
+    if (m_query == "gethostbyname")
+    {
+        struct sockaddr_in sa;
+        if (Utility::u2ip(m_data, sa))
+        {
+            std::string ip;
+            Utility::l2ip(sa.sin_addr, ip);
+            Send("A: " + ip + "\n");
+        }
+        else
+        {
+            Send("Failed\n");
+        }
+        Send("\n");
+    }
+    else
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (m_query == "gethostbyname2")
-	{
-		struct sockaddr_in6 sa;
-		if (Utility::u2ip(m_data, sa))
-		{
-			std::string ip;
-			Utility::l2ip(sa.sin6_addr, ip);
-			Send("AAAA: " + ip + "\n");
-		}
-		else
-		{
-			Send("Failed\n");
-		}
-		Send("\n");
-	}
-	else
+    if (m_query == "gethostbyname2")
+    {
+        struct sockaddr_in6 sa;
+        if (Utility::u2ip(m_data, sa))
+        {
+            std::string ip;
+            Utility::l2ip(sa.sin6_addr, ip);
+            Send("AAAA: " + ip + "\n");
+        }
+        else
+        {
+            Send("Failed\n");
+        }
+        Send("\n");
+    }
+    else
 #endif
 #endif
-	if (m_query == "gethostbyaddr")
-	{
-		if (Utility::isipv4( m_data ))
-		{
-			struct sockaddr_in sa;
-			if (!Utility::u2ip(m_data, sa, AI_NUMERICHOST))
-			{
-				Send("Failed: convert to sockaddr_in failed\n");
-			}
-			else
-			{
-				std::string name;
-				if (!Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), name))
-				{
-					Send("Failed: ipv4 reverse lookup of " + m_data + "\n");
-				}
-				else
-				{
-					Send("Name: " + name + "\n");
-				}
-			}
-		}
-		else
+    if (m_query == "gethostbyaddr")
+    {
+        if (Utility::isipv4( m_data ))
+        {
+            struct sockaddr_in sa;
+            if (!Utility::u2ip(m_data, sa, AI_NUMERICHOST))
+            {
+                Send("Failed: convert to sockaddr_in failed\n");
+            }
+            else
+            {
+                std::string name;
+                if (!Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), name))
+                {
+                    Send("Failed: ipv4 reverse lookup of " + m_data + "\n");
+                }
+                else
+                {
+                    Send("Name: " + name + "\n");
+                }
+            }
+        }
+        else
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-		if (Utility::isipv6( m_data ))
-		{
-			struct sockaddr_in6 sa;
-			if (!Utility::u2ip(m_data, sa, AI_NUMERICHOST))
-			{
-				Send("Failed: convert to sockaddr_in6 failed\n");
-			}
-			else
-			{
-				std::string name;
-				if (!Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), name))
-				{
-					Send("Failed: ipv6 reverse lookup of " + m_data + "\n");
-				}
-				else
-				{
-					Send("Name: " + name + "\n");
-				}
-			}
-		}
-		else
+        if (Utility::isipv6( m_data ))
+        {
+            struct sockaddr_in6 sa;
+            if (!Utility::u2ip(m_data, sa, AI_NUMERICHOST))
+            {
+                Send("Failed: convert to sockaddr_in6 failed\n");
+            }
+            else
+            {
+                std::string name;
+                if (!Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), name))
+                {
+                    Send("Failed: ipv6 reverse lookup of " + m_data + "\n");
+                }
+                else
+                {
+                    Send("Name: " + name + "\n");
+                }
+            }
+        }
+        else
 #endif
 #endif
-		{
-			Send("Failed: malformed address\n");
-		}
-		Send("\n");
-	}
-	else
-	{
-		std::string msg = "Unknown query type: " + m_query;
-		Handler().LogError(this, "OnDetached", 0, msg);
-		Send("Unknown\n\n");
-	}
-	SetCloseAndDelete();
+        {
+            Send("Failed: malformed address\n");
+        }
+        Send("\n");
+    }
+    else
+    {
+        std::string msg = "Unknown query type: " + m_query;
+        Handler().LogError(this, "OnDetached", 0, msg);
+        Send("Unknown\n\n");
+    }
+    SetCloseAndDelete();
 }
 
 
 void ResolvSocket::OnConnect()
 {
-	if (!m_resolv_host.empty())
-	{
+    if (!m_resolv_host.empty())
+    {
 #ifdef ENABLE_IPV6
-		std::string msg = (m_resolve_ipv6 ? "gethostbyname2 " : "gethostbyname ") + m_resolv_host + "\n";
-		m_query = m_resolve_ipv6 ? "gethostbyname2" : "gethostbyname";
+        std::string msg = (m_resolve_ipv6 ? "gethostbyname2 " : "gethostbyname ") + m_resolv_host + "\n";
+        m_query = m_resolve_ipv6 ? "gethostbyname2" : "gethostbyname";
 #else
-		std::string msg = "gethostbyname " + m_resolv_host + "\n";
-		m_query = "gethostbyname";
+        std::string msg = "gethostbyname " + m_resolv_host + "\n";
+        m_query = "gethostbyname";
 #endif
-		m_data = m_resolv_host;
-		Send( msg );
-		return;
-	}
+        m_data = m_resolv_host;
+        Send( msg );
+        return;
+    }
 #ifdef ENABLE_IPV6
-	if (m_resolve_ipv6)
-	{
-		std::string tmp;
-		Utility::l2ip(m_resolv_address6, tmp);
-		m_query = "gethostbyaddr";
-		m_data = tmp;
-		std::string msg = "gethostbyaddr " + tmp + "\n";
-		Send( msg );
-	}
+    if (m_resolve_ipv6)
+    {
+        std::string tmp;
+        Utility::l2ip(m_resolv_address6, tmp);
+        m_query = "gethostbyaddr";
+        m_data = tmp;
+        std::string msg = "gethostbyaddr " + tmp + "\n";
+        Send( msg );
+    }
 #endif
-	std::string tmp;
-	Utility::l2ip(m_resolv_address, tmp);
-	m_query = "gethostbyaddr";
-	m_data = tmp;
-	std::string msg = "gethostbyaddr " + tmp + "\n";
-	Send( msg );
+    std::string tmp;
+    Utility::l2ip(m_resolv_address, tmp);
+    m_query = "gethostbyaddr";
+    m_data = tmp;
+    std::string msg = "gethostbyaddr " + tmp + "\n";
+    Send( msg );
 }
 
 
 void ResolvSocket::OnDelete()
 {
-	if (m_parent)
-	{
-		if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
-		{
-			m_parent -> OnResolveFailed(m_resolv_id);
-		}
-		// update cache
-		if (!m_cached)
-		{
-			Lock lock(m_cache_mutex);
-			std::string value;
+    if (m_parent)
+    {
+        if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
+        {
+            m_parent -> OnResolveFailed(m_resolv_id);
+        }
+        // update cache
+        if (!m_cached)
+        {
+            Lock lock(m_cache_mutex);
+            std::string value;
 DEB(fprintf(stderr, " *** Update cache for [%s][%s] = '%s'\n", m_query.c_str(), m_data.c_str(), value.c_str());)
-			m_cache[m_query][m_data] = value;
-			m_cache_to[m_query][m_data] = time(NULL);
-		}
-		m_parent = NULL;
-	}
+            m_cache[m_query][m_data] = value;
+            m_cache_to[m_query][m_data] = time(NULL);
+        }
+        m_parent = NULL;
+    }
 }
 
 
diff --git a/dep/src/sockets/Socket.cpp b/dep/src/sockets/Socket.cpp
index 883363eb1dd..5e739ec0c71 100644
--- a/dep/src/sockets/Socket.cpp
+++ b/dep/src/sockets/Socket.cpp
@@ -1,6 +1,6 @@
 /** \file Socket.cpp
- **	\date  2004-02-13
- **	\author grymse@alhem.net
+ ** \date  2004-02-13
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2004-2007  Anders Hedstrom
@@ -114,15 +114,15 @@ Socket::Socket(ISocketHandler& h)
 
 Socket::~Socket()
 {
-	Handler().Remove(this);
-	if (m_socket != INVALID_SOCKET
+    Handler().Remove(this);
+    if (m_socket != INVALID_SOCKET
 #ifdef ENABLE_POOL
-		 && !m_bRetain
+         && !m_bRetain
 #endif
-		)
-	{
-		Close();
-	}
+        )
+    {
+        Close();
+    }
 }
 
 
@@ -143,11 +143,11 @@ void Socket::OnWrite()
 
 void Socket::OnException()
 {
-	// %! exception doesn't always mean something bad happened, this code should be reworked
-	// errno valid here?
-	int err = SoError();
-	Handler().LogError(this, "exception on select", err, StrError(err), LOG_LEVEL_FATAL);
-	SetCloseAndDelete();
+    // %! exception doesn't always mean something bad happened, this code should be reworked
+    // errno valid here?
+    int err = SoError();
+    Handler().LogError(this, "exception on select", err, StrError(err), LOG_LEVEL_FATAL);
+    SetCloseAndDelete();
 }
 
 
@@ -168,159 +168,159 @@ void Socket::OnAccept()
 
 int Socket::Close()
 {
-	if (m_socket == INVALID_SOCKET) // this could happen
-	{
-		Handler().LogError(this, "Socket::Close", 0, "file descriptor invalid", LOG_LEVEL_WARNING);
-		return 0;
-	}
-	int n;
-	if ((n = closesocket(m_socket)) == -1)
-	{
-		// failed...
-		Handler().LogError(this, "close", Errno, StrError(Errno), LOG_LEVEL_ERROR);
-	}
-	Handler().Set(m_socket, false, false, false); // remove from fd_set's
-	Handler().AddList(m_socket, LIST_CALLONCONNECT, false);
+    if (m_socket == INVALID_SOCKET) // this could happen
+    {
+        Handler().LogError(this, "Socket::Close", 0, "file descriptor invalid", LOG_LEVEL_WARNING);
+        return 0;
+    }
+    int n;
+    if ((n = closesocket(m_socket)) == -1)
+    {
+        // failed...
+        Handler().LogError(this, "close", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+    }
+    Handler().Set(m_socket, false, false, false); // remove from fd_set's
+    Handler().AddList(m_socket, LIST_CALLONCONNECT, false);
 #ifdef ENABLE_DETACH
-	Handler().AddList(m_socket, LIST_DETACH, false);
+    Handler().AddList(m_socket, LIST_DETACH, false);
 #endif
-	Handler().AddList(m_socket, LIST_TIMEOUT, false);
-	Handler().AddList(m_socket, LIST_RETRY, false);
-	Handler().AddList(m_socket, LIST_CLOSE, false);
-	m_socket = INVALID_SOCKET;
-	return n;
+    Handler().AddList(m_socket, LIST_TIMEOUT, false);
+    Handler().AddList(m_socket, LIST_RETRY, false);
+    Handler().AddList(m_socket, LIST_CLOSE, false);
+    m_socket = INVALID_SOCKET;
+    return n;
 }
 
 
 SOCKET Socket::CreateSocket(int af,int type, const std::string& protocol)
 {
-	struct protoent *p = NULL;
-	SOCKET s;
+    struct protoent *p = NULL;
+    SOCKET s;
 
 #ifdef ENABLE_POOL
-	m_socket_type = type;
-	m_socket_protocol = protocol;
-#endif
-	if (!protocol.empty())
-	{
-		p = getprotobyname( protocol.c_str() );
-		if (!p)
-		{
-			Handler().LogError(this, "getprotobyname", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-			SetCloseAndDelete();
+    m_socket_type = type;
+    m_socket_protocol = protocol;
+#endif
+    if (!protocol.empty())
+    {
+        p = getprotobyname( protocol.c_str() );
+        if (!p)
+        {
+            Handler().LogError(this, "getprotobyname", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+            SetCloseAndDelete();
 #ifdef ENABLE_EXCEPTIONS
-			throw Exception(std::string("getprotobyname() failed: ") + StrError(Errno));
-#endif
-			return INVALID_SOCKET;
-		}
-	}
-	int protno = p ? p -> p_proto : 0;
-
-	s = socket(af, type, protno);
-	if (s == INVALID_SOCKET)
-	{
-		Handler().LogError(this, "socket", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		SetCloseAndDelete();
+            throw Exception(std::string("getprotobyname() failed: ") + StrError(Errno));
+#endif
+            return INVALID_SOCKET;
+        }
+    }
+    int protno = p ? p -> p_proto : 0;
+
+    s = socket(af, type, protno);
+    if (s == INVALID_SOCKET)
+    {
+        Handler().LogError(this, "socket", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        SetCloseAndDelete();
 #ifdef ENABLE_EXCEPTIONS
-		throw Exception(std::string("socket() failed: ") + StrError(Errno));
+        throw Exception(std::string("socket() failed: ") + StrError(Errno));
 #endif
-		return INVALID_SOCKET;
-	}
-	Attach(s);
-	OnOptions(af, type, protno, s);
-	Attach(INVALID_SOCKET);
-	return s;
+        return INVALID_SOCKET;
+    }
+    Attach(s);
+    OnOptions(af, type, protno, s);
+    Attach(INVALID_SOCKET);
+    return s;
 }
 
 
 void Socket::Attach(SOCKET s)
 {
-	m_socket = s;
+    m_socket = s;
 }
 
 
 SOCKET Socket::GetSocket()
 {
-	return m_socket;
+    return m_socket;
 }
 
 
 void Socket::SetDeleteByHandler(bool x)
 {
-	m_bDel = x;
+    m_bDel = x;
 }
 
 
 bool Socket::DeleteByHandler()
 {
-	return m_bDel;
+    return m_bDel;
 }
 
 
 void Socket::SetCloseAndDelete(bool x)
 {
-	if (x != m_bClose)
-	{
-		Handler().AddList(m_socket, LIST_CLOSE, x);
-		m_bClose = x;
-		if (x)
-		{
-			m_tClose = time(NULL);
-		}
-	}
+    if (x != m_bClose)
+    {
+        Handler().AddList(m_socket, LIST_CLOSE, x);
+        m_bClose = x;
+        if (x)
+        {
+            m_tClose = time(NULL);
+        }
+    }
 }
 
 
 bool Socket::CloseAndDelete()
 {
-	return m_bClose;
+    return m_bClose;
 }
 
 
 void Socket::SetRemoteAddress(SocketAddress& ad) //struct sockaddr* sa, socklen_t l)
 {
-	m_remote_address = ad.GetCopy();
+    m_remote_address = ad.GetCopy();
 }
 
 
 std::auto_ptr<SocketAddress> Socket::GetRemoteSocketAddress()
 {
-	return m_remote_address -> GetCopy();
+    return m_remote_address -> GetCopy();
 }
 
 
 ISocketHandler& Socket::Handler() const
 {
 #ifdef ENABLE_DETACH
-	if (IsDetached())
-		return *m_slave_handler;
+    if (IsDetached())
+        return *m_slave_handler;
 #endif
-	return m_handler;
+    return m_handler;
 }
 
 
 ISocketHandler& Socket::MasterHandler() const
 {
-	return m_handler;
+    return m_handler;
 }
 
 
 ipaddr_t Socket::GetRemoteIP4()
 {
-	ipaddr_t l = 0;
+    ipaddr_t l = 0;
 #ifdef ENABLE_IPV6
-	if (m_ipv6)
-	{
-		Handler().LogError(this, "GetRemoteIP4", 0, "get ipv4 address for ipv6 socket", LOG_LEVEL_WARNING);
-	}
+    if (m_ipv6)
+    {
+        Handler().LogError(this, "GetRemoteIP4", 0, "get ipv4 address for ipv6 socket", LOG_LEVEL_WARNING);
+    }
 #endif
-	if (m_remote_address.get() != NULL)
-	{
-		struct sockaddr *p = *m_remote_address;
-		struct sockaddr_in *sa = (struct sockaddr_in *)p;
-		memcpy(&l, &sa -> sin_addr, sizeof(struct in_addr));
-	}
-	return l;
+    if (m_remote_address.get() != NULL)
+    {
+        struct sockaddr *p = *m_remote_address;
+        struct sockaddr_in *sa = (struct sockaddr_in *)p;
+        memcpy(&l, &sa -> sin_addr, sizeof(struct in_addr));
+    }
+    return l;
 }
 
 
@@ -328,21 +328,21 @@ ipaddr_t Socket::GetRemoteIP4()
 #ifdef IPPROTO_IPV6
 struct in6_addr Socket::GetRemoteIP6()
 {
-	if (!m_ipv6)
-	{
-		Handler().LogError(this, "GetRemoteIP6", 0, "get ipv6 address for ipv4 socket", LOG_LEVEL_WARNING);
-	}
-	struct sockaddr_in6 fail;
-	if (m_remote_address.get() != NULL)
-	{
-		struct sockaddr *p = *m_remote_address;
-		memcpy(&fail, p, sizeof(struct sockaddr_in6));
-	}
-	else
-	{
-		memset(&fail, 0, sizeof(struct sockaddr_in6));
-	}
-	return fail.sin6_addr;
+    if (!m_ipv6)
+    {
+        Handler().LogError(this, "GetRemoteIP6", 0, "get ipv6 address for ipv4 socket", LOG_LEVEL_WARNING);
+    }
+    struct sockaddr_in6 fail;
+    if (m_remote_address.get() != NULL)
+    {
+        struct sockaddr *p = *m_remote_address;
+        memcpy(&fail, p, sizeof(struct sockaddr_in6));
+    }
+    else
+    {
+        memset(&fail, 0, sizeof(struct sockaddr_in6));
+    }
+    return fail.sin6_addr;
 }
 #endif
 #endif
@@ -350,63 +350,63 @@ struct in6_addr Socket::GetRemoteIP6()
 
 port_t Socket::GetRemotePort()
 {
-	if (!m_remote_address.get())
-	{
-		return 0;
-	}
-	return m_remote_address -> GetPort();
+    if (!m_remote_address.get())
+    {
+        return 0;
+    }
+    return m_remote_address -> GetPort();
 }
 
 
 std::string Socket::GetRemoteAddress()
 {
-	if (!m_remote_address.get())
-	{
-		return "";
-	}
-	return m_remote_address -> Convert(false);
+    if (!m_remote_address.get())
+    {
+        return "";
+    }
+    return m_remote_address -> Convert(false);
 }
 
 
 std::string Socket::GetRemoteHostname()
 {
-	if (!m_remote_address.get())
-	{
-		return "";
-	}
-	return m_remote_address -> Reverse();
+    if (!m_remote_address.get())
+    {
+        return "";
+    }
+    return m_remote_address -> Reverse();
 }
 
 
 bool Socket::SetNonblocking(bool bNb)
 {
 #ifdef _WIN32
-	unsigned long l = bNb ? 1 : 0;
-	int n = ioctlsocket(m_socket, FIONBIO, &l);
-	if (n != 0)
-	{
-		Handler().LogError(this, "ioctlsocket(FIONBIO)", Errno, "");
-		return false;
-	}
-	return true;
+    unsigned long l = bNb ? 1 : 0;
+    int n = ioctlsocket(m_socket, FIONBIO, &l);
+    if (n != 0)
+    {
+        Handler().LogError(this, "ioctlsocket(FIONBIO)", Errno, "");
+        return false;
+    }
+    return true;
 #else
-	if (bNb)
-	{
-		if (fcntl(m_socket, F_SETFL, O_NONBLOCK) == -1)
-		{
-			Handler().LogError(this, "fcntl(F_SETFL, O_NONBLOCK)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
-			return false;
-		}
-	}
-	else
-	{
-		if (fcntl(m_socket, F_SETFL, 0) == -1)
-		{
-			Handler().LogError(this, "fcntl(F_SETFL, 0)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
-			return false;
-		}
-	}
-	return true;
+    if (bNb)
+    {
+        if (fcntl(m_socket, F_SETFL, O_NONBLOCK) == -1)
+        {
+            Handler().LogError(this, "fcntl(F_SETFL, O_NONBLOCK)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+            return false;
+        }
+    }
+    else
+    {
+        if (fcntl(m_socket, F_SETFL, 0) == -1)
+        {
+            Handler().LogError(this, "fcntl(F_SETFL, 0)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+            return false;
+        }
+    }
+    return true;
 #endif
 }
 
@@ -414,47 +414,47 @@ bool Socket::SetNonblocking(bool bNb)
 bool Socket::SetNonblocking(bool bNb, SOCKET s)
 {
 #ifdef _WIN32
-	unsigned long l = bNb ? 1 : 0;
-	int n = ioctlsocket(s, FIONBIO, &l);
-	if (n != 0)
-	{
-		Handler().LogError(this, "ioctlsocket(FIONBIO)", Errno, "");
-		return false;
-	}
-	return true;
+    unsigned long l = bNb ? 1 : 0;
+    int n = ioctlsocket(s, FIONBIO, &l);
+    if (n != 0)
+    {
+        Handler().LogError(this, "ioctlsocket(FIONBIO)", Errno, "");
+        return false;
+    }
+    return true;
 #else
-	if (bNb)
-	{
-		if (fcntl(s, F_SETFL, O_NONBLOCK) == -1)
-		{
-			Handler().LogError(this, "fcntl(F_SETFL, O_NONBLOCK)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
-			return false;
-		}
-	}
-	else
-	{
-		if (fcntl(s, F_SETFL, 0) == -1)
-		{
-			Handler().LogError(this, "fcntl(F_SETFL, 0)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
-			return false;
-		}
-	}
-	return true;
+    if (bNb)
+    {
+        if (fcntl(s, F_SETFL, O_NONBLOCK) == -1)
+        {
+            Handler().LogError(this, "fcntl(F_SETFL, O_NONBLOCK)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+            return false;
+        }
+    }
+    else
+    {
+        if (fcntl(s, F_SETFL, 0) == -1)
+        {
+            Handler().LogError(this, "fcntl(F_SETFL, 0)", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+            return false;
+        }
+    }
+    return true;
 #endif
 }
 
 
 void Socket::Set(bool bRead, bool bWrite, bool bException)
 {
-	Handler().Set(m_socket, bRead, bWrite, bException);
+    Handler().Set(m_socket, bRead, bWrite, bException);
 }
 
 
 bool Socket::Ready()
 {
-	if (m_socket != INVALID_SOCKET && !CloseAndDelete())
-		return true;
-	return false;
+    if (m_socket != INVALID_SOCKET && !CloseAndDelete())
+        return true;
+    return false;
 }
 
 
@@ -470,26 +470,26 @@ void Socket::OnConnectFailed()
 
 Socket *Socket::GetParent()
 {
-	return m_parent;
+    return m_parent;
 }
 
 
 void Socket::SetParent(Socket *x)
 {
-	m_parent = x;
+    m_parent = x;
 }
 
 
 port_t Socket::GetPort()
 {
-	Handler().LogError(this, "GetPort", 0, "GetPort only implemented for ListenSocket", LOG_LEVEL_WARNING);
-	return 0;
+    Handler().LogError(this, "GetPort", 0, "GetPort only implemented for ListenSocket", LOG_LEVEL_WARNING);
+    return 0;
 }
 
 
 bool Socket::OnConnectRetry()
 {
-	return true;
+    return true;
 }
 
 
@@ -502,33 +502,33 @@ void Socket::OnReconnect()
 
 time_t Socket::Uptime()
 {
-	return time(NULL) - m_tCreate;
+    return time(NULL) - m_tCreate;
 }
 
 
 #ifdef ENABLE_IPV6
 void Socket::SetIpv6(bool x)
 {
-	m_ipv6 = x;
+    m_ipv6 = x;
 }
 
 
 bool Socket::IsIpv6()
 {
-	return m_ipv6;
+    return m_ipv6;
 }
 #endif
 
 
 void Socket::DisableRead(bool x)
 {
-	m_b_disable_read = x;
+    m_b_disable_read = x;
 }
 
 
 bool Socket::IsDisableRead()
 {
-	return m_b_disable_read;
+    return m_b_disable_read;
 }
 
 
@@ -544,13 +544,13 @@ void Socket::Send(const std::string&,int)
 
 void Socket::SetConnected(bool x)
 {
-	m_connected = x;
+    m_connected = x;
 }
 
 
 bool Socket::IsConnected()
 {
-	return m_connected;
+    return m_connected;
 }
 
 
@@ -561,63 +561,63 @@ void Socket::OnDisconnect()
 
 void Socket::SetLost()
 {
-	m_bLost = true;
+    m_bLost = true;
 }
 
 
 bool Socket::Lost()
 {
-	return m_bLost;
+    return m_bLost;
 }
 
 
 void Socket::SetErasedByHandler(bool x)
 {
-	m_b_erased_by_handler = x;
+    m_b_erased_by_handler = x;
 }
 
 
 bool Socket::ErasedByHandler()
 {
-	return m_b_erased_by_handler;
+    return m_b_erased_by_handler;
 }
 
 
 time_t Socket::TimeSinceClose()
 {
-	return time(NULL) - m_tClose;
+    return time(NULL) - m_tClose;
 }
 
 
 void Socket::SetClientRemoteAddress(SocketAddress& ad)
 {
-	if (!ad.IsValid())
-	{
-		Handler().LogError(this, "SetClientRemoteAddress", 0, "remote address not valid", LOG_LEVEL_ERROR);
-	}
-	m_client_remote_address = ad.GetCopy();
+    if (!ad.IsValid())
+    {
+        Handler().LogError(this, "SetClientRemoteAddress", 0, "remote address not valid", LOG_LEVEL_ERROR);
+    }
+    m_client_remote_address = ad.GetCopy();
 }
 
 
 std::auto_ptr<SocketAddress> Socket::GetClientRemoteAddress()
 {
-	if (!m_client_remote_address.get())
-	{
-		Handler().LogError(this, "GetClientRemoteAddress", 0, "remote address not yet set", LOG_LEVEL_ERROR);
-	}
-	return m_client_remote_address -> GetCopy();
+    if (!m_client_remote_address.get())
+    {
+        Handler().LogError(this, "GetClientRemoteAddress", 0, "remote address not yet set", LOG_LEVEL_ERROR);
+    }
+    return m_client_remote_address -> GetCopy();
 }
 
 
 uint64_t Socket::GetBytesSent(bool)
 {
-	return 0;
+    return 0;
 }
 
 
 uint64_t Socket::GetBytesReceived(bool)
 {
-	return 0;
+    return 0;
 }
 
 
@@ -634,43 +634,43 @@ void Socket::OnSSLAccept()
 
 bool Socket::SSLNegotiate()
 {
-	return false;
+    return false;
 }
 
 
 bool Socket::IsSSL()
 {
-	return m_b_enable_ssl;
+    return m_b_enable_ssl;
 }
 
 
 void Socket::EnableSSL(bool x)
 {
-	m_b_enable_ssl = x;
+    m_b_enable_ssl = x;
 }
 
 
 bool Socket::IsSSLNegotiate()
 {
-	return m_b_ssl;
+    return m_b_ssl;
 }
 
 
 void Socket::SetSSLNegotiate(bool x)
 {
-	m_b_ssl = x;
+    m_b_ssl = x;
 }
 
 
 bool Socket::IsSSLServer()
 {
-	return m_b_ssl_server;
+    return m_b_ssl_server;
 }
 
 
 void Socket::SetSSLServer(bool x)
 {
-	m_b_ssl_server = x;
+    m_b_ssl_server = x;
 }
 
 
@@ -688,57 +688,57 @@ void Socket::OnSSLAcceptFailed()
 #ifdef ENABLE_POOL
 void Socket::CopyConnection(Socket *sock)
 {
-	Attach( sock -> GetSocket() );
+    Attach( sock -> GetSocket() );
 #ifdef ENABLE_IPV6
-	SetIpv6( sock -> IsIpv6() );
+    SetIpv6( sock -> IsIpv6() );
 #endif
-	SetSocketType( sock -> GetSocketType() );
-	SetSocketProtocol( sock -> GetSocketProtocol() );
+    SetSocketType( sock -> GetSocketType() );
+    SetSocketProtocol( sock -> GetSocketProtocol() );
 
-	SetClientRemoteAddress( *sock -> GetClientRemoteAddress() );
-	SetRemoteAddress( *sock -> GetRemoteSocketAddress() );
+    SetClientRemoteAddress( *sock -> GetClientRemoteAddress() );
+    SetRemoteAddress( *sock -> GetRemoteSocketAddress() );
 }
 
 
 void Socket::SetIsClient()
 {
-	m_bClient = true;
+    m_bClient = true;
 }
 
 
 void Socket::SetSocketType(int x)
 {
-	m_socket_type = x;
+    m_socket_type = x;
 }
 
 
 int Socket::GetSocketType()
 {
-	return m_socket_type;
+    return m_socket_type;
 }
 
 
 void Socket::SetSocketProtocol(const std::string& x)
 {
-	m_socket_protocol = x;
+    m_socket_protocol = x;
 }
 
 
 const std::string& Socket::GetSocketProtocol()
 {
-	return m_socket_protocol;
+    return m_socket_protocol;
 }
 
 
 void Socket::SetRetain()
 {
-	if (m_bClient) m_bRetain = true;
+    if (m_bClient) m_bRetain = true;
 }
 
 
 bool Socket::Retain()
 {
-	return m_bRetain;
+    return m_bRetain;
 }
 
 
@@ -748,74 +748,74 @@ bool Socket::Retain()
 #ifdef ENABLE_SOCKS4
 void Socket::OnSocks4Connect()
 {
-	Handler().LogError(this, "OnSocks4Connect", 0, "Use with TcpSocket only");
+    Handler().LogError(this, "OnSocks4Connect", 0, "Use with TcpSocket only");
 }
 
 
 void Socket::OnSocks4ConnectFailed()
 {
-	Handler().LogError(this, "OnSocks4ConnectFailed", 0, "Use with TcpSocket only");
+    Handler().LogError(this, "OnSocks4ConnectFailed", 0, "Use with TcpSocket only");
 }
 
 
 bool Socket::OnSocks4Read()
 {
-	Handler().LogError(this, "OnSocks4Read", 0, "Use with TcpSocket only");
-	return true;
+    Handler().LogError(this, "OnSocks4Read", 0, "Use with TcpSocket only");
+    return true;
 }
 
 
 void Socket::SetSocks4Host(const std::string& host)
 {
-	Utility::u2ip(host, m_socks4_host);
+    Utility::u2ip(host, m_socks4_host);
 }
 
 
 bool Socket::Socks4()
 {
-	return m_bSocks4;
+    return m_bSocks4;
 }
 
 
 void Socket::SetSocks4(bool x)
 {
-	m_bSocks4 = x;
+    m_bSocks4 = x;
 }
 
 
 void Socket::SetSocks4Host(ipaddr_t a)
 {
-	m_socks4_host = a;
+    m_socks4_host = a;
 }
 
 
 void Socket::SetSocks4Port(port_t p)
 {
-	m_socks4_port = p;
+    m_socks4_port = p;
 }
 
 
 void Socket::SetSocks4Userid(const std::string& x)
 {
-	m_socks4_userid = x;
+    m_socks4_userid = x;
 }
 
 
 ipaddr_t Socket::GetSocks4Host()
 {
-	return m_socks4_host;
+    return m_socks4_host;
 }
 
 
 port_t Socket::GetSocks4Port()
 {
-	return m_socks4_port;
+    return m_socks4_port;
 }
 
 
 const std::string& Socket::GetSocks4Userid()
 {
-	return m_socks4_userid;
+    return m_socks4_userid;
 }
 #endif // ENABLE_SOCKS4
 
@@ -823,22 +823,22 @@ const std::string& Socket::GetSocks4Userid()
 #ifdef ENABLE_DETACH
 bool Socket::Detach()
 {
-	if (!DeleteByHandler())
-		return false;
-	if (m_pThread)
-		return false;
-	if (m_detached)
-		return false;
-	SetDetach();
-	return true;
+    if (!DeleteByHandler())
+        return false;
+    if (m_pThread)
+        return false;
+    if (m_detached)
+        return false;
+    SetDetach();
+    return true;
 }
 
 
 void Socket::DetachSocket()
 {
-	SetDetached();
-	m_pThread = new SocketThread(this);
-	m_pThread -> SetRelease(true);
+    SetDetached();
+    m_pThread = new SocketThread(this);
+    m_pThread -> SetRelease(true);
 }
 
 
@@ -849,32 +849,32 @@ void Socket::OnDetached()
 
 void Socket::SetDetach(bool x)
 {
-	Handler().AddList(m_socket, LIST_DETACH, x);
-	m_detach = x;
+    Handler().AddList(m_socket, LIST_DETACH, x);
+    m_detach = x;
 }
 
 
 bool Socket::IsDetach()
 {
-	return m_detach;
+    return m_detach;
 }
 
 
 void Socket::SetDetached(bool x)
 {
-	m_detached = x;
+    m_detached = x;
 }
 
 
 const bool Socket::IsDetached() const
 {
-	return m_detached;
+    return m_detached;
 }
 
 
 void Socket::SetSlaveHandler(ISocketHandler *p)
 {
-	m_slave_handler = p;
+    m_slave_handler = p;
 }
 
 
@@ -882,40 +882,40 @@ Socket::SocketThread::SocketThread(Socket *p)
 :Thread(false)
 ,m_socket(p)
 {
-	// Creator will release
+    // Creator will release
 }
 
 
 Socket::SocketThread::~SocketThread()
 {
-	if (IsRunning())
-	{
-		SetRelease(true);
-		SetRunning(false);
+    if (IsRunning())
+    {
+        SetRelease(true);
+        SetRunning(false);
 #ifdef _WIN32
-		Sleep(1000);
+        Sleep(1000);
 #else
-		sleep(1);
+        sleep(1);
 #endif
-	}
+    }
 }
 
 
 void Socket::SocketThread::Run()
 {
-	SocketHandler h;
-	h.SetSlave();
-	h.Add(m_socket);
-	m_socket -> SetSlaveHandler(&h);
-	m_socket -> OnDetached();
-	while (h.GetCount() && IsRunning())
-	{
-		h.Select(0, 500000);
-	}
-	// m_socket now deleted oops
-	// yeah oops m_socket delete its socket thread, that means this
-	// so Socket will no longer delete its socket thread, instead we do this:
-	SetDeleteOnExit();
+    SocketHandler h;
+    h.SetSlave();
+    h.Add(m_socket);
+    m_socket -> SetSlaveHandler(&h);
+    m_socket -> OnDetached();
+    while (h.GetCount() && IsRunning())
+    {
+        h.Select(0, 500000);
+    }
+    // m_socket now deleted oops
+    // yeah oops m_socket delete its socket thread, that means this
+    // so Socket will no longer delete its socket thread, instead we do this:
+    SetDeleteOnExit();
 }
 #endif // ENABLE_DETACH
 
@@ -923,28 +923,28 @@ void Socket::SocketThread::Run()
 #ifdef ENABLE_RESOLVER
 int Socket::Resolve(const std::string& host,port_t port)
 {
-	return Handler().Resolve(this, host, port);
+    return Handler().Resolve(this, host, port);
 }
 
 
 #ifdef ENABLE_IPV6
 int Socket::Resolve6(const std::string& host,port_t port)
 {
-	return Handler().Resolve6(this, host, port);
+    return Handler().Resolve6(this, host, port);
 }
 #endif
 
 
 int Socket::Resolve(ipaddr_t a)
 {
-	return Handler().Resolve(this, a);
+    return Handler().Resolve(this, a);
 }
 
 
 #ifdef ENABLE_IPV6
 int Socket::Resolve(in6_addr& a)
 {
-	return Handler().Resolve(this, a);
+    return Handler().Resolve(this, a);
 }
 #endif
 
@@ -978,15 +978,15 @@ void Socket::OnResolveFailed(int)
 bool Socket::SetIpOptions(const void *p, socklen_t len)
 {
 #ifdef IP_OPTIONS
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_OPTIONS, (char *)p, len) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_OPTIONS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_OPTIONS, (char *)p, len) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_OPTIONS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "ip option not available", 0, "IP_OPTIONS", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "ip option not available", 0, "IP_OPTIONS", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -994,13 +994,13 @@ bool Socket::SetIpOptions(const void *p, socklen_t len)
 #ifdef IP_PKTINFO
 bool Socket::SetIpPktinfo(bool x)
 {
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_PKTINFO, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_PKTINFO)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_PKTINFO, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_PKTINFO)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1008,13 +1008,13 @@ bool Socket::SetIpPktinfo(bool x)
 #ifdef IP_RECVTOS
 bool Socket::SetIpRecvTOS(bool x)
 {
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVTOS, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVTOS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVTOS, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVTOS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1022,13 +1022,13 @@ bool Socket::SetIpRecvTOS(bool x)
 #ifdef IP_RECVTTL
 bool Socket::SetIpRecvTTL(bool x)
 {
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVTTL, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVTTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVTTL, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVTTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1036,13 +1036,13 @@ bool Socket::SetIpRecvTTL(bool x)
 #ifdef IP_RECVOPTS
 bool Socket::SetIpRecvopts(bool x)
 {
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVOPTS, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVOPTS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVOPTS, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVOPTS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1050,13 +1050,13 @@ bool Socket::SetIpRecvopts(bool x)
 #ifdef IP_RETOPTS
 bool Socket::SetIpRetopts(bool x)
 {
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_RETOPTS, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RETOPTS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_RETOPTS, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RETOPTS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1064,80 +1064,80 @@ bool Socket::SetIpRetopts(bool x)
 bool Socket::SetIpTOS(unsigned char tos)
 {
 #ifdef IP_TOS
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_TOS, (char *)&tos, sizeof(tos)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_TOS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_TOS, (char *)&tos, sizeof(tos)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_TOS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "ip option not available", 0, "IP_TOS", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "ip option not available", 0, "IP_TOS", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
 
 unsigned char Socket::IpTOS()
 {
-	unsigned char tos = 0;
+    unsigned char tos = 0;
 #ifdef IP_TOS
-	socklen_t len = sizeof(tos);
-	if (getsockopt(GetSocket(), IPPROTO_IP, IP_TOS, (char *)&tos, &len) == -1)
-	{
-		Handler().LogError(this, "getsockopt(IPPROTO_IP, IP_TOS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-	}
+    socklen_t len = sizeof(tos);
+    if (getsockopt(GetSocket(), IPPROTO_IP, IP_TOS, (char *)&tos, &len) == -1)
+    {
+        Handler().LogError(this, "getsockopt(IPPROTO_IP, IP_TOS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+    }
 #else
-	Handler().LogError(this, "ip option not available", 0, "IP_TOS", LOG_LEVEL_INFO);
+    Handler().LogError(this, "ip option not available", 0, "IP_TOS", LOG_LEVEL_INFO);
 #endif
-	return tos;
+    return tos;
 }
 
 
 bool Socket::SetIpTTL(int ttl)
 {
 #ifdef IP_TTL
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_TTL, (char *)&ttl, sizeof(ttl)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_TTL, (char *)&ttl, sizeof(ttl)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "ip option not available", 0, "IP_TTL", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "ip option not available", 0, "IP_TTL", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
 
 int Socket::IpTTL()
 {
-	int ttl = 0;
+    int ttl = 0;
 #ifdef IP_TTL
-	socklen_t len = sizeof(ttl);
-	if (getsockopt(GetSocket(), IPPROTO_IP, IP_TTL, (char *)&ttl, &len) == -1)
-	{
-		Handler().LogError(this, "getsockopt(IPPROTO_IP, IP_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-	}
+    socklen_t len = sizeof(ttl);
+    if (getsockopt(GetSocket(), IPPROTO_IP, IP_TTL, (char *)&ttl, &len) == -1)
+    {
+        Handler().LogError(this, "getsockopt(IPPROTO_IP, IP_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+    }
 #else
-	Handler().LogError(this, "ip option not available", 0, "IP_TTL", LOG_LEVEL_INFO);
+    Handler().LogError(this, "ip option not available", 0, "IP_TTL", LOG_LEVEL_INFO);
 #endif
-	return ttl;
+    return ttl;
 }
 
 
 bool Socket::SetIpHdrincl(bool x)
 {
 #ifdef IP_HDRINCL
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_HDRINCL, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_HDRINCL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_HDRINCL, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_HDRINCL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "ip option not available", 0, "IP_HDRINCL", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "ip option not available", 0, "IP_HDRINCL", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1145,13 +1145,13 @@ bool Socket::SetIpHdrincl(bool x)
 #ifdef IP_RECVERR
 bool Socket::SetIpRecverr(bool x)
 {
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVERR, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVERR)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVERR, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVERR)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1159,13 +1159,13 @@ bool Socket::SetIpRecverr(bool x)
 #ifdef IP_MTU_DISCOVER
 bool Socket::SetIpMtudiscover(bool x)
 {
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_MTU_DISCOVER, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MTU_DISCOVER)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_MTU_DISCOVER, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MTU_DISCOVER)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1173,13 +1173,13 @@ bool Socket::SetIpMtudiscover(bool x)
 #ifdef IP_MTU
 int Socket::IpMtu()
 {
-	int mtu = 0;
-	socklen_t len = sizeof(mtu);
-	if (getsockopt(GetSocket(), IPPROTO_IP, IP_MTU, (char *)&mtu, &len) == -1)
-	{
-		Handler().LogError(this, "getsockopt(IPPROTO_IP, IP_MTU)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-	}
-	return mtu;
+    int mtu = 0;
+    socklen_t len = sizeof(mtu);
+    if (getsockopt(GetSocket(), IPPROTO_IP, IP_MTU, (char *)&mtu, &len) == -1)
+    {
+        Handler().LogError(this, "getsockopt(IPPROTO_IP, IP_MTU)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+    }
+    return mtu;
 }
 #endif
 
@@ -1187,13 +1187,13 @@ int Socket::IpMtu()
 #ifdef IP_ROUTER_ALERT
 bool Socket::SetIpRouterAlert(bool x)
 {
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_ROUTER_ALERT, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_ROUTER_ALERT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_ROUTER_ALERT, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_ROUTER_ALERT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1201,48 +1201,48 @@ bool Socket::SetIpRouterAlert(bool x)
 bool Socket::SetIpMulticastTTL(int ttl)
 {
 #ifdef IP_MULTICAST_TTL
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_MULTICAST_TTL, (char *)&ttl, sizeof(ttl)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MULTICAST_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_MULTICAST_TTL, (char *)&ttl, sizeof(ttl)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MULTICAST_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "ip option not available", 0, "IP_MULTICAST_TTL", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "ip option not available", 0, "IP_MULTICAST_TTL", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
 
 int Socket::IpMulticastTTL()
 {
-	int ttl = 0;
+    int ttl = 0;
 #ifdef IP_MULTICAST_TTL
-	socklen_t len = sizeof(ttl);
-	if (getsockopt(GetSocket(), IPPROTO_IP, IP_MULTICAST_TTL, (char *)&ttl, &len) == -1)
-	{
-		Handler().LogError(this, "getsockopt(IPPROTO_IP, IP_MULTICAST_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-	}
+    socklen_t len = sizeof(ttl);
+    if (getsockopt(GetSocket(), IPPROTO_IP, IP_MULTICAST_TTL, (char *)&ttl, &len) == -1)
+    {
+        Handler().LogError(this, "getsockopt(IPPROTO_IP, IP_MULTICAST_TTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+    }
 #else
-	Handler().LogError(this, "ip option not available", 0, "IP_MULTICAST_TTL", LOG_LEVEL_INFO);
+    Handler().LogError(this, "ip option not available", 0, "IP_MULTICAST_TTL", LOG_LEVEL_INFO);
 #endif
-	return ttl;
+    return ttl;
 }
 
 
 bool Socket::SetMulticastLoop(bool x)
 {
 #ifdef IP_MULTICAST_LOOP
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_MULTICAST_LOOP, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MULTICAST_LOOP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_MULTICAST_LOOP, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MULTICAST_LOOP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "ip option not available", 0, "IP_MULTICAST_LOOP", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "ip option not available", 0, "IP_MULTICAST_LOOP", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1251,15 +1251,15 @@ bool Socket::SetMulticastLoop(bool x)
 bool Socket::IpAddMembership(struct ip_mreqn& ref)
 {
 #ifdef IP_ADD_MEMBERSHIP
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreqn)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_ADD_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreqn)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_ADD_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "ip option not available", 0, "IP_ADD_MEMBERSHIP", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "ip option not available", 0, "IP_ADD_MEMBERSHIP", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 #endif
@@ -1268,15 +1268,15 @@ bool Socket::IpAddMembership(struct ip_mreqn& ref)
 bool Socket::IpAddMembership(struct ip_mreq& ref)
 {
 #ifdef IP_ADD_MEMBERSHIP
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreq)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_ADD_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreq)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_ADD_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "ip option not available", 0, "IP_ADD_MEMBERSHIP", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "ip option not available", 0, "IP_ADD_MEMBERSHIP", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1285,15 +1285,15 @@ bool Socket::IpAddMembership(struct ip_mreq& ref)
 bool Socket::IpDropMembership(struct ip_mreqn& ref)
 {
 #ifdef IP_DROP_MEMBERSHIP
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_DROP_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreqn)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_DROP_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_DROP_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreqn)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_DROP_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "ip option not available", 0, "IP_DROP_MEMBERSHIP", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "ip option not available", 0, "IP_DROP_MEMBERSHIP", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 #endif
@@ -1302,15 +1302,15 @@ bool Socket::IpDropMembership(struct ip_mreqn& ref)
 bool Socket::IpDropMembership(struct ip_mreq& ref)
 {
 #ifdef IP_DROP_MEMBERSHIP
-	if (setsockopt(GetSocket(), IPPROTO_IP, IP_DROP_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreq)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_DROP_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), IPPROTO_IP, IP_DROP_MEMBERSHIP, (char *)&ref, sizeof(struct ip_mreq)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_DROP_MEMBERSHIP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "ip option not available", 0, "IP_DROP_MEMBERSHIP", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "ip option not available", 0, "IP_DROP_MEMBERSHIP", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1321,16 +1321,16 @@ bool Socket::IpDropMembership(struct ip_mreq& ref)
 bool Socket::SetSoReuseaddr(bool x)
 {
 #ifdef SO_REUSEADDR
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_REUSEADDR, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_REUSEADDR)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_REUSEADDR, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_REUSEADDR)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_REUSEADDR", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "SO_REUSEADDR", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1338,16 +1338,16 @@ bool Socket::SetSoReuseaddr(bool x)
 bool Socket::SetSoKeepalive(bool x)
 {
 #ifdef SO_KEEPALIVE
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_KEEPALIVE, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_KEEPALIVE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_KEEPALIVE, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_KEEPALIVE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_KEEPALIVE", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "SO_KEEPALIVE", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1355,43 +1355,43 @@ bool Socket::SetSoKeepalive(bool x)
 #ifdef SO_NOSIGPIPE
 bool Socket::SetSoNosigpipe(bool x)
 {
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_NOSIGPIPE, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_NOSIGPIPE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_NOSIGPIPE, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_NOSIGPIPE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
 
 bool Socket::SoAcceptconn()
 {
-	int value = 0;
+    int value = 0;
 #ifdef SO_ACCEPTCONN
-	socklen_t len = sizeof(value);
-	if (getsockopt(GetSocket(), SOL_SOCKET, SO_ACCEPTCONN, (char *)&value, &len) == -1)
-	{
-		Handler().LogError(this, "getsockopt(SOL_SOCKET, SO_ACCEPTCONN)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-	}
+    socklen_t len = sizeof(value);
+    if (getsockopt(GetSocket(), SOL_SOCKET, SO_ACCEPTCONN, (char *)&value, &len) == -1)
+    {
+        Handler().LogError(this, "getsockopt(SOL_SOCKET, SO_ACCEPTCONN)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+    }
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_ACCEPTCONN", LOG_LEVEL_INFO);
+    Handler().LogError(this, "socket option not available", 0, "SO_ACCEPTCONN", LOG_LEVEL_INFO);
 #endif
-	return value ? true : false;
+    return value ? true : false;
 }
 
 
 #ifdef SO_BSDCOMPAT
 bool Socket::SetSoBsdcompat(bool x)
 {
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_BSDCOMPAT, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_BSDCOMPAT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_BSDCOMPAT, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_BSDCOMPAT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1399,12 +1399,12 @@ bool Socket::SetSoBsdcompat(bool x)
 #ifdef SO_BINDTODEVICE
 bool Socket::SetSoBindtodevice(const std::string& intf)
 {
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_BINDTODEVICE, (char *)intf.c_str(), intf.size()) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_BINDTODEVICE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_BINDTODEVICE, (char *)intf.c_str(), intf.size()) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_BINDTODEVICE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1412,16 +1412,16 @@ bool Socket::SetSoBindtodevice(const std::string& intf)
 bool Socket::SetSoBroadcast(bool x)
 {
 #ifdef SO_BROADCAST
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_BROADCAST)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_BROADCAST)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_BROADCAST", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "SO_BROADCAST", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1429,49 +1429,49 @@ bool Socket::SetSoBroadcast(bool x)
 bool Socket::SetSoDebug(bool x)
 {
 #ifdef SO_DEBUG
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_DEBUG, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_DEBUG)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_DEBUG, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_DEBUG)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_DEBUG", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "SO_DEBUG", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
 
 int Socket::SoError()
 {
-	int value = 0;
+    int value = 0;
 #ifdef SO_ERROR
-	socklen_t len = sizeof(value);
-	if (getsockopt(GetSocket(), SOL_SOCKET, SO_ERROR, (char *)&value, &len) == -1)
-	{
-		Handler().LogError(this, "getsockopt(SOL_SOCKET, SO_ERROR)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-	}
+    socklen_t len = sizeof(value);
+    if (getsockopt(GetSocket(), SOL_SOCKET, SO_ERROR, (char *)&value, &len) == -1)
+    {
+        Handler().LogError(this, "getsockopt(SOL_SOCKET, SO_ERROR)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+    }
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_ERROR", LOG_LEVEL_INFO);
+    Handler().LogError(this, "socket option not available", 0, "SO_ERROR", LOG_LEVEL_INFO);
 #endif
-	return value;
+    return value;
 }
 
 
 bool Socket::SetSoDontroute(bool x)
 {
 #ifdef SO_DONTROUTE
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_DONTROUTE, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_DONTROUTE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_DONTROUTE, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_DONTROUTE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_DONTROUTE", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "SO_DONTROUTE", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1479,18 +1479,18 @@ bool Socket::SetSoDontroute(bool x)
 bool Socket::SetSoLinger(int onoff, int linger)
 {
 #ifdef SO_LINGER
-	struct linger stl;
-	stl.l_onoff = onoff;
-	stl.l_linger = linger;
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_LINGER, (char *)&stl, sizeof(stl)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_LINGER)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    struct linger stl;
+    stl.l_onoff = onoff;
+    stl.l_linger = linger;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_LINGER, (char *)&stl, sizeof(stl)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_LINGER)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_LINGER", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "SO_LINGER", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1498,16 +1498,16 @@ bool Socket::SetSoLinger(int onoff, int linger)
 bool Socket::SetSoOobinline(bool x)
 {
 #ifdef SO_OOBINLINE
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_OOBINLINE, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_OOBINLINE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_OOBINLINE, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_OOBINLINE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_OOBINLINE", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "SO_OOBINLINE", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1515,13 +1515,13 @@ bool Socket::SetSoOobinline(bool x)
 #ifdef SO_PASSCRED
 bool Socket::SetSoPasscred(bool x)
 {
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_PASSCRED, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_PASSCRED)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_PASSCRED, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_PASSCRED)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1529,12 +1529,12 @@ bool Socket::SetSoPasscred(bool x)
 #ifdef SO_PEERCRED
 bool Socket::SoPeercred(struct ucred& ucr)
 {
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_PEERCRED, (char *)&ucr, sizeof(ucr)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_PEERCRED)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_PEERCRED, (char *)&ucr, sizeof(ucr)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_PEERCRED)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1542,12 +1542,12 @@ bool Socket::SoPeercred(struct ucred& ucr)
 #ifdef SO_PRIORITY
 bool Socket::SetSoPriority(int x)
 {
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_PRIORITY, (char *)&x, sizeof(x)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_PRIORITY)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_PRIORITY, (char *)&x, sizeof(x)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_PRIORITY)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1555,15 +1555,15 @@ bool Socket::SetSoPriority(int x)
 bool Socket::SetSoRcvlowat(int x)
 {
 #ifdef SO_RCVLOWAT
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVLOWAT, (char *)&x, sizeof(x)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVLOWAT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVLOWAT, (char *)&x, sizeof(x)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVLOWAT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_RCVLOWAT", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "SO_RCVLOWAT", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1571,15 +1571,15 @@ bool Socket::SetSoRcvlowat(int x)
 bool Socket::SetSoSndlowat(int x)
 {
 #ifdef SO_SNDLOWAT
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDLOWAT, (char *)&x, sizeof(x)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDLOWAT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDLOWAT, (char *)&x, sizeof(x)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDLOWAT)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_SNDLOWAT", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "SO_SNDLOWAT", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1587,15 +1587,15 @@ bool Socket::SetSoSndlowat(int x)
 bool Socket::SetSoRcvtimeo(struct timeval& tv)
 {
 #ifdef SO_RCVTIMEO
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVTIMEO)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVTIMEO)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_RCVTIMEO", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "SO_RCVTIMEO", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1603,15 +1603,15 @@ bool Socket::SetSoRcvtimeo(struct timeval& tv)
 bool Socket::SetSoSndtimeo(struct timeval& tv)
 {
 #ifdef SO_SNDTIMEO
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDTIMEO)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDTIMEO)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_SNDTIMEO", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "SO_SNDTIMEO", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1619,44 +1619,44 @@ bool Socket::SetSoSndtimeo(struct timeval& tv)
 bool Socket::SetSoRcvbuf(int x)
 {
 #ifdef SO_RCVBUF
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVBUF, (char *)&x, sizeof(x)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVBUF, (char *)&x, sizeof(x)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_RCVBUF", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "SO_RCVBUF", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
 
 int Socket::SoRcvbuf()
 {
-	int value = 0;
+    int value = 0;
 #ifdef SO_RCVBUF
-	socklen_t len = sizeof(value);
-	if (getsockopt(GetSocket(), SOL_SOCKET, SO_RCVBUF, (char *)&value, &len) == -1)
-	{
-		Handler().LogError(this, "getsockopt(SOL_SOCKET, SO_RCVBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-	}
+    socklen_t len = sizeof(value);
+    if (getsockopt(GetSocket(), SOL_SOCKET, SO_RCVBUF, (char *)&value, &len) == -1)
+    {
+        Handler().LogError(this, "getsockopt(SOL_SOCKET, SO_RCVBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+    }
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_RCVBUF", LOG_LEVEL_INFO);
+    Handler().LogError(this, "socket option not available", 0, "SO_RCVBUF", LOG_LEVEL_INFO);
 #endif
-	return value;
+    return value;
 }
 
 
 #ifdef SO_RCVBUFFORCE
 bool Socket::SetSoRcvbufforce(int x)
 {
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVBUFFORCE, (char *)&x, sizeof(x)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVBUFFORCE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_RCVBUFFORCE, (char *)&x, sizeof(x)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_RCVBUFFORCE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1664,44 +1664,44 @@ bool Socket::SetSoRcvbufforce(int x)
 bool Socket::SetSoSndbuf(int x)
 {
 #ifdef SO_SNDBUF
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDBUF, (char *)&x, sizeof(x)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDBUF, (char *)&x, sizeof(x)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_SNDBUF", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "SO_SNDBUF", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
 
 int Socket::SoSndbuf()
 {
-	int value = 0;
+    int value = 0;
 #ifdef SO_SNDBUF
-	socklen_t len = sizeof(value);
-	if (getsockopt(GetSocket(), SOL_SOCKET, SO_SNDBUF, (char *)&value, &len) == -1)
-	{
-		Handler().LogError(this, "getsockopt(SOL_SOCKET, SO_SNDBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-	}
+    socklen_t len = sizeof(value);
+    if (getsockopt(GetSocket(), SOL_SOCKET, SO_SNDBUF, (char *)&value, &len) == -1)
+    {
+        Handler().LogError(this, "getsockopt(SOL_SOCKET, SO_SNDBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+    }
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_SNDBUF", LOG_LEVEL_INFO);
+    Handler().LogError(this, "socket option not available", 0, "SO_SNDBUF", LOG_LEVEL_INFO);
 #endif
-	return value;
+    return value;
 }
 
 
 #ifdef SO_SNDBUFFORCE
 bool Socket::SetSoSndbufforce(int x)
 {
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDBUFFORCE, (char *)&x, sizeof(x)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDBUFFORCE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDBUFFORCE, (char *)&x, sizeof(x)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDBUFFORCE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
@@ -1709,43 +1709,43 @@ bool Socket::SetSoSndbufforce(int x)
 #ifdef SO_TIMESTAMP
 bool Socket::SetSoTimestamp(bool x)
 {
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), SOL_SOCKET, SO_TIMESTAMP, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_TIMESTAMP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), SOL_SOCKET, SO_TIMESTAMP, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_TIMESTAMP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 }
 #endif
 
 
 int Socket::SoType()
 {
-	int value = 0;
+    int value = 0;
 #ifdef SO_TYPE
-	socklen_t len = sizeof(value);
-	if (getsockopt(GetSocket(), SOL_SOCKET, SO_TYPE, (char *)&value, &len) == -1)
-	{
-		Handler().LogError(this, "getsockopt(SOL_SOCKET, SO_TYPE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-	}
+    socklen_t len = sizeof(value);
+    if (getsockopt(GetSocket(), SOL_SOCKET, SO_TYPE, (char *)&value, &len) == -1)
+    {
+        Handler().LogError(this, "getsockopt(SOL_SOCKET, SO_TYPE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+    }
 #else
-	Handler().LogError(this, "socket option not available", 0, "SO_TYPE", LOG_LEVEL_INFO);
+    Handler().LogError(this, "socket option not available", 0, "SO_TYPE", LOG_LEVEL_INFO);
 #endif
-	return value;
+    return value;
 }
 
 
 #ifdef ENABLE_TRIGGERS
 void Socket::Subscribe(int id)
 {
-	Handler().Subscribe(id, this);
+    Handler().Subscribe(id, this);
 }
 
 
 void Socket::Unsubscribe(int id)
 {
-	Handler().Unsubscribe(id, this);
+    Handler().Unsubscribe(id, this);
 }
 
 
@@ -1762,14 +1762,14 @@ void Socket::OnCancelled(int)
 
 void Socket::SetTimeout(time_t secs)
 {
-	if (!secs)
-	{
-		Handler().AddList(m_socket, LIST_TIMEOUT, false);
-		return;
-	}
-	Handler().AddList(m_socket, LIST_TIMEOUT, true);
-	m_timeout_start = time(NULL);
-	m_timeout_limit = secs;
+    if (!secs)
+    {
+        Handler().AddList(m_socket, LIST_TIMEOUT, false);
+        return;
+    }
+    Handler().AddList(m_socket, LIST_TIMEOUT, true);
+    m_timeout_start = time(NULL);
+    m_timeout_limit = secs;
 }
 
 
@@ -1785,9 +1785,9 @@ void Socket::OnConnectTimeout()
 
 bool Socket::Timeout(time_t tnow)
 {
-	if (tnow - m_timeout_start > m_timeout_limit)
-		return true;
-	return false;
+    if (tnow - m_timeout_start > m_timeout_limit)
+        return true;
+    return false;
 }
 
 
@@ -1796,21 +1796,21 @@ port_t Socket::GetSockPort()
 {
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
-		struct sockaddr_in6 sa;
-		socklen_t sockaddr_length = sizeof(struct sockaddr_in6);
-		if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
-			memset(&sa, 0, sizeof(sa));
-		return ntohs(sa.sin6_port);
-	}
+    if (IsIpv6())
+    {
+        struct sockaddr_in6 sa;
+        socklen_t sockaddr_length = sizeof(struct sockaddr_in6);
+        if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
+            memset(&sa, 0, sizeof(sa));
+        return ntohs(sa.sin6_port);
+    }
 #endif
 #endif
-	struct sockaddr_in sa;
-	socklen_t sockaddr_length = sizeof(struct sockaddr_in);
-	if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
-		memset(&sa, 0, sizeof(sa));
-	return ntohs(sa.sin_port);
+    struct sockaddr_in sa;
+    socklen_t sockaddr_length = sizeof(struct sockaddr_in);
+    if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
+        memset(&sa, 0, sizeof(sa));
+    return ntohs(sa.sin_port);
 }
 
 
@@ -1819,19 +1819,19 @@ ipaddr_t Socket::GetSockIP4()
 {
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
-		return 0;
-	}
+    if (IsIpv6())
+    {
+        return 0;
+    }
 #endif
 #endif
-	struct sockaddr_in sa;
-	socklen_t sockaddr_length = sizeof(struct sockaddr_in);
-	if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
-		memset(&sa, 0, sizeof(sa));
-	ipaddr_t a;
-	memcpy(&a, &sa.sin_addr, 4);
-	return a;
+    struct sockaddr_in sa;
+    socklen_t sockaddr_length = sizeof(struct sockaddr_in);
+    if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
+        memset(&sa, 0, sizeof(sa));
+    ipaddr_t a;
+    memcpy(&a, &sa.sin_addr, 4);
+    return a;
 }
 
 
@@ -1840,18 +1840,18 @@ std::string Socket::GetSockAddress()
 {
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
-		return "";
-	}
+    if (IsIpv6())
+    {
+        return "";
+    }
 #endif
 #endif
-	struct sockaddr_in sa;
-	socklen_t sockaddr_length = sizeof(struct sockaddr_in);
-	if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
-		memset(&sa, 0, sizeof(sa));
-	Ipv4Address addr( sa );
-	return addr.Convert();
+    struct sockaddr_in sa;
+    socklen_t sockaddr_length = sizeof(struct sockaddr_in);
+    if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
+        memset(&sa, 0, sizeof(sa));
+    Ipv4Address addr( sa );
+    return addr.Convert();
 }
 
 
@@ -1860,33 +1860,33 @@ std::string Socket::GetSockAddress()
 /** Returns local ipv6 address for bound socket file descriptor. */
 struct in6_addr Socket::GetSockIP6()
 {
-	if (IsIpv6())
-	{
-		struct sockaddr_in6 sa;
-		socklen_t sockaddr_length = sizeof(struct sockaddr_in6);
-		if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
-			memset(&sa, 0, sizeof(sa));
-		return sa.sin6_addr;
-	}
-	struct in6_addr a;
-	memset(&a, 0, sizeof(a));
-	return a;
+    if (IsIpv6())
+    {
+        struct sockaddr_in6 sa;
+        socklen_t sockaddr_length = sizeof(struct sockaddr_in6);
+        if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
+            memset(&sa, 0, sizeof(sa));
+        return sa.sin6_addr;
+    }
+    struct in6_addr a;
+    memset(&a, 0, sizeof(a));
+    return a;
 }
 
 
 /** Returns local ipv6 address as text for bound socket file descriptor. */
 std::string Socket::GetSockAddress6()
 {
-	if (IsIpv6())
-	{
-		struct sockaddr_in6 sa;
-		socklen_t sockaddr_length = sizeof(struct sockaddr_in6);
-		if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
-			memset(&sa, 0, sizeof(sa));
-		Ipv6Address addr( sa );
-		return addr.Convert();
-	}
-	return "";
+    if (IsIpv6())
+    {
+        struct sockaddr_in6 sa;
+        socklen_t sockaddr_length = sizeof(struct sockaddr_in6);
+        if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
+            memset(&sa, 0, sizeof(sa));
+        Ipv6Address addr( sa );
+        return addr.Convert();
+    }
+    return "";
 }
 #endif
 #endif
diff --git a/dep/src/sockets/SocketHandler.cpp b/dep/src/sockets/SocketHandler.cpp
index 9ec5412af38..8a7307f4192 100644
--- a/dep/src/sockets/SocketHandler.cpp
+++ b/dep/src/sockets/SocketHandler.cpp
@@ -1,6 +1,6 @@
 /** \file SocketHandler.cpp
- **	\date  2004-02-13
- **	\author grymse@alhem.net
+ ** \date  2004-02-13
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2004-2007  Anders Hedstrom
@@ -8,7 +8,7 @@ Copyright (C) 2004-2007  Anders Hedstrom
 This library is made available under the terms of the GNU GPL.
 
 If you would like to use this library in a closed-source application,
-a separate license agreement is available. For information about 
+a separate license agreement is available. For information about
 the closed-source license agreement for the C++ sockets library,
 please visit http://www.alhem.net/Sockets/license.html and/or
 email license@alhem.net.
@@ -52,7 +52,7 @@ namespace SOCKETS_NAMESPACE {
 //#ifdef _DEBUG
 //#define DEB(x) x; fflush(stderr);
 //#else
-#define DEB(x) 
+#define DEB(x)
 //#endif
 
 
@@ -83,9 +83,9 @@ SocketHandler::SocketHandler(StdLog *p)
 ,m_slave(false)
 #endif
 {
-	FD_ZERO(&m_rfds);
-	FD_ZERO(&m_wfds);
-	FD_ZERO(&m_efds);
+    FD_ZERO(&m_rfds);
+    FD_ZERO(&m_wfds);
+    FD_ZERO(&m_efds);
 }
 
 
@@ -116,878 +116,878 @@ SocketHandler::SocketHandler(Mutex& mutex,StdLog *p)
 ,m_slave(false)
 #endif
 {
-	m_mutex.Lock();
-	FD_ZERO(&m_rfds);
-	FD_ZERO(&m_wfds);
-	FD_ZERO(&m_efds);
+    m_mutex.Lock();
+    FD_ZERO(&m_rfds);
+    FD_ZERO(&m_wfds);
+    FD_ZERO(&m_efds);
 }
 
 
 SocketHandler::~SocketHandler()
 {
 #ifdef ENABLE_RESOLVER
-	if (m_resolver)
-	{
-		m_resolver -> Quit();
-	}
+    if (m_resolver)
+    {
+        m_resolver -> Quit();
+    }
 #endif
-	{
-		while (m_sockets.size())
-		{
-DEB(			fprintf(stderr, "Emptying sockets list in SocketHandler destructor, %d instances\n", (int)m_sockets.size());)
-			socket_m::iterator it = m_sockets.begin();
-			Socket *p = it -> second;
-			if (p)
-			{
-DEB(				fprintf(stderr, "  fd %d\n", p -> GetSocket());)
-				p -> Close();
-DEB(				fprintf(stderr, "  fd closed %d\n", p -> GetSocket());)
-//				p -> OnDelete(); // hey, I turn this back on. what's the worst that could happen??!!
-				// MinionSocket breaks, calling MinderHandler methods in OnDelete -
-				// MinderHandler is already gone when that happens...
-
-				// only delete socket when controlled
-				// ie master sockethandler can delete non-detached sockets
-				// and a slave sockethandler can only delete a detach socket
-				if (p -> DeleteByHandler()
+    {
+        while (m_sockets.size())
+        {
+DEB(            fprintf(stderr, "Emptying sockets list in SocketHandler destructor, %d instances\n", (int)m_sockets.size());)
+            socket_m::iterator it = m_sockets.begin();
+            Socket *p = it -> second;
+            if (p)
+            {
+DEB(                fprintf(stderr, "  fd %d\n", p -> GetSocket());)
+                p -> Close();
+DEB(                fprintf(stderr, "  fd closed %d\n", p -> GetSocket());)
+//              p -> OnDelete(); // hey, I turn this back on. what's the worst that could happen??!!
+                // MinionSocket breaks, calling MinderHandler methods in OnDelete -
+                // MinderHandler is already gone when that happens...
+
+                // only delete socket when controlled
+                // ie master sockethandler can delete non-detached sockets
+                // and a slave sockethandler can only delete a detach socket
+                if (p -> DeleteByHandler()
 #ifdef ENABLE_DETACH
-					&& !(m_slave ^ p -> IsDetached()) 
+                    && !(m_slave ^ p -> IsDetached())
 #endif
-					)
-				{
-					p -> SetErasedByHandler();
-					delete p;
-				}
-				m_sockets.erase(it);
-			}
-			else
-			{
-				m_sockets.erase(it);
-			}
-DEB(			fprintf(stderr, "next\n");)
-		}
-DEB(		fprintf(stderr, "/Emptying sockets list in SocketHandler destructor, %d instances\n", (int)m_sockets.size());)
-	}
+                    )
+                {
+                    p -> SetErasedByHandler();
+                    delete p;
+                }
+                m_sockets.erase(it);
+            }
+            else
+            {
+                m_sockets.erase(it);
+            }
+DEB(            fprintf(stderr, "next\n");)
+        }
+DEB(        fprintf(stderr, "/Emptying sockets list in SocketHandler destructor, %d instances\n", (int)m_sockets.size());)
+    }
 #ifdef ENABLE_RESOLVER
-	if (m_resolver)
-	{
-		delete m_resolver;
-	}
+    if (m_resolver)
+    {
+        delete m_resolver;
+    }
 #endif
-	if (m_b_use_mutex)
-	{
-		m_mutex.Unlock();
-	}
+    if (m_b_use_mutex)
+    {
+        m_mutex.Unlock();
+    }
 }
 
 
 Mutex& SocketHandler::GetMutex() const
 {
-	return m_mutex; 
+    return m_mutex;
 }
 
 
 #ifdef ENABLE_DETACH
 void SocketHandler::SetSlave(bool x)
 {
-	m_slave = x;
+    m_slave = x;
 }
 
 
 bool SocketHandler::IsSlave()
 {
-	return m_slave;
+    return m_slave;
 }
 #endif
 
 
 void SocketHandler::RegStdLog(StdLog *log)
 {
-	m_stdlog = log;
+    m_stdlog = log;
 }
 
 
 void SocketHandler::LogError(Socket *p,const std::string& user_text,int err,const std::string& sys_err,loglevel_t t)
 {
-	if (m_stdlog)
-	{
-		m_stdlog -> error(this, p, user_text, err, sys_err, t);
-	}
+    if (m_stdlog)
+    {
+        m_stdlog -> error(this, p, user_text, err, sys_err, t);
+    }
 }
 
 
 void SocketHandler::Add(Socket *p)
 {
-	if (p -> GetSocket() == INVALID_SOCKET)
-	{
-		LogError(p, "Add", -1, "Invalid socket", LOG_LEVEL_WARNING);
-		if (p -> CloseAndDelete())
-		{
-			m_delete.push_back(p);
-		}
-		return;
-	}
-	if (m_add.find(p -> GetSocket()) != m_add.end())
-	{
-		LogError(p, "Add", (int)p -> GetSocket(), "Attempt to add socket already in add queue", LOG_LEVEL_FATAL);
-		m_delete.push_back(p);
-		return;
-	}
-	m_add[p -> GetSocket()] = p;
+    if (p -> GetSocket() == INVALID_SOCKET)
+    {
+        LogError(p, "Add", -1, "Invalid socket", LOG_LEVEL_WARNING);
+        if (p -> CloseAndDelete())
+        {
+            m_delete.push_back(p);
+        }
+        return;
+    }
+    if (m_add.find(p -> GetSocket()) != m_add.end())
+    {
+        LogError(p, "Add", (int)p -> GetSocket(), "Attempt to add socket already in add queue", LOG_LEVEL_FATAL);
+        m_delete.push_back(p);
+        return;
+    }
+    m_add[p -> GetSocket()] = p;
 }
 
 
 void SocketHandler::Get(SOCKET s,bool& r,bool& w,bool& e)
 {
-	if (s >= 0)
-	{
-		r = FD_ISSET(s, &m_rfds) ? true : false;
-		w = FD_ISSET(s, &m_wfds) ? true : false;
-		e = FD_ISSET(s, &m_efds) ? true : false;
-	}
+    if (s >= 0)
+    {
+        r = FD_ISSET(s, &m_rfds) ? true : false;
+        w = FD_ISSET(s, &m_wfds) ? true : false;
+        e = FD_ISSET(s, &m_efds) ? true : false;
+    }
 }
 
 
 void SocketHandler::Set(SOCKET s,bool bRead,bool bWrite,bool bException)
 {
-DEB(	fprintf(stderr, "Set(%d, %s, %s, %s)\n", s, bRead ? "true" : "false", bWrite ? "true" : "false", bException ? "true" : "false");)
-	if (s >= 0)
-	{
-		if (bRead)
-		{
-			if (!FD_ISSET(s, &m_rfds))
-			{
-				FD_SET(s, &m_rfds);
-			}
-		}
-		else
-		{
-			FD_CLR(s, &m_rfds);
-		}
-		if (bWrite)
-		{
-			if (!FD_ISSET(s, &m_wfds))
-			{
-				FD_SET(s, &m_wfds);
-			}
-		}
-		else
-		{
-			FD_CLR(s, &m_wfds);
-		}
-		if (bException)
-		{
-			if (!FD_ISSET(s, &m_efds))
-			{
-				FD_SET(s, &m_efds);
-			}
-		}
-		else
-		{
-			FD_CLR(s, &m_efds);
-		}
-	}
+DEB(    fprintf(stderr, "Set(%d, %s, %s, %s)\n", s, bRead ? "true" : "false", bWrite ? "true" : "false", bException ? "true" : "false");)
+    if (s >= 0)
+    {
+        if (bRead)
+        {
+            if (!FD_ISSET(s, &m_rfds))
+            {
+                FD_SET(s, &m_rfds);
+            }
+        }
+        else
+        {
+            FD_CLR(s, &m_rfds);
+        }
+        if (bWrite)
+        {
+            if (!FD_ISSET(s, &m_wfds))
+            {
+                FD_SET(s, &m_wfds);
+            }
+        }
+        else
+        {
+            FD_CLR(s, &m_wfds);
+        }
+        if (bException)
+        {
+            if (!FD_ISSET(s, &m_efds))
+            {
+                FD_SET(s, &m_efds);
+            }
+        }
+        else
+        {
+            FD_CLR(s, &m_efds);
+        }
+    }
 }
 
 
 int SocketHandler::Select(long sec,long usec)
 {
-	struct timeval tv;
-	tv.tv_sec = sec;
-	tv.tv_usec = usec;
-	return Select(&tv);
+    struct timeval tv;
+    tv.tv_sec = sec;
+    tv.tv_usec = usec;
+    return Select(&tv);
 }
 
 
 int SocketHandler::Select()
 {
-	if (!m_fds_callonconnect.empty() ||
+    if (!m_fds_callonconnect.empty() ||
 #ifdef ENABLE_DETACH
-		(!m_slave && !m_fds_detach.empty()) ||
+        (!m_slave && !m_fds_detach.empty()) ||
 #endif
-		!m_fds_timeout.empty() ||
-		!m_fds_retry.empty() ||
-		!m_fds_close.empty() ||
-		!m_fds_erase.empty())
-	{
-		return Select(0, 200000);
-	}
-	return Select(NULL);
+        !m_fds_timeout.empty() ||
+        !m_fds_retry.empty() ||
+        !m_fds_close.empty() ||
+        !m_fds_erase.empty())
+    {
+        return Select(0, 200000);
+    }
+    return Select(NULL);
 }
 
 
 int SocketHandler::Select(struct timeval *tsel)
 {
-	size_t ignore = 0;
-	while (m_add.size() > ignore)
-	{
-		if (m_sockets.size() >= FD_SETSIZE)
-		{
-			LogError(NULL, "Select", (int)m_sockets.size(), "FD_SETSIZE reached", LOG_LEVEL_WARNING);
-			break;
-		}
-		socket_m::iterator it = m_add.begin();
-		SOCKET s = it -> first;
-		Socket *p = it -> second;
-DEB(		fprintf(stderr, "Trying to add fd %d,  m_add.size() %d,  ignore %d\n", (int)s, (int)m_add.size(), (int)ignore);)
-		//
-		if (m_sockets.find(p -> GetSocket()) != m_sockets.end())
-		{
-			LogError(p, "Add", (int)p -> GetSocket(), "Attempt to add socket already in controlled queue", LOG_LEVEL_FATAL);
-			// %! it's a dup, don't add to delete queue, just ignore it
-			m_delete.push_back(p);
-			m_add.erase(it);
-//			ignore++;
-			continue;
-		}
-		if (!p -> CloseAndDelete())
-		{
-			StreamSocket *scp = dynamic_cast<StreamSocket *>(p);
-			if (scp && scp -> Connecting()) // 'Open' called before adding socket
-			{
-				Set(s,false,true);
-			}
-			else
-			{
-				TcpSocket *tcp = dynamic_cast<TcpSocket *>(p);
-				bool bWrite = tcp ? tcp -> GetOutputLength() != 0 : false;
-				if (p -> IsDisableRead())
-				{
-					Set(s, false, bWrite);
-				}
-				else
-				{
-					Set(s, true, bWrite);
-				}
-			}
-			m_maxsock = (s > m_maxsock) ? s : m_maxsock;
-		}
-		else
-		{
-			LogError(p, "Add", (int)p -> GetSocket(), "Trying to add socket with SetCloseAndDelete() true", LOG_LEVEL_WARNING);
-		}
-		// only add to m_fds (process fd_set events) if
-		//  slave handler and detached/detaching socket
-		//  master handler and non-detached socket
+    size_t ignore = 0;
+    while (m_add.size() > ignore)
+    {
+        if (m_sockets.size() >= FD_SETSIZE)
+        {
+            LogError(NULL, "Select", (int)m_sockets.size(), "FD_SETSIZE reached", LOG_LEVEL_WARNING);
+            break;
+        }
+        socket_m::iterator it = m_add.begin();
+        SOCKET s = it -> first;
+        Socket *p = it -> second;
+DEB(        fprintf(stderr, "Trying to add fd %d,  m_add.size() %d,  ignore %d\n", (int)s, (int)m_add.size(), (int)ignore);)
+        //
+        if (m_sockets.find(p -> GetSocket()) != m_sockets.end())
+        {
+            LogError(p, "Add", (int)p -> GetSocket(), "Attempt to add socket already in controlled queue", LOG_LEVEL_FATAL);
+            // %! it's a dup, don't add to delete queue, just ignore it
+            m_delete.push_back(p);
+            m_add.erase(it);
+//          ignore++;
+            continue;
+        }
+        if (!p -> CloseAndDelete())
+        {
+            StreamSocket *scp = dynamic_cast<StreamSocket *>(p);
+            if (scp && scp -> Connecting()) // 'Open' called before adding socket
+            {
+                Set(s,false,true);
+            }
+            else
+            {
+                TcpSocket *tcp = dynamic_cast<TcpSocket *>(p);
+                bool bWrite = tcp ? tcp -> GetOutputLength() != 0 : false;
+                if (p -> IsDisableRead())
+                {
+                    Set(s, false, bWrite);
+                }
+                else
+                {
+                    Set(s, true, bWrite);
+                }
+            }
+            m_maxsock = (s > m_maxsock) ? s : m_maxsock;
+        }
+        else
+        {
+            LogError(p, "Add", (int)p -> GetSocket(), "Trying to add socket with SetCloseAndDelete() true", LOG_LEVEL_WARNING);
+        }
+        // only add to m_fds (process fd_set events) if
+        //  slave handler and detached/detaching socket
+        //  master handler and non-detached socket
 #ifdef ENABLE_DETACH
-		if (!(m_slave ^ p -> IsDetach()))
+        if (!(m_slave ^ p -> IsDetach()))
 #endif
-		{
-			m_fds.push_back(s);
-		}
-		m_sockets[s] = p;
-		//
-		m_add.erase(it);
-	}
+        {
+            m_fds.push_back(s);
+        }
+        m_sockets[s] = p;
+        //
+        m_add.erase(it);
+    }
 #ifdef MACOSX
-	fd_set rfds;
-	fd_set wfds;
-	fd_set efds;
-	FD_COPY(&m_rfds, &rfds);
-	FD_COPY(&m_wfds, &wfds);
-	FD_COPY(&m_efds, &efds);
+    fd_set rfds;
+    fd_set wfds;
+    fd_set efds;
+    FD_COPY(&m_rfds, &rfds);
+    FD_COPY(&m_wfds, &wfds);
+    FD_COPY(&m_efds, &efds);
 #else
-	fd_set rfds = m_rfds;
-	fd_set wfds = m_wfds;
-	fd_set efds = m_efds;
+    fd_set rfds = m_rfds;
+    fd_set wfds = m_wfds;
+    fd_set efds = m_efds;
 #endif
-	int n;
-	if (m_b_use_mutex)
-	{
-		m_mutex.Unlock();
-		n = select( (int)(m_maxsock + 1),&rfds,&wfds,&efds,tsel);
-		m_mutex.Lock();
-	}
-	else
-	{
-		n = select( (int)(m_maxsock + 1),&rfds,&wfds,&efds,tsel);
-	}
-	if (n == -1)
-	{
-		/*
-			EBADF  An invalid file descriptor was given in one of the sets.
-			EINTR  A non blocked signal was caught.
-			EINVAL n is negative. Or struct timeval contains bad time values (<0).
-			ENOMEM select was unable to allocate memory for internal tables.
-		*/
-		if (Errno != m_preverror || m_errcnt++ % 10000 == 0)
-		{
-			LogError(NULL, "select", Errno, StrError(Errno));
-DEB(			fprintf(stderr, "m_maxsock: %d\n", m_maxsock);
-			fprintf(stderr, "%s\n", Errno == EINVAL ? "EINVAL" :
-				Errno == EINTR ? "EINTR" :
-				Errno == EBADF ? "EBADF" :
-				Errno == ENOMEM ? "ENOMEM" : "<another>");
-			// test bad fd
-			for (SOCKET i = 0; i <= m_maxsock; i++)
-			{
-				bool t = false;
-				FD_ZERO(&rfds);
-				FD_ZERO(&wfds);
-				FD_ZERO(&efds);
-				if (FD_ISSET(i, &m_rfds))
-				{
-					FD_SET(i, &rfds);
-					t = true;
-				}
-				if (FD_ISSET(i, &m_wfds))
-				{
-					FD_SET(i, &wfds);
-					t = true;
-				}
-				if (FD_ISSET(i, &m_efds))
-				{
-					FD_SET(i, &efds);
-					t = true;
-				}
-				if (t && m_sockets.find(i) == m_sockets.end())
-				{
-					fprintf(stderr, "Bad fd in fd_set: %d\n", i);
-				}
-			}
+    int n;
+    if (m_b_use_mutex)
+    {
+        m_mutex.Unlock();
+        n = select( (int)(m_maxsock + 1),&rfds,&wfds,&efds,tsel);
+        m_mutex.Lock();
+    }
+    else
+    {
+        n = select( (int)(m_maxsock + 1),&rfds,&wfds,&efds,tsel);
+    }
+    if (n == -1)
+    {
+        /*
+            EBADF  An invalid file descriptor was given in one of the sets.
+            EINTR  A non blocked signal was caught.
+            EINVAL n is negative. Or struct timeval contains bad time values (<0).
+            ENOMEM select was unable to allocate memory for internal tables.
+        */
+        if (Errno != m_preverror || m_errcnt++ % 10000 == 0)
+        {
+            LogError(NULL, "select", Errno, StrError(Errno));
+DEB(            fprintf(stderr, "m_maxsock: %d\n", m_maxsock);
+            fprintf(stderr, "%s\n", Errno == EINVAL ? "EINVAL" :
+                Errno == EINTR ? "EINTR" :
+                Errno == EBADF ? "EBADF" :
+                Errno == ENOMEM ? "ENOMEM" : "<another>");
+            // test bad fd
+            for (SOCKET i = 0; i <= m_maxsock; i++)
+            {
+                bool t = false;
+                FD_ZERO(&rfds);
+                FD_ZERO(&wfds);
+                FD_ZERO(&efds);
+                if (FD_ISSET(i, &m_rfds))
+                {
+                    FD_SET(i, &rfds);
+                    t = true;
+                }
+                if (FD_ISSET(i, &m_wfds))
+                {
+                    FD_SET(i, &wfds);
+                    t = true;
+                }
+                if (FD_ISSET(i, &m_efds))
+                {
+                    FD_SET(i, &efds);
+                    t = true;
+                }
+                if (t && m_sockets.find(i) == m_sockets.end())
+                {
+                    fprintf(stderr, "Bad fd in fd_set: %d\n", i);
+                }
+            }
 ) // DEB
-			m_preverror = Errno;
-		}
-		/// \todo rebuild fd_set's from active sockets list (m_sockets) here
-	}
-	else
-	if (!n)
-	{
-		m_preverror = -1;
-	}
-	else
-	if (n > 0)
-	{
-		for (socket_v::iterator it2 = m_fds.begin(); it2 != m_fds.end() && n; it2++)
-		{
-			SOCKET i = *it2;
-			if (FD_ISSET(i, &rfds))
-			{
-				socket_m::iterator itmp = m_sockets.find(i);
-				if (itmp != m_sockets.end()) // found
-				{
-					Socket *p = itmp -> second;
-					// new SSL negotiate method
+            m_preverror = Errno;
+        }
+        /// \todo rebuild fd_set's from active sockets list (m_sockets) here
+    }
+    else
+    if (!n)
+    {
+        m_preverror = -1;
+    }
+    else
+    if (n > 0)
+    {
+        for (socket_v::iterator it2 = m_fds.begin(); it2 != m_fds.end() && n; it2++)
+        {
+            SOCKET i = *it2;
+            if (FD_ISSET(i, &rfds))
+            {
+                socket_m::iterator itmp = m_sockets.find(i);
+                if (itmp != m_sockets.end()) // found
+                {
+                    Socket *p = itmp -> second;
+                    // new SSL negotiate method
 #ifdef HAVE_OPENSSL
-					if (p -> IsSSLNegotiate())
-					{
-						p -> SSLNegotiate();
-					}
-					else
+                    if (p -> IsSSLNegotiate())
+                    {
+                        p -> SSLNegotiate();
+                    }
+                    else
 #endif
-					{
-						p -> OnRead();
-					}
-				}
-				else
-				{
-					LogError(NULL, "GetSocket/handler/1", (int)i, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
-				}
-				n--;
-			}
-			if (FD_ISSET(i, &wfds))
-			{
-				socket_m::iterator itmp = m_sockets.find(i);
-				if (itmp != m_sockets.end()) // found
-				{
-					Socket *p = itmp -> second;
-					// new SSL negotiate method
+                    {
+                        p -> OnRead();
+                    }
+                }
+                else
+                {
+                    LogError(NULL, "GetSocket/handler/1", (int)i, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
+                }
+                n--;
+            }
+            if (FD_ISSET(i, &wfds))
+            {
+                socket_m::iterator itmp = m_sockets.find(i);
+                if (itmp != m_sockets.end()) // found
+                {
+                    Socket *p = itmp -> second;
+                    // new SSL negotiate method
 #ifdef HAVE_OPENSSL
-					if (p -> IsSSLNegotiate())
-					{
-						p -> SSLNegotiate();
-					}
-					else
+                    if (p -> IsSSLNegotiate())
+                    {
+                        p -> SSLNegotiate();
+                    }
+                    else
 #endif
-					{
-						p -> OnWrite();
-					}
-				}
-				else
-				{
-					LogError(NULL, "GetSocket/handler/2", (int)i, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
-				}
-				n--;
-			}
-			if (FD_ISSET(i, &efds))
-			{
-				socket_m::iterator itmp = m_sockets.find(i);
-				if (itmp != m_sockets.end()) // found
-				{
-					Socket *p = itmp -> second;
-					p -> OnException();
-				}
-				else
-				{
-					LogError(NULL, "GetSocket/handler/3", (int)i, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
-				}
-				n--;
-			}
-		} // m_fds loop
-		m_preverror = -1;
-	} // if (n > 0)
-
-	// check CallOnConnect - EVENT
-	if (!m_fds_callonconnect.empty())
-	{
-		socket_v tmp = m_fds_callonconnect;
-		for (socket_v::iterator it = tmp.begin(); it != tmp.end(); it++)
-		{
-			Socket *p = NULL;
-			{
-				socket_m::iterator itmp = m_sockets.find(*it);
-				if (itmp != m_sockets.end()) // found
-				{
-					p = itmp -> second;
-				}
-				else
-				{
-					LogError(NULL, "GetSocket/handler/4", (int)*it, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
-				}
-			}
-			if (p)
-			{
-//				if (p -> CallOnConnect() && p -> Ready() )
-				{
-					p -> SetConnected(); // moved here from inside if (tcp) check below
+                    {
+                        p -> OnWrite();
+                    }
+                }
+                else
+                {
+                    LogError(NULL, "GetSocket/handler/2", (int)i, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
+                }
+                n--;
+            }
+            if (FD_ISSET(i, &efds))
+            {
+                socket_m::iterator itmp = m_sockets.find(i);
+                if (itmp != m_sockets.end()) // found
+                {
+                    Socket *p = itmp -> second;
+                    p -> OnException();
+                }
+                else
+                {
+                    LogError(NULL, "GetSocket/handler/3", (int)i, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
+                }
+                n--;
+            }
+        } // m_fds loop
+        m_preverror = -1;
+    } // if (n > 0)
+
+    // check CallOnConnect - EVENT
+    if (!m_fds_callonconnect.empty())
+    {
+        socket_v tmp = m_fds_callonconnect;
+        for (socket_v::iterator it = tmp.begin(); it != tmp.end(); it++)
+        {
+            Socket *p = NULL;
+            {
+                socket_m::iterator itmp = m_sockets.find(*it);
+                if (itmp != m_sockets.end()) // found
+                {
+                    p = itmp -> second;
+                }
+                else
+                {
+                    LogError(NULL, "GetSocket/handler/4", (int)*it, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
+                }
+            }
+            if (p)
+            {
+//              if (p -> CallOnConnect() && p -> Ready() )
+                {
+                    p -> SetConnected(); // moved here from inside if (tcp) check below
 #ifdef HAVE_OPENSSL
-					if (p -> IsSSL()) // SSL Enabled socket
-						p -> OnSSLConnect();
-					else
+                    if (p -> IsSSL()) // SSL Enabled socket
+                        p -> OnSSLConnect();
+                    else
 #endif
 #ifdef ENABLE_SOCKS4
-					if (p -> Socks4())
-						p -> OnSocks4Connect();
-					else
+                    if (p -> Socks4())
+                        p -> OnSocks4Connect();
+                    else
 #endif
-					{
-						TcpSocket *tcp = dynamic_cast<TcpSocket *>(p);
-						if (tcp)
-						{
-							if (tcp -> GetOutputLength())
-							{
-								p -> OnWrite();
-							}
-						}
+                    {
+                        TcpSocket *tcp = dynamic_cast<TcpSocket *>(p);
+                        if (tcp)
+                        {
+                            if (tcp -> GetOutputLength())
+                            {
+                                p -> OnWrite();
+                            }
+                        }
 #ifdef ENABLE_RECONNECT
-						if (tcp && tcp -> IsReconnect())
-							p -> OnReconnect();
-						else
+                        if (tcp && tcp -> IsReconnect())
+                            p -> OnReconnect();
+                        else
 #endif
-						{
-//							LogError(p, "Calling OnConnect", 0, "Because CallOnConnect", LOG_LEVEL_INFO);
-							p -> OnConnect();
-						}
-					}
-//					p -> SetCallOnConnect( false );
-					AddList(p -> GetSocket(), LIST_CALLONCONNECT, false);
-				}
-			}
-		}
-	}
+                        {
+//                          LogError(p, "Calling OnConnect", 0, "Because CallOnConnect", LOG_LEVEL_INFO);
+                            p -> OnConnect();
+                        }
+                    }
+//                  p -> SetCallOnConnect( false );
+                    AddList(p -> GetSocket(), LIST_CALLONCONNECT, false);
+                }
+            }
+        }
+    }
 #ifdef ENABLE_DETACH
-	// check detach of socket if master handler - EVENT
-	if (!m_slave && !m_fds_detach.empty())
-	{
-		// %! why not using tmp list here??!?
-		for (socket_v::iterator it = m_fds_detach.begin(); it != m_fds_detach.end(); it++)
-		{
-			Socket *p = NULL;
-			{
-				socket_m::iterator itmp = m_sockets.find(*it);
-				if (itmp != m_sockets.end()) // found
-				{
-					p = itmp -> second;
-				}
-				else
-				{
-					LogError(NULL, "GetSocket/handler/5", (int)*it, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
-				}
-			}
-			if (p)
-			{
-//				if (p -> IsDetach())
-				{
-					Set(p -> GetSocket(), false, false, false);
-					// After DetachSocket(), all calls to Handler() will return a reference
-					// to the new slave SocketHandler running in the new thread.
-					p -> DetachSocket();
-					// Adding the file descriptor to m_fds_erase will now also remove the
-					// socket from the detach queue - tnx knightmad
-					m_fds_erase.push_back(p -> GetSocket());
-				}
-			}
-		}
-	}
+    // check detach of socket if master handler - EVENT
+    if (!m_slave && !m_fds_detach.empty())
+    {
+        // %! why not using tmp list here??!?
+        for (socket_v::iterator it = m_fds_detach.begin(); it != m_fds_detach.end(); it++)
+        {
+            Socket *p = NULL;
+            {
+                socket_m::iterator itmp = m_sockets.find(*it);
+                if (itmp != m_sockets.end()) // found
+                {
+                    p = itmp -> second;
+                }
+                else
+                {
+                    LogError(NULL, "GetSocket/handler/5", (int)*it, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
+                }
+            }
+            if (p)
+            {
+//              if (p -> IsDetach())
+                {
+                    Set(p -> GetSocket(), false, false, false);
+                    // After DetachSocket(), all calls to Handler() will return a reference
+                    // to the new slave SocketHandler running in the new thread.
+                    p -> DetachSocket();
+                    // Adding the file descriptor to m_fds_erase will now also remove the
+                    // socket from the detach queue - tnx knightmad
+                    m_fds_erase.push_back(p -> GetSocket());
+                }
+            }
+        }
+    }
 #endif
-	// check Connecting - connection timeout - conditional event
-	if (m_fds_timeout.size())
-	{
-		time_t tnow = time(NULL);
-		if (tnow != m_tlast)
-		{
-			socket_v tmp = m_fds_timeout;
-DEB(			fprintf(stderr, "Checking %d socket(s) for timeout\n", tmp.size());)
-			for (socket_v::iterator it = tmp.begin(); it != tmp.end(); it++)
-			{
-				Socket *p = NULL;
-				{
-					socket_m::iterator itmp = m_sockets.find(*it);
-					if (itmp != m_sockets.end()) // found
-					{
-						p = itmp -> second;
-					}
-					else
-					{
-						itmp = m_add.find(*it);
-						if (itmp != m_add.end())
-						{
-							p = itmp -> second;
-						}
-						else
-						{
-							LogError(NULL, "GetSocket/handler/6", (int)*it, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
-						}
-					}
-				}
-				if (p)
-				{
-					if (p -> Timeout(tnow))
-					{
-						StreamSocket *scp = dynamic_cast<StreamSocket *>(p);
-						if (scp && scp -> Connecting())
-							p -> OnConnectTimeout();
-						else
-							p -> OnTimeout();
-						p -> SetTimeout(0);
-					}
-				}
-			}
-			m_tlast = tnow;
-		} // tnow != tlast
-	}
-	// check retry client connect - EVENT
-	if (!m_fds_retry.empty())
-	{
-		socket_v tmp = m_fds_retry;
-		for (socket_v::iterator it = tmp.begin(); it != tmp.end(); it++)
-		{
-			Socket *p = NULL;
-			{
-				socket_m::iterator itmp = m_sockets.find(*it);
-				if (itmp != m_sockets.end()) // found
-				{
-					p = itmp -> second;
-				}
-				else
-				{
-					LogError(NULL, "GetSocket/handler/7", (int)*it, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
-				}
-			}
-			if (p)
-			{
-//				if (p -> RetryClientConnect())
-				{
-					TcpSocket *tcp = dynamic_cast<TcpSocket *>(p);
-					SOCKET nn = *it; //(*it3).first;
-					tcp -> SetRetryClientConnect(false);
-DEB(					fprintf(stderr, "Close() before retry client connect\n");)
-					p -> Close(); // removes from m_fds_retry
-					std::auto_ptr<SocketAddress> ad = p -> GetClientRemoteAddress();
-					if (ad.get())
-					{
-						tcp -> Open(*ad);
-					}
-					else
-					{
-						LogError(p, "RetryClientConnect", 0, "no address", LOG_LEVEL_ERROR);
-					}
-					Add(p);
-					m_fds_erase.push_back(nn);
-				}
-			}
-		}
-	}
-	// check close and delete - conditional event
-	if (!m_fds_close.empty())
-	{
-		socket_v tmp = m_fds_close;
-DEB(		fprintf(stderr, "m_fds_close.size() == %d\n", (int)m_fds_close.size());)
-		for (socket_v::iterator it = tmp.begin(); it != tmp.end(); it++)
-		{
-			Socket *p = NULL;
-			{
-				socket_m::iterator itmp = m_sockets.find(*it);
-				if (itmp != m_sockets.end()) // found
-				{
-					p = itmp -> second;
-				}
-				else
-				{
-					itmp = m_add.find(*it);
-					if (itmp != m_add.end())
-					{
-						p = itmp -> second;
-					}
-					else
-					{
-						LogError(NULL, "GetSocket/handler/8", (int)*it, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
-					}
-				}
-			}
-			if (p)
-			{
-//				if (p -> CloseAndDelete() )
-				{
-					TcpSocket *tcp = dynamic_cast<TcpSocket *>(p);
-					// new graceful tcp - flush and close timeout 5s
-					if (tcp && p -> IsConnected() && tcp -> GetFlushBeforeClose() && 
+    // check Connecting - connection timeout - conditional event
+    if (m_fds_timeout.size())
+    {
+        time_t tnow = time(NULL);
+        if (tnow != m_tlast)
+        {
+            socket_v tmp = m_fds_timeout;
+DEB(            fprintf(stderr, "Checking %d socket(s) for timeout\n", tmp.size());)
+            for (socket_v::iterator it = tmp.begin(); it != tmp.end(); it++)
+            {
+                Socket *p = NULL;
+                {
+                    socket_m::iterator itmp = m_sockets.find(*it);
+                    if (itmp != m_sockets.end()) // found
+                    {
+                        p = itmp -> second;
+                    }
+                    else
+                    {
+                        itmp = m_add.find(*it);
+                        if (itmp != m_add.end())
+                        {
+                            p = itmp -> second;
+                        }
+                        else
+                        {
+                            LogError(NULL, "GetSocket/handler/6", (int)*it, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
+                        }
+                    }
+                }
+                if (p)
+                {
+                    if (p -> Timeout(tnow))
+                    {
+                        StreamSocket *scp = dynamic_cast<StreamSocket *>(p);
+                        if (scp && scp -> Connecting())
+                            p -> OnConnectTimeout();
+                        else
+                            p -> OnTimeout();
+                        p -> SetTimeout(0);
+                    }
+                }
+            }
+            m_tlast = tnow;
+        } // tnow != tlast
+    }
+    // check retry client connect - EVENT
+    if (!m_fds_retry.empty())
+    {
+        socket_v tmp = m_fds_retry;
+        for (socket_v::iterator it = tmp.begin(); it != tmp.end(); it++)
+        {
+            Socket *p = NULL;
+            {
+                socket_m::iterator itmp = m_sockets.find(*it);
+                if (itmp != m_sockets.end()) // found
+                {
+                    p = itmp -> second;
+                }
+                else
+                {
+                    LogError(NULL, "GetSocket/handler/7", (int)*it, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
+                }
+            }
+            if (p)
+            {
+//              if (p -> RetryClientConnect())
+                {
+                    TcpSocket *tcp = dynamic_cast<TcpSocket *>(p);
+                    SOCKET nn = *it; //(*it3).first;
+                    tcp -> SetRetryClientConnect(false);
+DEB(                    fprintf(stderr, "Close() before retry client connect\n");)
+                    p -> Close(); // removes from m_fds_retry
+                    std::auto_ptr<SocketAddress> ad = p -> GetClientRemoteAddress();
+                    if (ad.get())
+                    {
+                        tcp -> Open(*ad);
+                    }
+                    else
+                    {
+                        LogError(p, "RetryClientConnect", 0, "no address", LOG_LEVEL_ERROR);
+                    }
+                    Add(p);
+                    m_fds_erase.push_back(nn);
+                }
+            }
+        }
+    }
+    // check close and delete - conditional event
+    if (!m_fds_close.empty())
+    {
+        socket_v tmp = m_fds_close;
+DEB(        fprintf(stderr, "m_fds_close.size() == %d\n", (int)m_fds_close.size());)
+        for (socket_v::iterator it = tmp.begin(); it != tmp.end(); it++)
+        {
+            Socket *p = NULL;
+            {
+                socket_m::iterator itmp = m_sockets.find(*it);
+                if (itmp != m_sockets.end()) // found
+                {
+                    p = itmp -> second;
+                }
+                else
+                {
+                    itmp = m_add.find(*it);
+                    if (itmp != m_add.end())
+                    {
+                        p = itmp -> second;
+                    }
+                    else
+                    {
+                        LogError(NULL, "GetSocket/handler/8", (int)*it, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
+                    }
+                }
+            }
+            if (p)
+            {
+//              if (p -> CloseAndDelete() )
+                {
+                    TcpSocket *tcp = dynamic_cast<TcpSocket *>(p);
+                    // new graceful tcp - flush and close timeout 5s
+                    if (tcp && p -> IsConnected() && tcp -> GetFlushBeforeClose() &&
 #ifdef HAVE_OPENSSL
-						!tcp -> IsSSL() && 
+                        !tcp -> IsSSL() &&
 #endif
-						p -> TimeSinceClose() < 5)
-					{
-DEB(						fprintf(stderr, " close(1)\n");)
-						if (tcp -> GetOutputLength())
-						{
-							LogError(p, "Closing", (int)tcp -> GetOutputLength(), "Sending all data before closing", LOG_LEVEL_INFO);
-						}
-						else // shutdown write when output buffer is empty
-						if (!(tcp -> GetShutdown() & SHUT_WR))
-						{
-							SOCKET nn = *it;
-							if (nn != INVALID_SOCKET && shutdown(nn, SHUT_WR) == -1)
-							{
-								LogError(p, "graceful shutdown", Errno, StrError(Errno), LOG_LEVEL_ERROR);
-							}
-							tcp -> SetShutdown(SHUT_WR);
-						}
-					}
-					else
+                        p -> TimeSinceClose() < 5)
+                    {
+DEB(                        fprintf(stderr, " close(1)\n");)
+                        if (tcp -> GetOutputLength())
+                        {
+                            LogError(p, "Closing", (int)tcp -> GetOutputLength(), "Sending all data before closing", LOG_LEVEL_INFO);
+                        }
+                        else // shutdown write when output buffer is empty
+                        if (!(tcp -> GetShutdown() & SHUT_WR))
+                        {
+                            SOCKET nn = *it;
+                            if (nn != INVALID_SOCKET && shutdown(nn, SHUT_WR) == -1)
+                            {
+                                LogError(p, "graceful shutdown", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+                            }
+                            tcp -> SetShutdown(SHUT_WR);
+                        }
+                    }
+                    else
 #ifdef ENABLE_RECONNECT
-					if (tcp && p -> IsConnected() && tcp -> Reconnect())
-					{
-						SOCKET nn = *it; //(*it3).first;
-DEB(						fprintf(stderr, " close(2) fd %d\n", nn);)
-						p -> SetCloseAndDelete(false);
-						tcp -> SetIsReconnect();
-						p -> SetConnected(false);
-DEB(						fprintf(stderr, "Close() before reconnect\n");)
-						p -> Close(); // dispose of old file descriptor (Open creates a new)
-						p -> OnDisconnect();
-						std::auto_ptr<SocketAddress> ad = p -> GetClientRemoteAddress();
-						if (ad.get())
-						{
-							tcp -> Open(*ad);
-						}
-						else
-						{
-							LogError(p, "Reconnect", 0, "no address", LOG_LEVEL_ERROR);
-						}
-						tcp -> ResetConnectionRetries();
-						Add(p);
-						m_fds_erase.push_back(nn);
-					}
-					else
+                    if (tcp && p -> IsConnected() && tcp -> Reconnect())
+                    {
+                        SOCKET nn = *it; //(*it3).first;
+DEB(                        fprintf(stderr, " close(2) fd %d\n", nn);)
+                        p -> SetCloseAndDelete(false);
+                        tcp -> SetIsReconnect();
+                        p -> SetConnected(false);
+DEB(                        fprintf(stderr, "Close() before reconnect\n");)
+                        p -> Close(); // dispose of old file descriptor (Open creates a new)
+                        p -> OnDisconnect();
+                        std::auto_ptr<SocketAddress> ad = p -> GetClientRemoteAddress();
+                        if (ad.get())
+                        {
+                            tcp -> Open(*ad);
+                        }
+                        else
+                        {
+                            LogError(p, "Reconnect", 0, "no address", LOG_LEVEL_ERROR);
+                        }
+                        tcp -> ResetConnectionRetries();
+                        Add(p);
+                        m_fds_erase.push_back(nn);
+                    }
+                    else
 #endif
-					{
-						SOCKET nn = *it; //(*it3).first;
-DEB(						fprintf(stderr, " close(3) fd %d GetSocket() %d\n", nn, p -> GetSocket());)
-						if (tcp && p -> IsConnected() && tcp -> GetOutputLength())
-						{
-							LogError(p, "Closing", (int)tcp -> GetOutputLength(), "Closing socket while data still left to send", LOG_LEVEL_WARNING);
-						}
+                    {
+                        SOCKET nn = *it; //(*it3).first;
+DEB(                        fprintf(stderr, " close(3) fd %d GetSocket() %d\n", nn, p -> GetSocket());)
+                        if (tcp && p -> IsConnected() && tcp -> GetOutputLength())
+                        {
+                            LogError(p, "Closing", (int)tcp -> GetOutputLength(), "Closing socket while data still left to send", LOG_LEVEL_WARNING);
+                        }
 #ifdef ENABLE_POOL
-						if (p -> Retain() && !p -> Lost())
-						{
-							PoolSocket *p2 = new PoolSocket(*this, p);
-							p2 -> SetDeleteByHandler();
-							Add(p2);
-							//
-							p -> SetCloseAndDelete(false); // added - remove from m_fds_close
-						}
-						else
+                        if (p -> Retain() && !p -> Lost())
+                        {
+                            PoolSocket *p2 = new PoolSocket(*this, p);
+                            p2 -> SetDeleteByHandler();
+                            Add(p2);
+                            //
+                            p -> SetCloseAndDelete(false); // added - remove from m_fds_close
+                        }
+                        else
 #endif // ENABLE_POOL
-						{
-							Set(p -> GetSocket(),false,false,false);
-DEB(							fprintf(stderr, "Close() before OnDelete\n");)
-							p -> Close();
-						}
-						p -> OnDelete();
-						if (p -> DeleteByHandler())
-						{
-							p -> SetErasedByHandler();
-						}
-						m_fds_erase.push_back(nn);
-					}
-				}
-			}
-		}
-	}
-
-	// check erased sockets
-	bool check_max_fd = false;
-	while (!m_fds_erase.empty())
-	{
-		socket_v::iterator it = m_fds_erase.begin();
-		SOCKET nn = *it;
+                        {
+                            Set(p -> GetSocket(),false,false,false);
+DEB(                            fprintf(stderr, "Close() before OnDelete\n");)
+                            p -> Close();
+                        }
+                        p -> OnDelete();
+                        if (p -> DeleteByHandler())
+                        {
+                            p -> SetErasedByHandler();
+                        }
+                        m_fds_erase.push_back(nn);
+                    }
+                }
+            }
+        }
+    }
+
+    // check erased sockets
+    bool check_max_fd = false;
+    while (!m_fds_erase.empty())
+    {
+        socket_v::iterator it = m_fds_erase.begin();
+        SOCKET nn = *it;
 #ifdef ENABLE_DETACH
-		{
-			for (socket_v::iterator it = m_fds_detach.begin(); it != m_fds_detach.end(); it++)
-			{
-				if (*it == nn)
-				{
-					m_fds_detach.erase(it);
-					break;
-				}
-			}
-		}
+        {
+            for (socket_v::iterator it = m_fds_detach.begin(); it != m_fds_detach.end(); it++)
+            {
+                if (*it == nn)
+                {
+                    m_fds_detach.erase(it);
+                    break;
+                }
+            }
+        }
 #endif
-		{
-			for (socket_v::iterator it = m_fds.begin(); it != m_fds.end(); it++)
-			{
-				if (*it == nn)
-				{
-					m_fds.erase(it);
-					break;
-				}
-			}
-		}
-		{
-			socket_m::iterator it = m_sockets.find(nn);
-			if (it != m_sockets.end())
-			{
-				Socket *p = it -> second;
-				/* Sometimes a SocketThread class can finish its run before the master
-				   sockethandler gets here. In that case, the SocketThread has set the
-				   'ErasedByHandler' flag on the socket which will make us end up with a
-				   double delete on the socket instance. 
-				   The fix is to make sure that the master sockethandler only can delete
-				   non-detached sockets, and a slave sockethandler only can delete
-				   detach sockets. */
-				if (p -> ErasedByHandler()
+        {
+            for (socket_v::iterator it = m_fds.begin(); it != m_fds.end(); it++)
+            {
+                if (*it == nn)
+                {
+                    m_fds.erase(it);
+                    break;
+                }
+            }
+        }
+        {
+            socket_m::iterator it = m_sockets.find(nn);
+            if (it != m_sockets.end())
+            {
+                Socket *p = it -> second;
+                /* Sometimes a SocketThread class can finish its run before the master
+                   sockethandler gets here. In that case, the SocketThread has set the
+                   'ErasedByHandler' flag on the socket which will make us end up with a
+                   double delete on the socket instance.
+                   The fix is to make sure that the master sockethandler only can delete
+                   non-detached sockets, and a slave sockethandler only can delete
+                   detach sockets. */
+                if (p -> ErasedByHandler()
 #ifdef ENABLE_DETACH
-					&& !(m_slave ^ p -> IsDetached()) 
+                    && !(m_slave ^ p -> IsDetached())
 #endif
-					)
-				{
+                    )
+                {
 #ifdef ENABLE_TRIGGERS
-					bool again = false;
-					do
-					{
-						again = false;
-						for (std::map<int, Socket *>::iterator it = m_trigger_src.begin(); it != m_trigger_src.end(); it++)
-						{
-							int id = it -> first;
-							Socket *src = it -> second;
-							if (src == p)
-							{
-								for (std::map<Socket *, bool>::iterator it = m_trigger_dst[id].begin(); it != m_trigger_dst[id].end(); it++)
-								{
-									Socket *dst = it -> first;
-									if (Valid(dst))
-									{
-										dst -> OnCancelled(id);
-									}
-								}
-								m_trigger_src.erase(m_trigger_src.find(id));
-								m_trigger_dst.erase(m_trigger_dst.find(id));
-								again = true;
-								break;
-							}
-						}
-					} while (again);
+                    bool again = false;
+                    do
+                    {
+                        again = false;
+                        for (std::map<int, Socket *>::iterator it = m_trigger_src.begin(); it != m_trigger_src.end(); it++)
+                        {
+                            int id = it -> first;
+                            Socket *src = it -> second;
+                            if (src == p)
+                            {
+                                for (std::map<Socket *, bool>::iterator it = m_trigger_dst[id].begin(); it != m_trigger_dst[id].end(); it++)
+                                {
+                                    Socket *dst = it -> first;
+                                    if (Valid(dst))
+                                    {
+                                        dst -> OnCancelled(id);
+                                    }
+                                }
+                                m_trigger_src.erase(m_trigger_src.find(id));
+                                m_trigger_dst.erase(m_trigger_dst.find(id));
+                                again = true;
+                                break;
+                            }
+                        }
+                    } while (again);
 #endif
-					delete p;
-				}
-				m_sockets.erase(it);
-			}
-		}
-		m_fds_erase.erase(it);
-		check_max_fd = true;
-	}
-	// calculate max file descriptor for select() call
-	if (check_max_fd)
-	{
-		m_maxsock = 0;
-		for (socket_v::iterator it = m_fds.begin(); it != m_fds.end(); it++)
-		{
-			SOCKET s = *it;
-			m_maxsock = s > m_maxsock ? s : m_maxsock;
-		}
-	}
-	// remove Add's that fizzed
-	while (!m_delete.empty())
-	{
-		std::list<Socket *>::iterator it = m_delete.begin();
-		Socket *p = *it;
-		p -> OnDelete();
-		m_delete.erase(it);
-		if (p -> DeleteByHandler()
+                    delete p;
+                }
+                m_sockets.erase(it);
+            }
+        }
+        m_fds_erase.erase(it);
+        check_max_fd = true;
+    }
+    // calculate max file descriptor for select() call
+    if (check_max_fd)
+    {
+        m_maxsock = 0;
+        for (socket_v::iterator it = m_fds.begin(); it != m_fds.end(); it++)
+        {
+            SOCKET s = *it;
+            m_maxsock = s > m_maxsock ? s : m_maxsock;
+        }
+    }
+    // remove Add's that fizzed
+    while (!m_delete.empty())
+    {
+        std::list<Socket *>::iterator it = m_delete.begin();
+        Socket *p = *it;
+        p -> OnDelete();
+        m_delete.erase(it);
+        if (p -> DeleteByHandler()
 #ifdef ENABLE_DETACH
-			&& !(m_slave ^ p -> IsDetached()) 
+            && !(m_slave ^ p -> IsDetached())
 #endif
-			)
-		{
-			p -> SetErasedByHandler();
+            )
+        {
+            p -> SetErasedByHandler();
 #ifdef ENABLE_TRIGGERS
-			bool again = false;
-			do
-			{
-				again = false;
-				for (std::map<int, Socket *>::iterator it = m_trigger_src.begin(); it != m_trigger_src.end(); it++)
-				{
-					int id = it -> first;
-					Socket *src = it -> second;
-					if (src == p)
-					{
-						for (std::map<Socket *, bool>::iterator it = m_trigger_dst[id].begin(); it != m_trigger_dst[id].end(); it++)
-						{
-							Socket *dst = it -> first;
-							if (Valid(dst))
-							{
-								dst -> OnCancelled(id);
-							}
-						}
-						m_trigger_src.erase(m_trigger_src.find(id));
-						m_trigger_dst.erase(m_trigger_dst.find(id));
-						again = true;
-						break;
-					}
-				}
-			} while (again);
+            bool again = false;
+            do
+            {
+                again = false;
+                for (std::map<int, Socket *>::iterator it = m_trigger_src.begin(); it != m_trigger_src.end(); it++)
+                {
+                    int id = it -> first;
+                    Socket *src = it -> second;
+                    if (src == p)
+                    {
+                        for (std::map<Socket *, bool>::iterator it = m_trigger_dst[id].begin(); it != m_trigger_dst[id].end(); it++)
+                        {
+                            Socket *dst = it -> first;
+                            if (Valid(dst))
+                            {
+                                dst -> OnCancelled(id);
+                            }
+                        }
+                        m_trigger_src.erase(m_trigger_src.find(id));
+                        m_trigger_dst.erase(m_trigger_dst.find(id));
+                        again = true;
+                        break;
+                    }
+                }
+            } while (again);
 #endif
-			delete p;
-		}
-	}
-	return n;
+            delete p;
+        }
+    }
+    return n;
 }
 
 
 #ifdef ENABLE_RESOLVER
 bool SocketHandler::Resolving(Socket *p0)
 {
-	std::map<Socket *, bool>::iterator it = m_resolve_q.find(p0);
-	return it != m_resolve_q.end();
+    std::map<Socket *, bool>::iterator it = m_resolve_q.find(p0);
+    return it != m_resolve_q.end();
 }
 #endif
 
 
 bool SocketHandler::Valid(Socket *p0)
 {
-	for (socket_m::iterator it = m_sockets.begin(); it != m_sockets.end(); it++)
-	{
-		Socket *p = it -> second;
-		if (p0 == p)
-			return true;
-	}
-	return false;
+    for (socket_m::iterator it = m_sockets.begin(); it != m_sockets.end(); it++)
+    {
+        Socket *p = it -> second;
+        if (p0 == p)
+            return true;
+    }
+    return false;
 }
 
 
 bool SocketHandler::OkToAccept(Socket *)
 {
-	return true;
+    return true;
 }
 
 
@@ -998,32 +998,32 @@ printf(" m_sockets : %d\n", m_sockets.size());
 printf(" m_add     : %d\n", m_add.size());
 printf(" m_delete  : %d\n", m_delete.size());
 */
-	return m_sockets.size() + m_add.size() + m_delete.size();
+    return m_sockets.size() + m_add.size() + m_delete.size();
 }
 
 
 #ifdef ENABLE_SOCKS4
 void SocketHandler::SetSocks4Host(ipaddr_t a)
 {
-	m_socks4_host = a;
+    m_socks4_host = a;
 }
 
 
 void SocketHandler::SetSocks4Host(const std::string& host)
 {
-	Utility::u2ip(host, m_socks4_host);
+    Utility::u2ip(host, m_socks4_host);
 }
 
 
 void SocketHandler::SetSocks4Port(port_t port)
 {
-	m_socks4_port = port;
+    m_socks4_port = port;
 }
 
 
 void SocketHandler::SetSocks4Userid(const std::string& id)
 {
-	m_socks4_userid = id;
+    m_socks4_userid = id;
 }
 #endif
 
@@ -1031,94 +1031,94 @@ void SocketHandler::SetSocks4Userid(const std::string& id)
 #ifdef ENABLE_RESOLVER
 int SocketHandler::Resolve(Socket *p,const std::string& host,port_t port)
 {
-	// check cache
-	ResolvSocket *resolv = new ResolvSocket(*this, p, host, port);
-	resolv -> SetId(++m_resolv_id);
-	resolv -> SetDeleteByHandler();
-	ipaddr_t local;
-	Utility::u2ip("127.0.0.1", local);
-	if (!resolv -> Open(local, m_resolver_port))
-	{
-		LogError(resolv, "Resolve", -1, "Can't connect to local resolve server", LOG_LEVEL_FATAL);
-	}
-	Add(resolv);
-	m_resolve_q[p] = true;
-DEB(	fprintf(stderr, " *** Resolve '%s:%d' id#%d  m_resolve_q size: %d  p: %p\n", host.c_str(), port, resolv -> GetId(), m_resolve_q.size(), p);)
-	return resolv -> GetId();
+    // check cache
+    ResolvSocket *resolv = new ResolvSocket(*this, p, host, port);
+    resolv -> SetId(++m_resolv_id);
+    resolv -> SetDeleteByHandler();
+    ipaddr_t local;
+    Utility::u2ip("127.0.0.1", local);
+    if (!resolv -> Open(local, m_resolver_port))
+    {
+        LogError(resolv, "Resolve", -1, "Can't connect to local resolve server", LOG_LEVEL_FATAL);
+    }
+    Add(resolv);
+    m_resolve_q[p] = true;
+DEB(    fprintf(stderr, " *** Resolve '%s:%d' id#%d  m_resolve_q size: %d  p: %p\n", host.c_str(), port, resolv -> GetId(), m_resolve_q.size(), p);)
+    return resolv -> GetId();
 }
 
 
 #ifdef ENABLE_IPV6
 int SocketHandler::Resolve6(Socket *p,const std::string& host,port_t port)
 {
-	// check cache
-	ResolvSocket *resolv = new ResolvSocket(*this, p, host, port, true);
-	resolv -> SetId(++m_resolv_id);
-	resolv -> SetDeleteByHandler();
-	ipaddr_t local;
-	Utility::u2ip("127.0.0.1", local);
-	if (!resolv -> Open(local, m_resolver_port))
-	{
-		LogError(resolv, "Resolve", -1, "Can't connect to local resolve server", LOG_LEVEL_FATAL);
-	}
-	Add(resolv);
-	m_resolve_q[p] = true;
-	return resolv -> GetId();
+    // check cache
+    ResolvSocket *resolv = new ResolvSocket(*this, p, host, port, true);
+    resolv -> SetId(++m_resolv_id);
+    resolv -> SetDeleteByHandler();
+    ipaddr_t local;
+    Utility::u2ip("127.0.0.1", local);
+    if (!resolv -> Open(local, m_resolver_port))
+    {
+        LogError(resolv, "Resolve", -1, "Can't connect to local resolve server", LOG_LEVEL_FATAL);
+    }
+    Add(resolv);
+    m_resolve_q[p] = true;
+    return resolv -> GetId();
 }
 #endif
 
 
 int SocketHandler::Resolve(Socket *p,ipaddr_t a)
 {
-	// check cache
-	ResolvSocket *resolv = new ResolvSocket(*this, p, a);
-	resolv -> SetId(++m_resolv_id);
-	resolv -> SetDeleteByHandler();
-	ipaddr_t local;
-	Utility::u2ip("127.0.0.1", local);
-	if (!resolv -> Open(local, m_resolver_port))
-	{
-		LogError(resolv, "Resolve", -1, "Can't connect to local resolve server", LOG_LEVEL_FATAL);
-	}
-	Add(resolv);
-	m_resolve_q[p] = true;
-	return resolv -> GetId();
+    // check cache
+    ResolvSocket *resolv = new ResolvSocket(*this, p, a);
+    resolv -> SetId(++m_resolv_id);
+    resolv -> SetDeleteByHandler();
+    ipaddr_t local;
+    Utility::u2ip("127.0.0.1", local);
+    if (!resolv -> Open(local, m_resolver_port))
+    {
+        LogError(resolv, "Resolve", -1, "Can't connect to local resolve server", LOG_LEVEL_FATAL);
+    }
+    Add(resolv);
+    m_resolve_q[p] = true;
+    return resolv -> GetId();
 }
 
 
 #ifdef ENABLE_IPV6
 int SocketHandler::Resolve(Socket *p,in6_addr& a)
 {
-	// check cache
-	ResolvSocket *resolv = new ResolvSocket(*this, p, a);
-	resolv -> SetId(++m_resolv_id);
-	resolv -> SetDeleteByHandler();
-	ipaddr_t local;
-	Utility::u2ip("127.0.0.1", local);
-	if (!resolv -> Open(local, m_resolver_port))
-	{
-		LogError(resolv, "Resolve", -1, "Can't connect to local resolve server", LOG_LEVEL_FATAL);
-	}
-	Add(resolv);
-	m_resolve_q[p] = true;
-	return resolv -> GetId();
+    // check cache
+    ResolvSocket *resolv = new ResolvSocket(*this, p, a);
+    resolv -> SetId(++m_resolv_id);
+    resolv -> SetDeleteByHandler();
+    ipaddr_t local;
+    Utility::u2ip("127.0.0.1", local);
+    if (!resolv -> Open(local, m_resolver_port))
+    {
+        LogError(resolv, "Resolve", -1, "Can't connect to local resolve server", LOG_LEVEL_FATAL);
+    }
+    Add(resolv);
+    m_resolve_q[p] = true;
+    return resolv -> GetId();
 }
 #endif
 
 
 void SocketHandler::EnableResolver(port_t port)
 {
-	if (!m_resolver)
-	{
-		m_resolver_port = port;
-		m_resolver = new ResolvServer(port);
-	}
+    if (!m_resolver)
+    {
+        m_resolver_port = port;
+        m_resolver = new ResolvServer(port);
+    }
 }
 
 
 bool SocketHandler::ResolverReady()
 {
-	return m_resolver ? m_resolver -> Ready() : false;
+    return m_resolver ? m_resolver -> Ready() : false;
 }
 #endif // ENABLE_RESOLVER
 
@@ -1126,45 +1126,45 @@ bool SocketHandler::ResolverReady()
 #ifdef ENABLE_SOCKS4
 void SocketHandler::SetSocks4TryDirect(bool x)
 {
-	m_bTryDirect = x;
+    m_bTryDirect = x;
 }
 
 
 ipaddr_t SocketHandler::GetSocks4Host()
 {
-	return m_socks4_host;
+    return m_socks4_host;
 }
 
 
 port_t SocketHandler::GetSocks4Port()
 {
-	return m_socks4_port;
+    return m_socks4_port;
 }
 
 
 const std::string& SocketHandler::GetSocks4Userid()
 {
-	return m_socks4_userid;
+    return m_socks4_userid;
 }
 
 
 bool SocketHandler::Socks4TryDirect()
 {
-	return m_bTryDirect;
+    return m_bTryDirect;
 }
 #endif
 
 
 #ifdef ENABLE_RESOLVER
-bool SocketHandler::ResolverEnabled() 
-{ 
-	return m_resolver ? true : false; 
+bool SocketHandler::ResolverEnabled()
+{
+    return m_resolver ? true : false;
 }
 
 
-port_t SocketHandler::GetResolverPort() 
-{ 
-	return m_resolver_port; 
+port_t SocketHandler::GetResolverPort()
+{
+    return m_resolver_port;
 }
 #endif // ENABLE_RESOLVER
 
@@ -1172,35 +1172,35 @@ port_t SocketHandler::GetResolverPort()
 #ifdef ENABLE_POOL
 ISocketHandler::PoolSocket *SocketHandler::FindConnection(int type,const std::string& protocol,SocketAddress& ad)
 {
-	for (socket_m::iterator it = m_sockets.begin(); it != m_sockets.end() && !m_sockets.empty(); it++)
-	{
-		PoolSocket *pools = dynamic_cast<PoolSocket *>(it -> second);
-		if (pools)
-		{
-			if (pools -> GetSocketType() == type &&
-			    pools -> GetSocketProtocol() == protocol &&
-// %!			    pools -> GetClientRemoteAddress() &&
-			    *pools -> GetClientRemoteAddress() == ad)
-			{
-				m_sockets.erase(it);
-				pools -> SetRetain(); // avoid Close in Socket destructor
-				return pools; // Caller is responsible that this socket is deleted
-			}
-		}
-	}
-	return NULL;
+    for (socket_m::iterator it = m_sockets.begin(); it != m_sockets.end() && !m_sockets.empty(); it++)
+    {
+        PoolSocket *pools = dynamic_cast<PoolSocket *>(it -> second);
+        if (pools)
+        {
+            if (pools -> GetSocketType() == type &&
+                pools -> GetSocketProtocol() == protocol &&
+// %!               pools -> GetClientRemoteAddress() &&
+                *pools -> GetClientRemoteAddress() == ad)
+            {
+                m_sockets.erase(it);
+                pools -> SetRetain(); // avoid Close in Socket destructor
+                return pools; // Caller is responsible that this socket is deleted
+            }
+        }
+    }
+    return NULL;
 }
 
 
 void SocketHandler::EnablePool(bool x)
 {
-	m_b_enable_pool = x;
+    m_b_enable_pool = x;
 }
 
 
-bool SocketHandler::PoolEnabled() 
-{ 
-	return m_b_enable_pool; 
+bool SocketHandler::PoolEnabled()
+{
+    return m_b_enable_pool;
 }
 #endif
 
@@ -1208,210 +1208,210 @@ bool SocketHandler::PoolEnabled()
 void SocketHandler::Remove(Socket *p)
 {
 #ifdef ENABLE_RESOLVER
-	std::map<Socket *, bool>::iterator it4 = m_resolve_q.find(p);
-	if (it4 != m_resolve_q.end())
-		m_resolve_q.erase(it4);
+    std::map<Socket *, bool>::iterator it4 = m_resolve_q.find(p);
+    if (it4 != m_resolve_q.end())
+        m_resolve_q.erase(it4);
 #endif
-	if (p -> ErasedByHandler())
-	{
-		return;
-	}
-	for (socket_m::iterator it = m_sockets.begin(); it != m_sockets.end(); it++)
-	{
-		if (it -> second == p)
-		{
-			LogError(p, "Remove", -1, "Socket destructor called while still in use", LOG_LEVEL_WARNING);
-			m_sockets.erase(it);
-			return;
-		}
-	}
-	for (socket_m::iterator it2 = m_add.begin(); it2 != m_add.end(); it2++)
-	{
-		if ((*it2).second == p)
-		{
-			LogError(p, "Remove", -2, "Socket destructor called while still in use", LOG_LEVEL_WARNING);
-			m_add.erase(it2);
-			return;
-		}
-	}
-	for (std::list<Socket *>::iterator it3 = m_delete.begin(); it3 != m_delete.end(); it3++)
-	{
-		if (*it3 == p)
-		{
-			LogError(p, "Remove", -3, "Socket destructor called while still in use", LOG_LEVEL_WARNING);
-			m_delete.erase(it3);
-			return;
-		}
-	}
+    if (p -> ErasedByHandler())
+    {
+        return;
+    }
+    for (socket_m::iterator it = m_sockets.begin(); it != m_sockets.end(); it++)
+    {
+        if (it -> second == p)
+        {
+            LogError(p, "Remove", -1, "Socket destructor called while still in use", LOG_LEVEL_WARNING);
+            m_sockets.erase(it);
+            return;
+        }
+    }
+    for (socket_m::iterator it2 = m_add.begin(); it2 != m_add.end(); it2++)
+    {
+        if ((*it2).second == p)
+        {
+            LogError(p, "Remove", -2, "Socket destructor called while still in use", LOG_LEVEL_WARNING);
+            m_add.erase(it2);
+            return;
+        }
+    }
+    for (std::list<Socket *>::iterator it3 = m_delete.begin(); it3 != m_delete.end(); it3++)
+    {
+        if (*it3 == p)
+        {
+            LogError(p, "Remove", -3, "Socket destructor called while still in use", LOG_LEVEL_WARNING);
+            m_delete.erase(it3);
+            return;
+        }
+    }
 }
 
 
 void SocketHandler::CheckSanity()
 {
-	CheckList(m_fds, "active sockets"); // active sockets
-	CheckList(m_fds_erase, "sockets to be erased"); // should always be empty anyway
-	CheckList(m_fds_callonconnect, "checklist CallOnConnect");
+    CheckList(m_fds, "active sockets"); // active sockets
+    CheckList(m_fds_erase, "sockets to be erased"); // should always be empty anyway
+    CheckList(m_fds_callonconnect, "checklist CallOnConnect");
 #ifdef ENABLE_DETACH
-	CheckList(m_fds_detach, "checklist Detach");
+    CheckList(m_fds_detach, "checklist Detach");
 #endif
-	CheckList(m_fds_timeout, "checklist Timeout");
-	CheckList(m_fds_retry, "checklist retry client connect");
-	CheckList(m_fds_close, "checklist close and delete");
+    CheckList(m_fds_timeout, "checklist Timeout");
+    CheckList(m_fds_retry, "checklist retry client connect");
+    CheckList(m_fds_close, "checklist close and delete");
 }
 
 
 void SocketHandler::CheckList(socket_v& ref,const std::string& listname)
 {
-	for (socket_v::iterator it = ref.begin(); it != ref.end(); it++)
-	{
-		SOCKET s = *it;
-		if (m_sockets.find(s) != m_sockets.end())
-			continue;
-		if (m_add.find(s) != m_add.end())
-			continue;
-		bool found = false;
-		for (std::list<Socket *>::iterator it = m_delete.begin(); it != m_delete.end(); it++)
-		{
-			Socket *p = *it;
-			if (p -> GetSocket() == s)
-			{
-				found = true;
-				break;
-			}
-		}
-		if (!found)
-		{
-			fprintf(stderr, "CheckList failed for \"%s\": fd %d\n", listname.c_str(), s);
-		}
-	}
+    for (socket_v::iterator it = ref.begin(); it != ref.end(); it++)
+    {
+        SOCKET s = *it;
+        if (m_sockets.find(s) != m_sockets.end())
+            continue;
+        if (m_add.find(s) != m_add.end())
+            continue;
+        bool found = false;
+        for (std::list<Socket *>::iterator it = m_delete.begin(); it != m_delete.end(); it++)
+        {
+            Socket *p = *it;
+            if (p -> GetSocket() == s)
+            {
+                found = true;
+                break;
+            }
+        }
+        if (!found)
+        {
+            fprintf(stderr, "CheckList failed for \"%s\": fd %d\n", listname.c_str(), s);
+        }
+    }
 }
 
 
 void SocketHandler::AddList(SOCKET s,list_t which_one,bool add)
 {
-	if (s == INVALID_SOCKET)
-	{
-DEB(		fprintf(stderr, "AddList:  invalid_socket\n");)
-		return;
-	}
-	socket_v& ref =
-		(which_one == LIST_CALLONCONNECT) ? m_fds_callonconnect :
+    if (s == INVALID_SOCKET)
+    {
+DEB(        fprintf(stderr, "AddList:  invalid_socket\n");)
+        return;
+    }
+    socket_v& ref =
+        (which_one == LIST_CALLONCONNECT) ? m_fds_callonconnect :
 #ifdef ENABLE_DETACH
-		(which_one == LIST_DETACH) ? m_fds_detach :
+        (which_one == LIST_DETACH) ? m_fds_detach :
 #endif
-		(which_one == LIST_TIMEOUT) ? m_fds_timeout :
-		(which_one == LIST_RETRY) ? m_fds_retry :
-		(which_one == LIST_CLOSE) ? m_fds_close : m_fds_close;
-	if (add)
-	{
+        (which_one == LIST_TIMEOUT) ? m_fds_timeout :
+        (which_one == LIST_RETRY) ? m_fds_retry :
+        (which_one == LIST_CLOSE) ? m_fds_close : m_fds_close;
+    if (add)
+    {
 #ifdef ENABLE_DETACH
-DEB(	fprintf(stderr, "AddList;  %5d: %s: %s\n", s, (which_one == LIST_CALLONCONNECT) ? "CallOnConnect" :
-		(which_one == LIST_DETACH) ? "Detach" :
-		(which_one == LIST_TIMEOUT) ? "Timeout" :
-		(which_one == LIST_RETRY) ? "Retry" :
-		(which_one == LIST_CLOSE) ? "Close" : "<undef>",
-		add ? "Add" : "Remove");)
+DEB(    fprintf(stderr, "AddList;  %5d: %s: %s\n", s, (which_one == LIST_CALLONCONNECT) ? "CallOnConnect" :
+        (which_one == LIST_DETACH) ? "Detach" :
+        (which_one == LIST_TIMEOUT) ? "Timeout" :
+        (which_one == LIST_RETRY) ? "Retry" :
+        (which_one == LIST_CLOSE) ? "Close" : "<undef>",
+        add ? "Add" : "Remove");)
 #else
-DEB(	fprintf(stderr, "AddList;  %5d: %s: %s\n", s, (which_one == LIST_CALLONCONNECT) ? "CallOnConnect" :
-		(which_one == LIST_TIMEOUT) ? "Timeout" :
-		(which_one == LIST_RETRY) ? "Retry" :
-		(which_one == LIST_CLOSE) ? "Close" : "<undef>",
-		add ? "Add" : "Remove");)
+DEB(    fprintf(stderr, "AddList;  %5d: %s: %s\n", s, (which_one == LIST_CALLONCONNECT) ? "CallOnConnect" :
+        (which_one == LIST_TIMEOUT) ? "Timeout" :
+        (which_one == LIST_RETRY) ? "Retry" :
+        (which_one == LIST_CLOSE) ? "Close" : "<undef>",
+        add ? "Add" : "Remove");)
 #endif
-	}
-	if (add)
-	{
-		for (socket_v::iterator it = ref.begin(); it != ref.end(); it++)
-		{
-			if (*it == s) // already there
-			{
-				return;
-			}
-		}
-		ref.push_back(s);
-		return;
-	}
-	// remove
-	for (socket_v::iterator it = ref.begin(); it != ref.end(); it++)
-	{
-		if (*it == s)
-		{
-			ref.erase(it);
-			break;
-		}
-	}
-//DEB(	fprintf(stderr, "/AddList\n");)
+    }
+    if (add)
+    {
+        for (socket_v::iterator it = ref.begin(); it != ref.end(); it++)
+        {
+            if (*it == s) // already there
+            {
+                return;
+            }
+        }
+        ref.push_back(s);
+        return;
+    }
+    // remove
+    for (socket_v::iterator it = ref.begin(); it != ref.end(); it++)
+    {
+        if (*it == s)
+        {
+            ref.erase(it);
+            break;
+        }
+    }
+//DEB(  fprintf(stderr, "/AddList\n");)
 }
 
 
 #ifdef ENABLE_TRIGGERS
 int SocketHandler::TriggerID(Socket *src)
 {
-	int id = m_next_trigger_id++;
-	m_trigger_src[id] = src;
-	return id;
+    int id = m_next_trigger_id++;
+    m_trigger_src[id] = src;
+    return id;
 }
 
 
 bool SocketHandler::Subscribe(int id, Socket *dst)
 {
-	if (m_trigger_src.find(id) != m_trigger_src.end())
-	{
-		std::map<Socket *, bool>::iterator it = m_trigger_dst[id].find(dst);
-		if (it != m_trigger_dst[id].end())
-		{
-			m_trigger_dst[id][dst] = true;
-			return true;
-		}
-		LogError(dst, "Subscribe", id, "Already subscribed", LOG_LEVEL_INFO);
-		return false;
-	}
-	LogError(dst, "Subscribe", id, "Trigger id not found", LOG_LEVEL_INFO);
-	return false;
+    if (m_trigger_src.find(id) != m_trigger_src.end())
+    {
+        std::map<Socket *, bool>::iterator it = m_trigger_dst[id].find(dst);
+        if (it != m_trigger_dst[id].end())
+        {
+            m_trigger_dst[id][dst] = true;
+            return true;
+        }
+        LogError(dst, "Subscribe", id, "Already subscribed", LOG_LEVEL_INFO);
+        return false;
+    }
+    LogError(dst, "Subscribe", id, "Trigger id not found", LOG_LEVEL_INFO);
+    return false;
 }
 
 
 bool SocketHandler::Unsubscribe(int id, Socket *dst)
 {
-	if (m_trigger_src.find(id) != m_trigger_src.end())
-	{
-		std::map<Socket *, bool>::iterator it = m_trigger_dst[id].find(dst);
-		if (it != m_trigger_dst[id].end())
-		{
-			m_trigger_dst[id].erase(it);
-			return true;
-		}
-		LogError(dst, "Unsubscribe", id, "Not subscribed", LOG_LEVEL_INFO);
-		return false;
-	}
-	LogError(dst, "Unsubscribe", id, "Trigger id not found", LOG_LEVEL_INFO);
-	return false;
+    if (m_trigger_src.find(id) != m_trigger_src.end())
+    {
+        std::map<Socket *, bool>::iterator it = m_trigger_dst[id].find(dst);
+        if (it != m_trigger_dst[id].end())
+        {
+            m_trigger_dst[id].erase(it);
+            return true;
+        }
+        LogError(dst, "Unsubscribe", id, "Not subscribed", LOG_LEVEL_INFO);
+        return false;
+    }
+    LogError(dst, "Unsubscribe", id, "Trigger id not found", LOG_LEVEL_INFO);
+    return false;
 }
 
 
 void SocketHandler::Trigger(int id, Socket::TriggerData& data, bool erase)
 {
-	if (m_trigger_src.find(id) != m_trigger_src.end())
-	{
-		data.SetSource( m_trigger_src[id] );
-		for (std::map<Socket *, bool>::iterator it = m_trigger_dst[id].begin(); it != m_trigger_dst[id].end(); it++)
-		{
-			Socket *dst = it -> first;
-			if (Valid(dst))
-			{
-				dst -> OnTrigger(id, data);
-			}
-		}
-		if (erase)
-		{
-			m_trigger_src.erase(m_trigger_src.find(id));
-			m_trigger_dst.erase(m_trigger_dst.find(id));
-		}
-	}
-	else
-	{
-		LogError(NULL, "Trigger", id, "Trigger id not found", LOG_LEVEL_INFO);
-	}
+    if (m_trigger_src.find(id) != m_trigger_src.end())
+    {
+        data.SetSource( m_trigger_src[id] );
+        for (std::map<Socket *, bool>::iterator it = m_trigger_dst[id].begin(); it != m_trigger_dst[id].end(); it++)
+        {
+            Socket *dst = it -> first;
+            if (Valid(dst))
+            {
+                dst -> OnTrigger(id, data);
+            }
+        }
+        if (erase)
+        {
+            m_trigger_src.erase(m_trigger_src.find(id));
+            m_trigger_dst.erase(m_trigger_dst.find(id));
+        }
+    }
+    else
+    {
+        LogError(NULL, "Trigger", id, "Trigger id not found", LOG_LEVEL_INFO);
+    }
 }
 #endif // ENABLE_TRIGGERS
 
diff --git a/dep/src/sockets/StdoutLog.cpp b/dep/src/sockets/StdoutLog.cpp
index c01d8b8c215..93ae535e6d3 100644
--- a/dep/src/sockets/StdoutLog.cpp
+++ b/dep/src/sockets/StdoutLog.cpp
@@ -1,6 +1,6 @@
 /** \file StdoutLog.cpp
- **	\date  2004-06-01
- **	\author grymse@alhem.net
+ ** \date  2004-06-01
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2004-2007  Anders Hedstrom
@@ -8,7 +8,7 @@ Copyright (C) 2004-2007  Anders Hedstrom
 This library is made available under the terms of the GNU GPL.
 
 If you would like to use this library in a closed-source application,
-a separate license agreement is available. For information about 
+a separate license agreement is available. For information about
 the closed-source license agreement for the C++ sockets library,
 please visit http://www.alhem.net/Sockets/license.html and/or
 email license@alhem.net.
@@ -43,49 +43,49 @@ namespace SOCKETS_NAMESPACE {
 
 void StdoutLog::error(ISocketHandler *,Socket *sock,const std::string& call,int err,const std::string& sys_err,loglevel_t lvl)
 {
-	time_t t = time(NULL);
-	struct tm tp;
+    time_t t = time(NULL);
+    struct tm tp;
 #ifdef _WIN32
-	memcpy(&tp, localtime(&t), sizeof(tp));
+    memcpy(&tp, localtime(&t), sizeof(tp));
 #else
-	localtime_r(&t, &tp);
+    localtime_r(&t, &tp);
 #endif
-	std::string level;
-	
-	switch (lvl)
-	{
-	case LOG_LEVEL_WARNING:
-		level = "Warning";
-		break;
-	case LOG_LEVEL_ERROR:
-		level = "Error";
-		break;
-	case LOG_LEVEL_FATAL:
-		level = "Fatal";
-		break;
-	case LOG_LEVEL_INFO:
-		level = "Info";
-		break;
-	}
-	if (sock)
-	{
-		printf("%d-%02d-%02d %02d:%02d:%02d :: fd %d :: %s: %d %s (%s)\n",
-			tp.tm_year + 1900,
-			tp.tm_mon + 1,
-			tp.tm_mday,
-			tp.tm_hour,tp.tm_min,tp.tm_sec,
-			sock -> GetSocket(),
-			call.c_str(),err,sys_err.c_str(),level.c_str());
-	}
-	else
-	{
-		printf("%d-%02d-%02d %02d:%02d:%02d :: %s: %d %s (%s)\n",
-			tp.tm_year + 1900,
-			tp.tm_mon + 1,
-			tp.tm_mday,
-			tp.tm_hour,tp.tm_min,tp.tm_sec,
-			call.c_str(),err,sys_err.c_str(),level.c_str());
-	}
+    std::string level;
+
+    switch (lvl)
+    {
+    case LOG_LEVEL_WARNING:
+        level = "Warning";
+        break;
+    case LOG_LEVEL_ERROR:
+        level = "Error";
+        break;
+    case LOG_LEVEL_FATAL:
+        level = "Fatal";
+        break;
+    case LOG_LEVEL_INFO:
+        level = "Info";
+        break;
+    }
+    if (sock)
+    {
+        printf("%d-%02d-%02d %02d:%02d:%02d :: fd %d :: %s: %d %s (%s)\n",
+            tp.tm_year + 1900,
+            tp.tm_mon + 1,
+            tp.tm_mday,
+            tp.tm_hour,tp.tm_min,tp.tm_sec,
+            sock -> GetSocket(),
+            call.c_str(),err,sys_err.c_str(),level.c_str());
+    }
+    else
+    {
+        printf("%d-%02d-%02d %02d:%02d:%02d :: %s: %d %s (%s)\n",
+            tp.tm_year + 1900,
+            tp.tm_mon + 1,
+            tp.tm_mday,
+            tp.tm_hour,tp.tm_min,tp.tm_sec,
+            call.c_str(),err,sys_err.c_str(),level.c_str());
+    }
 }
 
 
diff --git a/dep/src/sockets/StreamSocket.cpp b/dep/src/sockets/StreamSocket.cpp
index 5c5780e3085..4412d498536 100644
--- a/dep/src/sockets/StreamSocket.cpp
+++ b/dep/src/sockets/StreamSocket.cpp
@@ -28,136 +28,136 @@ StreamSocket::~StreamSocket()
 
 void StreamSocket::SetConnecting(bool x)
 {
-	if (x != m_bConnecting)
-	{
-		m_bConnecting = x;
-		if (x)
-		{
-			SetTimeout( GetConnectTimeout() );
-		}
-		else
-		{
-			SetTimeout( 0 );
-		}
-	}
+    if (x != m_bConnecting)
+    {
+        m_bConnecting = x;
+        if (x)
+        {
+            SetTimeout( GetConnectTimeout() );
+        }
+        else
+        {
+            SetTimeout( 0 );
+        }
+    }
 }
 
 
 bool StreamSocket::Connecting()
 {
-	return m_bConnecting;
+    return m_bConnecting;
 }
 
 
 bool StreamSocket::Ready()
 {
-	if (GetSocket() != INVALID_SOCKET && !Connecting() && !CloseAndDelete())
-		return true;
-	return false;
+    if (GetSocket() != INVALID_SOCKET && !Connecting() && !CloseAndDelete())
+        return true;
+    return false;
 }
 
 
 void StreamSocket::SetConnectTimeout(int x)
 {
-	m_connect_timeout = x;
+    m_connect_timeout = x;
 }
 
 
 int StreamSocket::GetConnectTimeout()
 {
-	return m_connect_timeout;
+    return m_connect_timeout;
 }
 
 
 void StreamSocket::SetFlushBeforeClose(bool x)
 {
-	m_flush_before_close = x;
+    m_flush_before_close = x;
 }
 
 
 bool StreamSocket::GetFlushBeforeClose()
 {
-	return m_flush_before_close;
+    return m_flush_before_close;
 }
 
 
 int StreamSocket::GetConnectionRetry()
 {
-	return m_connection_retry;
+    return m_connection_retry;
 }
 
 
 void StreamSocket::SetConnectionRetry(int x)
 {
-	m_connection_retry = x;
+    m_connection_retry = x;
 }
 
 
 int StreamSocket::GetConnectionRetries()
 {
-	return m_retries;
+    return m_retries;
 }
 
 
 void StreamSocket::IncreaseConnectionRetries()
 {
-	m_retries++;
+    m_retries++;
 }
 
 
 void StreamSocket::ResetConnectionRetries()
 {
-	m_retries = 0;
+    m_retries = 0;
 }
 
 
 void StreamSocket::SetCallOnConnect(bool x)
 {
-	Handler().AddList(GetSocket(), LIST_CALLONCONNECT, x);
-	m_call_on_connect = x;
+    Handler().AddList(GetSocket(), LIST_CALLONCONNECT, x);
+    m_call_on_connect = x;
 }
 
 
 bool StreamSocket::CallOnConnect()
 {
-	return m_call_on_connect;
+    return m_call_on_connect;
 }
 
 
 void StreamSocket::SetRetryClientConnect(bool x)
 {
-	Handler().AddList(GetSocket(), LIST_RETRY, x);
-	m_b_retry_connect = x;
+    Handler().AddList(GetSocket(), LIST_RETRY, x);
+    m_b_retry_connect = x;
 }
 
 
 bool StreamSocket::RetryClientConnect()
 {
-	return m_b_retry_connect;
+    return m_b_retry_connect;
 }
 
 
 void StreamSocket::SetLineProtocol(bool x)
 {
-	m_line_protocol = x;
+    m_line_protocol = x;
 }
 
 
 bool StreamSocket::LineProtocol()
 {
-	return m_line_protocol;
+    return m_line_protocol;
 }
 
 
 void StreamSocket::SetShutdown(int x)
 {
-	m_shutdown = x;
+    m_shutdown = x;
 }
 
 
 int StreamSocket::GetShutdown()
 {
-	return m_shutdown;
+    return m_shutdown;
 }
 
 
diff --git a/dep/src/sockets/TcpSocket.cpp b/dep/src/sockets/TcpSocket.cpp
index 36df37d5832..1dc54dd3fac 100644
--- a/dep/src/sockets/TcpSocket.cpp
+++ b/dep/src/sockets/TcpSocket.cpp
@@ -1,6 +1,6 @@
 /** \file TcpSocket.cpp
- **	\date  2004-02-13
- **	\author grymse@alhem.net
+ ** \date  2004-02-13
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2004-2007  Anders Hedstrom
@@ -8,7 +8,7 @@ Copyright (C) 2004-2007  Anders Hedstrom
 This library is made available under the terms of the GNU GPL.
 
 If you would like to use this library in a closed-source application,
-a separate license agreement is available. For information about 
+a separate license agreement is available. For information about
 the closed-source license agreement for the C++ sockets library,
 please visit http://www.alhem.net/Sockets/license.html and/or
 email license@alhem.net.
@@ -60,7 +60,7 @@ namespace SOCKETS_NAMESPACE {
 //#ifdef _DEBUG
 //#define DEB(x) x
 //#else
-#define DEB(x) 
+#define DEB(x)
 //#endif
 
 
@@ -148,30 +148,30 @@ TcpSocket::TcpSocket(ISocketHandler& h,size_t isize,size_t osize) : StreamSocket
 TcpSocket::~TcpSocket()
 {
 #ifdef SOCKETS_DYNAMIC_TEMP
-	delete[] m_buf;
+    delete[] m_buf;
 #endif
-	// %! empty m_obuf
-	while (m_obuf.size())
-	{
-		output_l::iterator it = m_obuf.begin();
-		OUTPUT *p = *it;
-		delete p;
-		m_obuf.erase(it);
-	}
+    // %! empty m_obuf
+    while (m_obuf.size())
+    {
+        output_l::iterator it = m_obuf.begin();
+        OUTPUT *p = *it;
+        delete p;
+        m_obuf.erase(it);
+    }
 #ifdef HAVE_OPENSSL
-	if (m_ssl)
-	{
-		SSL_free(m_ssl);
-	}
+    if (m_ssl)
+    {
+        SSL_free(m_ssl);
+    }
 #endif
 }
 
 
 bool TcpSocket::Open(ipaddr_t ip,port_t port,bool skip_socks)
 {
-	Ipv4Address ad(ip, port);
-	Ipv4Address local;
-	return Open(ad, local, skip_socks);
+    Ipv4Address ad(ip, port);
+    Ipv4Address local;
+    return Open(ad, local, skip_socks);
 }
 
 
@@ -179,8 +179,8 @@ bool TcpSocket::Open(ipaddr_t ip,port_t port,bool skip_socks)
 #ifdef IPPROTO_IPV6
 bool TcpSocket::Open(in6_addr ip,port_t port,bool skip_socks)
 {
-	Ipv6Address ad(ip, port);
-	return Open(ad, skip_socks);
+    Ipv6Address ad(ip, port);
+    return Open(ad, skip_socks);
 }
 #endif
 #endif
@@ -188,134 +188,134 @@ bool TcpSocket::Open(in6_addr ip,port_t port,bool skip_socks)
 
 bool TcpSocket::Open(SocketAddress& ad,bool skip_socks)
 {
-	Ipv4Address bind_ad("0.0.0.0", 0);
-	return Open(ad, bind_ad, skip_socks);
+    Ipv4Address bind_ad("0.0.0.0", 0);
+    return Open(ad, bind_ad, skip_socks);
 }
 
 
 bool TcpSocket::Open(SocketAddress& ad,SocketAddress& bind_ad,bool skip_socks)
 {
-	if (!ad.IsValid())
-	{
-		Handler().LogError(this, "Open", 0, "Invalid SocketAddress", LOG_LEVEL_FATAL);
-		SetCloseAndDelete();
-		return false;
-	}
-	if (Handler().GetCount() >= FD_SETSIZE)
-	{
-		Handler().LogError(this, "Open", 0, "no space left in fd_set", LOG_LEVEL_FATAL);
-		SetCloseAndDelete();
-		return false;
-	}
-	SetConnecting(false);
+    if (!ad.IsValid())
+    {
+        Handler().LogError(this, "Open", 0, "Invalid SocketAddress", LOG_LEVEL_FATAL);
+        SetCloseAndDelete();
+        return false;
+    }
+    if (Handler().GetCount() >= FD_SETSIZE)
+    {
+        Handler().LogError(this, "Open", 0, "no space left in fd_set", LOG_LEVEL_FATAL);
+        SetCloseAndDelete();
+        return false;
+    }
+    SetConnecting(false);
 #ifdef ENABLE_SOCKS4
-	SetSocks4(false);
+    SetSocks4(false);
 #endif
-	// check for pooling
+    // check for pooling
 #ifdef ENABLE_POOL
-	if (Handler().PoolEnabled())
-	{
-		ISocketHandler::PoolSocket *pools = Handler().FindConnection(SOCK_STREAM, "tcp", ad);
-		if (pools)
-		{
-			CopyConnection( pools );
-			delete pools;
-
-			SetIsClient();
-			SetCallOnConnect(); // ISocketHandler must call OnConnect
-			Handler().LogError(this, "SetCallOnConnect", 0, "Found pooled connection", LOG_LEVEL_INFO);
-			return true;
-		}
-	}
+    if (Handler().PoolEnabled())
+    {
+        ISocketHandler::PoolSocket *pools = Handler().FindConnection(SOCK_STREAM, "tcp", ad);
+        if (pools)
+        {
+            CopyConnection( pools );
+            delete pools;
+
+            SetIsClient();
+            SetCallOnConnect(); // ISocketHandler must call OnConnect
+            Handler().LogError(this, "SetCallOnConnect", 0, "Found pooled connection", LOG_LEVEL_INFO);
+            return true;
+        }
+    }
 #endif
-	// if not, create new connection
-	SOCKET s = CreateSocket(ad.GetFamily(), SOCK_STREAM, "tcp");
-	if (s == INVALID_SOCKET)
-	{
-		return false;
-	}
-	// socket must be nonblocking for async connect
-	if (!SetNonblocking(true, s))
-	{
-		SetCloseAndDelete();
-		closesocket(s);
-		return false;
-	}
+    // if not, create new connection
+    SOCKET s = CreateSocket(ad.GetFamily(), SOCK_STREAM, "tcp");
+    if (s == INVALID_SOCKET)
+    {
+        return false;
+    }
+    // socket must be nonblocking for async connect
+    if (!SetNonblocking(true, s))
+    {
+        SetCloseAndDelete();
+        closesocket(s);
+        return false;
+    }
 #ifdef ENABLE_POOL
-	SetIsClient(); // client because we connect
+    SetIsClient(); // client because we connect
 #endif
-	SetClientRemoteAddress(ad);
-	int n = 0;
-	if (bind_ad.GetPort() != 0)
-	{
-		bind(s, bind_ad, bind_ad);
-	}
+    SetClientRemoteAddress(ad);
+    int n = 0;
+    if (bind_ad.GetPort() != 0)
+    {
+        bind(s, bind_ad, bind_ad);
+    }
 #ifdef ENABLE_SOCKS4
-	if (!skip_socks && GetSocks4Host() && GetSocks4Port())
-	{
-		Ipv4Address sa(GetSocks4Host(), GetSocks4Port());
-		{
-			std::string sockshost;
-			Utility::l2ip(GetSocks4Host(), sockshost);
-			Handler().LogError(this, "Open", 0, "Connecting to socks4 server @ " + sockshost + ":" +
-				Utility::l2string(GetSocks4Port()), LOG_LEVEL_INFO);
-		}
-		SetSocks4();
-		n = connect(s, sa, sa);
-		SetRemoteAddress(sa);
-	}
-	else
+    if (!skip_socks && GetSocks4Host() && GetSocks4Port())
+    {
+        Ipv4Address sa(GetSocks4Host(), GetSocks4Port());
+        {
+            std::string sockshost;
+            Utility::l2ip(GetSocks4Host(), sockshost);
+            Handler().LogError(this, "Open", 0, "Connecting to socks4 server @ " + sockshost + ":" +
+                Utility::l2string(GetSocks4Port()), LOG_LEVEL_INFO);
+        }
+        SetSocks4();
+        n = connect(s, sa, sa);
+        SetRemoteAddress(sa);
+    }
+    else
 #endif
-	{
-		n = connect(s, ad, ad);
-		SetRemoteAddress(ad);
-	}
-	if (n == -1)
-	{
-		// check error code that means a connect is in progress
+    {
+        n = connect(s, ad, ad);
+        SetRemoteAddress(ad);
+    }
+    if (n == -1)
+    {
+        // check error code that means a connect is in progress
 #ifdef _WIN32
-		if (Errno == WSAEWOULDBLOCK)
+        if (Errno == WSAEWOULDBLOCK)
 #else
-		if (Errno == EINPROGRESS)
+        if (Errno == EINPROGRESS)
 #endif
-		{
-			Attach(s);
-			SetConnecting( true ); // this flag will control fd_set's
-		}
-		else
+        {
+            Attach(s);
+            SetConnecting( true ); // this flag will control fd_set's
+        }
+        else
 #ifdef ENABLE_SOCKS4
-		if (Socks4() && Handler().Socks4TryDirect() ) // retry
-		{
-			closesocket(s);
-			return Open(ad, true);
-		}
-		else
+        if (Socks4() && Handler().Socks4TryDirect() ) // retry
+        {
+            closesocket(s);
+            return Open(ad, true);
+        }
+        else
 #endif
 #ifdef ENABLE_RECONNECT
-		if (Reconnect())
-		{
-			Handler().LogError(this, "connect: failed, reconnect pending", Errno, StrError(Errno), LOG_LEVEL_INFO);
-			Attach(s);
-			SetConnecting( true ); // this flag will control fd_set's
-		}
-		else
+        if (Reconnect())
+        {
+            Handler().LogError(this, "connect: failed, reconnect pending", Errno, StrError(Errno), LOG_LEVEL_INFO);
+            Attach(s);
+            SetConnecting( true ); // this flag will control fd_set's
+        }
+        else
 #endif
-		{
-			Handler().LogError(this, "connect: failed", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-			SetCloseAndDelete();
-			closesocket(s);
-			return false;
-		}
-	}
-	else
-	{
-		Attach(s);
-		SetCallOnConnect(); // ISocketHandler must call OnConnect
-	}
+        {
+            Handler().LogError(this, "connect: failed", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+            SetCloseAndDelete();
+            closesocket(s);
+            return false;
+        }
+    }
+    else
+    {
+        Attach(s);
+        SetCallOnConnect(); // ISocketHandler must call OnConnect
+    }
 
-	// 'true' means connected or connecting(not yet connected)
-	// 'false' means something failed
-	return true; //!Connecting();
+    // 'true' means connected or connecting(not yet connected)
+    // 'false' means something failed
+    return true; //!Connecting();
 }
 
 
@@ -323,47 +323,47 @@ bool TcpSocket::Open(const std::string &host,port_t port)
 {
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
+    if (IsIpv6())
+    {
 #ifdef ENABLE_RESOLVER
-		if (!Handler().ResolverEnabled() || Utility::isipv6(host) )
-		{
+        if (!Handler().ResolverEnabled() || Utility::isipv6(host) )
+        {
 #endif
-			in6_addr a;
-			if (!Utility::u2ip(host, a))
-			{
-				SetCloseAndDelete();
-				return false;
-			}
-			Ipv6Address ad(a, port);
-			Ipv6Address local;
-			return Open(ad, local);
+            in6_addr a;
+            if (!Utility::u2ip(host, a))
+            {
+                SetCloseAndDelete();
+                return false;
+            }
+            Ipv6Address ad(a, port);
+            Ipv6Address local;
+            return Open(ad, local);
 #ifdef ENABLE_RESOLVER
-		}
-		m_resolver_id = Resolve6(host, port);
-		return true;
+        }
+        m_resolver_id = Resolve6(host, port);
+        return true;
 #endif
-	}
+    }
 #endif
 #endif
 #ifdef ENABLE_RESOLVER
-	if (!Handler().ResolverEnabled() || Utility::isipv4(host) )
-	{
+    if (!Handler().ResolverEnabled() || Utility::isipv4(host) )
+    {
 #endif
-		ipaddr_t l;
-		if (!Utility::u2ip(host,l))
-		{
-			SetCloseAndDelete();
-			return false;
-		}
-		Ipv4Address ad(l, port);
-		Ipv4Address local;
-		return Open(ad, local);
+        ipaddr_t l;
+        if (!Utility::u2ip(host,l))
+        {
+            SetCloseAndDelete();
+            return false;
+        }
+        Ipv4Address ad(l, port);
+        Ipv4Address local;
+        return Open(ad, local);
 #ifdef ENABLE_RESOLVER
-	}
-	// resolve using async resolver thread
-	m_resolver_id = Resolve(host, port);
-	return true;
+    }
+    // resolve using async resolver thread
+    m_resolver_id = Resolve(host, port);
+    return true;
 #endif
 }
 
@@ -371,58 +371,58 @@ bool TcpSocket::Open(const std::string &host,port_t port)
 #ifdef ENABLE_RESOLVER
 void TcpSocket::OnResolved(int id,ipaddr_t a,port_t port)
 {
-DEB(	fprintf(stderr, "TcpSocket::OnResolved id %d addr %x port %d\n", id, a, port);)
-	if (id == m_resolver_id)
-	{
-		if (a && port)
-		{
-			Ipv4Address ad(a, port);
-			Ipv4Address local;
-			if (Open(ad, local))
-			{
-				if (!Handler().Valid(this))
-				{
-					Handler().Add(this);
-				}
-			}
-		}
-		else
-		{
-			Handler().LogError(this, "OnResolved", 0, "Resolver failed", LOG_LEVEL_FATAL);
-			SetCloseAndDelete();
-		}
-	}
-	else
-	{
-		Handler().LogError(this, "OnResolved", id, "Resolver returned wrong job id", LOG_LEVEL_FATAL);
-		SetCloseAndDelete();
-	}
+DEB(    fprintf(stderr, "TcpSocket::OnResolved id %d addr %x port %d\n", id, a, port);)
+    if (id == m_resolver_id)
+    {
+        if (a && port)
+        {
+            Ipv4Address ad(a, port);
+            Ipv4Address local;
+            if (Open(ad, local))
+            {
+                if (!Handler().Valid(this))
+                {
+                    Handler().Add(this);
+                }
+            }
+        }
+        else
+        {
+            Handler().LogError(this, "OnResolved", 0, "Resolver failed", LOG_LEVEL_FATAL);
+            SetCloseAndDelete();
+        }
+    }
+    else
+    {
+        Handler().LogError(this, "OnResolved", id, "Resolver returned wrong job id", LOG_LEVEL_FATAL);
+        SetCloseAndDelete();
+    }
 }
 
 
 #ifdef ENABLE_IPV6
 void TcpSocket::OnResolved(int id,in6_addr& a,port_t port)
 {
-	if (id == m_resolver_id)
-	{
-		Ipv6Address ad(a, port);
-		if (ad.IsValid())
-		{
-			Ipv6Address local;
-			if (Open(ad, local))
-			{
-				if (!Handler().Valid(this))
-				{
-					Handler().Add(this);
-				}
-			}
-		}
-	}
-	else
-	{
-		Handler().LogError(this, "OnResolved", id, "Resolver returned wrong job id", LOG_LEVEL_FATAL);
-		SetCloseAndDelete();
-	}
+    if (id == m_resolver_id)
+    {
+        Ipv6Address ad(a, port);
+        if (ad.IsValid())
+        {
+            Ipv6Address local;
+            if (Open(ad, local))
+            {
+                if (!Handler().Valid(this))
+                {
+                    Handler().Add(this);
+                }
+            }
+        }
+    }
+    else
+    {
+        Handler().LogError(this, "OnResolved", id, "Resolver returned wrong job id", LOG_LEVEL_FATAL);
+        SetCloseAndDelete();
+    }
 }
 #endif
 #endif
@@ -430,191 +430,191 @@ void TcpSocket::OnResolved(int id,in6_addr& a,port_t port)
 
 void TcpSocket::OnRead()
 {
-	int n = 0;
+    int n = 0;
 #ifdef SOCKETS_DYNAMIC_TEMP
-	char *buf = m_buf;
+    char *buf = m_buf;
 #else
-	char buf[TCP_BUFSIZE_READ];
+    char buf[TCP_BUFSIZE_READ];
 #endif
 #ifdef HAVE_OPENSSL
-	if (IsSSL())
-	{
-		if (!Ready())
-			return;
-		n = SSL_read(m_ssl, buf, TCP_BUFSIZE_READ);
-		if (n == -1)
-		{
-			n = SSL_get_error(m_ssl, n);
-			switch (n)
-			{
-			case SSL_ERROR_NONE:
-			case SSL_ERROR_WANT_READ:
-			case SSL_ERROR_WANT_WRITE:
-				break;
-			case SSL_ERROR_ZERO_RETURN:
-DEB(				fprintf(stderr, "SSL_read() returns zero - closing socket\n");)
-				OnDisconnect();
-				SetCloseAndDelete(true);
-				SetFlushBeforeClose(false);
-				SetLost();
-				break;
-			default:
-DEB(				fprintf(stderr, "SSL read problem, errcode = %d\n",n);)
-				OnDisconnect();
-				SetCloseAndDelete(true);
-				SetFlushBeforeClose(false);
-				SetLost();
-			}
-			return;
-		}
-		else
-		if (!n)
-		{
-			OnDisconnect();
-			SetCloseAndDelete(true);
-			SetFlushBeforeClose(false);
-			SetLost();
-			SetShutdown(SHUT_WR);
-			return;
-		}
-		else
-		if (n > 0 && n <= TCP_BUFSIZE_READ)
-		{
-			m_bytes_received += n;
-			if (GetTrafficMonitor())
-			{
-				GetTrafficMonitor() -> fwrite(buf, 1, n);
-			}
-			if (!m_b_input_buffer_disabled && !ibuf.Write(buf,n))
-			{
-				Handler().LogError(this, "OnRead(ssl)", 0, "ibuf overflow", LOG_LEVEL_WARNING);
-			}
-		}
-		else
-		{
-			Handler().LogError(this, "OnRead(ssl)", n, "abnormal value from SSL_read", LOG_LEVEL_ERROR);
-		}
-	}
-	else
+    if (IsSSL())
+    {
+        if (!Ready())
+            return;
+        n = SSL_read(m_ssl, buf, TCP_BUFSIZE_READ);
+        if (n == -1)
+        {
+            n = SSL_get_error(m_ssl, n);
+            switch (n)
+            {
+            case SSL_ERROR_NONE:
+            case SSL_ERROR_WANT_READ:
+            case SSL_ERROR_WANT_WRITE:
+                break;
+            case SSL_ERROR_ZERO_RETURN:
+DEB(                fprintf(stderr, "SSL_read() returns zero - closing socket\n");)
+                OnDisconnect();
+                SetCloseAndDelete(true);
+                SetFlushBeforeClose(false);
+                SetLost();
+                break;
+            default:
+DEB(                fprintf(stderr, "SSL read problem, errcode = %d\n",n);)
+                OnDisconnect();
+                SetCloseAndDelete(true);
+                SetFlushBeforeClose(false);
+                SetLost();
+            }
+            return;
+        }
+        else
+        if (!n)
+        {
+            OnDisconnect();
+            SetCloseAndDelete(true);
+            SetFlushBeforeClose(false);
+            SetLost();
+            SetShutdown(SHUT_WR);
+            return;
+        }
+        else
+        if (n > 0 && n <= TCP_BUFSIZE_READ)
+        {
+            m_bytes_received += n;
+            if (GetTrafficMonitor())
+            {
+                GetTrafficMonitor() -> fwrite(buf, 1, n);
+            }
+            if (!m_b_input_buffer_disabled && !ibuf.Write(buf,n))
+            {
+                Handler().LogError(this, "OnRead(ssl)", 0, "ibuf overflow", LOG_LEVEL_WARNING);
+            }
+        }
+        else
+        {
+            Handler().LogError(this, "OnRead(ssl)", n, "abnormal value from SSL_read", LOG_LEVEL_ERROR);
+        }
+    }
+    else
 #endif // HAVE_OPENSSL
-	{
-		n = recv(GetSocket(), buf, TCP_BUFSIZE_READ, MSG_NOSIGNAL);
-		if (n == -1)
-		{
-			Handler().LogError(this, "read", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-			OnDisconnect();
-			SetCloseAndDelete(true);
-			SetFlushBeforeClose(false);
-			SetLost();
-			return;
-		}
-		else
-		if (!n)
-		{
-			OnDisconnect();
-			SetCloseAndDelete(true);
-			SetFlushBeforeClose(false);
-			SetLost();
-			SetShutdown(SHUT_WR);
-			return;
-		}
-		else
-		if (n > 0 && n <= TCP_BUFSIZE_READ)
-		{
-			m_bytes_received += n;
-			if (GetTrafficMonitor())
-			{
-				GetTrafficMonitor() -> fwrite(buf, 1, n);
-			}
-			if (!m_b_input_buffer_disabled && !ibuf.Write(buf,n))
-			{
-				Handler().LogError(this, "OnRead", 0, "ibuf overflow", LOG_LEVEL_WARNING);
-			}
-		}
-		else
-		{
-			Handler().LogError(this, "OnRead", n, "abnormal value from recv", LOG_LEVEL_ERROR);
-		}
-	}
-	//
-	OnRead( buf, n );
+    {
+        n = recv(GetSocket(), buf, TCP_BUFSIZE_READ, MSG_NOSIGNAL);
+        if (n == -1)
+        {
+            Handler().LogError(this, "read", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+            OnDisconnect();
+            SetCloseAndDelete(true);
+            SetFlushBeforeClose(false);
+            SetLost();
+            return;
+        }
+        else
+        if (!n)
+        {
+            OnDisconnect();
+            SetCloseAndDelete(true);
+            SetFlushBeforeClose(false);
+            SetLost();
+            SetShutdown(SHUT_WR);
+            return;
+        }
+        else
+        if (n > 0 && n <= TCP_BUFSIZE_READ)
+        {
+            m_bytes_received += n;
+            if (GetTrafficMonitor())
+            {
+                GetTrafficMonitor() -> fwrite(buf, 1, n);
+            }
+            if (!m_b_input_buffer_disabled && !ibuf.Write(buf,n))
+            {
+                Handler().LogError(this, "OnRead", 0, "ibuf overflow", LOG_LEVEL_WARNING);
+            }
+        }
+        else
+        {
+            Handler().LogError(this, "OnRead", n, "abnormal value from recv", LOG_LEVEL_ERROR);
+        }
+    }
+    //
+    OnRead( buf, n );
 }
 
 
 void TcpSocket::OnRead( char *buf, size_t n )
 {
-	// unbuffered
-	if (n > 0 && n <= TCP_BUFSIZE_READ)
-	{
-		if (LineProtocol())
-		{
-			buf[n] = 0;
-			size_t i = 0;
-			if (m_skip_c && (buf[i] == 13 || buf[i] == 10) && buf[i] != m_c)
-			{
-				m_skip_c = false;
-				i++;
-			}
-			size_t x = i;
-			for (; i < n && LineProtocol(); i++)
-			{
-				while ((buf[i] == 13 || buf[i] == 10) && LineProtocol())
-				{
-					char c = buf[i];
-					buf[i] = 0;
-					if (buf[x])
-					{
-						m_line += (buf + x);
-					}
-					OnLine( m_line );
-					i++;
-					m_skip_c = true;
-					m_c = c;
-					if (i < n && (buf[i] == 13 || buf[i] == 10) && buf[i] != c)
-					{
-						m_skip_c = false;
-						i++;
-					}
-					x = i;
-					m_line = "";
-				}
-				if (!LineProtocol())
-				{
-					break;
-				}
-			}
-			if (!LineProtocol())
-			{
-				if (i < n)
-				{
-					OnRawData(buf + i, n - i);
-				}
-			}
-			else
-			if (buf[x])
-			{
-				m_line += (buf + x);
-			}
-		}
-		else
-		{
-			OnRawData(buf, n);
-		}
-	}
-	if (m_b_input_buffer_disabled)
-	{
-		return;
-	}
-	// further processing: socks4
+    // unbuffered
+    if (n > 0 && n <= TCP_BUFSIZE_READ)
+    {
+        if (LineProtocol())
+        {
+            buf[n] = 0;
+            size_t i = 0;
+            if (m_skip_c && (buf[i] == 13 || buf[i] == 10) && buf[i] != m_c)
+            {
+                m_skip_c = false;
+                i++;
+            }
+            size_t x = i;
+            for (; i < n && LineProtocol(); i++)
+            {
+                while ((buf[i] == 13 || buf[i] == 10) && LineProtocol())
+                {
+                    char c = buf[i];
+                    buf[i] = 0;
+                    if (buf[x])
+                    {
+                        m_line += (buf + x);
+                    }
+                    OnLine( m_line );
+                    i++;
+                    m_skip_c = true;
+                    m_c = c;
+                    if (i < n && (buf[i] == 13 || buf[i] == 10) && buf[i] != c)
+                    {
+                        m_skip_c = false;
+                        i++;
+                    }
+                    x = i;
+                    m_line = "";
+                }
+                if (!LineProtocol())
+                {
+                    break;
+                }
+            }
+            if (!LineProtocol())
+            {
+                if (i < n)
+                {
+                    OnRawData(buf + i, n - i);
+                }
+            }
+            else
+            if (buf[x])
+            {
+                m_line += (buf + x);
+            }
+        }
+        else
+        {
+            OnRawData(buf, n);
+        }
+    }
+    if (m_b_input_buffer_disabled)
+    {
+        return;
+    }
+    // further processing: socks4
 #ifdef ENABLE_SOCKS4
-	if (Socks4())
-	{
-		bool need_more = false;
-		while (GetInputLength() && !need_more && !CloseAndDelete())
-		{
-			need_more = OnSocks4Read();
-		}
-	}
+    if (Socks4())
+    {
+        bool need_more = false;
+        while (GetInputLength() && !need_more && !CloseAndDelete())
+        {
+            need_more = OnSocks4Read();
+        }
+    }
 #endif
 }
 
@@ -626,252 +626,252 @@ void TcpSocket::OnWriteComplete()
 
 void TcpSocket::OnWrite()
 {
-	if (Connecting())
-	{
-		int err = SoError();
-
-		// don't reset connecting flag on error here, we want the OnConnectFailed timeout later on
-		if (!err) // ok
-		{
-			Set(!IsDisableRead(), false);
-			SetConnecting(false);
-			SetCallOnConnect();
-			return;
-		}
-		Handler().LogError(this, "tcp: connect failed", err, StrError(err), LOG_LEVEL_FATAL);
-		Set(false, false); // no more monitoring because connection failed
-
-		// failed
+    if (Connecting())
+    {
+        int err = SoError();
+
+        // don't reset connecting flag on error here, we want the OnConnectFailed timeout later on
+        if (!err) // ok
+        {
+            Set(!IsDisableRead(), false);
+            SetConnecting(false);
+            SetCallOnConnect();
+            return;
+        }
+        Handler().LogError(this, "tcp: connect failed", err, StrError(err), LOG_LEVEL_FATAL);
+        Set(false, false); // no more monitoring because connection failed
+
+        // failed
 #ifdef ENABLE_SOCKS4
-		if (Socks4())
-		{
-			// %! leave 'Connecting' flag set?
-			OnSocks4ConnectFailed();
-			return;
-		}
+        if (Socks4())
+        {
+            // %! leave 'Connecting' flag set?
+            OnSocks4ConnectFailed();
+            return;
+        }
 #endif
-		if (GetConnectionRetry() == -1 ||
-			(GetConnectionRetry() && GetConnectionRetries() < GetConnectionRetry()) )
-		{
-			// even though the connection failed at once, only retry after
-			// the connection timeout.
-			// should we even try to connect again, when CheckConnect returns
-			// false it's because of a connection error - not a timeout...
-			return;
-		}
-		SetConnecting(false);
-		SetCloseAndDelete( true );
-		/// \todo state reason why connect failed
-		OnConnectFailed();
-		return;
-	}
-	// try send next block in buffer
-	// if full block is sent, repeat
-	// if all blocks are sent, reset m_wfds
-
-	bool repeat = false;
-	size_t sz = m_transfer_limit ? GetOutputLength() : 0;
-	do
-	{
-		output_l::iterator it = m_obuf.begin();
-		OUTPUT *p = *it;
-		repeat = false;
-		int n = TryWrite(p -> Buf(), p -> Len());
-		if (n > 0)
-		{
-			size_t left = p -> Remove(n);
-			m_output_length -= n;
-			if (!left)
-			{
-				delete p;
-				m_obuf.erase(it);
-				if (!m_obuf.size())
-				{
-					m_obuf_top = NULL;
-					OnWriteComplete();
-				}
-				else
-				{
-					repeat = true;
-				}
-			}
-		}
-	} while (repeat);
-
-	if (m_transfer_limit && sz > m_transfer_limit && GetOutputLength() < m_transfer_limit)
-	{
-		OnTransferLimit();
-	}
-
-	// check output buffer set, set/reset m_wfds accordingly
-	{
-		bool br;
-		bool bw;
-		bool bx;
-		Handler().Get(GetSocket(), br, bw, bx);
-		if (m_obuf.size())
-			Set(br, true);
-		else
-			Set(br, false);
-	}
+        if (GetConnectionRetry() == -1 ||
+            (GetConnectionRetry() && GetConnectionRetries() < GetConnectionRetry()) )
+        {
+            // even though the connection failed at once, only retry after
+            // the connection timeout.
+            // should we even try to connect again, when CheckConnect returns
+            // false it's because of a connection error - not a timeout...
+            return;
+        }
+        SetConnecting(false);
+        SetCloseAndDelete( true );
+        /// \todo state reason why connect failed
+        OnConnectFailed();
+        return;
+    }
+    // try send next block in buffer
+    // if full block is sent, repeat
+    // if all blocks are sent, reset m_wfds
+
+    bool repeat = false;
+    size_t sz = m_transfer_limit ? GetOutputLength() : 0;
+    do
+    {
+        output_l::iterator it = m_obuf.begin();
+        OUTPUT *p = *it;
+        repeat = false;
+        int n = TryWrite(p -> Buf(), p -> Len());
+        if (n > 0)
+        {
+            size_t left = p -> Remove(n);
+            m_output_length -= n;
+            if (!left)
+            {
+                delete p;
+                m_obuf.erase(it);
+                if (!m_obuf.size())
+                {
+                    m_obuf_top = NULL;
+                    OnWriteComplete();
+                }
+                else
+                {
+                    repeat = true;
+                }
+            }
+        }
+    } while (repeat);
+
+    if (m_transfer_limit && sz > m_transfer_limit && GetOutputLength() < m_transfer_limit)
+    {
+        OnTransferLimit();
+    }
+
+    // check output buffer set, set/reset m_wfds accordingly
+    {
+        bool br;
+        bool bw;
+        bool bx;
+        Handler().Get(GetSocket(), br, bw, bx);
+        if (m_obuf.size())
+            Set(br, true);
+        else
+            Set(br, false);
+    }
 }
 
 
 int TcpSocket::TryWrite(const char *buf, size_t len)
 {
-	int n = 0;
+    int n = 0;
 #ifdef HAVE_OPENSSL
-	if (IsSSL())
-	{
-		n = SSL_write(m_ssl, buf, (int)len);
-		if (n == -1)
-		{
-			int errnr = SSL_get_error(m_ssl, n);
-			if ( errnr != SSL_ERROR_WANT_READ && errnr != SSL_ERROR_WANT_WRITE )
-			{
-				OnDisconnect();
-				SetCloseAndDelete(true);
-				SetFlushBeforeClose(false);
-				SetLost();
-				const char *errbuf = ERR_error_string(errnr, NULL);
-				Handler().LogError(this, "OnWrite/SSL_write", errnr, errbuf, LOG_LEVEL_FATAL);
-			}
-			return 0;
-		}
-		else
-		if (!n)
-		{
-			OnDisconnect();
-			SetCloseAndDelete(true);
-			SetFlushBeforeClose(false);
-			SetLost();
-DEB(			int errnr = SSL_get_error(m_ssl, n);
-			const char *errbuf = ERR_error_string(errnr, NULL);
-			fprintf(stderr, "SSL_write() returns 0: %d : %s\n",errnr, errbuf);)
-		}
-	}
-	else
+    if (IsSSL())
+    {
+        n = SSL_write(m_ssl, buf, (int)len);
+        if (n == -1)
+        {
+            int errnr = SSL_get_error(m_ssl, n);
+            if ( errnr != SSL_ERROR_WANT_READ && errnr != SSL_ERROR_WANT_WRITE )
+            {
+                OnDisconnect();
+                SetCloseAndDelete(true);
+                SetFlushBeforeClose(false);
+                SetLost();
+                const char *errbuf = ERR_error_string(errnr, NULL);
+                Handler().LogError(this, "OnWrite/SSL_write", errnr, errbuf, LOG_LEVEL_FATAL);
+            }
+            return 0;
+        }
+        else
+        if (!n)
+        {
+            OnDisconnect();
+            SetCloseAndDelete(true);
+            SetFlushBeforeClose(false);
+            SetLost();
+DEB(            int errnr = SSL_get_error(m_ssl, n);
+            const char *errbuf = ERR_error_string(errnr, NULL);
+            fprintf(stderr, "SSL_write() returns 0: %d : %s\n",errnr, errbuf);)
+        }
+    }
+    else
 #endif // HAVE_OPENSSL
-	{
-		n = send(GetSocket(), buf, (int)len, MSG_NOSIGNAL);
-		if (n == -1)
-		{
-		// normal error codes:
-		// WSAEWOULDBLOCK
-		//       EAGAIN or EWOULDBLOCK
+    {
+        n = send(GetSocket(), buf, (int)len, MSG_NOSIGNAL);
+        if (n == -1)
+        {
+        // normal error codes:
+        // WSAEWOULDBLOCK
+        //       EAGAIN or EWOULDBLOCK
 #ifdef _WIN32
-			if (Errno != WSAEWOULDBLOCK)
+            if (Errno != WSAEWOULDBLOCK)
 #else
-			if (Errno != EWOULDBLOCK)
+            if (Errno != EWOULDBLOCK)
 #endif
-			{	
-				Handler().LogError(this, "send", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-				OnDisconnect();
-				SetCloseAndDelete(true);
-				SetFlushBeforeClose(false);
-				SetLost();
-			}
-			return 0;
-		}
-	}
-	if (n > 0)
-	{
-		m_bytes_sent += n;
-		if (GetTrafficMonitor())
-		{
-			GetTrafficMonitor() -> fwrite(buf, 1, n);
-		}
-	}
-	return n;
+            {
+                Handler().LogError(this, "send", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+                OnDisconnect();
+                SetCloseAndDelete(true);
+                SetFlushBeforeClose(false);
+                SetLost();
+            }
+            return 0;
+        }
+    }
+    if (n > 0)
+    {
+        m_bytes_sent += n;
+        if (GetTrafficMonitor())
+        {
+            GetTrafficMonitor() -> fwrite(buf, 1, n);
+        }
+    }
+    return n;
 }
 
 
 void TcpSocket::Buffer(const char *buf, size_t len)
 {
-	size_t ptr = 0;
-	m_output_length += len;
-	while (ptr < len)
-	{
-		// buf/len => pbuf/sz
-		size_t space = 0;
-		if (m_obuf_top && (space = m_obuf_top -> Space()) > 0)
-		{
-			const char *pbuf = buf + ptr;
-			size_t sz = len - ptr;
-			if (space >= sz)
-			{
-				m_obuf_top -> Add(pbuf, sz);
-				ptr += sz;
-			}
-			else
-			{
-				m_obuf_top -> Add(pbuf, space);
-				ptr += space;
-			}
-		}
-		else
-		{
-			m_obuf_top = new OUTPUT;
-			m_obuf.push_back( m_obuf_top );
-		}
-	}
+    size_t ptr = 0;
+    m_output_length += len;
+    while (ptr < len)
+    {
+        // buf/len => pbuf/sz
+        size_t space = 0;
+        if (m_obuf_top && (space = m_obuf_top -> Space()) > 0)
+        {
+            const char *pbuf = buf + ptr;
+            size_t sz = len - ptr;
+            if (space >= sz)
+            {
+                m_obuf_top -> Add(pbuf, sz);
+                ptr += sz;
+            }
+            else
+            {
+                m_obuf_top -> Add(pbuf, space);
+                ptr += space;
+            }
+        }
+        else
+        {
+            m_obuf_top = new OUTPUT;
+            m_obuf.push_back( m_obuf_top );
+        }
+    }
 }
 
 
 void TcpSocket::Send(const std::string &str,int i)
 {
-	SendBuf(str.c_str(),str.size(),i);
+    SendBuf(str.c_str(),str.size(),i);
 }
 
 
 void TcpSocket::SendBuf(const char *buf,size_t len,int)
 {
-	if (!Ready() && !Connecting())
-	{
-		Handler().LogError(this, "SendBuf", -1, "Attempt to write to a non-ready socket" ); // warning
-		if (GetSocket() == INVALID_SOCKET)
-			Handler().LogError(this, "SendBuf", 0, " * GetSocket() == INVALID_SOCKET", LOG_LEVEL_INFO);
-		if (Connecting())
-			Handler().LogError(this, "SendBuf", 0, " * Connecting()", LOG_LEVEL_INFO);
-		if (CloseAndDelete())
-			Handler().LogError(this, "SendBuf", 0, " * CloseAndDelete()", LOG_LEVEL_INFO);
-		return;
-	}
-	if (!IsConnected())
-	{
-		Handler().LogError(this, "SendBuf", -1, "Attempt to write to a non-connected socket, will be sent on connect" ); // warning
-		Buffer(buf, len);
-		return;
-	}
-	if (m_obuf_top)
-	{
-		Buffer(buf, len);
-		return;
-	}
-	int n = TryWrite(buf, len);
-	if (n >= 0 && n < (int)len)
-	{
-		Buffer(buf + n, len - n);
-	}
-	// if ( data in buffer || !IsConnected )
-	// {
-	//   add to buffer
-	// }
-	// else
-	// try_send
-	// if any data is unsent, buffer it and set m_wfds
-
-	// check output buffer set, set/reset m_wfds accordingly
-	{
-		bool br;
-		bool bw;
-		bool bx;
-		Handler().Get(GetSocket(), br, bw, bx);
-		if (m_obuf.size())
-			Set(br, true);
-		else
-			Set(br, false);
-	}
+    if (!Ready() && !Connecting())
+    {
+        Handler().LogError(this, "SendBuf", -1, "Attempt to write to a non-ready socket" ); // warning
+        if (GetSocket() == INVALID_SOCKET)
+            Handler().LogError(this, "SendBuf", 0, " * GetSocket() == INVALID_SOCKET", LOG_LEVEL_INFO);
+        if (Connecting())
+            Handler().LogError(this, "SendBuf", 0, " * Connecting()", LOG_LEVEL_INFO);
+        if (CloseAndDelete())
+            Handler().LogError(this, "SendBuf", 0, " * CloseAndDelete()", LOG_LEVEL_INFO);
+        return;
+    }
+    if (!IsConnected())
+    {
+        Handler().LogError(this, "SendBuf", -1, "Attempt to write to a non-connected socket, will be sent on connect" ); // warning
+        Buffer(buf, len);
+        return;
+    }
+    if (m_obuf_top)
+    {
+        Buffer(buf, len);
+        return;
+    }
+    int n = TryWrite(buf, len);
+    if (n >= 0 && n < (int)len)
+    {
+        Buffer(buf + n, len - n);
+    }
+    // if ( data in buffer || !IsConnected )
+    // {
+    //   add to buffer
+    // }
+    // else
+    // try_send
+    // if any data is unsent, buffer it and set m_wfds
+
+    // check output buffer set, set/reset m_wfds accordingly
+    {
+        bool br;
+        bool bw;
+        bool bx;
+        Handler().Get(GetSocket(), br, bw, bx);
+        if (m_obuf.size())
+            Set(br, true);
+        else
+            Set(br, false);
+    }
 }
 
 
@@ -896,478 +896,478 @@ TcpSocket::TcpSocket(const TcpSocket& s)
 #ifdef ENABLE_SOCKS4
 void TcpSocket::OnSocks4Connect()
 {
-	char request[1000];
-	memset(request, 0, sizeof(request));
-	request[0] = 4; // socks v4
-	request[1] = 1; // command code: CONNECT
-	{
-		std::auto_ptr<SocketAddress> ad = GetClientRemoteAddress();
-		if (ad.get())
-		{
-			struct sockaddr *p0 = (struct sockaddr *)*ad;
-			struct sockaddr_in *p = (struct sockaddr_in *)p0;
-			if (p -> sin_family == AF_INET)
-			{
-				memcpy(request + 2, &p -> sin_port, 2); // nwbo is ok here
-				memcpy(request + 4, &p -> sin_addr, sizeof(struct in_addr));
-			}
-			else
-			{
-				/// \todo warn
-			}
-		}
-		else
-		{
-			/// \todo warn
-		}
-	}
-	strcpy(request + 8, GetSocks4Userid().c_str());
-	size_t length = GetSocks4Userid().size() + 8 + 1;
-	SendBuf(request, length);
-	m_socks4_state = 0;
+    char request[1000];
+    memset(request, 0, sizeof(request));
+    request[0] = 4; // socks v4
+    request[1] = 1; // command code: CONNECT
+    {
+        std::auto_ptr<SocketAddress> ad = GetClientRemoteAddress();
+        if (ad.get())
+        {
+            struct sockaddr *p0 = (struct sockaddr *)*ad;
+            struct sockaddr_in *p = (struct sockaddr_in *)p0;
+            if (p -> sin_family == AF_INET)
+            {
+                memcpy(request + 2, &p -> sin_port, 2); // nwbo is ok here
+                memcpy(request + 4, &p -> sin_addr, sizeof(struct in_addr));
+            }
+            else
+            {
+                /// \todo warn
+            }
+        }
+        else
+        {
+            /// \todo warn
+        }
+    }
+    strcpy(request + 8, GetSocks4Userid().c_str());
+    size_t length = GetSocks4Userid().size() + 8 + 1;
+    SendBuf(request, length);
+    m_socks4_state = 0;
 }
 
 
 void TcpSocket::OnSocks4ConnectFailed()
 {
-	Handler().LogError(this,"OnSocks4ConnectFailed",0,"connection to socks4 server failed, trying direct connection",LOG_LEVEL_WARNING);
-	if (!Handler().Socks4TryDirect())
-	{
-		SetConnecting(false);
-		SetCloseAndDelete();
-		OnConnectFailed(); // just in case
-	}
-	else
-	{
-		SetRetryClientConnect();
-	}
+    Handler().LogError(this,"OnSocks4ConnectFailed",0,"connection to socks4 server failed, trying direct connection",LOG_LEVEL_WARNING);
+    if (!Handler().Socks4TryDirect())
+    {
+        SetConnecting(false);
+        SetCloseAndDelete();
+        OnConnectFailed(); // just in case
+    }
+    else
+    {
+        SetRetryClientConnect();
+    }
 }
 
 
 bool TcpSocket::OnSocks4Read()
 {
-	switch (m_socks4_state)
-	{
-	case 0:
-		ibuf.Read(&m_socks4_vn, 1);
-		m_socks4_state = 1;
-		break;
-	case 1:
-		ibuf.Read(&m_socks4_cd, 1);
-		m_socks4_state = 2;
-		break;
-	case 2:
-		if (GetInputLength() > 1)
-		{
-			ibuf.Read( (char *)&m_socks4_dstport, 2);
-			m_socks4_state = 3;
-		}
-		else
-		{
-			return true;
-		}
-		break;
-	case 3:
-		if (GetInputLength() > 3)
-		{
-			ibuf.Read( (char *)&m_socks4_dstip, 4);
-			SetSocks4(false);
-			
-			switch (m_socks4_cd)
-			{
-			case 90:
-				OnConnect();
-				Handler().LogError(this, "OnSocks4Read", 0, "Connection established", LOG_LEVEL_INFO);
-				break;
-			case 91:
-			case 92:
-			case 93:
-				Handler().LogError(this,"OnSocks4Read",m_socks4_cd,"socks4 server reports connect failed",LOG_LEVEL_FATAL);
-				SetConnecting(false);
-				SetCloseAndDelete();
-				OnConnectFailed();
-				break;
-			default:
-				Handler().LogError(this,"OnSocks4Read",m_socks4_cd,"socks4 server unrecognized response",LOG_LEVEL_FATAL);
-				SetCloseAndDelete();
-				break;
-			}
-		}
-		else
-		{
-			return true;
-		}
-		break;
-	}
-	return false;
+    switch (m_socks4_state)
+    {
+    case 0:
+        ibuf.Read(&m_socks4_vn, 1);
+        m_socks4_state = 1;
+        break;
+    case 1:
+        ibuf.Read(&m_socks4_cd, 1);
+        m_socks4_state = 2;
+        break;
+    case 2:
+        if (GetInputLength() > 1)
+        {
+            ibuf.Read( (char *)&m_socks4_dstport, 2);
+            m_socks4_state = 3;
+        }
+        else
+        {
+            return true;
+        }
+        break;
+    case 3:
+        if (GetInputLength() > 3)
+        {
+            ibuf.Read( (char *)&m_socks4_dstip, 4);
+            SetSocks4(false);
+
+            switch (m_socks4_cd)
+            {
+            case 90:
+                OnConnect();
+                Handler().LogError(this, "OnSocks4Read", 0, "Connection established", LOG_LEVEL_INFO);
+                break;
+            case 91:
+            case 92:
+            case 93:
+                Handler().LogError(this,"OnSocks4Read",m_socks4_cd,"socks4 server reports connect failed",LOG_LEVEL_FATAL);
+                SetConnecting(false);
+                SetCloseAndDelete();
+                OnConnectFailed();
+                break;
+            default:
+                Handler().LogError(this,"OnSocks4Read",m_socks4_cd,"socks4 server unrecognized response",LOG_LEVEL_FATAL);
+                SetCloseAndDelete();
+                break;
+            }
+        }
+        else
+        {
+            return true;
+        }
+        break;
+    }
+    return false;
 }
 #endif
 
 
 void TcpSocket::Sendf(const char *format, ...)
 {
-	va_list ap;
-	va_start(ap, format);
-	char slask[5000]; // vsprintf / vsnprintf temporary
+    va_list ap;
+    va_start(ap, format);
+    char slask[5000]; // vsprintf / vsnprintf temporary
 #ifdef _WIN32
-	vsprintf(slask, format, ap);
+    vsprintf(slask, format, ap);
 #else
-	vsnprintf(slask, 5000, format, ap);
+    vsnprintf(slask, 5000, format, ap);
 #endif
-	va_end(ap);
-	Send( slask );
+    va_end(ap);
+    Send( slask );
 }
 
 
 #ifdef HAVE_OPENSSL
 void TcpSocket::OnSSLConnect()
 {
-	SetNonblocking(true);
-	{
-		if (m_ssl_ctx)
-		{
-DEB(			fprintf(stderr, "SSL Context already initialized - closing socket\n");)
-			SetCloseAndDelete(true);
-			return;
-		}
-		InitSSLClient();
-	}
-	if (m_ssl_ctx)
-	{
-		/* Connect the SSL socket */
-		m_ssl = SSL_new(m_ssl_ctx);
-		if (!m_ssl)
-		{
-DEB(			fprintf(stderr, " m_ssl is NULL\n");)
-			SetCloseAndDelete(true);
-			return;
-		}
-		SSL_set_mode(m_ssl, SSL_MODE_AUTO_RETRY);
-		m_sbio = BIO_new_socket((int)GetSocket(), BIO_NOCLOSE);
-		if (!m_sbio)
-		{
-DEB(			fprintf(stderr, " m_sbio is NULL\n");)
-			SetCloseAndDelete(true);
-			return;
-		}
-		SSL_set_bio(m_ssl, m_sbio, m_sbio);
-		if (!SSLNegotiate())
-		{
-			SetSSLNegotiate();
-		}
-	}
-	else
-	{
-		SetCloseAndDelete();
-	}
+    SetNonblocking(true);
+    {
+        if (m_ssl_ctx)
+        {
+DEB(            fprintf(stderr, "SSL Context already initialized - closing socket\n");)
+            SetCloseAndDelete(true);
+            return;
+        }
+        InitSSLClient();
+    }
+    if (m_ssl_ctx)
+    {
+        /* Connect the SSL socket */
+        m_ssl = SSL_new(m_ssl_ctx);
+        if (!m_ssl)
+        {
+DEB(            fprintf(stderr, " m_ssl is NULL\n");)
+            SetCloseAndDelete(true);
+            return;
+        }
+        SSL_set_mode(m_ssl, SSL_MODE_AUTO_RETRY);
+        m_sbio = BIO_new_socket((int)GetSocket(), BIO_NOCLOSE);
+        if (!m_sbio)
+        {
+DEB(            fprintf(stderr, " m_sbio is NULL\n");)
+            SetCloseAndDelete(true);
+            return;
+        }
+        SSL_set_bio(m_ssl, m_sbio, m_sbio);
+        if (!SSLNegotiate())
+        {
+            SetSSLNegotiate();
+        }
+    }
+    else
+    {
+        SetCloseAndDelete();
+    }
 }
 
 
 void TcpSocket::OnSSLAccept()
 {
-	SetNonblocking(true);
-	{
-		if (m_ssl_ctx)
-		{
-DEB(			fprintf(stderr, "SSL Context already initialized - closing socket\n");)
-			SetCloseAndDelete(true);
-			return;
-		}
-		InitSSLServer();
-		SetSSLServer();
-	}
-	if (m_ssl_ctx)
-	{
-		m_ssl = SSL_new(m_ssl_ctx);
-		if (!m_ssl)
-		{
-DEB(			fprintf(stderr, " m_ssl is NULL\n");)
-			SetCloseAndDelete(true);
-			return;
-		}
-		SSL_set_mode(m_ssl, SSL_MODE_AUTO_RETRY);
-		m_sbio = BIO_new_socket((int)GetSocket(), BIO_NOCLOSE);
-		if (!m_sbio)
-		{
-DEB(			fprintf(stderr, " m_sbio is NULL\n");)
-			SetCloseAndDelete(true);
-			return;
-		}
-		SSL_set_bio(m_ssl, m_sbio, m_sbio);
-//		if (!SSLNegotiate())
-		{
-			SetSSLNegotiate();
-		}
-	}
+    SetNonblocking(true);
+    {
+        if (m_ssl_ctx)
+        {
+DEB(            fprintf(stderr, "SSL Context already initialized - closing socket\n");)
+            SetCloseAndDelete(true);
+            return;
+        }
+        InitSSLServer();
+        SetSSLServer();
+    }
+    if (m_ssl_ctx)
+    {
+        m_ssl = SSL_new(m_ssl_ctx);
+        if (!m_ssl)
+        {
+DEB(            fprintf(stderr, " m_ssl is NULL\n");)
+            SetCloseAndDelete(true);
+            return;
+        }
+        SSL_set_mode(m_ssl, SSL_MODE_AUTO_RETRY);
+        m_sbio = BIO_new_socket((int)GetSocket(), BIO_NOCLOSE);
+        if (!m_sbio)
+        {
+DEB(            fprintf(stderr, " m_sbio is NULL\n");)
+            SetCloseAndDelete(true);
+            return;
+        }
+        SSL_set_bio(m_ssl, m_sbio, m_sbio);
+//      if (!SSLNegotiate())
+        {
+            SetSSLNegotiate();
+        }
+    }
 }
 
 
 bool TcpSocket::SSLNegotiate()
 {
-	if (!IsSSLServer()) // client
-	{
-		int r = SSL_connect(m_ssl);
-		if (r > 0)
-		{
-			SetSSLNegotiate(false);
-			/// \todo: resurrect certificate check... client
-//			CheckCertificateChain( "");//ServerHOST);
-			SetNonblocking(false);
-			//
-			{
-				SetConnected();
-				if (GetOutputLength())
-				{
-					OnWrite();
-				}
-			}
+    if (!IsSSLServer()) // client
+    {
+        int r = SSL_connect(m_ssl);
+        if (r > 0)
+        {
+            SetSSLNegotiate(false);
+            /// \todo: resurrect certificate check... client
+//          CheckCertificateChain( "");//ServerHOST);
+            SetNonblocking(false);
+            //
+            {
+                SetConnected();
+                if (GetOutputLength())
+                {
+                    OnWrite();
+                }
+            }
 #ifdef ENABLE_RECONNECT
-			if (IsReconnect())
-				OnReconnect();
-			else
+            if (IsReconnect())
+                OnReconnect();
+            else
 #endif
-			{
-				OnConnect();
-			}
-			Handler().LogError(this, "SSLNegotiate/SSL_connect", 0, "Connection established", LOG_LEVEL_INFO);
-			return true;
-		}
-		else
-		if (!r)
-		{
-			Handler().LogError(this, "SSLNegotiate/SSL_connect", 0, "Connection failed", LOG_LEVEL_INFO);
-			SetSSLNegotiate(false);
-			SetCloseAndDelete();
-			OnSSLConnectFailed();
-		}
-		else
-		{
-			r = SSL_get_error(m_ssl, r);
-			if (r != SSL_ERROR_WANT_READ && r != SSL_ERROR_WANT_WRITE)
-			{
-				Handler().LogError(this, "SSLNegotiate/SSL_connect", -1, "Connection failed", LOG_LEVEL_INFO);
-DEB(				fprintf(stderr, "SSL_connect() failed - closing socket, return code: %d\n",r);)
-				SetSSLNegotiate(false);
-				SetCloseAndDelete(true);
-				OnSSLConnectFailed();
-			}
-		}
-	}
-	else // server
-	{
-		int r = SSL_accept(m_ssl);
-		if (r > 0)
-		{
-			SetSSLNegotiate(false);
-			/// \todo: resurrect certificate check... server
-//			CheckCertificateChain( "");//ClientHOST);
-			SetNonblocking(false);
-			//
-			{
-				SetConnected();
-				if (GetOutputLength())
-				{
-					OnWrite();
-				}
-			}
-			OnAccept();
-			Handler().LogError(this, "SSLNegotiate/SSL_accept", 0, "Connection established", LOG_LEVEL_INFO);
-			return true;
-		}
-		else
-		if (!r)
-		{
-			Handler().LogError(this, "SSLNegotiate/SSL_accept", 0, "Connection failed", LOG_LEVEL_INFO);
-			SetSSLNegotiate(false);
-			SetCloseAndDelete();
-			OnSSLAcceptFailed();
-		}
-		else
-		{
-			r = SSL_get_error(m_ssl, r);
-			if (r != SSL_ERROR_WANT_READ && r != SSL_ERROR_WANT_WRITE)
-			{
-				Handler().LogError(this, "SSLNegotiate/SSL_accept", -1, "Connection failed", LOG_LEVEL_INFO);
-DEB(				fprintf(stderr, "SSL_accept() failed - closing socket, return code: %d\n",r);)
-				SetSSLNegotiate(false);
-				SetCloseAndDelete(true);
-				OnSSLAcceptFailed();
-			}
-		}
-	}
-	return false;
+            {
+                OnConnect();
+            }
+            Handler().LogError(this, "SSLNegotiate/SSL_connect", 0, "Connection established", LOG_LEVEL_INFO);
+            return true;
+        }
+        else
+        if (!r)
+        {
+            Handler().LogError(this, "SSLNegotiate/SSL_connect", 0, "Connection failed", LOG_LEVEL_INFO);
+            SetSSLNegotiate(false);
+            SetCloseAndDelete();
+            OnSSLConnectFailed();
+        }
+        else
+        {
+            r = SSL_get_error(m_ssl, r);
+            if (r != SSL_ERROR_WANT_READ && r != SSL_ERROR_WANT_WRITE)
+            {
+                Handler().LogError(this, "SSLNegotiate/SSL_connect", -1, "Connection failed", LOG_LEVEL_INFO);
+DEB(                fprintf(stderr, "SSL_connect() failed - closing socket, return code: %d\n",r);)
+                SetSSLNegotiate(false);
+                SetCloseAndDelete(true);
+                OnSSLConnectFailed();
+            }
+        }
+    }
+    else // server
+    {
+        int r = SSL_accept(m_ssl);
+        if (r > 0)
+        {
+            SetSSLNegotiate(false);
+            /// \todo: resurrect certificate check... server
+//          CheckCertificateChain( "");//ClientHOST);
+            SetNonblocking(false);
+            //
+            {
+                SetConnected();
+                if (GetOutputLength())
+                {
+                    OnWrite();
+                }
+            }
+            OnAccept();
+            Handler().LogError(this, "SSLNegotiate/SSL_accept", 0, "Connection established", LOG_LEVEL_INFO);
+            return true;
+        }
+        else
+        if (!r)
+        {
+            Handler().LogError(this, "SSLNegotiate/SSL_accept", 0, "Connection failed", LOG_LEVEL_INFO);
+            SetSSLNegotiate(false);
+            SetCloseAndDelete();
+            OnSSLAcceptFailed();
+        }
+        else
+        {
+            r = SSL_get_error(m_ssl, r);
+            if (r != SSL_ERROR_WANT_READ && r != SSL_ERROR_WANT_WRITE)
+            {
+                Handler().LogError(this, "SSLNegotiate/SSL_accept", -1, "Connection failed", LOG_LEVEL_INFO);
+DEB(                fprintf(stderr, "SSL_accept() failed - closing socket, return code: %d\n",r);)
+                SetSSLNegotiate(false);
+                SetCloseAndDelete(true);
+                OnSSLAcceptFailed();
+            }
+        }
+    }
+    return false;
 }
 
 
 void TcpSocket::InitSSLClient()
 {
-	InitializeContext("", SSLv23_method());
+    InitializeContext("", SSLv23_method());
 }
 
 
 void TcpSocket::InitSSLServer()
 {
-	Handler().LogError(this, "InitSSLServer", 0, "You MUST implement your own InitSSLServer method", LOG_LEVEL_FATAL);
-	SetCloseAndDelete();
+    Handler().LogError(this, "InitSSLServer", 0, "You MUST implement your own InitSSLServer method", LOG_LEVEL_FATAL);
+    SetCloseAndDelete();
 }
 
 
 void TcpSocket::InitializeContext(const std::string& context, SSL_METHOD *meth_in)
 {
-	/* Create our context*/
-	static std::map<std::string, SSL_CTX *> client_contexts;
-	if (client_contexts.find(context) == client_contexts.end())
-	{
-		SSL_METHOD *meth = meth_in ? meth_in : SSLv3_method();
-		m_ssl_ctx = client_contexts[context] = SSL_CTX_new(meth);
-		SSL_CTX_set_mode(m_ssl_ctx, SSL_MODE_AUTO_RETRY);
-	}
-	else
-	{
-		m_ssl_ctx = client_contexts[context];
-	}
+    /* Create our context*/
+    static std::map<std::string, SSL_CTX *> client_contexts;
+    if (client_contexts.find(context) == client_contexts.end())
+    {
+        SSL_METHOD *meth = meth_in ? meth_in : SSLv3_method();
+        m_ssl_ctx = client_contexts[context] = SSL_CTX_new(meth);
+        SSL_CTX_set_mode(m_ssl_ctx, SSL_MODE_AUTO_RETRY);
+    }
+    else
+    {
+        m_ssl_ctx = client_contexts[context];
+    }
 }
 
 
 void TcpSocket::InitializeContext(const std::string& context,const std::string& keyfile,const std::string& password,SSL_METHOD *meth_in)
 {
-	/* Create our context*/
-	static std::map<std::string, SSL_CTX *> server_contexts;
-	if (server_contexts.find(context) == server_contexts.end())
-	{
-		SSL_METHOD *meth = meth_in ? meth_in : SSLv3_method();
-		m_ssl_ctx = server_contexts[context] = SSL_CTX_new(meth);
-		SSL_CTX_set_mode(m_ssl_ctx, SSL_MODE_AUTO_RETRY);
-		// session id
-		if (!context.empty())
-			SSL_CTX_set_session_id_context(m_ssl_ctx, (const unsigned char *)context.c_str(), (unsigned int)context.size());
-		else
-			SSL_CTX_set_session_id_context(m_ssl_ctx, (const unsigned char *)"--empty--", 9);
-	}
-	else
-	{
-		m_ssl_ctx = server_contexts[context];
-	}
-
-	/* Load our keys and certificates*/
-	if (!(SSL_CTX_use_certificate_file(m_ssl_ctx, keyfile.c_str(), SSL_FILETYPE_PEM)))
-	{
-		Handler().LogError(this, "TcpSocket InitializeContext", 0, "Couldn't read certificate file " + keyfile, LOG_LEVEL_FATAL);
-	}
-
-	m_password = password;
-	SSL_CTX_set_default_passwd_cb(m_ssl_ctx, SSL_password_cb);
-	SSL_CTX_set_default_passwd_cb_userdata(m_ssl_ctx, this);
-	if (!(SSL_CTX_use_PrivateKey_file(m_ssl_ctx, keyfile.c_str(), SSL_FILETYPE_PEM)))
-	{
-		Handler().LogError(this, "TcpSocket InitializeContext", 0, "Couldn't read private key file " + keyfile, LOG_LEVEL_FATAL);
-	}
+    /* Create our context*/
+    static std::map<std::string, SSL_CTX *> server_contexts;
+    if (server_contexts.find(context) == server_contexts.end())
+    {
+        SSL_METHOD *meth = meth_in ? meth_in : SSLv3_method();
+        m_ssl_ctx = server_contexts[context] = SSL_CTX_new(meth);
+        SSL_CTX_set_mode(m_ssl_ctx, SSL_MODE_AUTO_RETRY);
+        // session id
+        if (!context.empty())
+            SSL_CTX_set_session_id_context(m_ssl_ctx, (const unsigned char *)context.c_str(), (unsigned int)context.size());
+        else
+            SSL_CTX_set_session_id_context(m_ssl_ctx, (const unsigned char *)"--empty--", 9);
+    }
+    else
+    {
+        m_ssl_ctx = server_contexts[context];
+    }
+
+    /* Load our keys and certificates*/
+    if (!(SSL_CTX_use_certificate_file(m_ssl_ctx, keyfile.c_str(), SSL_FILETYPE_PEM)))
+    {
+        Handler().LogError(this, "TcpSocket InitializeContext", 0, "Couldn't read certificate file " + keyfile, LOG_LEVEL_FATAL);
+    }
+
+    m_password = password;
+    SSL_CTX_set_default_passwd_cb(m_ssl_ctx, SSL_password_cb);
+    SSL_CTX_set_default_passwd_cb_userdata(m_ssl_ctx, this);
+    if (!(SSL_CTX_use_PrivateKey_file(m_ssl_ctx, keyfile.c_str(), SSL_FILETYPE_PEM)))
+    {
+        Handler().LogError(this, "TcpSocket InitializeContext", 0, "Couldn't read private key file " + keyfile, LOG_LEVEL_FATAL);
+    }
 }
 
 
 void TcpSocket::InitializeContext(const std::string& context,const std::string& certfile,const std::string& keyfile,const std::string& password,SSL_METHOD *meth_in)
 {
-	/* Create our context*/
-	static std::map<std::string, SSL_CTX *> server_contexts;
-	if (server_contexts.find(context) == server_contexts.end())
-	{
-		SSL_METHOD *meth = meth_in ? meth_in : SSLv3_method();
-		m_ssl_ctx = server_contexts[context] = SSL_CTX_new(meth);
-		SSL_CTX_set_mode(m_ssl_ctx, SSL_MODE_AUTO_RETRY);
-		// session id
-		if (context.size())
-			SSL_CTX_set_session_id_context(m_ssl_ctx, (const unsigned char *)context.c_str(), (unsigned int)context.size());
-		else
-			SSL_CTX_set_session_id_context(m_ssl_ctx, (const unsigned char *)"--empty--", 9);
-	}
-	else
-	{
-		m_ssl_ctx = server_contexts[context];
-	}
-
-	/* Load our keys and certificates*/
-	if (!(SSL_CTX_use_certificate_file(m_ssl_ctx, certfile.c_str(), SSL_FILETYPE_PEM)))
-	{
-		Handler().LogError(this, "TcpSocket InitializeContext", 0, "Couldn't read certificate file " + keyfile, LOG_LEVEL_FATAL);
-	}
-
-	m_password = password;
-	SSL_CTX_set_default_passwd_cb(m_ssl_ctx, SSL_password_cb);
-	SSL_CTX_set_default_passwd_cb_userdata(m_ssl_ctx, this);
-	if (!(SSL_CTX_use_PrivateKey_file(m_ssl_ctx, keyfile.c_str(), SSL_FILETYPE_PEM)))
-	{
-		Handler().LogError(this, "TcpSocket InitializeContext", 0, "Couldn't read private key file " + keyfile, LOG_LEVEL_FATAL);
-	}
+    /* Create our context*/
+    static std::map<std::string, SSL_CTX *> server_contexts;
+    if (server_contexts.find(context) == server_contexts.end())
+    {
+        SSL_METHOD *meth = meth_in ? meth_in : SSLv3_method();
+        m_ssl_ctx = server_contexts[context] = SSL_CTX_new(meth);
+        SSL_CTX_set_mode(m_ssl_ctx, SSL_MODE_AUTO_RETRY);
+        // session id
+        if (context.size())
+            SSL_CTX_set_session_id_context(m_ssl_ctx, (const unsigned char *)context.c_str(), (unsigned int)context.size());
+        else
+            SSL_CTX_set_session_id_context(m_ssl_ctx, (const unsigned char *)"--empty--", 9);
+    }
+    else
+    {
+        m_ssl_ctx = server_contexts[context];
+    }
+
+    /* Load our keys and certificates*/
+    if (!(SSL_CTX_use_certificate_file(m_ssl_ctx, certfile.c_str(), SSL_FILETYPE_PEM)))
+    {
+        Handler().LogError(this, "TcpSocket InitializeContext", 0, "Couldn't read certificate file " + keyfile, LOG_LEVEL_FATAL);
+    }
+
+    m_password = password;
+    SSL_CTX_set_default_passwd_cb(m_ssl_ctx, SSL_password_cb);
+    SSL_CTX_set_default_passwd_cb_userdata(m_ssl_ctx, this);
+    if (!(SSL_CTX_use_PrivateKey_file(m_ssl_ctx, keyfile.c_str(), SSL_FILETYPE_PEM)))
+    {
+        Handler().LogError(this, "TcpSocket InitializeContext", 0, "Couldn't read private key file " + keyfile, LOG_LEVEL_FATAL);
+    }
 }
 
 
 int TcpSocket::SSL_password_cb(char *buf,int num,int rwflag,void *userdata)
 {
-	Socket *p0 = static_cast<Socket *>(userdata);
-	TcpSocket *p = dynamic_cast<TcpSocket *>(p0);
-	std::string pw = p ? p -> GetPassword() : "";
-	if ( (size_t)num < pw.size() + 1)
-	{
-		return 0;
-	}
-	strcpy(buf,pw.c_str());
-	return (int)pw.size();
+    Socket *p0 = static_cast<Socket *>(userdata);
+    TcpSocket *p = dynamic_cast<TcpSocket *>(p0);
+    std::string pw = p ? p -> GetPassword() : "";
+    if ( (size_t)num < pw.size() + 1)
+    {
+        return 0;
+    }
+    strcpy(buf,pw.c_str());
+    return (int)pw.size();
 }
 #endif // HAVE_OPENSSL
 
 
 int TcpSocket::Close()
 {
-	if (GetSocket() == INVALID_SOCKET) // this could happen
-	{
-		Handler().LogError(this, "Socket::Close", 0, "file descriptor invalid", LOG_LEVEL_WARNING);
-		return 0;
-	}
-	int n;
-	SetNonblocking(true);
-	if (!Lost() && IsConnected() && !(GetShutdown() & SHUT_WR))
-	{
-		if (shutdown(GetSocket(), SHUT_WR) == -1)
-		{
-			// failed...
-			Handler().LogError(this, "shutdown", Errno, StrError(Errno), LOG_LEVEL_ERROR);
-		}
-	}
-	//
-	char tmp[1000];
-	if (!Lost() && (n = recv(GetSocket(),tmp,1000,0)) >= 0)
-	{
-		if (n)
-		{
-			Handler().LogError(this, "read() after shutdown", n, "bytes read", LOG_LEVEL_WARNING);
-		}
-	}
+    if (GetSocket() == INVALID_SOCKET) // this could happen
+    {
+        Handler().LogError(this, "Socket::Close", 0, "file descriptor invalid", LOG_LEVEL_WARNING);
+        return 0;
+    }
+    int n;
+    SetNonblocking(true);
+    if (!Lost() && IsConnected() && !(GetShutdown() & SHUT_WR))
+    {
+        if (shutdown(GetSocket(), SHUT_WR) == -1)
+        {
+            // failed...
+            Handler().LogError(this, "shutdown", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+        }
+    }
+    //
+    char tmp[1000];
+    if (!Lost() && (n = recv(GetSocket(),tmp,1000,0)) >= 0)
+    {
+        if (n)
+        {
+            Handler().LogError(this, "read() after shutdown", n, "bytes read", LOG_LEVEL_WARNING);
+        }
+    }
 #ifdef HAVE_OPENSSL
-	if (IsSSL() && m_ssl)
-		SSL_shutdown(m_ssl);
-	if (m_ssl)
-	{
-		SSL_free(m_ssl);
-		m_ssl = NULL;
-	}
+    if (IsSSL() && m_ssl)
+        SSL_shutdown(m_ssl);
+    if (m_ssl)
+    {
+        SSL_free(m_ssl);
+        m_ssl = NULL;
+    }
 #endif
-	return Socket::Close();
+    return Socket::Close();
 }
 
 
 #ifdef HAVE_OPENSSL
 SSL_CTX *TcpSocket::GetSslContext()
 {
-	if (!m_ssl_ctx)
-		Handler().LogError(this, "GetSslContext", 0, "SSL Context is NULL; check InitSSLServer/InitSSLClient", LOG_LEVEL_WARNING);
-	return m_ssl_ctx;
+    if (!m_ssl_ctx)
+        Handler().LogError(this, "GetSslContext", 0, "SSL Context is NULL; check InitSSLServer/InitSSLClient", LOG_LEVEL_WARNING);
+    return m_ssl_ctx;
 }
 
 SSL *TcpSocket::GetSsl()
 {
-	if (!m_ssl)
-		Handler().LogError(this, "GetSsl", 0, "SSL is NULL; check InitSSLServer/InitSSLClient", LOG_LEVEL_WARNING);
-	return m_ssl;
+    if (!m_ssl)
+        Handler().LogError(this, "GetSsl", 0, "SSL is NULL; check InitSSLServer/InitSSLClient", LOG_LEVEL_WARNING);
+    return m_ssl;
 }
 #endif
 
@@ -1375,7 +1375,7 @@ SSL *TcpSocket::GetSsl()
 #ifdef ENABLE_RECONNECT
 void TcpSocket::SetReconnect(bool x)
 {
-	m_b_reconnect = x;
+    m_b_reconnect = x;
 }
 #endif
 
@@ -1387,50 +1387,50 @@ void TcpSocket::OnRawData(const char *buf_in,size_t len)
 
 size_t TcpSocket::GetInputLength()
 {
-	return ibuf.GetLength();
+    return ibuf.GetLength();
 }
 
 
 size_t TcpSocket::GetOutputLength()
 {
-	return m_output_length;
+    return m_output_length;
 }
 
 
 uint64_t TcpSocket::GetBytesReceived(bool clear)
 {
-	uint64_t z = m_bytes_received;
-	if (clear)
-		m_bytes_received = 0;
-	return z;
+    uint64_t z = m_bytes_received;
+    if (clear)
+        m_bytes_received = 0;
+    return z;
 }
 
 
 uint64_t TcpSocket::GetBytesSent(bool clear)
 {
-	uint64_t z = m_bytes_sent;
-	if (clear)
-		m_bytes_sent = 0;
-	return z;
+    uint64_t z = m_bytes_sent;
+    if (clear)
+        m_bytes_sent = 0;
+    return z;
 }
 
 
 #ifdef ENABLE_RECONNECT
 bool TcpSocket::Reconnect()
 {
-	return m_b_reconnect;
+    return m_b_reconnect;
 }
 
 
 void TcpSocket::SetIsReconnect(bool x)
 {
-	m_b_is_reconnect = x;
+    m_b_is_reconnect = x;
 }
 
 
 bool TcpSocket::IsReconnect()
 {
-	return m_b_is_reconnect;
+    return m_b_is_reconnect;
 }
 #endif
 
@@ -1438,48 +1438,48 @@ bool TcpSocket::IsReconnect()
 #ifdef HAVE_OPENSSL
 const std::string& TcpSocket::GetPassword()
 {
-	return m_password;
+    return m_password;
 }
 #endif
 
 
 void TcpSocket::DisableInputBuffer(bool x)
 {
-	m_b_input_buffer_disabled = x;
+    m_b_input_buffer_disabled = x;
 }
 
 
 void TcpSocket::OnOptions(int family,int type,int protocol,SOCKET s)
 {
-DEB(	fprintf(stderr, "Socket::OnOptions()\n");)
+DEB(    fprintf(stderr, "Socket::OnOptions()\n");)
 #ifdef SO_NOSIGPIPE
-	SetSoNosigpipe(true);
+    SetSoNosigpipe(true);
 #endif
-	SetSoReuseaddr(true);
-	SetSoKeepalive(true);
+    SetSoReuseaddr(true);
+    SetSoKeepalive(true);
 }
 
 
 void TcpSocket::SetLineProtocol(bool x)
 {
-	StreamSocket::SetLineProtocol(x);
-	DisableInputBuffer(x);
+    StreamSocket::SetLineProtocol(x);
+    DisableInputBuffer(x);
 }
 
 
 bool TcpSocket::SetTcpNodelay(bool x)
 {
 #ifdef TCP_NODELAY
-	int optval = x ? 1 : 0;
-	if (setsockopt(GetSocket(), IPPROTO_TCP, TCP_NODELAY, (char *)&optval, sizeof(optval)) == -1)
-	{
-		Handler().LogError(this, "setsockopt(IPPROTO_TCP, TCP_NODELAY)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-		return false;
-	}
-	return true;
+    int optval = x ? 1 : 0;
+    if (setsockopt(GetSocket(), IPPROTO_TCP, TCP_NODELAY, (char *)&optval, sizeof(optval)) == -1)
+    {
+        Handler().LogError(this, "setsockopt(IPPROTO_TCP, TCP_NODELAY)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+        return false;
+    }
+    return true;
 #else
-	Handler().LogError(this, "socket option not available", 0, "TCP_NODELAY", LOG_LEVEL_INFO);
-	return false;
+    Handler().LogError(this, "socket option not available", 0, "TCP_NODELAY", LOG_LEVEL_INFO);
+    return false;
 #endif
 }
 
@@ -1497,73 +1497,73 @@ TcpSocket::CircularBuffer::CircularBuffer(size_t size)
 
 TcpSocket::CircularBuffer::~CircularBuffer()
 {
-	delete[] buf;
+    delete[] buf;
 }
 
 
 bool TcpSocket::CircularBuffer::Write(const char *s,size_t l)
 {
-	if (m_q + l > m_max)
-	{
-		return false; // overflow
-	}
-	m_count += (unsigned long)l;
-	if (m_t + l > m_max) // block crosses circular border
-	{
-		size_t l1 = m_max - m_t; // size left until circular border crossing
-		// always copy full block to buffer(buf) + top pointer(m_t)
-		// because we have doubled the buffer size for performance reasons
-		memcpy(buf + m_t, s, l);
-		memcpy(buf, s + l1, l - l1);
-		m_t = l - l1;
-		m_q += l;
-	}
-	else
-	{
-		memcpy(buf + m_t, s, l);
-		memcpy(buf + m_max + m_t, s, l);
-		m_t += l;
-		if (m_t >= m_max)
-			m_t -= m_max;
-		m_q += l;
-	}
-	return true;
+    if (m_q + l > m_max)
+    {
+        return false; // overflow
+    }
+    m_count += (unsigned long)l;
+    if (m_t + l > m_max) // block crosses circular border
+    {
+        size_t l1 = m_max - m_t; // size left until circular border crossing
+        // always copy full block to buffer(buf) + top pointer(m_t)
+        // because we have doubled the buffer size for performance reasons
+        memcpy(buf + m_t, s, l);
+        memcpy(buf, s + l1, l - l1);
+        m_t = l - l1;
+        m_q += l;
+    }
+    else
+    {
+        memcpy(buf + m_t, s, l);
+        memcpy(buf + m_max + m_t, s, l);
+        m_t += l;
+        if (m_t >= m_max)
+            m_t -= m_max;
+        m_q += l;
+    }
+    return true;
 }
 
 
 bool TcpSocket::CircularBuffer::Read(char *s,size_t l)
 {
-	if (l > m_q)
-	{
-		return false; // not enough chars
-	}
-	if (m_b + l > m_max) // block crosses circular border
-	{
-		size_t l1 = m_max - m_b;
-		if (s)
-		{
-			memcpy(s, buf + m_b, l1);
-			memcpy(s + l1, buf, l - l1);
-		}
-		m_b = l - l1;
-		m_q -= l;
-	}
-	else
-	{
-		if (s)
-		{
-			memcpy(s, buf + m_b, l);
-		}
-		m_b += l;
-		if (m_b >= m_max)
-			m_b -= m_max;
-		m_q -= l;
-	}
-	if (!m_q)
-	{
-		m_b = m_t = 0;
-	}
-	return true;
+    if (l > m_q)
+    {
+        return false; // not enough chars
+    }
+    if (m_b + l > m_max) // block crosses circular border
+    {
+        size_t l1 = m_max - m_b;
+        if (s)
+        {
+            memcpy(s, buf + m_b, l1);
+            memcpy(s + l1, buf, l - l1);
+        }
+        m_b = l - l1;
+        m_q -= l;
+    }
+    else
+    {
+        if (s)
+        {
+            memcpy(s, buf + m_b, l);
+        }
+        m_b += l;
+        if (m_b >= m_max)
+            m_b -= m_max;
+        m_q -= l;
+    }
+    if (!m_q)
+    {
+        m_b = m_t = 0;
+    }
+    return true;
 }
 
 bool TcpSocket::CircularBuffer::SoftRead(char *s, size_t l)
@@ -1593,144 +1593,144 @@ bool TcpSocket::CircularBuffer::SoftRead(char *s, size_t l)
 
 bool TcpSocket::CircularBuffer::Remove(size_t l)
 {
-	return Read(NULL, l);
+    return Read(NULL, l);
 }
 
 
 size_t TcpSocket::CircularBuffer::GetLength()
 {
-	return m_q;
+    return m_q;
 }
 
 
 const char *TcpSocket::CircularBuffer::GetStart()
 {
-	return buf + m_b;
+    return buf + m_b;
 }
 
 
 size_t TcpSocket::CircularBuffer::GetL()
 {
-	return (m_b + m_q > m_max) ? m_max - m_b : m_q;
+    return (m_b + m_q > m_max) ? m_max - m_b : m_q;
 }
 
 
 size_t TcpSocket::CircularBuffer::Space()
 {
-	return m_max - m_q;
+    return m_max - m_q;
 }
 
 
 unsigned long TcpSocket::CircularBuffer::ByteCounter(bool clear)
 {
-	if (clear)
-	{
-		unsigned long x = m_count;
-		m_count = 0;
-		return x;
-	}
-	return m_count;
+    if (clear)
+    {
+        unsigned long x = m_count;
+        m_count = 0;
+        return x;
+    }
+    return m_count;
 }
 
 
 std::string TcpSocket::CircularBuffer::ReadString(size_t l)
 {
-	char *sz = new char[l + 1];
-	if (!Read(sz, l)) // failed, debug printout in Read() method
-	{
-		delete[] sz;
-		return "";
-	}
-	sz[l] = 0;
-	std::string tmp = sz;
-	delete[] sz;
-	return tmp;
+    char *sz = new char[l + 1];
+    if (!Read(sz, l)) // failed, debug printout in Read() method
+    {
+        delete[] sz;
+        return "";
+    }
+    sz[l] = 0;
+    std::string tmp = sz;
+    delete[] sz;
+    return tmp;
 }
 
 
 void TcpSocket::OnConnectTimeout()
 {
-	Handler().LogError(this, "connect", -1, "connect timeout", LOG_LEVEL_FATAL);
+    Handler().LogError(this, "connect", -1, "connect timeout", LOG_LEVEL_FATAL);
 #ifdef ENABLE_SOCKS4
-	if (Socks4())
-	{
-		OnSocks4ConnectFailed();
-		// retry direct connection
-	}
-	else
+    if (Socks4())
+    {
+        OnSocks4ConnectFailed();
+        // retry direct connection
+    }
+    else
 #endif
-	if (GetConnectionRetry() == -1 ||
-		(GetConnectionRetry() && GetConnectionRetries() < GetConnectionRetry()) )
-	{
-		IncreaseConnectionRetries();
-		// ask socket via OnConnectRetry callback if we should continue trying
-		if (OnConnectRetry())
-		{
-			SetRetryClientConnect();
-		}
-		else
-		{
-			SetCloseAndDelete( true );
-			/// \todo state reason why connect failed
-			OnConnectFailed();
-		}
-	}
-	else
-	{
-		SetCloseAndDelete(true);
-		/// \todo state reason why connect failed
-		OnConnectFailed();
-	}
-	//
-	SetConnecting(false);
+    if (GetConnectionRetry() == -1 ||
+        (GetConnectionRetry() && GetConnectionRetries() < GetConnectionRetry()) )
+    {
+        IncreaseConnectionRetries();
+        // ask socket via OnConnectRetry callback if we should continue trying
+        if (OnConnectRetry())
+        {
+            SetRetryClientConnect();
+        }
+        else
+        {
+            SetCloseAndDelete( true );
+            /// \todo state reason why connect failed
+            OnConnectFailed();
+        }
+    }
+    else
+    {
+        SetCloseAndDelete(true);
+        /// \todo state reason why connect failed
+        OnConnectFailed();
+    }
+    //
+    SetConnecting(false);
 }
 
 
 #ifdef _WIN32
 void TcpSocket::OnException()
 {
-	if (Connecting())
-	{
+    if (Connecting())
+    {
 #ifdef ENABLE_SOCKS4
-		if (Socks4())
-			OnSocks4ConnectFailed();
-		else
+        if (Socks4())
+            OnSocks4ConnectFailed();
+        else
 #endif
-		if (GetConnectionRetry() == -1 ||
-			(GetConnectionRetry() &&
-			 GetConnectionRetries() < GetConnectionRetry() ))
-		{
-			// even though the connection failed at once, only retry after
-			// the connection timeout
-			// should we even try to connect again, when CheckConnect returns
-			// false it's because of a connection error - not a timeout...
-		}
-		else
-		{
-			SetConnecting(false); // tnx snibbe
-			SetCloseAndDelete();
-			OnConnectFailed();
-		}
-		return;
-	}
-	// %! exception doesn't always mean something bad happened, this code should be reworked
-	// errno valid here?
-	int err = SoError();
-	Handler().LogError(this, "exception on select", err, StrError(err), LOG_LEVEL_FATAL);
-	SetCloseAndDelete();
+        if (GetConnectionRetry() == -1 ||
+            (GetConnectionRetry() &&
+             GetConnectionRetries() < GetConnectionRetry() ))
+        {
+            // even though the connection failed at once, only retry after
+            // the connection timeout
+            // should we even try to connect again, when CheckConnect returns
+            // false it's because of a connection error - not a timeout...
+        }
+        else
+        {
+            SetConnecting(false); // tnx snibbe
+            SetCloseAndDelete();
+            OnConnectFailed();
+        }
+        return;
+    }
+    // %! exception doesn't always mean something bad happened, this code should be reworked
+    // errno valid here?
+    int err = SoError();
+    Handler().LogError(this, "exception on select", err, StrError(err), LOG_LEVEL_FATAL);
+    SetCloseAndDelete();
 }
 #endif // _WIN32
 
 
 int TcpSocket::Protocol()
 {
-	return IPPROTO_TCP;
+    return IPPROTO_TCP;
 }
 
 
 void TcpSocket::SetTransferLimit(size_t sz)
 {
-	m_transfer_limit = sz;
+    m_transfer_limit = sz;
 }
 
 
diff --git a/dep/src/sockets/Thread.cpp b/dep/src/sockets/Thread.cpp
index 2717e32d016..e1834ab4a87 100644
--- a/dep/src/sockets/Thread.cpp
+++ b/dep/src/sockets/Thread.cpp
@@ -1,6 +1,6 @@
 /** \file Thread.cpp
- **	\date  2004-10-30
- **	\author grymse@alhem.net
+ ** \date  2004-10-30
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2004-2007  Anders Hedstrom
@@ -51,111 +51,111 @@ Thread::Thread(bool release)
 ,m_b_destructor(false)
 {
 #ifdef _WIN32
-//	m_thread = ::CreateThread(NULL, 0, StartThread, this, 0, &m_dwThreadId);
-	m_thread = (HANDLE)_beginthreadex(NULL, 0, &StartThread, this, 0, &m_dwThreadId);
+//  m_thread = ::CreateThread(NULL, 0, StartThread, this, 0, &m_dwThreadId);
+    m_thread = (HANDLE)_beginthreadex(NULL, 0, &StartThread, this, 0, &m_dwThreadId);
 #else
-	pthread_attr_t attr;
-
-	pthread_attr_init(&attr);
-	pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
-	if (pthread_create(&m_thread,&attr, StartThread,this) == -1)
-	{
-		perror("Thread: create failed");
-		SetRunning(false);
-	}
-//	pthread_attr_destroy(&attr);
+    pthread_attr_t attr;
+
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
+    if (pthread_create(&m_thread,&attr, StartThread,this) == -1)
+    {
+        perror("Thread: create failed");
+        SetRunning(false);
+    }
+//  pthread_attr_destroy(&attr);
 #endif
-	m_release = release;
+    m_release = release;
 }
 
 
 Thread::~Thread()
 {
-	m_b_destructor = true;
-	if (m_running)
-	{
-		SetRelease(true);
-		SetRunning(false);
+    m_b_destructor = true;
+    if (m_running)
+    {
+        SetRelease(true);
+        SetRunning(false);
 #ifdef _WIN32
-		Sleep(1000);
+        Sleep(1000);
 #else
-		sleep(1);
+        sleep(1);
 #endif
-	}
+    }
 #ifdef _WIN32
-	if (m_thread)
-		::CloseHandle(m_thread);
+    if (m_thread)
+        ::CloseHandle(m_thread);
 #endif
 }
 
 
 threadfunc_t STDPREFIX Thread::StartThread(threadparam_t zz)
 {
-	Thread *p = (Thread *)zz;
+    Thread *p = (Thread *)zz;
 
-	while (p -> m_running && !p -> m_release)
-	{
+    while (p -> m_running && !p -> m_release)
+    {
 #ifdef _WIN32
-		Sleep(1000);
+        Sleep(1000);
 #else
-		sleep(1);
+        sleep(1);
 #endif
-	}
-	if (p -> m_running)
-	{
-		p -> Run();
-	}
-	p -> SetRunning(false); // if return
-	if (p -> DeleteOnExit() && !p -> IsDestructor())
-	{
-		delete p;
-	}
+    }
+    if (p -> m_running)
+    {
+        p -> Run();
+    }
+    p -> SetRunning(false); // if return
+    if (p -> DeleteOnExit() && !p -> IsDestructor())
+    {
+        delete p;
+    }
 #ifdef _WIN32
-	_endthreadex(0);
+    _endthreadex(0);
 #endif
-	return (threadfunc_t)NULL;
+    return (threadfunc_t)NULL;
 }
 
 
 bool Thread::IsRunning()
 {
- 	return m_running;
+    return m_running;
 }
 
 
 void Thread::SetRunning(bool x)
 {
- 	m_running = x;
+    m_running = x;
 }
 
 
 bool Thread::IsReleased()
 {
- 	return m_release;
+    return m_release;
 }
 
 
 void Thread::SetRelease(bool x)
 {
- 	m_release = x;
+    m_release = x;
 }
 
 
 bool Thread::DeleteOnExit()
 {
-	return m_b_delete_on_exit;
+    return m_b_delete_on_exit;
 }
 
 
 void Thread::SetDeleteOnExit(bool x)
 {
-	m_b_delete_on_exit = x;
+    m_b_delete_on_exit = x;
 }
 
 
 bool Thread::IsDestructor()
 {
-	return m_b_destructor;
+    return m_b_destructor;
 }
 
 
diff --git a/dep/src/sockets/UdpSocket.cpp b/dep/src/sockets/UdpSocket.cpp
index 5d949496b25..229a26414e5 100644
--- a/dep/src/sockets/UdpSocket.cpp
+++ b/dep/src/sockets/UdpSocket.cpp
@@ -1,6 +1,6 @@
 /** \file UdpSocket.cpp
- **	\date  2004-02-13
- **	\author grymse@alhem.net
+ ** \date  2004-02-13
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2004-2007  Anders Hedstrom
@@ -64,7 +64,7 @@ UdpSocket::UdpSocket(ISocketHandler& h, int ibufsz, bool ipv6, int retries) : So
 {
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	SetIpv6(ipv6);
+    SetIpv6(ipv6);
 #endif
 #endif
 }
@@ -72,8 +72,8 @@ UdpSocket::UdpSocket(ISocketHandler& h, int ibufsz, bool ipv6, int retries) : So
 
 UdpSocket::~UdpSocket()
 {
-	Close();
-	delete[] m_ibuf;
+    Close();
+    delete[] m_ibuf;
 }
 
 
@@ -81,15 +81,15 @@ int UdpSocket::Bind(port_t &port, int range)
 {
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
-		Ipv6Address ad(port);
-		return Bind(ad, range);
-	}
+    if (IsIpv6())
+    {
+        Ipv6Address ad(port);
+        return Bind(ad, range);
+    }
 #endif
 #endif
-	Ipv4Address ad(port);
-	return Bind(ad, range);
+    Ipv4Address ad(port);
+    return Bind(ad, range);
 }
 
 
@@ -97,32 +97,32 @@ int UdpSocket::Bind(const std::string& intf, port_t &port, int range)
 {
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
-		Ipv6Address ad(intf, port);
-		if (ad.IsValid())
-		{
-			return Bind(ad, range);
-		}
-		SetCloseAndDelete();
-		return -1;
-	}
+    if (IsIpv6())
+    {
+        Ipv6Address ad(intf, port);
+        if (ad.IsValid())
+        {
+            return Bind(ad, range);
+        }
+        SetCloseAndDelete();
+        return -1;
+    }
 #endif
 #endif
-	Ipv4Address ad(intf, port);
-	if (ad.IsValid())
-	{
-		return Bind(ad, range);
-	}
-	SetCloseAndDelete();
-	return -1;
+    Ipv4Address ad(intf, port);
+    if (ad.IsValid())
+    {
+        return Bind(ad, range);
+    }
+    SetCloseAndDelete();
+    return -1;
 }
 
 
 int UdpSocket::Bind(ipaddr_t a, port_t &port, int range)
 {
-	Ipv4Address ad(a, port);
-	return Bind(ad, range);
+    Ipv4Address ad(a, port);
+    return Bind(ad, range);
 }
 
 
@@ -130,8 +130,8 @@ int UdpSocket::Bind(ipaddr_t a, port_t &port, int range)
 #ifdef IPPROTO_IPV6
 int UdpSocket::Bind(in6_addr a, port_t &port, int range)
 {
-	Ipv6Address ad(a, port);
-	return Bind(ad, range);
+    Ipv6Address ad(a, port);
+    return Bind(ad, range);
 }
 #endif
 #endif
@@ -139,42 +139,42 @@ int UdpSocket::Bind(in6_addr a, port_t &port, int range)
 
 int UdpSocket::Bind(SocketAddress& ad, int range)
 {
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
-	}
-	if (GetSocket() != INVALID_SOCKET)
-	{
-		SetNonblocking(true);
-		int n = bind(GetSocket(), ad, ad);
-		int tries = range;
-		while (n == -1 && tries--)
-		{
-			ad.SetPort(ad.GetPort() + 1);
-			n = bind(GetSocket(), ad, ad);
-		}
-		if (n == -1)
-		{
-			Handler().LogError(this, "bind", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-			SetCloseAndDelete();
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
+    }
+    if (GetSocket() != INVALID_SOCKET)
+    {
+        SetNonblocking(true);
+        int n = bind(GetSocket(), ad, ad);
+        int tries = range;
+        while (n == -1 && tries--)
+        {
+            ad.SetPort(ad.GetPort() + 1);
+            n = bind(GetSocket(), ad, ad);
+        }
+        if (n == -1)
+        {
+            Handler().LogError(this, "bind", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+            SetCloseAndDelete();
 #ifdef ENABLE_EXCEPTIONS
-			throw Exception("bind() failed for UdpSocket, port:range: " + Utility::l2string(ad.GetPort()) + ":" + Utility::l2string(range));
+            throw Exception("bind() failed for UdpSocket, port:range: " + Utility::l2string(ad.GetPort()) + ":" + Utility::l2string(range));
 #endif
-			return -1;
-		}
-		m_bind_ok = true;
-		m_port = ad.GetPort();
-		return 0;
-	}
-	return -1;
+            return -1;
+        }
+        m_bind_ok = true;
+        m_port = ad.GetPort();
+        return 0;
+    }
+    return -1;
 }
 
 
 /** if you wish to use Send, first Open a connection */
 bool UdpSocket::Open(ipaddr_t l, port_t port)
 {
-	Ipv4Address ad(l, port);
-	return Open(ad);
+    Ipv4Address ad(l, port);
+    return Open(ad);
 }
 
 
@@ -182,23 +182,23 @@ bool UdpSocket::Open(const std::string& host, port_t port)
 {
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
-		Ipv6Address ad(host, port);
-		if (ad.IsValid())
-		{
-			return Open(ad);
-		}
-		return false;
-	}
+    if (IsIpv6())
+    {
+        Ipv6Address ad(host, port);
+        if (ad.IsValid())
+        {
+            return Open(ad);
+        }
+        return false;
+    }
 #endif
 #endif
-	Ipv4Address ad(host, port);
-	if (ad.IsValid())
-	{
-		return Open(ad);
-	}
-	return false;
+    Ipv4Address ad(host, port);
+    if (ad.IsValid())
+    {
+        return Open(ad);
+    }
+    return false;
 }
 
 
@@ -206,8 +206,8 @@ bool UdpSocket::Open(const std::string& host, port_t port)
 #ifdef IPPROTO_IPV6
 bool UdpSocket::Open(struct in6_addr& a, port_t port)
 {
-	Ipv6Address ad(a, port);
-	return Open(ad);
+    Ipv6Address ad(a, port);
+    return Open(ad);
 }
 #endif
 #endif
@@ -215,23 +215,23 @@ bool UdpSocket::Open(struct in6_addr& a, port_t port)
 
 bool UdpSocket::Open(SocketAddress& ad)
 {
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
-	}
-	if (GetSocket() != INVALID_SOCKET)
-	{
-		SetNonblocking(true);
-		if (connect(GetSocket(), ad, ad) == -1)
-		{
-			Handler().LogError(this, "connect", Errno, StrError(Errno), LOG_LEVEL_FATAL);
-			SetCloseAndDelete();
-			return false;
-		}
-		SetConnected();
-		return true;
-	}
-	return false;
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
+    }
+    if (GetSocket() != INVALID_SOCKET)
+    {
+        SetNonblocking(true);
+        if (connect(GetSocket(), ad, ad) == -1)
+        {
+            Handler().LogError(this, "connect", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+            SetCloseAndDelete();
+            return false;
+        }
+        SetConnected();
+        return true;
+    }
+    return false;
 }
 
 
@@ -239,32 +239,32 @@ void UdpSocket::CreateConnection()
 {
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
-		if (GetSocket() == INVALID_SOCKET)
-		{
-			SOCKET s = CreateSocket(AF_INET6, SOCK_DGRAM, "udp");
-			if (s == INVALID_SOCKET)
-			{
-				return;
-			}
-			SetNonblocking(true, s);
-			Attach(s);
-		}
-		return;
-	}
-#endif
-#endif
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		SOCKET s = CreateSocket(AF_INET, SOCK_DGRAM, "udp");
-		if (s == INVALID_SOCKET)
-		{
-			return;
-		}
-		SetNonblocking(true, s);
-		Attach(s);
-	}
+    if (IsIpv6())
+    {
+        if (GetSocket() == INVALID_SOCKET)
+        {
+            SOCKET s = CreateSocket(AF_INET6, SOCK_DGRAM, "udp");
+            if (s == INVALID_SOCKET)
+            {
+                return;
+            }
+            SetNonblocking(true, s);
+            Attach(s);
+        }
+        return;
+    }
+#endif
+#endif
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        SOCKET s = CreateSocket(AF_INET, SOCK_DGRAM, "udp");
+        if (s == INVALID_SOCKET)
+        {
+            return;
+        }
+        SetNonblocking(true, s);
+        Attach(s);
+    }
 }
 
 
@@ -273,30 +273,30 @@ void UdpSocket::SendToBuf(const std::string& h, port_t p, const char *data, int
 {
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
-		Ipv6Address ad(h, p);
-		if (ad.IsValid())
-		{
-			SendToBuf(ad, data, len, flags);
-		}
-		return;
-	}
+    if (IsIpv6())
+    {
+        Ipv6Address ad(h, p);
+        if (ad.IsValid())
+        {
+            SendToBuf(ad, data, len, flags);
+        }
+        return;
+    }
 #endif
 #endif
-	Ipv4Address ad(h, p);
-	if (ad.IsValid())
-	{
-		SendToBuf(ad, data, len, flags);
-	}
+    Ipv4Address ad(h, p);
+    if (ad.IsValid())
+    {
+        SendToBuf(ad, data, len, flags);
+    }
 }
 
 
 /** send to specified address */
 void UdpSocket::SendToBuf(ipaddr_t a, port_t p, const char *data, int len, int flags)
 {
-	Ipv4Address ad(a, p);
-	SendToBuf(ad, data, len, flags);
+    Ipv4Address ad(a, p);
+    SendToBuf(ad, data, len, flags);
 }
 
 
@@ -304,8 +304,8 @@ void UdpSocket::SendToBuf(ipaddr_t a, port_t p, const char *data, int len, int f
 #ifdef IPPROTO_IPV6
 void UdpSocket::SendToBuf(in6_addr a, port_t p, const char *data, int len, int flags)
 {
-	Ipv6Address ad(a, p);
-	SendToBuf(ad, data, len, flags);
+    Ipv6Address ad(a, p);
+    SendToBuf(ad, data, len, flags);
 }
 #endif
 #endif
@@ -313,30 +313,30 @@ void UdpSocket::SendToBuf(in6_addr a, port_t p, const char *data, int len, int f
 
 void UdpSocket::SendToBuf(SocketAddress& ad, const char *data, int len, int flags)
 {
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
-	}
-	if (GetSocket() != INVALID_SOCKET)
-	{
-		SetNonblocking(true);
-		if ((m_last_size_written = sendto(GetSocket(), data, len, flags, ad, ad)) == -1)
-		{
-			Handler().LogError(this, "sendto", Errno, StrError(Errno), LOG_LEVEL_ERROR);
-		}
-	}
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
+    }
+    if (GetSocket() != INVALID_SOCKET)
+    {
+        SetNonblocking(true);
+        if ((m_last_size_written = sendto(GetSocket(), data, len, flags, ad, ad)) == -1)
+        {
+            Handler().LogError(this, "sendto", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+        }
+    }
 }
 
 
 void UdpSocket::SendTo(const std::string& a, port_t p, const std::string& str, int flags)
 {
-	SendToBuf(a, p, str.c_str(), (int)str.size(), flags);
+    SendToBuf(a, p, str.c_str(), (int)str.size(), flags);
 }
 
 
 void UdpSocket::SendTo(ipaddr_t a, port_t p, const std::string& str, int flags)
 {
-	SendToBuf(a, p, str.c_str(), (int)str.size(), flags);
+    SendToBuf(a, p, str.c_str(), (int)str.size(), flags);
 }
 
 
@@ -344,7 +344,7 @@ void UdpSocket::SendTo(ipaddr_t a, port_t p, const std::string& str, int flags)
 #ifdef IPPROTO_IPV6
 void UdpSocket::SendTo(in6_addr a, port_t p, const std::string& str, int flags)
 {
-	SendToBuf(a, p, str.c_str(), (int)str.size(), flags);
+    SendToBuf(a, p, str.c_str(), (int)str.size(), flags);
 }
 #endif
 #endif
@@ -352,93 +352,93 @@ void UdpSocket::SendTo(in6_addr a, port_t p, const std::string& str, int flags)
 
 void UdpSocket::SendTo(SocketAddress& ad, const std::string& str, int flags)
 {
-	SendToBuf(ad, str.c_str(), (int)str.size(), flags);
+    SendToBuf(ad, str.c_str(), (int)str.size(), flags);
 }
 
 
 /** send to connected address */
 void UdpSocket::SendBuf(const char *data, size_t len, int flags)
 {
-	if (!IsConnected())
-	{
-		Handler().LogError(this, "SendBuf", 0, "not connected", LOG_LEVEL_ERROR);
-		return;
-	}
-	if ((m_last_size_written = send(GetSocket(), data, (int)len, flags)) == -1)
-	{
-		Handler().LogError(this, "send", Errno, StrError(Errno), LOG_LEVEL_ERROR);
-	}
+    if (!IsConnected())
+    {
+        Handler().LogError(this, "SendBuf", 0, "not connected", LOG_LEVEL_ERROR);
+        return;
+    }
+    if ((m_last_size_written = send(GetSocket(), data, (int)len, flags)) == -1)
+    {
+        Handler().LogError(this, "send", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+    }
 }
 
 
 void UdpSocket::Send(const std::string& str, int flags)
 {
-	SendBuf(str.c_str(), (int)str.size(), flags);
+    SendBuf(str.c_str(), (int)str.size(), flags);
 }
 
 
 #if defined(LINUX) || defined(MACOSX)
 int UdpSocket::ReadTS(char *ioBuf, int inBufSize, struct sockaddr *from, socklen_t fromlen, struct timeval *ts)
 {
-	struct msghdr msg;
-	struct iovec vec[1];
-	union {
-		struct cmsghdr cm;
+    struct msghdr msg;
+    struct iovec vec[1];
+    union {
+        struct cmsghdr cm;
 #ifdef MACOSX
 #ifdef __DARWIN_UNIX03
 #define ALIGNBYTES __DARWIN_ALIGNBYTES
 #endif
 #define myALIGN(p) (((unsigned int)(p) + ALIGNBYTES) &~ ALIGNBYTES)
 #define myCMSG_SPACE(l) (myALIGN(sizeof(struct cmsghdr)) + myALIGN(l))
-		char data[ myCMSG_SPACE(sizeof(struct timeval)) ];
+        char data[ myCMSG_SPACE(sizeof(struct timeval)) ];
 #else
-		char data[ CMSG_SPACE(sizeof(struct timeval)) ];
+        char data[ CMSG_SPACE(sizeof(struct timeval)) ];
 #endif
-	} cmsg_un;
-	struct cmsghdr *cmsg;
-	struct timeval *tv;
+    } cmsg_un;
+    struct cmsghdr *cmsg;
+    struct timeval *tv;
 
-	vec[0].iov_base = ioBuf;
-	vec[0].iov_len = inBufSize;
+    vec[0].iov_base = ioBuf;
+    vec[0].iov_len = inBufSize;
 
-	memset(&msg, 0, sizeof(msg));
-	memset(from, 0, fromlen);
-	memset(ioBuf, 0, inBufSize);
-	memset(&cmsg_un, 0, sizeof(cmsg_un));
+    memset(&msg, 0, sizeof(msg));
+    memset(from, 0, fromlen);
+    memset(ioBuf, 0, inBufSize);
+    memset(&cmsg_un, 0, sizeof(cmsg_un));
 
-	msg.msg_name = (caddr_t)from;
-	msg.msg_namelen = fromlen;
-	msg.msg_iov = vec;
-	msg.msg_iovlen = 1;
-	msg.msg_control = cmsg_un.data;
-	msg.msg_controllen = sizeof(cmsg_un.data);
-	msg.msg_flags = 0;
+    msg.msg_name = (caddr_t)from;
+    msg.msg_namelen = fromlen;
+    msg.msg_iov = vec;
+    msg.msg_iovlen = 1;
+    msg.msg_control = cmsg_un.data;
+    msg.msg_controllen = sizeof(cmsg_un.data);
+    msg.msg_flags = 0;
 
-	// Original version - for reference only
-	//int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
+    // Original version - for reference only
+    //int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 
-	int n = recvmsg(GetSocket(), &msg, MSG_DONTWAIT);
+    int n = recvmsg(GetSocket(), &msg, MSG_DONTWAIT);
 
-	// now ioBuf will contain the data, as if we used recvfrom
+    // now ioBuf will contain the data, as if we used recvfrom
 
-	// Now get the time
-	if(n != -1 && msg.msg_controllen >= sizeof(struct cmsghdr) && !(msg.msg_flags & MSG_CTRUNC))
-	{
-		tv = 0;
-		for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg))
-		{
-			if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_TIMESTAMP)
-			{
-				tv = (struct timeval *)CMSG_DATA(cmsg);
-			}
-		}
-		if (tv)
-		{
-			memcpy(ts, tv, sizeof(struct timeval));
-		}
-	}
-	// The address is in network order, but that's OK right now
-	return n;
+    // Now get the time
+    if(n != -1 && msg.msg_controllen >= sizeof(struct cmsghdr) && !(msg.msg_flags & MSG_CTRUNC))
+    {
+        tv = 0;
+        for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg))
+        {
+            if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_TIMESTAMP)
+            {
+                tv = (struct timeval *)CMSG_DATA(cmsg);
+            }
+        }
+        if (tv)
+        {
+            memcpy(ts, tv, sizeof(struct timeval));
+        }
+    }
+    // The address is in network order, but that's OK right now
+    return n;
 }
 #endif
 
@@ -447,324 +447,324 @@ void UdpSocket::OnRead()
 {
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
-		struct sockaddr_in6 sa;
-		socklen_t sa_len = sizeof(sa);
-		if (m_b_read_ts)
-		{
-			struct timeval ts;
-			Utility::GetTime(&ts);
+    if (IsIpv6())
+    {
+        struct sockaddr_in6 sa;
+        socklen_t sa_len = sizeof(sa);
+        if (m_b_read_ts)
+        {
+            struct timeval ts;
+            Utility::GetTime(&ts);
 #if !defined(LINUX) && !defined(MACOSX)
-			int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
+            int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 #else
-			int n = ReadTS(m_ibuf, m_ibufsz, (struct sockaddr *)&sa, sa_len, &ts);
-#endif
-			if (n > 0)
-			{
-				this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len, &ts);
-			}
-			else
-			if (n == -1)
-			{
+            int n = ReadTS(m_ibuf, m_ibufsz, (struct sockaddr *)&sa, sa_len, &ts);
+#endif
+            if (n > 0)
+            {
+                this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len, &ts);
+            }
+            else
+            if (n == -1)
+            {
 #ifdef _WIN32
-				if (Errno != WSAEWOULDBLOCK)
+                if (Errno != WSAEWOULDBLOCK)
 #else
-				if (Errno != EWOULDBLOCK)
-#endif
-					Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
-			}
-			return;
-		}
-		int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
-		int q = m_retries; // receive max 10 at one cycle
-		while (n > 0)
-		{
-			if (sa_len != sizeof(sa))
-			{
-				Handler().LogError(this, "recvfrom", 0, "unexpected address struct size", LOG_LEVEL_WARNING);
-			}
-			this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len);
-			if (!q--)
-				break;
-			//
-			n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
-		}
-		if (n == -1)
-		{
+                if (Errno != EWOULDBLOCK)
+#endif
+                    Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+            }
+            return;
+        }
+        int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
+        int q = m_retries; // receive max 10 at one cycle
+        while (n > 0)
+        {
+            if (sa_len != sizeof(sa))
+            {
+                Handler().LogError(this, "recvfrom", 0, "unexpected address struct size", LOG_LEVEL_WARNING);
+            }
+            this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len);
+            if (!q--)
+                break;
+            //
+            n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
+        }
+        if (n == -1)
+        {
 #ifdef _WIN32
-			if (Errno != WSAEWOULDBLOCK)
+            if (Errno != WSAEWOULDBLOCK)
 #else
-			if (Errno != EWOULDBLOCK)
+            if (Errno != EWOULDBLOCK)
 #endif
-				Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
-		}
-		return;
-	}
+                Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+        }
+        return;
+    }
 #endif
 #endif
-	struct sockaddr_in sa;
-	socklen_t sa_len = sizeof(sa);
-	if (m_b_read_ts)
-	{
-		struct timeval ts;
-		Utility::GetTime(&ts);
+    struct sockaddr_in sa;
+    socklen_t sa_len = sizeof(sa);
+    if (m_b_read_ts)
+    {
+        struct timeval ts;
+        Utility::GetTime(&ts);
 #if !defined(LINUX) && !defined(MACOSX)
-		int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
+        int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
 #else
-		int n = ReadTS(m_ibuf, m_ibufsz, (struct sockaddr *)&sa, sa_len, &ts);
-#endif
-		if (n > 0)
-		{
-			this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len, &ts);
-		}
-		else
-		if (n == -1)
-		{
+        int n = ReadTS(m_ibuf, m_ibufsz, (struct sockaddr *)&sa, sa_len, &ts);
+#endif
+        if (n > 0)
+        {
+            this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len, &ts);
+        }
+        else
+        if (n == -1)
+        {
 #ifdef _WIN32
-			if (Errno != WSAEWOULDBLOCK)
+            if (Errno != WSAEWOULDBLOCK)
 #else
-			if (Errno != EWOULDBLOCK)
-#endif
-				Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
-		}
-		return;
-	}
-	int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
-	int q = m_retries;
-	while (n > 0)
-	{
-		if (sa_len != sizeof(sa))
-		{
-			Handler().LogError(this, "recvfrom", 0, "unexpected address struct size", LOG_LEVEL_WARNING);
-		}
-		this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len);
-		if (!q--)
-			break;
-		//
-		n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
-	}
-	if (n == -1)
-	{
+            if (Errno != EWOULDBLOCK)
+#endif
+                Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+        }
+        return;
+    }
+    int n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
+    int q = m_retries;
+    while (n > 0)
+    {
+        if (sa_len != sizeof(sa))
+        {
+            Handler().LogError(this, "recvfrom", 0, "unexpected address struct size", LOG_LEVEL_WARNING);
+        }
+        this -> OnRawData(m_ibuf, n, (struct sockaddr *)&sa, sa_len);
+        if (!q--)
+            break;
+        //
+        n = recvfrom(GetSocket(), m_ibuf, m_ibufsz, 0, (struct sockaddr *)&sa, &sa_len);
+    }
+    if (n == -1)
+    {
 #ifdef _WIN32
-		if (Errno != WSAEWOULDBLOCK)
+        if (Errno != WSAEWOULDBLOCK)
 #else
-		if (Errno != EWOULDBLOCK)
+        if (Errno != EWOULDBLOCK)
 #endif
-			Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
-	}
+            Handler().LogError(this, "recvfrom", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+    }
 }
 
 
 void UdpSocket::SetBroadcast(bool b)
 {
-	int one = 1;
-	int zero = 0;
-
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		CreateConnection();
-	}
-	if (b)
-	{
-		if (setsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *) &one, sizeof(one)) == -1)
-		{
-			Handler().LogError(this, "SetBroadcast", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-		}
-	}
-	else
-	{
-		if (setsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *) &zero, sizeof(zero)) == -1)
-		{
-			Handler().LogError(this, "SetBroadcast", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-		}
-	}
+    int one = 1;
+    int zero = 0;
+
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        CreateConnection();
+    }
+    if (b)
+    {
+        if (setsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *) &one, sizeof(one)) == -1)
+        {
+            Handler().LogError(this, "SetBroadcast", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+        }
+    }
+    else
+    {
+        if (setsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *) &zero, sizeof(zero)) == -1)
+        {
+            Handler().LogError(this, "SetBroadcast", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+        }
+    }
 }
 
 
 bool UdpSocket::IsBroadcast()
 {
-	int is_broadcast = 0;
-	socklen_t size;
+    int is_broadcast = 0;
+    socklen_t size;
 
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		CreateConnection();
-	}
-	if (getsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *)&is_broadcast, &size) == -1)
-	{
-		Handler().LogError(this, "IsBroadcast", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-	}
-	return is_broadcast != 0;
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        CreateConnection();
+    }
+    if (getsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *)&is_broadcast, &size) == -1)
+    {
+        Handler().LogError(this, "IsBroadcast", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+    }
+    return is_broadcast != 0;
 }
 
 
 void UdpSocket::SetMulticastTTL(int ttl)
 {
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		CreateConnection();
-	}
-	if (setsockopt(GetSocket(), SOL_IP, IP_MULTICAST_TTL, (char *)&ttl, sizeof(int)) == -1)
-	{
-		Handler().LogError(this, "SetMulticastTTL", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-	}
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        CreateConnection();
+    }
+    if (setsockopt(GetSocket(), SOL_IP, IP_MULTICAST_TTL, (char *)&ttl, sizeof(int)) == -1)
+    {
+        Handler().LogError(this, "SetMulticastTTL", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+    }
 }
 
 
 int UdpSocket::GetMulticastTTL()
 {
-	int ttl = 0;
-	socklen_t size = sizeof(int);
+    int ttl = 0;
+    socklen_t size = sizeof(int);
 
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		CreateConnection();
-	}
-	if (getsockopt(GetSocket(), SOL_IP, IP_MULTICAST_TTL, (char *)&ttl, &size) == -1)
-	{
-		Handler().LogError(this, "GetMulticastTTL", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-	}
-	return ttl;
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        CreateConnection();
+    }
+    if (getsockopt(GetSocket(), SOL_IP, IP_MULTICAST_TTL, (char *)&ttl, &size) == -1)
+    {
+        Handler().LogError(this, "GetMulticastTTL", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+    }
+    return ttl;
 }
 
 
 void UdpSocket::SetMulticastLoop(bool x)
 {
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		CreateConnection();
-	}
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        CreateConnection();
+    }
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
-		int val = x ? 1 : 0;
-		if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *)&val, sizeof(int)) == -1)
-		{
-			Handler().LogError(this, "SetMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-		}
-		return;
-	}
+    if (IsIpv6())
+    {
+        int val = x ? 1 : 0;
+        if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *)&val, sizeof(int)) == -1)
+        {
+            Handler().LogError(this, "SetMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+        }
+        return;
+    }
 #endif
 #endif
-	int val = x ? 1 : 0;
-	if (setsockopt(GetSocket(), SOL_IP, IP_MULTICAST_LOOP, (char *)&val, sizeof(int)) == -1)
-	{
-		Handler().LogError(this, "SetMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-	}
+    int val = x ? 1 : 0;
+    if (setsockopt(GetSocket(), SOL_IP, IP_MULTICAST_LOOP, (char *)&val, sizeof(int)) == -1)
+    {
+        Handler().LogError(this, "SetMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+    }
 }
 
 
 bool UdpSocket::IsMulticastLoop()
 {
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		CreateConnection();
-	}
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        CreateConnection();
+    }
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
-		int is_loop = 0;
-		socklen_t size = sizeof(int);
-		if (getsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *)&is_loop, &size) == -1)
-		{
-			Handler().LogError(this, "IsMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-		}
-		return is_loop ? true : false;
-	}
+    if (IsIpv6())
+    {
+        int is_loop = 0;
+        socklen_t size = sizeof(int);
+        if (getsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *)&is_loop, &size) == -1)
+        {
+            Handler().LogError(this, "IsMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+        }
+        return is_loop ? true : false;
+    }
 #endif
 #endif
-	int is_loop = 0;
-	socklen_t size = sizeof(int);
-	if (getsockopt(GetSocket(), SOL_IP, IP_MULTICAST_LOOP, (char *)&is_loop, &size) == -1)
-	{
-		Handler().LogError(this, "IsMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-	}
-	return is_loop ? true : false;
+    int is_loop = 0;
+    socklen_t size = sizeof(int);
+    if (getsockopt(GetSocket(), SOL_IP, IP_MULTICAST_LOOP, (char *)&is_loop, &size) == -1)
+    {
+        Handler().LogError(this, "IsMulticastLoop", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+    }
+    return is_loop ? true : false;
 }
 
 
 void UdpSocket::AddMulticastMembership(const std::string& group, const std::string& local_if, int if_index)
 {
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		CreateConnection();
-	}
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        CreateConnection();
+    }
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
-		struct ipv6_mreq x;
-		struct in6_addr addr;
-		if (Utility::u2ip( group, addr ))
-		{
-			x.ipv6mr_multiaddr = addr;
-			x.ipv6mr_interface = if_index;
-			if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (char *)&x, sizeof(struct ipv6_mreq)) == -1)
-			{
-				Handler().LogError(this, "AddMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-			}
-		}
-		return;
-	}
-#endif
-#endif
-	struct ip_mreq x; // ip_mreqn
-	ipaddr_t addr;
-	if (Utility::u2ip( group, addr ))
-	{
-		memcpy(&x.imr_multiaddr.s_addr, &addr, sizeof(addr));
-		Utility::u2ip( local_if, addr);
-		memcpy(&x.imr_interface.s_addr, &addr, sizeof(addr));
-//		x.imr_ifindex = if_index;
-		if (setsockopt(GetSocket(), SOL_IP, IP_ADD_MEMBERSHIP, (char *)&x, sizeof(struct ip_mreq)) == -1)
-		{
-			Handler().LogError(this, "AddMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-		}
-	}
+    if (IsIpv6())
+    {
+        struct ipv6_mreq x;
+        struct in6_addr addr;
+        if (Utility::u2ip( group, addr ))
+        {
+            x.ipv6mr_multiaddr = addr;
+            x.ipv6mr_interface = if_index;
+            if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (char *)&x, sizeof(struct ipv6_mreq)) == -1)
+            {
+                Handler().LogError(this, "AddMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+            }
+        }
+        return;
+    }
+#endif
+#endif
+    struct ip_mreq x; // ip_mreqn
+    ipaddr_t addr;
+    if (Utility::u2ip( group, addr ))
+    {
+        memcpy(&x.imr_multiaddr.s_addr, &addr, sizeof(addr));
+        Utility::u2ip( local_if, addr);
+        memcpy(&x.imr_interface.s_addr, &addr, sizeof(addr));
+//      x.imr_ifindex = if_index;
+        if (setsockopt(GetSocket(), SOL_IP, IP_ADD_MEMBERSHIP, (char *)&x, sizeof(struct ip_mreq)) == -1)
+        {
+            Handler().LogError(this, "AddMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+        }
+    }
 }
 
 
 void UdpSocket::DropMulticastMembership(const std::string& group, const std::string& local_if, int if_index)
 {
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		CreateConnection();
-	}
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        CreateConnection();
+    }
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (IsIpv6())
-	{
-		struct ipv6_mreq x;
-		struct in6_addr addr;
-		if (Utility::u2ip( group, addr ))
-		{
-			x.ipv6mr_multiaddr = addr;
-			x.ipv6mr_interface = if_index;
-			if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, (char *)&x, sizeof(struct ipv6_mreq)) == -1)
-			{
-				Handler().LogError(this, "DropMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-			}
-		}
-		return;
-	}
-#endif
-#endif
-	struct ip_mreq x; // ip_mreqn
-	ipaddr_t addr;
-	if (Utility::u2ip( group, addr ))
-	{
-		memcpy(&x.imr_multiaddr.s_addr, &addr, sizeof(addr));
-		Utility::u2ip( local_if, addr);
-		memcpy(&x.imr_interface.s_addr, &addr, sizeof(addr));
-//		x.imr_ifindex = if_index;
-		if (setsockopt(GetSocket(), SOL_IP, IP_DROP_MEMBERSHIP, (char *)&x, sizeof(struct ip_mreq)) == -1)
-		{
-			Handler().LogError(this, "DropMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-		}
-	}
+    if (IsIpv6())
+    {
+        struct ipv6_mreq x;
+        struct in6_addr addr;
+        if (Utility::u2ip( group, addr ))
+        {
+            x.ipv6mr_multiaddr = addr;
+            x.ipv6mr_interface = if_index;
+            if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, (char *)&x, sizeof(struct ipv6_mreq)) == -1)
+            {
+                Handler().LogError(this, "DropMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+            }
+        }
+        return;
+    }
+#endif
+#endif
+    struct ip_mreq x; // ip_mreqn
+    ipaddr_t addr;
+    if (Utility::u2ip( group, addr ))
+    {
+        memcpy(&x.imr_multiaddr.s_addr, &addr, sizeof(addr));
+        Utility::u2ip( local_if, addr);
+        memcpy(&x.imr_interface.s_addr, &addr, sizeof(addr));
+//      x.imr_ifindex = if_index;
+        if (setsockopt(GetSocket(), SOL_IP, IP_DROP_MEMBERSHIP, (char *)&x, sizeof(struct ip_mreq)) == -1)
+        {
+            Handler().LogError(this, "DropMulticastMembership", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+        }
+    }
 }
 
 
@@ -772,40 +772,40 @@ void UdpSocket::DropMulticastMembership(const std::string& group, const std::str
 #ifdef IPPROTO_IPV6
 void UdpSocket::SetMulticastHops(int hops)
 {
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		CreateConnection();
-	}
-	if (!IsIpv6())
-	{
-		Handler().LogError(this, "SetMulticastHops", 0, "Ipv6 only", LOG_LEVEL_ERROR);
-		return;
-	}
-	if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&hops, sizeof(int)) == -1)
-	{
-		Handler().LogError(this, "SetMulticastHops", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-	}
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        CreateConnection();
+    }
+    if (!IsIpv6())
+    {
+        Handler().LogError(this, "SetMulticastHops", 0, "Ipv6 only", LOG_LEVEL_ERROR);
+        return;
+    }
+    if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&hops, sizeof(int)) == -1)
+    {
+        Handler().LogError(this, "SetMulticastHops", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+    }
 }
 
 
 int UdpSocket::GetMulticastHops()
 {
-	if (GetSocket() == INVALID_SOCKET)
-	{
-		CreateConnection();
-	}
-	if (!IsIpv6())
-	{
-		Handler().LogError(this, "SetMulticastHops", 0, "Ipv6 only", LOG_LEVEL_ERROR);
-		return -1;
-	}
-	int hops = 0;
-	socklen_t size = sizeof(int);
-	if (getsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&hops, &size) == -1)
-	{
-		Handler().LogError(this, "GetMulticastHops", Errno, StrError(Errno), LOG_LEVEL_WARNING);
-	}
-	return hops;
+    if (GetSocket() == INVALID_SOCKET)
+    {
+        CreateConnection();
+    }
+    if (!IsIpv6())
+    {
+        Handler().LogError(this, "SetMulticastHops", 0, "Ipv6 only", LOG_LEVEL_ERROR);
+        return -1;
+    }
+    int hops = 0;
+    socklen_t size = sizeof(int);
+    if (getsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&hops, &size) == -1)
+    {
+        Handler().LogError(this, "GetMulticastHops", Errno, StrError(Errno), LOG_LEVEL_WARNING);
+    }
+    return hops;
 }
 #endif // IPPROTO_IPV6
 #endif
@@ -813,7 +813,7 @@ int UdpSocket::GetMulticastHops()
 
 bool UdpSocket::IsBound()
 {
-	return m_bind_ok;
+    return m_bind_ok;
 }
 
 
@@ -829,19 +829,19 @@ void UdpSocket::OnRawData(const char *buf, size_t len, struct sockaddr *sa, sock
 
 port_t UdpSocket::GetPort()
 {
-	return m_port;
+    return m_port;
 }
 
 
 int UdpSocket::GetLastSizeWritten()
 {
-	return m_last_size_written;
+    return m_last_size_written;
 }
 
 
 void UdpSocket::SetTimestamp(bool x)
 {
-	m_b_read_ts = x;
+    m_b_read_ts = x;
 }
 
 
diff --git a/dep/src/sockets/Utility.cpp b/dep/src/sockets/Utility.cpp
index c1327035d7a..e552da3b6e7 100644
--- a/dep/src/sockets/Utility.cpp
+++ b/dep/src/sockets/Utility.cpp
@@ -1,6 +1,6 @@
 /** \file Utility.cpp
- **	\date  2004-02-13
- **	\author grymse@alhem.net
+ ** \date  2004-02-13
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2004-2007  Anders Hedstrom
@@ -8,7 +8,7 @@ Copyright (C) 2004-2007  Anders Hedstrom
 This library is made available under the terms of the GNU GPL.
 
 If you would like to use this library in a closed-source application,
-a separate license agreement is available. For information about 
+a separate license agreement is available. For information about
 the closed-source license agreement for the C++ sockets library,
 please visit http://www.alhem.net/Sockets/license.html and/or
 email license@alhem.net.
@@ -71,69 +71,69 @@ std::string Utility::m_local_addr6;
 
 std::string Utility::base64(const std::string& str_in)
 {
-	std::string str;
-	Base64 m_b;
-	m_b.encode(str_in, str, false); // , false == do not add cr/lf
-	return str;
+    std::string str;
+    Base64 m_b;
+    m_b.encode(str_in, str, false); // , false == do not add cr/lf
+    return str;
 }
 
 
 std::string Utility::base64d(const std::string& str_in)
 {
-	std::string str;
-	Base64 m_b;
-	m_b.decode(str_in, str);
-	return str;
+    std::string str;
+    Base64 m_b;
+    m_b.decode(str_in, str);
+    return str;
 }
 
 
 std::string Utility::l2string(long l)
 {
-	std::string str;
-	char tmp[100];
-	sprintf(tmp,"%ld",l);
-	str = tmp;
-	return str;
+    std::string str;
+    char tmp[100];
+    sprintf(tmp,"%ld",l);
+    str = tmp;
+    return str;
 }
 
 
 std::string Utility::bigint2string(uint64_t l)
 {
-	std::string str;
-	uint64_t tmp = l;
-	while (tmp)
-	{
-		uint64_t a = tmp % 10;
-		str = (char)(a + 48) + str;
-		tmp /= 10;
-	}
-	if (str.empty())
-	{
-		str = "0";
-	}
-	return str;
+    std::string str;
+    uint64_t tmp = l;
+    while (tmp)
+    {
+        uint64_t a = tmp % 10;
+        str = (char)(a + 48) + str;
+        tmp /= 10;
+    }
+    if (str.empty())
+    {
+        str = "0";
+    }
+    return str;
 }
 
 
-uint64_t Utility::atoi64(const std::string& str) 
+uint64_t Utility::atoi64(const std::string& str)
 {
-	uint64_t l = 0;
-	for (size_t i = 0; i < str.size(); i++)
-	{
-		l = l * 10 + str[i] - 48;
-	}
-	return l;
+    uint64_t l = 0;
+    for (size_t i = 0; i < str.size(); i++)
+    {
+        l = l * 10 + str[i] - 48;
+    }
+    return l;
 }
 
 
 unsigned int Utility::hex2unsigned(const std::string& str)
 {
-	unsigned int r = 0;
-	for (size_t i = 0; i < str.size(); i++)
-	{
-		r = r * 16 + str[i] - 48 - ((str[i] >= 'A') ? 7 : 0) - ((str[i] >= 'a') ? 32 : 0);
-	}
-	return r;
+    unsigned int r = 0;
+    for (size_t i = 0; i < str.size(); i++)
+    {
+        r = r * 16 + str[i] - 48 - ((str[i] >= 'A') ? 7 : 0) - ((str[i] >= 'a') ? 32 : 0);
+    }
+    return r;
 }
 
 
@@ -143,28 +143,28 @@ unsigned int Utility::hex2unsigned(const std::string& str)
 */
 std::string Utility::rfc1738_encode(const std::string& src)
 {
-static	char hex[] = "0123456789ABCDEF";
-	std::string dst;
-	for (size_t i = 0; i < src.size(); i++)
-	{
-		if (isalnum(src[i]))
-		{
-			dst += src[i];
-		}
-		else
-		if (src[i] == ' ')
-		{
-			dst += '+';
-		}
-		else
-		{
-			unsigned char c = static_cast<unsigned char>(src[i]);
-			dst += '%';
-			dst += hex[c / 16];
-			dst += hex[c % 16];
-		}
-	}
-	return dst;
+static  char hex[] = "0123456789ABCDEF";
+    std::string dst;
+    for (size_t i = 0; i < src.size(); i++)
+    {
+        if (isalnum(src[i]))
+        {
+            dst += src[i];
+        }
+        else
+        if (src[i] == ' ')
+        {
+            dst += '+';
+        }
+        else
+        {
+            unsigned char c = static_cast<unsigned char>(src[i]);
+            dst += '%';
+            dst += hex[c / 16];
+            dst += hex[c % 16];
+        }
+    }
+    return dst;
 } // rfc1738_encode
 
 
@@ -174,95 +174,95 @@ static	char hex[] = "0123456789ABCDEF";
 */
 std::string Utility::rfc1738_decode(const std::string& src)
 {
-	std::string dst;
-	for (size_t i = 0; i < src.size(); i++)
-	{
-		if (src[i] == '%' && isxdigit(src[i + 1]) && isxdigit(src[i + 2]))
-		{
-			char c1 = src[++i];
-			char c2 = src[++i];
-			c1 = c1 - 48 - ((c1 >= 'A') ? 7 : 0) - ((c1 >= 'a') ? 32 : 0);
-			c2 = c2 - 48 - ((c2 >= 'A') ? 7 : 0) - ((c2 >= 'a') ? 32 : 0);
-			dst += (char)(c1 * 16 + c2);
-		}
-		else
-		if (src[i] == '+')
-		{
-			dst += ' ';
-		}
-		else
-		{
-			dst += src[i];
-		}
-	}
-	return dst;
+    std::string dst;
+    for (size_t i = 0; i < src.size(); i++)
+    {
+        if (src[i] == '%' && isxdigit(src[i + 1]) && isxdigit(src[i + 2]))
+        {
+            char c1 = src[++i];
+            char c2 = src[++i];
+            c1 = c1 - 48 - ((c1 >= 'A') ? 7 : 0) - ((c1 >= 'a') ? 32 : 0);
+            c2 = c2 - 48 - ((c2 >= 'A') ? 7 : 0) - ((c2 >= 'a') ? 32 : 0);
+            dst += (char)(c1 * 16 + c2);
+        }
+        else
+        if (src[i] == '+')
+        {
+            dst += ' ';
+        }
+        else
+        {
+            dst += src[i];
+        }
+    }
+    return dst;
 } // rfc1738_decode
 
 
 bool Utility::isipv4(const std::string& str)
 {
-	int dots = 0;
-	// %! ignore :port?
-	for (size_t i = 0; i < str.size(); i++)
-	{
-		if (str[i] == '.')
-			dots++;
-		else
-		if (!isdigit(str[i]))
-			return false;
-	}
-	if (dots != 3)
-		return false;
-	return true;
+    int dots = 0;
+    // %! ignore :port?
+    for (size_t i = 0; i < str.size(); i++)
+    {
+        if (str[i] == '.')
+            dots++;
+        else
+        if (!isdigit(str[i]))
+            return false;
+    }
+    if (dots != 3)
+        return false;
+    return true;
 }
 
 
 bool Utility::isipv6(const std::string& str)
 {
-	size_t qc = 0;
-	size_t qd = 0;
-	for (size_t i = 0; i < str.size(); i++)
-	{
-		qc += (str[i] == ':') ? 1 : 0;
-		qd += (str[i] == '.') ? 1 : 0;
-	}
-	if (qc > 7)
-	{
-		return false;
-	}
-	if (qd && qd != 3)
-	{
-		return false;
-	}
-	Parse pa(str,":.");
-	std::string tmp = pa.getword();
-	while (!tmp.empty())
-	{
-		if (tmp.size() > 4)
-		{
-			return false;
-		}
-		for (size_t i = 0; i < tmp.size(); i++)
-		{
-			if (tmp[i] < '0' || (tmp[i] > '9' && tmp[i] < 'A') ||
-				(tmp[i] > 'F' && tmp[i] < 'a') || tmp[i] > 'f')
-			{
-				return false;
-			}
-		}
-		//
-		tmp = pa.getword();
-	}
-	return true;
+    size_t qc = 0;
+    size_t qd = 0;
+    for (size_t i = 0; i < str.size(); i++)
+    {
+        qc += (str[i] == ':') ? 1 : 0;
+        qd += (str[i] == '.') ? 1 : 0;
+    }
+    if (qc > 7)
+    {
+        return false;
+    }
+    if (qd && qd != 3)
+    {
+        return false;
+    }
+    Parse pa(str,":.");
+    std::string tmp = pa.getword();
+    while (!tmp.empty())
+    {
+        if (tmp.size() > 4)
+        {
+            return false;
+        }
+        for (size_t i = 0; i < tmp.size(); i++)
+        {
+            if (tmp[i] < '0' || (tmp[i] > '9' && tmp[i] < 'A') ||
+                (tmp[i] > 'F' && tmp[i] < 'a') || tmp[i] > 'f')
+            {
+                return false;
+            }
+        }
+        //
+        tmp = pa.getword();
+    }
+    return true;
 }
 
 
 bool Utility::u2ip(const std::string& str, ipaddr_t& l)
 {
-	struct sockaddr_in sa;
-	bool r = Utility::u2ip(str, sa);
-	memcpy(&l, &sa.sin_addr, sizeof(l));
-	return r;
+    struct sockaddr_in sa;
+    bool r = Utility::u2ip(str, sa);
+    memcpy(&l, &sa.sin_addr, sizeof(l));
+    return r;
 }
 
 
@@ -270,10 +270,10 @@ bool Utility::u2ip(const std::string& str, ipaddr_t& l)
 #ifdef IPPROTO_IPV6
 bool Utility::u2ip(const std::string& str, struct in6_addr& l)
 {
-	struct sockaddr_in6 sa;
-	bool r = Utility::u2ip(str, sa);
-	l = sa.sin6_addr;
-	return r;
+    struct sockaddr_in6 sa;
+    bool r = Utility::u2ip(str, sa);
+    l = sa.sin6_addr;
+    return r;
 }
 #endif
 #endif
@@ -281,21 +281,21 @@ bool Utility::u2ip(const std::string& str, struct in6_addr& l)
 
 void Utility::l2ip(const ipaddr_t ip, std::string& str)
 {
-	struct sockaddr_in sa;
-	memset(&sa, 0, sizeof(sa));
-	sa.sin_family = AF_INET;
-	memcpy(&sa.sin_addr, &ip, sizeof(sa.sin_addr));
-	Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), str, NI_NUMERICHOST);
+    struct sockaddr_in sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sin_family = AF_INET;
+    memcpy(&sa.sin_addr, &ip, sizeof(sa.sin_addr));
+    Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), str, NI_NUMERICHOST);
 }
 
 
 void Utility::l2ip(const in_addr& ip, std::string& str)
 {
-	struct sockaddr_in sa;
-	memset(&sa, 0, sizeof(sa));
-	sa.sin_family = AF_INET;
-	sa.sin_addr = ip;
-	Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), str, NI_NUMERICHOST);
+    struct sockaddr_in sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sin_family = AF_INET;
+    sa.sin_addr = ip;
+    Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), str, NI_NUMERICHOST);
 }
 
 
@@ -303,61 +303,61 @@ void Utility::l2ip(const in_addr& ip, std::string& str)
 #ifdef IPPROTO_IPV6
 void Utility::l2ip(const struct in6_addr& ip, std::string& str,bool mixed)
 {
-	char slask[100]; // l2ip temporary
-	*slask = 0;
-	unsigned int prev = 0;
-	bool skipped = false;
-	bool ok_to_skip = true;
-	if (mixed)
-	{
-		unsigned short x;
-		unsigned short addr16[8];
-		memcpy(addr16, &ip, sizeof(addr16));
-		for (size_t i = 0; i < 6; i++)
-		{
-			x = ntohs(addr16[i]);
-			if (*slask && (x || !ok_to_skip || prev))
-				strcat(slask,":");
-			if (x || !ok_to_skip)
-			{
-				sprintf(slask + strlen(slask),"%x", x);
-				if (x && skipped)
-					ok_to_skip = false;
-			}
-			else
-			{
-				skipped = true;
-			}
-			prev = x;
-		}
-		x = ntohs(addr16[6]);
-		sprintf(slask + strlen(slask),":%u.%u",x / 256,x & 255);
-		x = ntohs(addr16[7]);
-		sprintf(slask + strlen(slask),".%u.%u",x / 256,x & 255);
-	}
-	else
-	{
-		struct sockaddr_in6 sa;
-		memset(&sa, 0, sizeof(sa));
-		sa.sin6_family = AF_INET6;
-		sa.sin6_addr = ip;
-		Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), str, NI_NUMERICHOST);
-		return;
-	}
-	str = slask;
+    char slask[100]; // l2ip temporary
+    *slask = 0;
+    unsigned int prev = 0;
+    bool skipped = false;
+    bool ok_to_skip = true;
+    if (mixed)
+    {
+        unsigned short x;
+        unsigned short addr16[8];
+        memcpy(addr16, &ip, sizeof(addr16));
+        for (size_t i = 0; i < 6; i++)
+        {
+            x = ntohs(addr16[i]);
+            if (*slask && (x || !ok_to_skip || prev))
+                strcat(slask,":");
+            if (x || !ok_to_skip)
+            {
+                sprintf(slask + strlen(slask),"%x", x);
+                if (x && skipped)
+                    ok_to_skip = false;
+            }
+            else
+            {
+                skipped = true;
+            }
+            prev = x;
+        }
+        x = ntohs(addr16[6]);
+        sprintf(slask + strlen(slask),":%u.%u",x / 256,x & 255);
+        x = ntohs(addr16[7]);
+        sprintf(slask + strlen(slask),".%u.%u",x / 256,x & 255);
+    }
+    else
+    {
+        struct sockaddr_in6 sa;
+        memset(&sa, 0, sizeof(sa));
+        sa.sin6_family = AF_INET6;
+        sa.sin6_addr = ip;
+        Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), str, NI_NUMERICHOST);
+        return;
+    }
+    str = slask;
 }
 
 
 int Utility::in6_addr_compare(in6_addr a,in6_addr b)
 {
-	for (size_t i = 0; i < 16; i++)
-	{
-		if (a.s6_addr[i] < b.s6_addr[i])
-			return -1;
-		if (a.s6_addr[i] > b.s6_addr[i])
-			return 1;
-	}
-	return 0;
+    for (size_t i = 0; i < 16; i++)
+    {
+        if (a.s6_addr[i] < b.s6_addr[i])
+            return -1;
+        if (a.s6_addr[i] > b.s6_addr[i])
+            return 1;
+    }
+    return 0;
 }
 #endif
 #endif
@@ -365,60 +365,60 @@ int Utility::in6_addr_compare(in6_addr a,in6_addr b)
 
 void Utility::ResolveLocal()
 {
-	char h[256];
-
-	// get local hostname and translate into ip-address
-	*h = 0;
-	gethostname(h,255);
-	{
-		if (Utility::u2ip(h, m_ip))
-		{
-			Utility::l2ip(m_ip, m_addr);
-		}
-	}
+    char h[256];
+
+    // get local hostname and translate into ip-address
+    *h = 0;
+    gethostname(h,255);
+    {
+        if (Utility::u2ip(h, m_ip))
+        {
+            Utility::l2ip(m_ip, m_addr);
+        }
+    }
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	memset(&m_local_ip6, 0, sizeof(m_local_ip6));
-	{
-		if (Utility::u2ip(h, m_local_ip6))
-		{
-			Utility::l2ip(m_local_ip6, m_local_addr6);
-		}
-	}
+    memset(&m_local_ip6, 0, sizeof(m_local_ip6));
+    {
+        if (Utility::u2ip(h, m_local_ip6))
+        {
+            Utility::l2ip(m_local_ip6, m_local_addr6);
+        }
+    }
 #endif
 #endif
-	m_host = h;
-	m_local_resolved = true;
+    m_host = h;
+    m_local_resolved = true;
 }
 
 
 const std::string& Utility::GetLocalHostname()
 {
-	if (!m_local_resolved)
-	{
-		ResolveLocal();
-	}
-	return m_host;
+    if (!m_local_resolved)
+    {
+        ResolveLocal();
+    }
+    return m_host;
 }
 
 
 ipaddr_t Utility::GetLocalIP()
 {
-	if (!m_local_resolved)
-	{
-		ResolveLocal();
-	}
-	return m_ip;
+    if (!m_local_resolved)
+    {
+        ResolveLocal();
+    }
+    return m_ip;
 }
 
 
 const std::string& Utility::GetLocalAddress()
 {
-	if (!m_local_resolved)
-	{
-		ResolveLocal();
-	}
-	return m_addr;
+    if (!m_local_resolved)
+    {
+        ResolveLocal();
+    }
+    return m_addr;
 }
 
 
@@ -426,21 +426,21 @@ const std::string& Utility::GetLocalAddress()
 #ifdef IPPROTO_IPV6
 const struct in6_addr& Utility::GetLocalIP6()
 {
-	if (!m_local_resolved)
-	{
-		ResolveLocal();
-	}
-	return m_local_ip6;
+    if (!m_local_resolved)
+    {
+        ResolveLocal();
+    }
+    return m_local_ip6;
 }
 
 
 const std::string& Utility::GetLocalAddress6()
 {
-	if (!m_local_resolved)
-	{
-		ResolveLocal();
-	}
-	return m_local_addr6;
+    if (!m_local_resolved)
+    {
+        ResolveLocal();
+    }
+    return m_local_addr6;
 }
 #endif
 #endif
@@ -449,23 +449,23 @@ const std::string& Utility::GetLocalAddress6()
 void Utility::SetEnv(const std::string& var,const std::string& value)
 {
 #if (defined(SOLARIS8) || defined(SOLARIS))
-	{
-		static std::map<std::string, char *> vmap;
-		if (vmap.find(var) != vmap.end())
-		{
-			delete[] vmap[var];
-		}
-		vmap[var] = new char[var.size() + 1 + value.size() + 1];
-		sprintf(vmap[var], "%s=%s", var.c_str(), value.c_str());
-		putenv( vmap[var] );
-	}
+    {
+        static std::map<std::string, char *> vmap;
+        if (vmap.find(var) != vmap.end())
+        {
+            delete[] vmap[var];
+        }
+        vmap[var] = new char[var.size() + 1 + value.size() + 1];
+        sprintf(vmap[var], "%s=%s", var.c_str(), value.c_str());
+        putenv( vmap[var] );
+    }
 #elif defined _WIN32
-	{
-		std::string slask = var + "=" + value;
-		_putenv( (char *)slask.c_str());
-	}
+    {
+        std::string slask = var + "=" + value;
+        _putenv( (char *)slask.c_str());
+    }
 #else
-	setenv(var.c_str(), value.c_str(), 1);
+    setenv(var.c_str(), value.c_str(), 1);
 #endif
 }
 
@@ -474,160 +474,160 @@ std::string Utility::Sa2String(struct sockaddr *sa)
 {
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	if (sa -> sa_family == AF_INET6)
-	{
-		struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)sa;
-		std::string tmp;
-		Utility::l2ip(sa6 -> sin6_addr, tmp);
-		return tmp + ":" + Utility::l2string(ntohs(sa6 -> sin6_port));
-	}
+    if (sa -> sa_family == AF_INET6)
+    {
+        struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)sa;
+        std::string tmp;
+        Utility::l2ip(sa6 -> sin6_addr, tmp);
+        return tmp + ":" + Utility::l2string(ntohs(sa6 -> sin6_port));
+    }
 #endif
 #endif
-	if (sa -> sa_family == AF_INET)
-	{
-		struct sockaddr_in *sa4 = (struct sockaddr_in *)sa;
-		ipaddr_t a;
-		memcpy(&a, &sa4 -> sin_addr, 4);
-		std::string tmp;
-		Utility::l2ip(a, tmp);
-		return tmp + ":" + Utility::l2string(ntohs(sa4 -> sin_port));
-	}
-	return "";
+    if (sa -> sa_family == AF_INET)
+    {
+        struct sockaddr_in *sa4 = (struct sockaddr_in *)sa;
+        ipaddr_t a;
+        memcpy(&a, &sa4 -> sin_addr, 4);
+        std::string tmp;
+        Utility::l2ip(a, tmp);
+        return tmp + ":" + Utility::l2string(ntohs(sa4 -> sin_port));
+    }
+    return "";
 }
 
 
 void Utility::GetTime(struct timeval *p)
 {
 #ifdef _WIN32
-	FILETIME ft; // Contains a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC).
-	GetSystemTimeAsFileTime(&ft);
-	uint64_t tt;
-	memcpy(&tt, &ft, sizeof(tt));
-	tt /= 10; // make it usecs
-	p->tv_sec = (long)tt / 1000000;
-	p->tv_usec = (long)tt % 1000000;
+    FILETIME ft; // Contains a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC).
+    GetSystemTimeAsFileTime(&ft);
+    uint64_t tt;
+    memcpy(&tt, &ft, sizeof(tt));
+    tt /= 10; // make it usecs
+    p->tv_sec = (long)tt / 1000000;
+    p->tv_usec = (long)tt % 1000000;
 #else
-	gettimeofday(p, NULL);
+    gettimeofday(p, NULL);
 #endif
 }
 
 
 std::auto_ptr<SocketAddress> Utility::CreateAddress(struct sockaddr *sa,socklen_t sa_len)
 {
-	switch (sa -> sa_family)
-	{
-	case AF_INET:
-		if (sa_len == sizeof(struct sockaddr_in))
-		{
-			struct sockaddr_in *p = (struct sockaddr_in *)sa;
-			return std::auto_ptr<SocketAddress>(new Ipv4Address(*p));
-		}
-		break;
+    switch (sa -> sa_family)
+    {
+    case AF_INET:
+        if (sa_len == sizeof(struct sockaddr_in))
+        {
+            struct sockaddr_in *p = (struct sockaddr_in *)sa;
+            return std::auto_ptr<SocketAddress>(new Ipv4Address(*p));
+        }
+        break;
 #ifdef ENABLE_IPV6
 #ifdef IPPROTO_IPV6
-	case AF_INET6:
-		if (sa_len == sizeof(struct sockaddr_in6))
-		{
-			struct sockaddr_in6 *p = (struct sockaddr_in6 *)sa;
-			return std::auto_ptr<SocketAddress>(new Ipv6Address(*p));
-		}
-		break;
+    case AF_INET6:
+        if (sa_len == sizeof(struct sockaddr_in6))
+        {
+            struct sockaddr_in6 *p = (struct sockaddr_in6 *)sa;
+            return std::auto_ptr<SocketAddress>(new Ipv6Address(*p));
+        }
+        break;
 #endif
 #endif
-	}
-	return std::auto_ptr<SocketAddress>(NULL);
+    }
+    return std::auto_ptr<SocketAddress>(NULL);
 }
 
 
 bool Utility::u2ip(const std::string& host, struct sockaddr_in& sa, int ai_flags)
 {
-	memset(&sa, 0, sizeof(sa));
-	sa.sin_family = AF_INET;
+    memset(&sa, 0, sizeof(sa));
+    sa.sin_family = AF_INET;
 #ifdef NO_GETADDRINFO
-	if ((ai_flags & AI_NUMERICHOST) != 0 || isipv4(host))
-	{
-		Parse pa((char *)host.c_str(), ".");
-		union {
-			struct {
-				unsigned char b1;
-				unsigned char b2;
-				unsigned char b3;
-				unsigned char b4;
-			} a;
-			ipaddr_t l;
-		} u;
-		u.a.b1 = static_cast<unsigned char>(pa.getvalue());
-		u.a.b2 = static_cast<unsigned char>(pa.getvalue());
-		u.a.b3 = static_cast<unsigned char>(pa.getvalue());
-		u.a.b4 = static_cast<unsigned char>(pa.getvalue());
-		memcpy(&sa.sin_addr, &u.l, sizeof(sa.sin_addr));
-		return true;
-	}
+    if ((ai_flags & AI_NUMERICHOST) != 0 || isipv4(host))
+    {
+        Parse pa((char *)host.c_str(), ".");
+        union {
+            struct {
+                unsigned char b1;
+                unsigned char b2;
+                unsigned char b3;
+                unsigned char b4;
+            } a;
+            ipaddr_t l;
+        } u;
+        u.a.b1 = static_cast<unsigned char>(pa.getvalue());
+        u.a.b2 = static_cast<unsigned char>(pa.getvalue());
+        u.a.b3 = static_cast<unsigned char>(pa.getvalue());
+        u.a.b4 = static_cast<unsigned char>(pa.getvalue());
+        memcpy(&sa.sin_addr, &u.l, sizeof(sa.sin_addr));
+        return true;
+    }
 #ifndef LINUX
-	struct hostent *he = gethostbyname( host.c_str() );
-	if (!he)
-	{
-		return false;
-	}
-	memcpy(&sa.sin_addr, he -> h_addr, sizeof(sa.sin_addr));
+    struct hostent *he = gethostbyname( host.c_str() );
+    if (!he)
+    {
+        return false;
+    }
+    memcpy(&sa.sin_addr, he -> h_addr, sizeof(sa.sin_addr));
 #else
-	struct hostent he;
-	struct hostent *result = NULL;
-	int myerrno = 0;
-	char buf[2000];
-	int n = gethostbyname_r(host.c_str(), &he, buf, sizeof(buf), &result, &myerrno);
-	if (n || !result)
-	{
-		return false;
-	}
-	if (he.h_addr_list && he.h_addr_list[0])
-		memcpy(&sa.sin_addr, he.h_addr, 4);
-	else
-		return false;
+    struct hostent he;
+    struct hostent *result = NULL;
+    int myerrno = 0;
+    char buf[2000];
+    int n = gethostbyname_r(host.c_str(), &he, buf, sizeof(buf), &result, &myerrno);
+    if (n || !result)
+    {
+        return false;
+    }
+    if (he.h_addr_list && he.h_addr_list[0])
+        memcpy(&sa.sin_addr, he.h_addr, 4);
+    else
+        return false;
 #endif
-	return true;
+    return true;
 #else
-	struct addrinfo hints;
-	memset(&hints, 0, sizeof(hints));
-	// AI_NUMERICHOST
-	// AI_CANONNAME
-	// AI_PASSIVE - server
-	// AI_ADDRCONFIG
-	// AI_V4MAPPED
-	// AI_ALL
-	// AI_NUMERICSERV
-	hints.ai_flags = ai_flags;
-	hints.ai_family = AF_INET;
-	hints.ai_socktype = 0;
-	hints.ai_protocol = 0;
-	struct addrinfo *res;
-	if (Utility::isipv4(host))
-		hints.ai_flags |= AI_NUMERICHOST;
-	int n = getaddrinfo(host.c_str(), NULL, &hints, &res);
-	if (!n)
-	{
-		std::vector<struct addrinfo *> vec;
-		struct addrinfo *ai = res;
-		while (ai)
-		{
-			if (ai -> ai_addrlen == sizeof(sa))
-				vec.push_back( ai );
-			ai = ai -> ai_next;
-		}
-		if (vec.empty())
-			return false;
-		ai = vec[Utility::Rnd() % vec.size()];
-		{
-			memcpy(&sa, ai -> ai_addr, ai -> ai_addrlen);
-		}
-		freeaddrinfo(res);
-		return true;
-	}
-	std::string error = "Error: ";
+    struct addrinfo hints;
+    memset(&hints, 0, sizeof(hints));
+    // AI_NUMERICHOST
+    // AI_CANONNAME
+    // AI_PASSIVE - server
+    // AI_ADDRCONFIG
+    // AI_V4MAPPED
+    // AI_ALL
+    // AI_NUMERICSERV
+    hints.ai_flags = ai_flags;
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = 0;
+    hints.ai_protocol = 0;
+    struct addrinfo *res;
+    if (Utility::isipv4(host))
+        hints.ai_flags |= AI_NUMERICHOST;
+    int n = getaddrinfo(host.c_str(), NULL, &hints, &res);
+    if (!n)
+    {
+        std::vector<struct addrinfo *> vec;
+        struct addrinfo *ai = res;
+        while (ai)
+        {
+            if (ai -> ai_addrlen == sizeof(sa))
+                vec.push_back( ai );
+            ai = ai -> ai_next;
+        }
+        if (vec.empty())
+            return false;
+        ai = vec[Utility::Rnd() % vec.size()];
+        {
+            memcpy(&sa, ai -> ai_addr, ai -> ai_addrlen);
+        }
+        freeaddrinfo(res);
+        return true;
+    }
+    std::string error = "Error: ";
 #ifndef __CYGWIN__
-	error += gai_strerror(n);
+    error += gai_strerror(n);
 #endif
-	return false;
+    return false;
 #endif // NO_GETADDRINFO
 }
 
@@ -636,112 +636,112 @@ bool Utility::u2ip(const std::string& host, struct sockaddr_in& sa, int ai_flags
 #ifdef IPPROTO_IPV6
 bool Utility::u2ip(const std::string& host, struct sockaddr_in6& sa, int ai_flags)
 {
-	memset(&sa, 0, sizeof(sa));
-	sa.sin6_family = AF_INET6;
+    memset(&sa, 0, sizeof(sa));
+    sa.sin6_family = AF_INET6;
 #ifdef NO_GETADDRINFO
-	if ((ai_flags & AI_NUMERICHOST) != 0 || isipv6(host))
-	{
-		std::list<std::string> vec;
-		size_t x = 0;
-		for (size_t i = 0; i <= host.size(); i++)
-		{
-			if (i == host.size() || host[i] == ':')
-			{
-				std::string s = host.substr(x, i - x);
-				//
-				if (strstr(s.c_str(),".")) // x.x.x.x
-				{
-					Parse pa(s,".");
-					char slask[100]; // u2ip temporary hex2string conversion
-					unsigned long b0 = static_cast<unsigned long>(pa.getvalue());
-					unsigned long b1 = static_cast<unsigned long>(pa.getvalue());
-					unsigned long b2 = static_cast<unsigned long>(pa.getvalue());
-					unsigned long b3 = static_cast<unsigned long>(pa.getvalue());
-					sprintf(slask,"%lx",b0 * 256 + b1);
-					vec.push_back(slask);
-					sprintf(slask,"%lx",b2 * 256 + b3);
-					vec.push_back(slask);
-				}
-				else
-				{
-					vec.push_back(s);
-				}
-				//
-				x = i + 1;
-			}
-		}
-		size_t sz = vec.size(); // number of byte pairs
-		size_t i = 0; // index in in6_addr.in6_u.u6_addr16[] ( 0 .. 7 )
-		unsigned short addr16[8];
-		for (std::list<std::string>::iterator it = vec.begin(); it != vec.end(); it++)
-		{
-			std::string bytepair = *it;
-			if (!bytepair.empty())
-			{
-				addr16[i++] = htons(Utility::hex2unsigned(bytepair));
-			}
-			else
-			{
-				addr16[i++] = 0;
-				while (sz++ < 8)
-				{
-					addr16[i++] = 0;
-				}
-			}
-		}
-		memcpy(&sa.sin6_addr, addr16, sizeof(addr16));
-		return true;
-	}
+    if ((ai_flags & AI_NUMERICHOST) != 0 || isipv6(host))
+    {
+        std::list<std::string> vec;
+        size_t x = 0;
+        for (size_t i = 0; i <= host.size(); i++)
+        {
+            if (i == host.size() || host[i] == ':')
+            {
+                std::string s = host.substr(x, i - x);
+                //
+                if (strstr(s.c_str(),".")) // x.x.x.x
+                {
+                    Parse pa(s,".");
+                    char slask[100]; // u2ip temporary hex2string conversion
+                    unsigned long b0 = static_cast<unsigned long>(pa.getvalue());
+                    unsigned long b1 = static_cast<unsigned long>(pa.getvalue());
+                    unsigned long b2 = static_cast<unsigned long>(pa.getvalue());
+                    unsigned long b3 = static_cast<unsigned long>(pa.getvalue());
+                    sprintf(slask,"%lx",b0 * 256 + b1);
+                    vec.push_back(slask);
+                    sprintf(slask,"%lx",b2 * 256 + b3);
+                    vec.push_back(slask);
+                }
+                else
+                {
+                    vec.push_back(s);
+                }
+                //
+                x = i + 1;
+            }
+        }
+        size_t sz = vec.size(); // number of byte pairs
+        size_t i = 0; // index in in6_addr.in6_u.u6_addr16[] ( 0 .. 7 )
+        unsigned short addr16[8];
+        for (std::list<std::string>::iterator it = vec.begin(); it != vec.end(); it++)
+        {
+            std::string bytepair = *it;
+            if (!bytepair.empty())
+            {
+                addr16[i++] = htons(Utility::hex2unsigned(bytepair));
+            }
+            else
+            {
+                addr16[i++] = 0;
+                while (sz++ < 8)
+                {
+                    addr16[i++] = 0;
+                }
+            }
+        }
+        memcpy(&sa.sin6_addr, addr16, sizeof(addr16));
+        return true;
+    }
 #ifdef SOLARIS
-	int errnum = 0;
-	struct hostent *he = getipnodebyname( host.c_str(), AF_INET6, 0, &errnum );
+    int errnum = 0;
+    struct hostent *he = getipnodebyname( host.c_str(), AF_INET6, 0, &errnum );
 #else
-	struct hostent *he = gethostbyname2( host.c_str(), AF_INET6 );
+    struct hostent *he = gethostbyname2( host.c_str(), AF_INET6 );
 #endif
-	if (!he)
-	{
-		return false;
-	}
-	memcpy(&sa.sin6_addr,he -> h_addr_list[0],he -> h_length);
+    if (!he)
+    {
+        return false;
+    }
+    memcpy(&sa.sin6_addr,he -> h_addr_list[0],he -> h_length);
 #ifdef SOLARIS
-	free(he);
+    free(he);
 #endif
-	return true;
+    return true;
 #else
-	struct addrinfo hints;
-	memset(&hints, 0, sizeof(hints));
-	hints.ai_flags = ai_flags;
-	hints.ai_family = AF_INET6;
-	hints.ai_socktype = 0;
-	hints.ai_protocol = 0;
-	struct addrinfo *res;
-	if (Utility::isipv6(host))
-		hints.ai_flags |= AI_NUMERICHOST;
-	int n = getaddrinfo(host.c_str(), NULL, &hints, &res);
-	if (!n)
-	{
-		std::vector<struct addrinfo *> vec;
-		struct addrinfo *ai = res;
-		while (ai)
-		{
-			if (ai -> ai_addrlen == sizeof(sa))
-				vec.push_back( ai );
-			ai = ai -> ai_next;
-		}
-		if (vec.empty())
-			return false;
-		ai = vec[Utility::Rnd() % vec.size()];
-		{
-			memcpy(&sa, ai -> ai_addr, ai -> ai_addrlen);
-		}
-		freeaddrinfo(res);
-		return true;
-	}
-	std::string error = "Error: ";
+    struct addrinfo hints;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_flags = ai_flags;
+    hints.ai_family = AF_INET6;
+    hints.ai_socktype = 0;
+    hints.ai_protocol = 0;
+    struct addrinfo *res;
+    if (Utility::isipv6(host))
+        hints.ai_flags |= AI_NUMERICHOST;
+    int n = getaddrinfo(host.c_str(), NULL, &hints, &res);
+    if (!n)
+    {
+        std::vector<struct addrinfo *> vec;
+        struct addrinfo *ai = res;
+        while (ai)
+        {
+            if (ai -> ai_addrlen == sizeof(sa))
+                vec.push_back( ai );
+            ai = ai -> ai_next;
+        }
+        if (vec.empty())
+            return false;
+        ai = vec[Utility::Rnd() % vec.size()];
+        {
+            memcpy(&sa, ai -> ai_addr, ai -> ai_addrlen);
+        }
+        freeaddrinfo(res);
+        return true;
+    }
+    std::string error = "Error: ";
 #ifndef __CYGWIN__
-	error += gai_strerror(n);
+    error += gai_strerror(n);
 #endif
-	return false;
+    return false;
 #endif // NO_GETADDRINFO
 }
 #endif // IPPROTO_IPV6
@@ -750,123 +750,123 @@ bool Utility::u2ip(const std::string& host, struct sockaddr_in6& sa, int ai_flag
 
 bool Utility::reverse(struct sockaddr *sa, socklen_t sa_len, std::string& hostname, int flags)
 {
-	std::string service;
-	return Utility::reverse(sa, sa_len, hostname, service, flags);
+    std::string service;
+    return Utility::reverse(sa, sa_len, hostname, service, flags);
 }
 
 
 bool Utility::reverse(struct sockaddr *sa, socklen_t sa_len, std::string& hostname, std::string& service, int flags)
 {
-	hostname = "";
-	service = "";
+    hostname = "";
+    service = "";
 #ifdef NO_GETADDRINFO
-	switch (sa -> sa_family)
-	{
-	case AF_INET:
-		if (flags & NI_NUMERICHOST)
-		{
-			union {
-				struct {
-					unsigned char b1;
-					unsigned char b2;
-					unsigned char b3;
-					unsigned char b4;
-				} a;
-				ipaddr_t l;
-			} u;
-			struct sockaddr_in *sa_in = (struct sockaddr_in *)sa;
-			memcpy(&u.l, &sa_in -> sin_addr, sizeof(u.l));
-			char tmp[100];
-			sprintf(tmp, "%u.%u.%u.%u", u.a.b1, u.a.b2, u.a.b3, u.a.b4);
-			hostname = tmp;
-			return true;
-		}
-		else
-		{
-			struct sockaddr_in *sa_in = (struct sockaddr_in *)sa;
-			struct hostent *h = gethostbyaddr( (const char *)&sa_in -> sin_addr, sizeof(sa_in -> sin_addr), AF_INET);
-			if (h)
-			{
-				hostname = h -> h_name;
-				return true;
-			}
-		}
-		break;
+    switch (sa -> sa_family)
+    {
+    case AF_INET:
+        if (flags & NI_NUMERICHOST)
+        {
+            union {
+                struct {
+                    unsigned char b1;
+                    unsigned char b2;
+                    unsigned char b3;
+                    unsigned char b4;
+                } a;
+                ipaddr_t l;
+            } u;
+            struct sockaddr_in *sa_in = (struct sockaddr_in *)sa;
+            memcpy(&u.l, &sa_in -> sin_addr, sizeof(u.l));
+            char tmp[100];
+            sprintf(tmp, "%u.%u.%u.%u", u.a.b1, u.a.b2, u.a.b3, u.a.b4);
+            hostname = tmp;
+            return true;
+        }
+        else
+        {
+            struct sockaddr_in *sa_in = (struct sockaddr_in *)sa;
+            struct hostent *h = gethostbyaddr( (const char *)&sa_in -> sin_addr, sizeof(sa_in -> sin_addr), AF_INET);
+            if (h)
+            {
+                hostname = h -> h_name;
+                return true;
+            }
+        }
+        break;
 #ifdef ENABLE_IPV6
-	case AF_INET6:
-		if (flags & NI_NUMERICHOST)
-		{
-			char slask[100]; // l2ip temporary
-			*slask = 0;
-			unsigned int prev = 0;
-			bool skipped = false;
-			bool ok_to_skip = true;
-			{
-				unsigned short addr16[8];
-				struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *)sa;
-				memcpy(addr16, &sa_in6 -> sin6_addr, sizeof(addr16));
-				for (size_t i = 0; i < 8; i++)
-				{
-					unsigned short x = ntohs(addr16[i]);
-					if (*slask && (x || !ok_to_skip || prev))
-						strcat(slask,":");
-					if (x || !ok_to_skip)
-					{
-						sprintf(slask + strlen(slask),"%x", x);
-						if (x && skipped)
-							ok_to_skip = false;
-					}
-					else
-					{
-						skipped = true;
-					}
-					prev = x;
-				}
-			}
-			if (!*slask)
-				strcpy(slask, "::");
-			hostname = slask;
-			return true;
-		}
-		else
-		{
-			// %! TODO: ipv6 reverse lookup
-			struct sockaddr_in6 *sa_in = (struct sockaddr_in6 *)sa;
-			struct hostent *h = gethostbyaddr( (const char *)&sa_in -> sin6_addr, sizeof(sa_in -> sin6_addr), AF_INET6);
-			if (h)
-			{
-				hostname = h -> h_name;
-				return true;
-			}
-		}
-		break;
+    case AF_INET6:
+        if (flags & NI_NUMERICHOST)
+        {
+            char slask[100]; // l2ip temporary
+            *slask = 0;
+            unsigned int prev = 0;
+            bool skipped = false;
+            bool ok_to_skip = true;
+            {
+                unsigned short addr16[8];
+                struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *)sa;
+                memcpy(addr16, &sa_in6 -> sin6_addr, sizeof(addr16));
+                for (size_t i = 0; i < 8; i++)
+                {
+                    unsigned short x = ntohs(addr16[i]);
+                    if (*slask && (x || !ok_to_skip || prev))
+                        strcat(slask,":");
+                    if (x || !ok_to_skip)
+                    {
+                        sprintf(slask + strlen(slask),"%x", x);
+                        if (x && skipped)
+                            ok_to_skip = false;
+                    }
+                    else
+                    {
+                        skipped = true;
+                    }
+                    prev = x;
+                }
+            }
+            if (!*slask)
+                strcpy(slask, "::");
+            hostname = slask;
+            return true;
+        }
+        else
+        {
+            // %! TODO: ipv6 reverse lookup
+            struct sockaddr_in6 *sa_in = (struct sockaddr_in6 *)sa;
+            struct hostent *h = gethostbyaddr( (const char *)&sa_in -> sin6_addr, sizeof(sa_in -> sin6_addr), AF_INET6);
+            if (h)
+            {
+                hostname = h -> h_name;
+                return true;
+            }
+        }
+        break;
 #endif
-	}
-	return false;
+    }
+    return false;
 #else
-	char host[NI_MAXHOST];
-	char serv[NI_MAXSERV];
-	// NI_NOFQDN
-	// NI_NUMERICHOST
-	// NI_NAMEREQD
-	// NI_NUMERICSERV
-	// NI_DGRAM
-	int n = getnameinfo(sa, sa_len, host, sizeof(host), serv, sizeof(serv), flags);
-	if (n)
-	{
-		// EAI_AGAIN
-		// EAI_BADFLAGS
-		// EAI_FAIL
-		// EAI_FAMILY
-		// EAI_MEMORY
-		// EAI_NONAME
-		// EAI_OVERFLOW
-		// EAI_SYSTEM
-		return false;
-	}
-	hostname = host;
-	service = serv;
-	return true;
+    char host[NI_MAXHOST];
+    char serv[NI_MAXSERV];
+    // NI_NOFQDN
+    // NI_NUMERICHOST
+    // NI_NAMEREQD
+    // NI_NUMERICSERV
+    // NI_DGRAM
+    int n = getnameinfo(sa, sa_len, host, sizeof(host), serv, sizeof(serv), flags);
+    if (n)
+    {
+        // EAI_AGAIN
+        // EAI_BADFLAGS
+        // EAI_FAIL
+        // EAI_FAMILY
+        // EAI_MEMORY
+        // EAI_NONAME
+        // EAI_OVERFLOW
+        // EAI_SYSTEM
+        return false;
+    }
+    hostname = host;
+    service = serv;
+    return true;
 #endif // NO_GETADDRINFO
 }
 
@@ -874,32 +874,32 @@ bool Utility::reverse(struct sockaddr *sa, socklen_t sa_len, std::string& hostna
 bool Utility::u2service(const std::string& name, int& service, int ai_flags)
 {
 #ifdef NO_GETADDRINFO
-	// %!
-	return false;
+    // %!
+    return false;
 #else
-	struct addrinfo hints;
-	service = 0;
-	memset(&hints, 0, sizeof(hints));
-	// AI_NUMERICHOST
-	// AI_CANONNAME
-	// AI_PASSIVE - server
-	// AI_ADDRCONFIG
-	// AI_V4MAPPED
-	// AI_ALL
-	// AI_NUMERICSERV
-	hints.ai_flags = ai_flags;
-	hints.ai_family = AF_UNSPEC;
-	hints.ai_socktype = 0;
-	hints.ai_protocol = 0;
-	struct addrinfo *res;
-	int n = getaddrinfo(NULL, name.c_str(), &hints, &res);
-	if (!n)
-	{
-		service = res -> ai_protocol;
-		freeaddrinfo(res);
-		return true;
-	}
-	return false;
+    struct addrinfo hints;
+    service = 0;
+    memset(&hints, 0, sizeof(hints));
+    // AI_NUMERICHOST
+    // AI_CANONNAME
+    // AI_PASSIVE - server
+    // AI_ADDRCONFIG
+    // AI_V4MAPPED
+    // AI_ALL
+    // AI_NUMERICSERV
+    hints.ai_flags = ai_flags;
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = 0;
+    hints.ai_protocol = 0;
+    struct addrinfo *res;
+    int n = getaddrinfo(NULL, name.c_str(), &hints, &res);
+    if (!n)
+    {
+        service = res -> ai_protocol;
+        freeaddrinfo(res);
+        return true;
+    }
+    return false;
 #endif // NO_GETADDRINFO
 }
 
@@ -907,90 +907,90 @@ bool Utility::u2service(const std::string& name, int& service, int ai_flags)
 unsigned long Utility::ThreadID()
 {
 #ifdef _WIN32
-	return GetCurrentThreadId();
+    return GetCurrentThreadId();
 #else
-	return (unsigned long)pthread_self();
+    return (unsigned long)pthread_self();
 #endif
 }
 
 
 std::string Utility::ToLower(const std::string& str)
 {
-	std::string r;
-	for (size_t i = 0; i < str.size(); i++)
-	{
-		if (str[i] >= 'A' && str[i] <= 'Z')
-			r += str[i] | 32;
-		else
-			r += str[i];
-	}
-	return r;
+    std::string r;
+    for (size_t i = 0; i < str.size(); i++)
+    {
+        if (str[i] >= 'A' && str[i] <= 'Z')
+            r += str[i] | 32;
+        else
+            r += str[i];
+    }
+    return r;
 }
 
 
 std::string Utility::ToUpper(const std::string& str)
 {
-	std::string r;
-	for (size_t i = 0; i < str.size(); i++)
-	{
-		if (str[i] >= 'a' && str[i] <= 'z')
-			r += (char)(str[i] - 32);
-		else
-			r += str[i];
-	}
-	return r;
+    std::string r;
+    for (size_t i = 0; i < str.size(); i++)
+    {
+        if (str[i] >= 'a' && str[i] <= 'z')
+            r += (char)(str[i] - 32);
+        else
+            r += str[i];
+    }
+    return r;
 }
 
 
 std::string Utility::ToString(double d)
 {
-	char tmp[100];
-	sprintf(tmp, "%f", d);
-	return tmp;
+    char tmp[100];
+    sprintf(tmp, "%f", d);
+    return tmp;
 }
 
 
 unsigned long Utility::Rnd()
 {
-static	Utility::Rng generator( (unsigned long)time(NULL) );
-	return generator.Get();
+static  Utility::Rng generator( (unsigned long)time(NULL) );
+    return generator.Get();
 }
 
 
 Utility::Rng::Rng(unsigned long seed) : m_value( 0 )
 {
-	m_tmp[0]= seed & 0xffffffffUL;
-	for (int i = 1; i < TWIST_LEN; i++)
-	{
-		m_tmp[i] = (1812433253UL * (m_tmp[i - 1] ^ (m_tmp[i - 1] >> 30)) + i);
-	}
+    m_tmp[0]= seed & 0xffffffffUL;
+    for (int i = 1; i < TWIST_LEN; i++)
+    {
+        m_tmp[i] = (1812433253UL * (m_tmp[i - 1] ^ (m_tmp[i - 1] >> 30)) + i);
+    }
 }
-					
+
 
 unsigned long Utility::Rng::Get()
 {
-	unsigned long val = m_tmp[m_value];
-	++m_value;
-	if (m_value == TWIST_LEN)
-	{
-		for (int i = 0; i < TWIST_IB; ++i)
-		{
-			unsigned long s = TWIST(m_tmp, i, i + 1);
-			m_tmp[i] = m_tmp[i + TWIST_IA] ^ (s >> 1) ^ MAGIC_TWIST(s);
-		}
-		{
-			for (int i = 0; i < TWIST_LEN - 1; ++i)
-			{
-				unsigned long s = TWIST(m_tmp, i, i + 1);
-				m_tmp[i] = m_tmp[i - TWIST_IB] ^ (s >> 1) ^ MAGIC_TWIST(s);
-			}
-		}
-		unsigned long s = TWIST(m_tmp, TWIST_LEN - 1, 0);
-		m_tmp[TWIST_LEN - 1] = m_tmp[TWIST_IA - 1] ^ (s >> 1) ^ MAGIC_TWIST(s);
-
-		m_value = 0;
-	}
-	return val;
+    unsigned long val = m_tmp[m_value];
+    ++m_value;
+    if (m_value == TWIST_LEN)
+    {
+        for (int i = 0; i < TWIST_IB; ++i)
+        {
+            unsigned long s = TWIST(m_tmp, i, i + 1);
+            m_tmp[i] = m_tmp[i + TWIST_IA] ^ (s >> 1) ^ MAGIC_TWIST(s);
+        }
+        {
+            for (int i = 0; i < TWIST_LEN - 1; ++i)
+            {
+                unsigned long s = TWIST(m_tmp, i, i + 1);
+                m_tmp[i] = m_tmp[i - TWIST_IB] ^ (s >> 1) ^ MAGIC_TWIST(s);
+            }
+        }
+        unsigned long s = TWIST(m_tmp, TWIST_LEN - 1, 0);
+        m_tmp[TWIST_LEN - 1] = m_tmp[TWIST_IA - 1] ^ (s >> 1) ^ MAGIC_TWIST(s);
+
+        m_value = 0;
+    }
+    return val;
 }
 
 #ifdef SOCKETS_NAMESPACE
diff --git a/dep/src/sockets/socket_include.cpp b/dep/src/sockets/socket_include.cpp
index 07b986b02b7..6f08e8e16ab 100644
--- a/dep/src/sockets/socket_include.cpp
+++ b/dep/src/sockets/socket_include.cpp
@@ -1,6 +1,6 @@
 /** \file socket_include.cpp
- **	\date  2004-11-28
- **	\author grymse@alhem.net
+ ** \date  2004-11-28
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2004-2007  Anders Hedstrom
@@ -8,7 +8,7 @@ Copyright (C) 2004-2007  Anders Hedstrom
 This library is made available under the terms of the GNU GPL.
 
 If you would like to use this library in a closed-source application,
-a separate license agreement is available. For information about 
+a separate license agreement is available. For information about
 the closed-source license agreement for the C++ sockets library,
 please visit http://www.alhem.net/Sockets/license.html and/or
 email license@alhem.net.
@@ -30,60 +30,60 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include <stdio.h>
 
 // only to be included in win32 projects
-const char *StrError(int x) 
+const char *StrError(int x)
 {
-static	char tmp[100];
-	switch (x)
-	{
-	case 10004: return "Interrupted function call.";
-	case 10013: return "Permission denied.";
-	case 10014: return "Bad address.";
-	case 10022: return "Invalid argument.";
-	case 10024: return "Too many open files.";
-	case 10035: return "Resource temporarily unavailable.";
-	case 10036: return "Operation now in progress.";
-	case 10037: return "Operation already in progress.";
-	case 10038: return "Socket operation on nonsocket.";
-	case 10039: return "Destination address required.";
-	case 10040: return "Message too long.";
-	case 10041: return "Protocol wrong type for socket.";
-	case 10042: return "Bad protocol option.";
-	case 10043: return "Protocol not supported.";
-	case 10044: return "Socket type not supported.";
-	case 10045: return "Operation not supported.";
-	case 10046: return "Protocol family not supported.";
-	case 10047: return "Address family not supported by protocol family.";
-	case 10048: return "Address already in use.";
-	case 10049: return "Cannot assign requested address.";
-	case 10050: return "Network is down.";
-	case 10051: return "Network is unreachable.";
-	case 10052: return "Network dropped connection on reset.";
-	case 10053: return "Software caused connection abort.";
-	case 10054: return "Connection reset by peer.";
-	case 10055: return "No buffer space available.";
-	case 10056: return "Socket is already connected.";
-	case 10057: return "Socket is not connected.";
-	case 10058: return "Cannot send after socket shutdown.";
-	case 10060: return "Connection timed out.";
-	case 10061: return "Connection refused.";
-	case 10064: return "Host is down.";
-	case 10065: return "No route to host.";
-	case 10067: return "Too many processes.";
-	case 10091: return "Network subsystem is unavailable.";
-	case 10092: return "Winsock.dll version out of range.";
-	case 10093: return "Successful WSAStartup not yet performed.";
-	case 10101: return "Graceful shutdown in progress.";
-	case 10109: return "Class type not found.";
-	case 11001: return "Host not found.";
-	case 11002: return "Nonauthoritative host not found.";
-	case 11003: return "This is a nonrecoverable error.";
-	case 11004: return "Valid name, no data record of requested type.";
+static  char tmp[100];
+    switch (x)
+    {
+    case 10004: return "Interrupted function call.";
+    case 10013: return "Permission denied.";
+    case 10014: return "Bad address.";
+    case 10022: return "Invalid argument.";
+    case 10024: return "Too many open files.";
+    case 10035: return "Resource temporarily unavailable.";
+    case 10036: return "Operation now in progress.";
+    case 10037: return "Operation already in progress.";
+    case 10038: return "Socket operation on nonsocket.";
+    case 10039: return "Destination address required.";
+    case 10040: return "Message too long.";
+    case 10041: return "Protocol wrong type for socket.";
+    case 10042: return "Bad protocol option.";
+    case 10043: return "Protocol not supported.";
+    case 10044: return "Socket type not supported.";
+    case 10045: return "Operation not supported.";
+    case 10046: return "Protocol family not supported.";
+    case 10047: return "Address family not supported by protocol family.";
+    case 10048: return "Address already in use.";
+    case 10049: return "Cannot assign requested address.";
+    case 10050: return "Network is down.";
+    case 10051: return "Network is unreachable.";
+    case 10052: return "Network dropped connection on reset.";
+    case 10053: return "Software caused connection abort.";
+    case 10054: return "Connection reset by peer.";
+    case 10055: return "No buffer space available.";
+    case 10056: return "Socket is already connected.";
+    case 10057: return "Socket is not connected.";
+    case 10058: return "Cannot send after socket shutdown.";
+    case 10060: return "Connection timed out.";
+    case 10061: return "Connection refused.";
+    case 10064: return "Host is down.";
+    case 10065: return "No route to host.";
+    case 10067: return "Too many processes.";
+    case 10091: return "Network subsystem is unavailable.";
+    case 10092: return "Winsock.dll version out of range.";
+    case 10093: return "Successful WSAStartup not yet performed.";
+    case 10101: return "Graceful shutdown in progress.";
+    case 10109: return "Class type not found.";
+    case 11001: return "Host not found.";
+    case 11002: return "Nonauthoritative host not found.";
+    case 11003: return "This is a nonrecoverable error.";
+    case 11004: return "Valid name, no data record of requested type.";
 
-	default:
-		break;
-	}
-	sprintf(tmp, "Winsock error code: %d", x);
-	return tmp;
+    default:
+        break;
+    }
+    sprintf(tmp, "Winsock error code: %d", x);
+    return tmp;
 }