Replace tabs with spaces in more files.

--HG--
branch : trunk

1 files changed, 490 insertions, 490 deletions

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;
 }