[svn] * Proper SVN structureinit

--HG--
branch : trunk

26 files changed, 4280 insertions, 0 deletions

diff --git a/dep/include/sockets/Base64.h b/dep/include/sockets/Base64.h
new file mode 100644
index 00000000000..a632bbec730
--- /dev/null
+++ b/dep/include/sockets/Base64.h
@@ -0,0 +1,77 @@
+/** \file Base64.h
+ **	\date  2004-02-13
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_Base64_H
+#define _SOCKETS_Base64_H
+
+#include "sockets-config.h"
+#ifdef _MSC_VER
+#pragma warning(disable:4514)
+#endif
+
+#include <stdio.h>
+#include <string>
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+/** \defgroup util Utilities */
+
+/** Base64 encode/decode. 
+	\ingroup util */
+class Base64
+{
+public:
+	Base64();
+
+	void encode(FILE *, std::string& , bool add_crlf = true);
+	void encode(const std::string&, std::string& , bool add_crlf = true);
+	void encode(const char *, size_t, std::string& , bool add_crlf = true);
+	void encode(const unsigned char *, size_t, std::string& , bool add_crlf = true);
+
+	void decode(const std::string&, std::string& );
+	void decode(const std::string&, unsigned char *, size_t&);
+
+	size_t decode_length(const std::string& );
+
+private:
+	Base64(const Base64& ) {}
+	Base64& operator=(const Base64& ) { return *this; }
+static	const char *bstr;
+static	const char rstr[128];
+};
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // _SOCKETS_Base64_H
+
diff --git a/dep/include/sockets/Exception.h b/dep/include/sockets/Exception.h
new file mode 100644
index 00000000000..81ba7373d0d
--- /dev/null
+++ b/dep/include/sockets/Exception.h
@@ -0,0 +1,58 @@
+/**
+ **	\file Exception.h
+ **	\date  2007-09-28
+ **	\author grymse@alhem.net
+**/
+/*
+Copyright (C) 2007  Anders Hedstrom
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _Sockets_Exception_H
+#define _Sockets_Exception_H
+
+#include <string>
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+
+
+class Exception
+{
+public:
+	Exception(const std::string& description);
+	virtual ~Exception() {}
+
+	virtual const std::string ToString() const;
+
+	Exception(const Exception& ) {} // copy constructor
+
+	Exception& operator=(const Exception& ) { return *this; } // assignment operator
+
+private:
+	std::string m_description;
+
+};
+
+
+
+#ifdef SOCKETS_NAMESPACE
+} // namespace SOCKETS_NAMESPACE {
+#endif
+
+#endif // _Sockets_Exception_H
+
diff --git a/dep/include/sockets/File.h b/dep/include/sockets/File.h
new file mode 100644
index 00000000000..58a1b71bb85
--- /dev/null
+++ b/dep/include/sockets/File.h
@@ -0,0 +1,84 @@
+/** \file File.h
+ **	\date  2005-04-25
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_File_H
+#define _SOCKETS_File_H
+
+#include "sockets-config.h"
+#include "IFile.h"
+#include <stdio.h>
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+
+/** IFile implementation of a disk file. 
+	\ingroup file */
+class File : public IFile
+{
+public:
+	File();
+	~File();
+
+	bool fopen(const std::string&, const std::string&);
+	void fclose();
+
+	size_t fread(char *, size_t, size_t) const;
+	size_t fwrite(const char *, size_t, size_t);
+
+	char *fgets(char *, int) const;
+	void fprintf(const char *format, ...);
+
+	off_t size() const;
+	bool eof() const;
+
+	void reset_read() const;
+	void reset_write();
+
+private:
+	File(const File& ) {} // copy constructor
+	File& operator=(const File& ) { return *this; } // assignment operator
+
+	std::string m_path;
+	std::string m_mode;
+	FILE *m_fil;
+	mutable long m_rptr;
+	long m_wptr;
+};
+
+
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // _SOCKETS_File_H
+
diff --git a/dep/include/sockets/IFile.h b/dep/include/sockets/IFile.h
new file mode 100644
index 00000000000..aecc50f5997
--- /dev/null
+++ b/dep/include/sockets/IFile.h
@@ -0,0 +1,71 @@
+/** \file IFile.h
+ **	\date  2005-04-25
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_IFile_H
+#define _SOCKETS_IFile_H
+
+#include "sockets-config.h"
+#include <string>
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+/** \defgroup file File handling */
+/** Pure virtual file I/O interface. 
+	\ingroup file */
+class IFile
+{
+public:
+	virtual ~IFile() {}
+
+	virtual bool fopen(const std::string&, const std::string&) = 0;
+	virtual void fclose() = 0;
+
+	virtual size_t fread(char *, size_t, size_t) const = 0;
+	virtual size_t fwrite(const char *, size_t, size_t) = 0;
+
+	virtual char *fgets(char *, int) const = 0;
+	virtual void fprintf(const char *format, ...) = 0;
+
+	virtual off_t size() const = 0;
+	virtual bool eof() const = 0;
+
+	virtual void reset_read() const = 0;
+	virtual void reset_write() = 0;
+
+};
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // _SOCKETS_IFile_H
+
diff --git a/dep/include/sockets/ISocketHandler.h b/dep/include/sockets/ISocketHandler.h
new file mode 100644
index 00000000000..2667e2d22ed
--- /dev/null
+++ b/dep/include/sockets/ISocketHandler.h
@@ -0,0 +1,232 @@
+/** \file ISocketHandler.h
+ **	\date  2004-02-13
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_ISocketHandler_H
+#define _SOCKETS_ISocketHandler_H
+#include "sockets-config.h"
+
+#include <list>
+
+#include "socket_include.h"
+#include "Socket.h"
+#include "StdLog.h"
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+typedef enum {
+	LIST_CALLONCONNECT = 0,
+#ifdef ENABLE_DETACH
+	LIST_DETACH,
+#endif
+	LIST_TIMEOUT,
+	LIST_RETRY,
+	LIST_CLOSE
+} list_t;
+
+class SocketAddress;
+class Mutex;
+
+
+/** Socket container class, event generator. 
+	\ingroup basic */
+class ISocketHandler
+{
+	friend class Socket;
+
+public:
+	/** Connection pool class for internal use by the ISocketHandler. 
+		\ingroup internal */
+#ifdef ENABLE_POOL
+	class PoolSocket : public Socket
+	{
+	public:
+		PoolSocket(ISocketHandler& h,Socket *src) : Socket(h) {
+			CopyConnection( src );
+			SetIsClient();
+		}
+
+		void OnRead() {
+			Handler().LogError(this, "OnRead", 0, "data on hibernating socket", LOG_LEVEL_FATAL);
+			SetCloseAndDelete();
+		}
+		void OnOptions(int,int,int,SOCKET) {}
+
+	};
+#endif
+
+public:
+	virtual ~ISocketHandler() {}
+
+	/** Get mutex reference for threadsafe operations. */
+	virtual Mutex& GetMutex() const = 0;
+
+	/** Register StdLog object for error callback. 
+		\param log Pointer to log class */
+	virtual void RegStdLog(StdLog *log) = 0;
+
+	/** Log error to log class for print out / storage. */
+	virtual void LogError(Socket *p,const std::string& user_text,int err,const std::string& sys_err,loglevel_t t = LOG_LEVEL_WARNING) = 0;
+
+	// -------------------------------------------------------------------------
+	// Socket stuff
+	// -------------------------------------------------------------------------
+	/** Add socket instance to socket map. Removal is always automatic. */
+	virtual void Add(Socket *) = 0;
+private:
+	/** Remove socket from socket map, used by Socket class. */
+	virtual void Remove(Socket *) = 0;
+public:
+	/** Get status of read/write/exception file descriptor set for a socket. */
+	virtual void Get(SOCKET s,bool& r,bool& w,bool& e) = 0;
+	/** Set read/write/exception file descriptor sets (fd_set). */
+	virtual void Set(SOCKET s,bool bRead,bool bWrite,bool bException = true) = 0;
+
+	/** Wait for events, generate callbacks. */
+	virtual int Select(long sec,long usec) = 0;
+	/** This method will not return until an event has been detected. */
+	virtual int Select() = 0;
+	/** Wait for events, generate callbacks. */
+	virtual int Select(struct timeval *tsel) = 0;
+
+	/** Check that a socket really is handled by this socket handler. */
+	virtual bool Valid(Socket *) = 0;
+	/** Return number of sockets handled by this handler.  */
+	virtual size_t GetCount() = 0;
+
+	/** Override and return false to deny all incoming connections. 
+		\param p ListenSocket class pointer (use GetPort to identify which one) */
+	virtual bool OkToAccept(Socket *p) = 0;
+
+	/** Called by Socket when a socket changes state. */
+	virtual void AddList(SOCKET s,list_t which_one,bool add) = 0;
+
+	// -------------------------------------------------------------------------
+	// Connection pool
+	// -------------------------------------------------------------------------
+#ifdef ENABLE_POOL
+	/** Find available open connection (used by connection pool). */
+	virtual ISocketHandler::PoolSocket *FindConnection(int type,const std::string& protocol,SocketAddress&) = 0;
+	/** Enable connection pool (by default disabled). */
+	virtual void EnablePool(bool = true) = 0;
+	/** Check pool status. 
+		\return true if connection pool is enabled */
+	virtual bool PoolEnabled() = 0;
+#endif // ENABLE_POOL
+
+	// -------------------------------------------------------------------------
+	// Socks4
+	// -------------------------------------------------------------------------
+#ifdef ENABLE_SOCKS4
+	/** Set socks4 server ip that all new tcp sockets should use. */
+	virtual void SetSocks4Host(ipaddr_t) = 0;
+	/** Set socks4 server hostname that all new tcp sockets should use. */
+	virtual void SetSocks4Host(const std::string& ) = 0;
+	/** Set socks4 server port number that all new tcp sockets should use. */
+	virtual void SetSocks4Port(port_t) = 0;
+	/** Set optional socks4 userid. */
+	virtual void SetSocks4Userid(const std::string& ) = 0;
+	/** If connection to socks4 server fails, immediately try direct connection to final host. */
+	virtual void SetSocks4TryDirect(bool = true) = 0;
+	/** Get socks4 server ip. 
+		\return socks4 server ip */
+	virtual ipaddr_t GetSocks4Host() = 0;
+	/** Get socks4 port number.
+		\return socks4 port number */
+	virtual port_t GetSocks4Port() = 0;
+	/** Get socks4 userid (optional).
+		\return socks4 userid */
+	virtual const std::string& GetSocks4Userid() = 0;
+	/** Check status of socks4 try direct flag.
+		\return true if direct connection should be tried if connection to socks4 server fails */
+	virtual bool Socks4TryDirect() = 0;
+#endif // ENABLE_SOCKS4
+
+	// -------------------------------------------------------------------------
+	// DNS resolve server
+	// -------------------------------------------------------------------------
+#ifdef ENABLE_RESOLVER
+	/** Enable asynchronous DNS. 
+		\param port Listen port of asynchronous dns server */
+	virtual void EnableResolver(port_t = 16667) = 0;
+	/** Check resolver status.
+		\return true if resolver is enabled */
+	virtual bool ResolverEnabled() = 0;
+	/** Queue a dns request.
+		\param host Hostname to be resolved
+		\param port Port number will be echoed in Socket::OnResolved callback */
+	virtual int Resolve(Socket *,const std::string& host,port_t port) = 0;
+#ifdef ENABLE_IPV6
+	virtual int Resolve6(Socket *,const std::string& host,port_t port) = 0;
+#endif
+	/** Do a reverse dns lookup. */
+	virtual int Resolve(Socket *,ipaddr_t a) = 0;
+#ifdef ENABLE_IPV6
+	virtual int Resolve(Socket *,in6_addr& a) = 0;
+#endif
+	/** Get listen port of asynchronous dns server. */
+	virtual port_t GetResolverPort() = 0;
+	/** Resolver thread ready for queries. */
+	virtual bool ResolverReady() = 0;
+	/** Returns true if socket waiting for a resolve event. */
+	virtual bool Resolving(Socket *) = 0;
+#endif // ENABLE_RESOLVER
+
+#ifdef ENABLE_TRIGGERS
+	/** Fetch unique trigger id. */
+	virtual int TriggerID(Socket *src) = 0;
+	/** Subscribe socket to trigger id. */
+	virtual bool Subscribe(int id, Socket *dst) = 0;
+	/** Unsubscribe socket from trigger id. */
+	virtual bool Unsubscribe(int id, Socket *dst) = 0;
+	/** Execute OnTrigger for subscribed sockets.
+		\param id Trigger ID
+		\param data Data passed from source to destination
+		\param erase Empty trigger id source and destination maps if 'true',
+			Leave them in place if 'false' - if a trigger should be called many times */
+	virtual void Trigger(int id, Socket::TriggerData& data, bool erase = true) = 0;
+#endif // ENABLE_TRIGGERS
+
+#ifdef ENABLE_DETACH
+	/** Indicates that the handler runs under SocketThread. */
+	virtual void SetSlave(bool x = true) = 0;
+	/** Indicates that the handler runs under SocketThread. */
+	virtual bool IsSlave() = 0;
+#endif // ENABLE_DETACH
+
+};
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // _SOCKETS_ISocketHandler_H
+
diff --git a/dep/include/sockets/Ipv4Address.h b/dep/include/sockets/Ipv4Address.h
new file mode 100644
index 00000000000..b58c2ce9425
--- /dev/null
+++ b/dep/include/sockets/Ipv4Address.h
@@ -0,0 +1,98 @@
+/**
+ **	\file Ipv4Address.h
+ **	\date  2006-09-21
+ **	\author grymse@alhem.net
+**/
+/*
+Copyright (C) 2007  Anders Hedstrom
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_Ipv4Address_H
+#define _SOCKETS_Ipv4Address_H
+
+#include "sockets-config.h"
+#include "SocketAddress.h"
+
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+
+/* Ipv4 address implementation.
+	\ingroup basic */
+class Ipv4Address : public SocketAddress
+{
+public:
+	/** Create empty Ipv4 address structure.
+		\param port Port number */
+	Ipv4Address(port_t port = 0);
+	/** Create Ipv4 address structure.
+		\param a Socket address in network byte order (as returned by Utility::u2ip)
+		\param port Port number in host byte order */
+	Ipv4Address(ipaddr_t a,port_t port);
+	/** Create Ipv4 address structure.
+		\param a Socket address in network byte order
+		\param port Port number in host byte order */
+	Ipv4Address(struct in_addr& a,port_t port);
+	/** Create Ipv4 address structure.
+		\param host Hostname to be resolved
+		\param port Port number in host byte order */
+	Ipv4Address(const std::string& host,port_t port);
+	Ipv4Address(struct sockaddr_in&);
+	~Ipv4Address();
+
+	// SocketAddress implementation
+
+	operator struct sockaddr *();
+	operator socklen_t();
+	bool operator==(SocketAddress&);
+
+	void SetPort(port_t port);
+	port_t GetPort();
+
+	void SetAddress(struct sockaddr *sa);
+	int GetFamily();
+
+	bool IsValid();
+	std::auto_ptr<SocketAddress> GetCopy();
+
+	/** Convert address struct to text. */
+	std::string Convert(bool include_port = false);
+	std::string Reverse();
+
+	/** Resolve hostname. */
+static	bool Resolve(const std::string& hostname,struct in_addr& a);
+	/** Reverse resolve (IP to hostname). */
+static	bool Reverse(struct in_addr& a,std::string& name);
+	/** Convert address struct to text. */
+static	std::string Convert(struct in_addr& a);
+
+private:
+	Ipv4Address(const Ipv4Address& ) {} // copy constructor
+	Ipv4Address& operator=(const Ipv4Address& ) { return *this; } // assignment operator
+	struct sockaddr_in m_addr;
+	bool m_valid;
+};
+
+
+
+
+#ifdef SOCKETS_NAMESPACE
+} // namespace SOCKETS_NAMESPACE {
+#endif
+#endif // _SOCKETS_Ipv4Address_H
+
diff --git a/dep/include/sockets/Ipv6Address.h b/dep/include/sockets/Ipv6Address.h
new file mode 100644
index 00000000000..a0711417956
--- /dev/null
+++ b/dep/include/sockets/Ipv6Address.h
@@ -0,0 +1,107 @@
+/**
+ **	\file Ipv6Address.h
+ **	\date  2006-09-21
+ **	\author grymse@alhem.net
+**/
+/*
+Copyright (C) 2007  Anders Hedstrom
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_Ipv6Address_H
+#define _SOCKETS_Ipv6Address_H
+#include "sockets-config.h"
+#ifdef ENABLE_IPV6
+
+#include "SocketAddress.h"
+#ifdef IPPROTO_IPV6
+#if defined( _WIN32) && !defined(__CYGWIN__)
+typedef unsigned __int32 uint32_t;
+#endif
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+
+/** Ipv6 address implementation.
+	\ingroup basic */
+class Ipv6Address : public SocketAddress
+{
+public:
+	/** Create empty Ipv6 address structure.
+		\param port Port number */
+	Ipv6Address(port_t port = 0);
+	/** Create Ipv6 address structure.
+		\param a Socket address in network byte order
+		\param port Port number in host byte order */
+	Ipv6Address(struct in6_addr& a,port_t port);
+	/** Create Ipv6 address structure.
+		\param host Hostname to be resolved
+		\param port Port number in host byte order */
+	Ipv6Address(const std::string& host,port_t port);
+	Ipv6Address(struct sockaddr_in6&);
+	~Ipv6Address();
+
+	// SocketAddress implementation
+
+	operator struct sockaddr *();
+	operator socklen_t();
+	bool operator==(SocketAddress&);
+
+	void SetPort(port_t port);
+	port_t GetPort();
+
+	void SetAddress(struct sockaddr *sa);
+	int GetFamily();
+
+	bool IsValid();
+	std::auto_ptr<SocketAddress> GetCopy();
+
+	/** Convert address struct to text. */
+	std::string Convert(bool include_port = false);
+	std::string Reverse();
+
+	/** Resolve hostname. */
+static	bool Resolve(const std::string& hostname,struct in6_addr& a);
+	/** Reverse resolve (IP to hostname). */
+static	bool Reverse(struct in6_addr& a,std::string& name);
+	/** Convert address struct to text. */
+static	std::string Convert(struct in6_addr& a,bool mixed = false);
+
+	void SetFlowinfo(uint32_t);
+	uint32_t GetFlowinfo();
+#ifndef _WIN32
+	void SetScopeId(uint32_t);
+	uint32_t GetScopeId();
+#endif
+
+private:
+	Ipv6Address(const Ipv6Address& ) {} // copy constructor
+	Ipv6Address& operator=(const Ipv6Address& ) { return *this; } // assignment operator
+	struct sockaddr_in6 m_addr;
+	bool m_valid;
+};
+
+
+
+
+#ifdef SOCKETS_NAMESPACE
+} // namespace SOCKETS_NAMESPACE {
+#endif
+#endif // IPPROTO_IPV6
+#endif // ENABLE_IPV6
+#endif // _SOCKETS_Ipv6Address_H
+
diff --git a/dep/include/sockets/ListenSocket.h b/dep/include/sockets/ListenSocket.h
new file mode 100644
index 00000000000..f4edc37d6c3
--- /dev/null
+++ b/dep/include/sockets/ListenSocket.h
@@ -0,0 +1,420 @@
+/** \file ListenSocket.h
+ **	\date  2004-02-13
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, 
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_ListenSocket_H
+#define _SOCKETS_ListenSocket_H
+#include "sockets-config.h"
+
+#ifdef _WIN32
+#include <stdlib.h>
+#else
+#include <errno.h>
+#endif
+
+#include "ISocketHandler.h"
+#include "Socket.h"
+#include "Utility.h"
+#include "SctpSocket.h"
+#include "Ipv4Address.h"
+#include "Ipv6Address.h"
+#ifdef ENABLE_EXCEPTIONS
+#include "Exception.h"
+#endif
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+
+/** Binds incoming port number to new Socket class X. 
+	\ingroup basic */
+template <class X>
+class ListenSocket : public Socket
+{
+public:
+	/** Constructor.
+		\param h ISocketHandler reference
+		\param use_creator Optional use of creator (default true) */
+	ListenSocket(ISocketHandler& h,bool use_creator = true) : Socket(h), m_depth(0), m_creator(NULL)
+	,m_bHasCreate(false)
+	{
+		if (use_creator)
+		{
+			m_creator = new X(h);
+			Socket *tmp = m_creator -> Create();
+			if (tmp && dynamic_cast<X *>(tmp))
+			{
+				m_bHasCreate = true;
+			}
+			if (tmp)
+			{
+				delete tmp;
+			}
+		}
+	}
+	~ListenSocket() {
+		if (m_creator)
+		{
+			delete m_creator;
+		}
+	}
+
+	/** Close file descriptor. */
+	int Close() {
+		if (GetSocket() != INVALID_SOCKET)
+		{
+			closesocket(GetSocket());
+		}
+		return 0;
+	}
+
+	/** Bind and listen to any interface.
+		\param port Port (0 is random)
+		\param depth Listen queue depth */
+	int Bind(port_t port,int depth = 20) {
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+		if (IsIpv6())
+		{
+			Ipv6Address ad(port);
+			return Bind(ad, depth);
+		}
+		else
+#endif
+#endif
+		{
+			Ipv4Address ad(port);
+			return Bind(ad, depth);
+		}
+	}
+
+	int Bind(SocketAddress& ad,int depth) {
+#ifdef USE_SCTP
+		if (dynamic_cast<SctpSocket *>(m_creator))
+		{
+			return Bind(ad, "sctp", depth);
+		}
+#endif
+		return Bind(ad, "tcp", depth);
+	}
+
+	/** Bind and listen to any interface, with optional protocol.
+		\param port Port (0 is random)
+		\param protocol Network protocol
+		\param depth Listen queue depth */
+	int Bind(port_t port,const std::string& protocol,int depth = 20) {
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+		if (IsIpv6())
+		{
+			Ipv6Address ad(port);
+			return Bind(ad, protocol, depth);
+		}
+		else
+#endif
+#endif
+		{
+			Ipv4Address ad(port);
+			return Bind(ad, protocol, depth);
+		}
+	}
+
+	/** Bind and listen to specific interface.
+		\param intf Interface hostname
+		\param port Port (0 is random)
+		\param depth Listen queue depth */
+	int Bind(const std::string& intf,port_t port,int depth = 20) {
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+		if (IsIpv6())
+		{
+			Ipv6Address ad(intf, port);
+			if (ad.IsValid())
+			{
+				return Bind(ad, depth);
+			}
+			Handler().LogError(this, "Bind", 0, "name resolution of interface name failed", LOG_LEVEL_FATAL);
+			return -1;
+		}
+		else
+#endif
+#endif
+		{
+			Ipv4Address ad(intf, port);
+			if (ad.IsValid())
+			{
+				return Bind(ad, depth);
+			}
+			Handler().LogError(this, "Bind", 0, "name resolution of interface name failed", LOG_LEVEL_FATAL);
+			return -1;
+		}
+	}
+
+	/** Bind and listen to specific interface.
+		\param intf Interface hostname
+		\param port Port (0 is random)
+		\param protocol Network protocol
+		\param depth Listen queue depth */
+	int Bind(const std::string& intf,port_t port,const std::string& protocol,int depth = 20) {
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+		if (IsIpv6())
+		{
+			Ipv6Address ad(intf, port);
+			if (ad.IsValid())
+			{
+				return Bind(ad, protocol, depth);
+			}
+			Handler().LogError(this, "Bind", 0, "name resolution of interface name failed", LOG_LEVEL_FATAL);
+			return -1;
+		}
+		else
+#endif
+#endif
+		{
+			Ipv4Address ad(intf, port);
+			if (ad.IsValid())
+			{
+				return Bind(ad, protocol, depth);
+			}
+			Handler().LogError(this, "Bind", 0, "name resolution of interface name failed", LOG_LEVEL_FATAL);
+			return -1;
+		}
+	}
+
+	/** Bind and listen to ipv4 interface.
+		\param a Ipv4 interface address
+		\param port Port (0 is random)
+		\param depth Listen queue depth */
+	int Bind(ipaddr_t a,port_t port,int depth = 20) {
+		Ipv4Address ad(a, port);
+#ifdef USE_SCTP
+		if (dynamic_cast<SctpSocket *>(m_creator))
+		{
+			return Bind(ad, "sctp", depth);
+		}
+#endif
+		return Bind(ad, "tcp", depth);
+	}
+	/** Bind and listen to ipv4 interface.
+		\param a Ipv4 interface address
+		\param port Port (0 is random)
+		\param protocol Network protocol
+		\param depth Listen queue depth */
+	int Bind(ipaddr_t a,port_t port,const std::string& protocol,int depth) {
+		Ipv4Address ad(a, port);
+		return Bind(ad, protocol, depth);
+	}
+
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+	/** Bind and listen to ipv6 interface.
+		\param a Ipv6 interface address
+		\param port Port (0 is random)
+		\param depth Listen queue depth */
+	int Bind(in6_addr a,port_t port,int depth = 20) {
+		Ipv6Address ad(a, port);
+#ifdef USE_SCTP
+		if (dynamic_cast<SctpSocket *>(m_creator))
+		{
+			return Bind(ad, "sctp", depth);
+		}
+#endif
+		return Bind(ad, "tcp", depth);
+	}
+	/** Bind and listen to ipv6 interface.
+		\param a Ipv6 interface address
+		\param port Port (0 is random)
+		\param protocol Network protocol
+		\param depth Listen queue depth */
+	int Bind(in6_addr a,port_t port,const std::string& protocol,int depth) {
+		Ipv6Address ad(a, port);
+		return Bind(ad, protocol, depth);
+	}
+#endif
+#endif
+
+	/** Bind and listen to network interface.
+		\param ad Interface address
+		\param protocol Network protocol
+		\param depth Listen queue depth */
+	int Bind(SocketAddress& ad,const std::string& protocol,int depth) {
+		SOCKET s;
+		if ( (s = CreateSocket(ad.GetFamily(), SOCK_STREAM, protocol)) == INVALID_SOCKET)
+		{
+			return -1;
+		}
+		if (bind(s, ad, ad) == -1)
+		{
+			Handler().LogError(this, "bind", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+			closesocket(s);
+#ifdef ENABLE_EXCEPTIONS
+			throw Exception("bind() failed for port " + Utility::l2string(ad.GetPort()) + ": " + StrError(Errno));
+#endif
+			return -1;
+		}
+		if (listen(s, depth) == -1)
+		{
+			Handler().LogError(this, "listen", Errno, StrError(Errno), LOG_LEVEL_FATAL);
+			closesocket(s);
+#ifdef ENABLE_EXCEPTIONS
+			throw Exception("listen() failed for port " + Utility::l2string(ad.GetPort()) + ": " + StrError(Errno));
+#endif
+			return -1;
+		}
+		m_depth = depth;
+		Attach(s);
+		return 0;
+	}
+
+	/** Return assigned port number. */
+	port_t GetPort()
+	{
+		return GetSockPort();
+	}
+
+	/** Return listen queue depth. */
+	int GetDepth()
+	{
+		return m_depth;
+	}
+
+	/** OnRead on a ListenSocket receives an incoming connection. */
+	void OnRead()
+	{
+		struct sockaddr sa;
+		socklen_t sa_len = sizeof(struct sockaddr);
+		SOCKET a_s = accept(GetSocket(), &sa, &sa_len);
+
+		if (a_s == INVALID_SOCKET)
+		{
+			Handler().LogError(this, "accept", Errno, StrError(Errno), LOG_LEVEL_ERROR);
+			return;
+		}
+		if (!Handler().OkToAccept(this))
+		{
+			Handler().LogError(this, "accept", -1, "Not OK to accept", LOG_LEVEL_WARNING);
+			closesocket(a_s);
+			return;
+		}
+		if (Handler().GetCount() >= FD_SETSIZE)
+		{
+			Handler().LogError(this, "accept", (int)Handler().GetCount(), "ISocketHandler fd_set limit reached", LOG_LEVEL_FATAL);
+			closesocket(a_s);
+			return;
+		}
+		Socket *tmp = m_bHasCreate ? m_creator -> Create() : new X(Handler());
+#ifdef ENABLE_IPV6
+		tmp -> SetIpv6( IsIpv6() );
+#endif
+		tmp -> SetParent(this);
+		tmp -> Attach(a_s);
+		tmp -> SetNonblocking(true);
+		{
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+			if (sa_len == sizeof(struct sockaddr_in6))
+			{
+				struct sockaddr_in6 *p = (struct sockaddr_in6 *)&sa;
+				if (p -> sin6_family == AF_INET6)
+				{
+					Ipv6Address ad(p -> sin6_addr,ntohs(p -> sin6_port));
+					ad.SetFlowinfo(p -> sin6_flowinfo);
+#ifndef _WIN32
+					ad.SetScopeId(p -> sin6_scope_id);
+#endif
+					tmp -> SetRemoteAddress(ad);
+				}
+			}
+#endif
+#endif
+			if (sa_len == sizeof(struct sockaddr_in))
+			{
+				struct sockaddr_in *p = (struct sockaddr_in *)&sa;
+				if (p -> sin_family == AF_INET)
+				{
+					Ipv4Address ad(p -> sin_addr,ntohs(p -> sin_port));
+					tmp -> SetRemoteAddress(ad);
+				}
+			}
+		}
+		tmp -> SetConnected(true);
+		tmp -> Init();
+		tmp -> SetDeleteByHandler(true);
+		Handler().Add(tmp);
+#ifdef HAVE_OPENSSL
+		if (tmp -> IsSSL()) // SSL Enabled socket
+		{
+			// %! OnSSLAccept calls SSLNegotiate that can finish in this one call.
+			// %! If that happens and negotiation fails, the 'tmp' instance is
+			// %! still added to the list of active sockets in the sockethandler.
+			// %! See bugfix for this in SocketHandler::Select - don't Set rwx
+			// %! flags if CloseAndDelete() flag is true.
+			// %! An even better fugbix (see TcpSocket::OnSSLAccept) now avoids
+			// %! the Add problem altogether, so ignore the above.
+			// %! (OnSSLAccept does no longer call SSLNegotiate().)
+			tmp -> OnSSLAccept();
+		}
+		else
+#endif
+		{
+			tmp -> OnAccept();
+		}
+	}
+
+	/** Please don't use this method.
+		"accept()" is handled automatically in the OnRead() method. */
+        virtual SOCKET Accept(SOCKET socket, struct sockaddr *saptr, socklen_t *lenptr)
+        {
+                return accept(socket, saptr, lenptr);
+        }
+
+        bool HasCreator() { return m_bHasCreate; }
+
+	void OnOptions(int,int,int,SOCKET) {
+		SetSoReuseaddr(true);
+	}
+
+protected:
+	ListenSocket(const ListenSocket& s) : Socket(s) {}
+private:
+	ListenSocket& operator=(const ListenSocket& ) { return *this; }
+	int m_depth;
+	X *m_creator;
+	bool m_bHasCreate;
+};
+
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // _SOCKETS_ListenSocket_H
+
diff --git a/dep/include/sockets/Lock.h b/dep/include/sockets/Lock.h
new file mode 100644
index 00000000000..71fdd5e733d
--- /dev/null
+++ b/dep/include/sockets/Lock.h
@@ -0,0 +1,59 @@
+/** \file Lock.h
+ **	\date  2005-08-22
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_Lock_H
+#define _SOCKETS_Lock_H
+
+#include "sockets-config.h"
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+class Mutex;
+
+/** Mutex encapsulation class. 
+	\ingroup threading */
+class Lock
+{
+public:
+	Lock(Mutex&);
+	~Lock();
+
+private:
+	Mutex& m_mutex;
+};
+
+
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+#endif // _SOCKETS_Lock_H
+
diff --git a/dep/include/sockets/Mutex.h b/dep/include/sockets/Mutex.h
new file mode 100644
index 00000000000..1de27760a1c
--- /dev/null
+++ b/dep/include/sockets/Mutex.h
@@ -0,0 +1,68 @@
+/** \file Mutex.h
+ **	\date  2004-10-30
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_Mutex_H
+#define _SOCKETS_Mutex_H
+
+#include "sockets-config.h"
+#ifndef _WIN32
+#include <pthread.h>
+#else
+#include <windows.h>
+#endif
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+/** Mutex container class, used by Lock. 
+	\ingroup threading */
+class Mutex
+{
+	friend class Lock;
+public:
+	Mutex();
+	~Mutex();
+
+	void Lock();
+	void Unlock();
+private:
+#ifdef _WIN32
+	HANDLE m_mutex;
+#else
+	pthread_mutex_t m_mutex;
+#endif
+};
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+#endif // _SOCKETS_Mutex_H
+
diff --git a/dep/include/sockets/Parse.h b/dep/include/sockets/Parse.h
new file mode 100644
index 00000000000..6961f3b1bc9
--- /dev/null
+++ b/dep/include/sockets/Parse.h
@@ -0,0 +1,101 @@
+/** \file Parse.h - parse a string
+ **
+ **	Written: 1999-Feb-10 grymse@alhem.net
+ **/
+
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+#ifndef _SOCKETS_Parse_H
+#define _SOCKETS_Parse_H
+
+#include "sockets-config.h"
+#ifdef _MSC_VER
+#pragma warning(disable:4514)
+#endif
+
+#include <string>
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+
+/***************************************************/
+/* interface of class Parse */
+
+/** Splits a string whatever way you want.
+	\ingroup util */
+class Parse
+{
+public:
+	Parse();
+	Parse(const std::string&);
+	Parse(const std::string&,const std::string&);
+	Parse(const std::string&,const std::string&,short);
+	~Parse();
+	short issplit(const char);
+	void getsplit();
+	void getsplit(std::string&);
+	std::string getword();
+	void getword(std::string&);
+	void getword(std::string&,std::string&,int);
+	std::string getrest();
+	void getrest(std::string&);
+	long getvalue();
+	void setbreak(const char);
+	int getwordlen();
+	int getrestlen();
+	void enablebreak(const char c) {
+		pa_enable = c;
+	}
+	void disablebreak(const char c) {
+		pa_disable = c;
+	}
+	void getline();
+	void getline(std::string&);
+	size_t getptr() { return pa_the_ptr; }
+	void EnableQuote(bool b) { pa_quote = b; }
+
+private:
+	std::string pa_the_str;
+	std::string pa_splits;
+	std::string pa_ord;
+	size_t   pa_the_ptr;
+	char  pa_breakchar;
+	char  pa_enable;
+	char  pa_disable;
+	short pa_nospace;
+	bool  pa_quote;
+};
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // _SOCKETS_Parse_H
+
diff --git a/dep/include/sockets/ResolvServer.h b/dep/include/sockets/ResolvServer.h
new file mode 100644
index 00000000000..f8f8f5aadbf
--- /dev/null
+++ b/dep/include/sockets/ResolvServer.h
@@ -0,0 +1,73 @@
+/** \file ResolvServer.h
+ **	\date  2005-03-24
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_ResolvServer_H
+#define _SOCKETS_ResolvServer_H
+#include "sockets-config.h"
+#ifdef ENABLE_RESOLVER
+#include "socket_include.h"
+#include "Thread.h"
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+/** \defgroup async Asynchronous DNS */
+/** Async DNS resolver thread. 
+	\ingroup async */
+class ResolvServer : public Thread
+{
+public:
+	ResolvServer(port_t);
+	~ResolvServer();
+
+	void Run();
+	void Quit();
+
+	bool Ready();
+
+private:
+	ResolvServer(const ResolvServer& ) {} // copy constructor
+	ResolvServer& operator=(const ResolvServer& ) { return *this; } // assignment operator
+
+	bool m_quit;
+	port_t m_port;
+	bool m_ready;
+};
+
+
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // ENABLE_RESOLVER
+#endif // _SOCKETS_ResolvServer_H
+
diff --git a/dep/include/sockets/ResolvSocket.h b/dep/include/sockets/ResolvSocket.h
new file mode 100644
index 00000000000..ff4b1a5a982
--- /dev/null
+++ b/dep/include/sockets/ResolvSocket.h
@@ -0,0 +1,106 @@
+/** \file ResolvSocket.h
+ **	\date  2005-03-24
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_ResolvSocket_H
+#define _SOCKETS_ResolvSocket_H
+#include "sockets-config.h"
+#ifdef ENABLE_RESOLVER
+#include "TcpSocket.h"
+#include <map>
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+class Mutex;
+
+/** Async DNS resolver socket. 
+	\ingroup async */
+class ResolvSocket : public TcpSocket
+{
+	typedef std::map<std::string, /* type */
+			std::map<std::string, std::string> > cache_t; /* host, result */
+	typedef std::map<std::string, /* type */
+			std::map<std::string, time_t> > timeout_t; /* host, time */
+
+public:
+	ResolvSocket(ISocketHandler&);
+	ResolvSocket(ISocketHandler&, Socket *parent, const std::string& host, port_t port, bool ipv6 = false);
+	ResolvSocket(ISocketHandler&, Socket *parent, ipaddr_t);
+#ifdef ENABLE_IPV6
+	ResolvSocket(ISocketHandler&, Socket *parent, in6_addr&);
+#endif
+	~ResolvSocket();
+
+	void OnAccept() { m_bServer = true; }
+	void OnLine(const std::string& line);
+	void OnDetached();
+	void OnDelete();
+
+	void SetId(int x) { m_resolv_id = x; }
+	int GetId() { return m_resolv_id; }
+
+	void OnConnect();
+
+#ifdef ENABLE_IPV6
+	void SetResolveIpv6(bool x = true) { m_resolve_ipv6 = x; }
+#endif
+
+private:
+	ResolvSocket(const ResolvSocket& s) : TcpSocket(s) {} // copy constructor
+	ResolvSocket& operator=(const ResolvSocket& ) { return *this; } // assignment operator
+
+	std::string m_query;
+	std::string m_data;
+	bool m_bServer;
+	Socket *m_parent;
+	int m_resolv_id;
+	std::string m_resolv_host;
+	port_t m_resolv_port;
+	ipaddr_t m_resolv_address;
+#ifdef ENABLE_IPV6
+	bool m_resolve_ipv6;
+	in6_addr m_resolv_address6;
+#endif
+	static cache_t m_cache;
+	static timeout_t m_cache_to;
+	static Mutex m_cache_mutex;
+	bool m_cached;
+};
+
+
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // ENABLE_RESOLVER
+#endif // _SOCKETS_ResolvSocket_H
+
diff --git a/dep/include/sockets/SctpSocket.h b/dep/include/sockets/SctpSocket.h
new file mode 100644
index 00000000000..d6d55f6be78
--- /dev/null
+++ b/dep/include/sockets/SctpSocket.h
@@ -0,0 +1,109 @@
+/**
+ **	\file SctpSocket.h
+ **	\date  2006-09-04
+ **	\author grymse@alhem.net
+**/
+/*
+Copyright (C) 2007  Anders Hedstrom
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_SctpSocket_H
+#define _SOCKETS_SctpSocket_H
+#include "sockets-config.h"
+
+#include "StreamSocket.h"
+#ifdef USE_SCTP
+#include <netinet/sctp.h>
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+#define SCTP_BUFSIZE_READ 16400
+
+class SocketAddress;
+
+
+class SctpSocket : public StreamSocket
+{
+public:
+	/** SctpSocket constructor.
+		\param h Owner
+		\param type SCTP_STREAM or SCTP_SEQPACKET */
+	SctpSocket(ISocketHandler& h,int type);
+	~SctpSocket();
+
+	/** bind() */
+	int Bind(const std::string&,port_t);
+	int Bind(SocketAddress&);
+	/** sctp_bindx() */
+	int AddAddress(const std::string&,port_t);
+	int AddAddress(SocketAddress&);
+	/** sctp_bindx() */
+	int RemoveAddress(const std::string&,port_t);
+	int RemoveAddress(SocketAddress&);
+
+	/** connect() */
+	int Open(const std::string&,port_t);
+	int Open(SocketAddress&);
+
+	/** Connect timeout callback. */
+	void OnConnectTimeout();
+#ifdef _WIN32
+	/** Connection failed reported as exception on win32 */
+	void OnException();
+#endif
+
+#ifndef SOLARIS
+	/** sctp_connectx() */
+	int AddConnection(const std::string&,port_t);
+	int AddConnection(SocketAddress&);
+#endif
+
+	/** Get peer addresses of an association. */
+	int getpaddrs(sctp_assoc_t id,std::list<std::string>&);
+	/** Get all bound addresses of an association. */
+	int getladdrs(sctp_assoc_t id,std::list<std::string>&);
+
+	/** sctp_peeloff */
+	int PeelOff(sctp_assoc_t id);
+
+	/** recvmsg callback */
+	virtual void OnReceiveMessage(const char *buf,size_t sz,struct sockaddr *sa,socklen_t sa_len,struct sctp_sndrcvinfo *sinfo,int msg_flags) = 0;
+
+	void OnOptions(int,int,int,SOCKET) {}
+
+	virtual int Protocol();
+
+protected:
+	SctpSocket(const SctpSocket& s) : StreamSocket(s) {}
+	void OnRead();
+	void OnWrite();
+
+private:
+	SctpSocket& operator=(const SctpSocket& s) { return *this; }
+	int m_type; ///< SCTP_STREAM or SCTP_SEQPACKET
+	char *m_buf; ///< Temporary receive buffer
+};
+
+
+#ifdef SOCKETS_NAMESPACE
+} // namespace SOCKETS_NAMESPACE
+#endif
+
+#endif // USE_SCTP
+#endif // _SOCKETS_SctpSocket_H
+
diff --git a/dep/include/sockets/Socket.h b/dep/include/sockets/Socket.h
new file mode 100644
index 00000000000..bdb5fc60392
--- /dev/null
+++ b/dep/include/sockets/Socket.h
@@ -0,0 +1,739 @@
+/** \file Socket.h
+ ** \date  2004-02-13
+ ** \author grymse@alhem.net
+**/
+/*
+Copyright (C) 2004-2007  Anders Hedstrom
+
+This software 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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_Socket_H
+#define _SOCKETS_Socket_H
+#include "sockets-config.h"
+
+#include <string>
+#include <vector>
+#include <list>
+#ifdef HAVE_OPENSSL
+#include <openssl/ssl.h>
+#endif
+
+#include "socket_include.h"
+#include <time.h>
+#include "SocketAddress.h"
+#include "Thread.h"
+
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+
+class ISocketHandler;
+class SocketAddress;
+class IFile;
+
+
+/** \defgroup basic Basic sockets */
+/** Socket base class.
+	\ingroup basic */
+class Socket
+{
+	friend class ISocketHandler;
+#ifdef ENABLE_DETACH
+	/** Detached socket run thread. 
+		\ingroup internal */
+	class SocketThread : public Thread
+	{
+	public:
+		SocketThread(Socket *p);
+		~SocketThread();
+
+		void Run();
+
+	private:
+		Socket *GetSocket() const { return m_socket; }
+		SocketThread(const SocketThread& s) : m_socket(s.GetSocket()) {}
+		SocketThread& operator=(const SocketThread& ) { return *this; }
+		Socket *m_socket;
+	};
+#endif // ENABLE_DETACH
+
+#ifdef ENABLE_TRIGGERS
+public:
+	/** Data pass class from source to destination. */
+	class TriggerData
+	{
+	public:
+		TriggerData() : m_src(NULL) {}
+		virtual ~TriggerData() {}
+
+		Socket *GetSource() const { return m_src; }
+		void SetSource(Socket *x) { m_src = x; }
+
+	private:
+		Socket *m_src;
+	};
+#endif // ENABLE_TRIGGERS
+
+	/** Socket mode flags. */
+/*
+	enum {
+		// Socket
+		SOCK_DEL = 			0x01, ///< Delete by handler flag
+		SOCK_CLOSE = 			0x02, ///< Close and delete flag
+		SOCK_DISABLE_READ = 		0x04, ///< Disable checking for read events
+		SOCK_CONNECTED = 		0x08, ///< Socket is connected (tcp/udp)
+
+		SOCK_ERASED_BY_HANDLER = 	0x10, ///< Set by handler before delete
+		// HAVE_OPENSSL
+		SOCK_ENABLE_SSL = 		0x20, ///< Enable SSL for this TcpSocket
+		SOCK_SSL = 			0x40, ///< ssl negotiation mode (TcpSocket)
+		SOCK_SSL_SERVER = 		0x80, ///< True if this is an incoming ssl TcpSocket connection
+
+		// ENABLE_IPV6
+		SOCK_IPV6 = 			0x0100, ///< This is an ipv6 socket if this one is true
+		// ENABLE_POOL
+		SOCK_CLIENT = 			0x0200, ///< only client connections are pooled
+		SOCK_RETAIN = 			0x0400, ///< keep connection on close
+		SOCK_LOST = 			0x0800, ///< connection lost
+
+		// ENABLE_SOCKS4
+		SOCK_SOCKS4 = 			0x1000, ///< socks4 negotiation mode (TcpSocket)
+		// ENABLE_DETACH
+		SOCK_DETACH = 			0x2000, ///< Socket ordered to detach flag
+		SOCK_DETACHED = 		0x4000, ///< Socket has been detached
+		// StreamSocket
+		STREAMSOCK_CONNECTING =		0x8000, ///< Flag indicating connection in progress
+
+		STREAMSOCK_FLUSH_BEFORE_CLOSE = 0x010000L, ///< Send all data before closing (default true)
+		STREAMSOCK_CALL_ON_CONNECT =	0x020000L, ///< OnConnect will be called next ISocketHandler cycle if true
+		STREAMSOCK_RETRY_CONNECT =	0x040000L, ///< Try another connection attempt next ISocketHandler cycle
+		STREAMSOCK_LINE_PROTOCOL =	0x080000L, ///< Line protocol mode flag
+
+	};
+*/
+
+public:
+	/** "Default" constructor */
+	Socket(ISocketHandler&);
+
+	virtual ~Socket();
+
+	/** Socket class instantiation method. Used when a "non-standard" constructor
+	 * needs to be used for the socket class. Note: the socket class still needs
+	 * the "default" constructor with one ISocketHandler& as input parameter.
+	 */
+	virtual Socket *Create() { return NULL; }
+
+	/** Returns reference to sockethandler that owns the socket. 
+	If the socket is detached, this is a reference to the slave sockethandler.
+	*/
+	ISocketHandler& Handler() const;
+
+	/** Returns reference to sockethandler that owns the socket. 
+	This one always returns the reference to the original sockethandler,
+	even if the socket is detached.
+	*/
+	ISocketHandler& MasterHandler() const;
+
+	/** Called by ListenSocket after accept but before socket is added to handler.
+	 * CTcpSocket uses this to create its ICrypt member variable.
+	 * The ICrypt member variable is created by a virtual method, therefore
+	 * it can't be called directly from the CTcpSocket constructor.
+	 * Also used to determine if incoming HTTP connection is normal (port 80)
+	 * or ssl (port 443).
+	 */
+	virtual void Init();
+
+	/** Create a socket file descriptor.
+		\param af Address family AF_INET / AF_INET6 / ...
+		\param type SOCK_STREAM / SOCK_DGRAM / ...
+		\param protocol "tcp" / "udp" / ... */
+	SOCKET CreateSocket(int af,int type,const std::string& protocol = "");
+
+	/** Assign this socket a file descriptor created
+		by a call to socket() or otherwise. */
+	void Attach(SOCKET s);
+
+	/** Return file descriptor assigned to this socket. */
+	SOCKET GetSocket();
+
+	/** Close connection immediately - internal use.
+		\sa SetCloseAndDelete */
+	virtual int Close();
+
+	/** Add file descriptor to sockethandler fd_set's. */
+	void Set(bool bRead,bool bWrite,bool bException = true);
+
+	/** Returns true when socket file descriptor is valid
+		and socket is not about to be closed. */
+	virtual bool Ready();
+
+	/** Returns pointer to ListenSocket that created this instance
+	 * on an incoming connection. */
+	Socket *GetParent();
+
+	/** Used by ListenSocket to set parent pointer of newly created
+	 * socket instance. */
+	void SetParent(Socket *);
+
+	/** Get listening port from ListenSocket<>. */
+	virtual port_t GetPort();
+
+	/** Set socket non-block operation. */
+	bool SetNonblocking(bool);
+
+	/** Set socket non-block operation. */
+	bool SetNonblocking(bool, SOCKET);
+
+	/** Total lifetime of instance. */
+	time_t Uptime();
+
+	/** Set address/port of last connect() call. */
+	void SetClientRemoteAddress(SocketAddress&);
+
+	/** Get address/port of last connect() call. */
+	std::auto_ptr<SocketAddress> GetClientRemoteAddress();
+
+	/** Common interface for SendBuf used by Tcp and Udp sockets. */
+	virtual void SendBuf(const char *,size_t,int = 0);
+
+	/** Common interface for Send used by Tcp and Udp sockets. */
+	virtual void Send(const std::string&,int = 0);
+
+	/** Outgoing traffic counter. */
+	virtual uint64_t GetBytesSent(bool clear = false);
+
+	/** Incoming traffic counter. */
+	virtual uint64_t GetBytesReceived(bool clear = false);
+
+	// LIST_TIMEOUT
+
+	/** Enable timeout control. 0=disable timeout check. */
+	void SetTimeout(time_t secs);
+
+	/** Check timeout. \return true if time limit reached */
+	bool Timeout(time_t tnow);
+
+	/** Used by ListenSocket. ipv4 and ipv6 */
+	void SetRemoteAddress(SocketAddress&);
+
+	/** \name Event callbacks */
+	//@{
+
+	/** Called when there is something to be read from the file descriptor. */
+	virtual void OnRead();
+	/** Called when there is room for another write on the file descriptor. */
+	virtual void OnWrite();
+	/** Called on socket exception. */
+	virtual void OnException();
+	/** Called before a socket class is deleted by the ISocketHandler. */
+	virtual void OnDelete();
+	/** Called when a connection has completed. */
+	virtual void OnConnect();
+	/** Called when an incoming connection has been completed. */
+	virtual void OnAccept();
+	/** Called when a complete line has been read and the socket is in
+	 * line protocol mode. */
+	virtual void OnLine(const std::string& );
+	/** Called on connect timeout (5s). */
+	virtual void OnConnectFailed();
+	/** Called when a client socket is created, to set socket options.
+		\param family AF_INET, AF_INET6, etc
+		\param type SOCK_STREAM, SOCK_DGRAM, etc
+		\param protocol Protocol number (tcp, udp, sctp, etc)
+		\param s Socket file descriptor
+	*/
+	virtual void OnOptions(int family,int type,int protocol,SOCKET s) = 0;
+	/** Connection retry callback - return false to abort connection attempts */
+	virtual bool OnConnectRetry();
+#ifdef ENABLE_RECONNECT
+	/** a reconnect has been made */
+	virtual void OnReconnect();
+#endif
+	/** TcpSocket: When a disconnect has been detected (recv/SSL_read returns 0 bytes). */
+	virtual void OnDisconnect();
+	/** Timeout callback. */
+	virtual void OnTimeout();
+	/** Connection timeout. */
+	virtual void OnConnectTimeout();
+	//@}
+
+	/** \name Socket mode flags, set/reset */
+	//@{
+	/** Set delete by handler true when you want the sockethandler to
+		delete the socket instance after use. */
+	void SetDeleteByHandler(bool = true);
+	/** Check delete by handler flag.
+		\return true if this instance should be deleted by the sockethandler */
+	bool DeleteByHandler();
+
+	// LIST_CLOSE - conditional event queue
+
+	/** Set close and delete to terminate the connection. */
+	void SetCloseAndDelete(bool = true);
+	/** Check close and delete flag.
+		\return true if this socket should be closed and the instance removed */
+	bool CloseAndDelete();
+
+	/** Return number of seconds since socket was ordered to close. \sa SetCloseAndDelete */
+	time_t TimeSinceClose();
+
+	/** Ignore read events for an output only socket. */
+	void DisableRead(bool x = true);
+	/** Check ignore read events flag.
+		\return true if read events should be ignored */
+	bool IsDisableRead();
+
+	/** Set connected status. */
+	void SetConnected(bool = true);
+	/** Check connected status.
+		\return true if connected */
+	bool IsConnected();
+
+	/** Connection lost - error while reading/writing from a socket - TcpSocket only. */
+	void SetLost();
+	/** Check connection lost status flag, used by TcpSocket only.
+		\return true if there was an error while r/w causing the socket to close */
+	bool Lost();
+
+	/** Set flag indicating the socket is being actively deleted by the sockethandler. */
+	void SetErasedByHandler(bool x = true);
+	/** Get value of flag indicating socket is deleted by sockethandler. */
+	bool ErasedByHandler();
+
+	//@}
+
+	/** \name Information about remote connection */
+	//@{
+	/** Returns address of remote end. */
+	std::auto_ptr<SocketAddress> GetRemoteSocketAddress();
+	/** Returns address of remote end: ipv4. */
+	ipaddr_t GetRemoteIP4();
+#ifdef ENABLE_IPV6
+	/** Returns address of remote end: ipv6. */
+#ifdef IPPROTO_IPV6
+	struct in6_addr GetRemoteIP6();
+#endif
+#endif
+	/** Returns remote port number: ipv4 and ipv6. */
+	port_t GetRemotePort();
+	/** Returns remote ip as string? ipv4 and ipv6. */
+	std::string GetRemoteAddress();
+	/** ipv4 and ipv6(not implemented) */
+	std::string GetRemoteHostname();
+	//@}
+
+	/** Returns local port number for bound socket file descriptor. */
+	port_t GetSockPort();
+	/** Returns local ipv4 address for bound socket file descriptor. */
+	ipaddr_t GetSockIP4();
+	/** Returns local ipv4 address as text for bound socket file descriptor. */
+	std::string GetSockAddress();
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+	/** Returns local ipv6 address for bound socket file descriptor. */
+	struct in6_addr GetSockIP6();
+	/** Returns local ipv6 address as text for bound socket file descriptor. */
+	std::string GetSockAddress6();
+#endif
+#endif
+	// --------------------------------------------------------------------------
+	/** @name IP options
+	   When an ip or socket option is available on all of the operating systems
+	   I'm testing on (linux 2.4.x, _win32, macosx, solaris9 intel) they are not
+	   checked with an #ifdef below.
+	   This might cause a compile error on other operating systems. */
+	// --------------------------------------------------------------------------
+
+	// IP options
+	//@{
+
+	bool SetIpOptions(const void *p, socklen_t len);
+	bool SetIpTOS(unsigned char tos);
+	unsigned char IpTOS();
+	bool SetIpTTL(int ttl);
+	int IpTTL();
+	bool SetIpHdrincl(bool x = true);
+	bool SetIpMulticastTTL(int);
+	int IpMulticastTTL();
+	bool SetMulticastLoop(bool x = true);
+	bool IpAddMembership(struct ip_mreq&);
+	bool IpDropMembership(struct ip_mreq&);
+
+#ifdef IP_PKTINFO
+	bool SetIpPktinfo(bool x = true);
+#endif
+#ifdef IP_RECVTOS
+	bool SetIpRecvTOS(bool x = true);
+#endif
+#ifdef IP_RECVTTL
+	bool SetIpRecvTTL(bool x = true);
+#endif
+#ifdef IP_RECVOPTS
+	bool SetIpRecvopts(bool x = true);
+#endif
+#ifdef IP_RETOPTS
+	bool SetIpRetopts(bool x = true);
+#endif
+#ifdef IP_RECVERR
+	bool SetIpRecverr(bool x = true);
+#endif
+#ifdef IP_MTU_DISCOVER
+	bool SetIpMtudiscover(bool x = true);
+#endif
+#ifdef IP_MTU
+	int IpMtu();
+#endif
+#ifdef IP_ROUTER_ALERT
+	bool SetIpRouterAlert(bool x = true);
+#endif
+#ifdef LINUX
+	bool IpAddMembership(struct ip_mreqn&);
+#endif
+#ifdef LINUX
+	bool IpDropMembership(struct ip_mreqn&);
+#endif
+	//@}
+
+	// SOCKET options
+	/** @name Socket Options */
+	//@{
+
+	bool SoAcceptconn();
+	bool SetSoBroadcast(bool x = true);
+	bool SetSoDebug(bool x = true);
+	int SoError();
+	bool SetSoDontroute(bool x = true);
+	bool SetSoLinger(int onoff, int linger);
+	bool SetSoOobinline(bool x = true);
+	bool SetSoRcvlowat(int);
+	bool SetSoSndlowat(int);
+	bool SetSoRcvtimeo(struct timeval&);
+	bool SetSoSndtimeo(struct timeval&);
+	bool SetSoRcvbuf(int);
+	int SoRcvbuf();
+	bool SetSoSndbuf(int);
+	int SoSndbuf();
+	int SoType();
+	bool SetSoReuseaddr(bool x = true);
+	bool SetSoKeepalive(bool x = true);
+
+#ifdef SO_BSDCOMPAT
+	bool SetSoBsdcompat(bool x = true);
+#endif
+#ifdef SO_BINDTODEVICE
+	bool SetSoBindtodevice(const std::string& intf);
+#endif
+#ifdef SO_PASSCRED
+	bool SetSoPasscred(bool x = true);
+#endif
+#ifdef SO_PEERCRED
+	bool SoPeercred(struct ucred& );
+#endif
+#ifdef SO_PRIORITY
+	bool SetSoPriority(int);
+#endif
+#ifdef SO_RCVBUFFORCE
+	bool SetSoRcvbufforce(int);
+#endif
+#ifdef SO_SNDBUFFORCE
+	bool SetSoSndbufforce(int);
+#endif
+#ifdef SO_TIMESTAMP
+	bool SetSoTimestamp(bool x = true);
+#endif
+#ifdef SO_NOSIGPIPE
+	bool SetSoNosigpipe(bool x = true);
+#endif
+	//@}
+
+	// TCP options in TcpSocket.h/TcpSocket.cpp
+
+
+#ifdef HAVE_OPENSSL
+	/** @name SSL Support */
+	//@{
+	/** SSL client/server support - internal use. \sa TcpSocket */
+	virtual void OnSSLConnect();
+	/** SSL client/server support - internal use. \sa TcpSocket */
+	virtual void OnSSLAccept();
+	/** SSL negotiation failed for client connect. */
+	virtual void OnSSLConnectFailed();
+	/** SSL negotiation failed for server accept. */
+	virtual void OnSSLAcceptFailed();
+	/** new SSL support */
+	virtual bool SSLNegotiate();
+	/** Check if SSL is Enabled for this TcpSocket.
+		\return true if this is a TcpSocket with SSL enabled */
+	bool IsSSL();
+	/** Enable SSL operation for a TcpSocket. */
+	void EnableSSL(bool x = true);
+	/** Still negotiating ssl connection.
+		\return true if ssl negotiating is still in progress */
+	bool IsSSLNegotiate();
+	/** Set flag indicating ssl handshaking still in progress. */
+	void SetSSLNegotiate(bool x = true);
+	/** OnAccept called with SSL Enabled.
+		\return true if this is a TcpSocket with an incoming SSL connection */
+	bool IsSSLServer();
+	/** Set flag indicating that this is a TcpSocket with incoming SSL connection. */
+	void SetSSLServer(bool x = true);
+	/** SSL; Get pointer to ssl context structure. */
+	virtual SSL_CTX *GetSslContext() { return NULL; }
+	/** SSL; Get pointer to ssl structure. */
+	virtual SSL *GetSsl() { return NULL; }
+	//@}
+#endif // HAVE_OPENSSL
+
+#ifdef ENABLE_IPV6
+	/** Enable ipv6 for this socket. */
+	void SetIpv6(bool x = true);
+	/** Check ipv6 socket.
+		\return true if this is an ipv6 socket */
+	bool IsIpv6();
+#endif
+
+#ifdef ENABLE_POOL
+	/** @name Connection Pool */
+	//@{
+	/** Client = connecting TcpSocket. */
+	void SetIsClient();
+	/** Socket type from socket() call. */
+	void SetSocketType(int x);
+	/** Socket type from socket() call. */
+	int GetSocketType();
+	/** Protocol type from socket() call. */
+	void SetSocketProtocol(const std::string& x);
+	/** Protocol type from socket() call. */
+	const std::string& GetSocketProtocol();
+	/** Instruct a client socket to stay open in the connection pool after use.
+		If you have connected to a server using tcp, you can call SetRetain
+		to leave the connection open after your socket instance has been deleted.
+		The next connection you make to the same server will reuse the already
+		opened connection, if it is still available.
+	*/
+	void SetRetain();
+	/** Check retain flag.
+		\return true if the socket should be moved to connection pool after use */
+	bool Retain();
+	/** Copy connection parameters from sock. */
+	void CopyConnection(Socket *sock);
+	//@}
+#endif // ENABLE_POOL
+
+#ifdef ENABLE_SOCKS4
+	/** \name Socks4 support */
+	//@{
+	/** Socks4 client support internal use. \sa TcpSocket */
+	virtual void OnSocks4Connect();
+	/** Socks4 client support internal use. \sa TcpSocket */
+	virtual void OnSocks4ConnectFailed();
+	/** Socks4 client support internal use. \sa TcpSocket */
+	virtual bool OnSocks4Read();
+	/** Called when the last write caused the tcp output buffer to
+	 * become empty. */
+	/** socket still in socks4 negotiation mode */
+	bool Socks4();
+	/** Set flag indicating Socks4 handshaking in progress */
+	void SetSocks4(bool x = true);
+
+	/** Set socks4 server host address to use */
+	void SetSocks4Host(ipaddr_t a);
+	/** Set socks4 server hostname to use. */
+	void SetSocks4Host(const std::string& );
+	/** Socks4 server port to use. */
+	void SetSocks4Port(port_t p);
+	/** Provide a socks4 userid if required by the socks4 server. */
+	void SetSocks4Userid(const std::string& x);
+	/** Get the ip address of socks4 server to use.
+		\return socks4 server host address */
+	ipaddr_t GetSocks4Host();
+	/** Get the socks4 server port to use.
+		\return socks4 server port */
+	port_t GetSocks4Port();
+	/** Get socks4 userid.
+		\return Socks4 userid */
+	const std::string& GetSocks4Userid();
+	//@}
+#endif // ENABLE_SOCKS4
+
+#ifdef ENABLE_RESOLVER
+	/** \name Asynchronous Resolver */
+	//@{
+	/** Request an asynchronous dns resolution.
+		\param host hostname to be resolved
+		\param port port number passed along for the ride
+		\return Resolve ID */
+	int Resolve(const std::string& host,port_t port = 0);
+#ifdef ENABLE_IPV6
+	int Resolve6(const std::string& host, port_t port = 0);
+#endif
+	/** Callback returning a resolved address.
+		\param id Resolve ID from Resolve call
+		\param a resolved ip address
+		\param port port number passed to Resolve */
+	virtual void OnResolved(int id,ipaddr_t a,port_t port);
+#ifdef ENABLE_IPV6
+	virtual void OnResolved(int id,in6_addr& a,port_t port);
+#endif
+	/** Request asynchronous reverse dns lookup.
+		\param a in_addr to be translated */
+	int Resolve(ipaddr_t a);
+#ifdef ENABLE_IPV6
+	int Resolve(in6_addr& a);
+#endif
+	/** Callback returning reverse resolve results.
+		\param id Resolve ID
+		\param name Resolved hostname */
+	virtual void OnReverseResolved(int id,const std::string& name);
+	/** Callback indicating failed dns lookup.
+		\param id Resolve ID */
+	virtual void OnResolveFailed(int id);
+	//@}
+#endif  // ENABLE_RESOLVER
+
+#ifdef ENABLE_DETACH
+	/** \name Thread Support */
+	//@{
+	/** Callback fires when a new socket thread has started and this
+		socket is ready for operation again.
+		\sa ResolvSocket */
+	virtual void OnDetached();
+
+	// LIST_DETACH
+
+	/** Internal use. */
+	void SetDetach(bool x = true);
+	/** Check detach flag.
+		\return true if the socket should detach to its own thread */
+	bool IsDetach();
+
+	/** Internal use. */
+	void SetDetached(bool x = true);
+	/** Check detached flag.
+		\return true if the socket runs in its own thread. */
+	const bool IsDetached() const;
+	/** Order this socket to start its own thread and call OnDetached
+		when ready for operation. */
+	bool Detach();
+	/** Store the slave sockethandler pointer. */
+	void SetSlaveHandler(ISocketHandler *);
+	/** Create new thread for this socket to run detached in. */
+	void DetachSocket();
+	//@}
+#endif // ENABLE_DETACH
+
+	/** Write traffic to an IFile. Socket will not delete this object. */
+	void SetTrafficMonitor(IFile *p) { m_traffic_monitor = p; }
+
+#ifdef ENABLE_TRIGGERS
+	/** \name Triggers */
+	//@{
+	/** Subscribe to trigger id. */
+	void Subscribe(int id);
+	/** Unsubscribe from trigger id. */
+	void Unsubscribe(int id);
+	/** Trigger callback, with data passed from source to destination. */
+	virtual void OnTrigger(int id, const TriggerData& data);
+	/** Trigger cancelled because source has been deleted (as in delete). */
+	virtual void OnCancelled(int id);
+	//@}
+#endif
+
+protected:
+	/** default constructor not available */
+	Socket() : m_handler(m_handler) {}
+	/** copy constructor not available */
+	Socket(const Socket& s) : m_handler(s.m_handler) {}
+
+	/** assignment operator not available. */
+	Socket& operator=(const Socket& ) { return *this; }
+
+	/** All traffic will be written to this IFile, if set. */
+	IFile *GetTrafficMonitor() { return m_traffic_monitor; }
+
+//	unsigned long m_flags; ///< boolean flags, replacing old 'bool' members
+
+private:
+	ISocketHandler& m_handler; ///< Reference of ISocketHandler in control of this socket
+	SOCKET m_socket; ///< File descriptor
+	bool m_bDel; ///< Delete by handler flag
+	bool m_bClose; ///< Close and delete flag
+	time_t m_tCreate; ///< Time in seconds when this socket was created
+	Socket *m_parent; ///< Pointer to ListenSocket class, valid for incoming sockets
+	bool m_b_disable_read; ///< Disable checking for read events
+	bool m_connected; ///< Socket is connected (tcp/udp)
+	bool m_b_erased_by_handler; ///< Set by handler before delete
+	time_t m_tClose; ///< Time in seconds when ordered to close
+	std::auto_ptr<SocketAddress> m_client_remote_address; ///< Address of last connect()
+	std::auto_ptr<SocketAddress> m_remote_address; ///< Remote end address
+	IFile *m_traffic_monitor;
+	time_t m_timeout_start; ///< Set by SetTimeout
+	time_t m_timeout_limit; ///< Defined by SetTimeout
+	bool m_bLost; ///< connection lost
+
+#ifdef _WIN32
+static	WSAInitializer m_winsock_init; ///< Winsock initialization singleton class
+#endif
+
+#ifdef HAVE_OPENSSL
+	bool m_b_enable_ssl; ///< Enable SSL for this TcpSocket
+	bool m_b_ssl; ///< ssl negotiation mode (TcpSocket)
+	bool m_b_ssl_server; ///< True if this is an incoming ssl TcpSocket connection
+#endif
+
+#ifdef ENABLE_IPV6
+	bool m_ipv6; ///< This is an ipv6 socket if this one is true
+#endif
+
+#ifdef ENABLE_POOL
+	int m_socket_type; ///< Type of socket, from socket() call
+	std::string m_socket_protocol; ///< Protocol, from socket() call
+	bool m_bClient; ///< only client connections are pooled
+	bool m_bRetain; ///< keep connection on close
+#endif
+
+#ifdef ENABLE_SOCKS4
+	bool m_bSocks4; ///< socks4 negotiation mode (TcpSocket)
+	ipaddr_t m_socks4_host; ///< socks4 server address
+	port_t m_socks4_port; ///< socks4 server port number
+	std::string m_socks4_userid; ///< socks4 server usedid
+#endif
+
+#ifdef ENABLE_DETACH
+	bool m_detach; ///< Socket ordered to detach flag
+	bool m_detached; ///< Socket has been detached
+	SocketThread *m_pThread; ///< Detach socket thread class pointer
+	ISocketHandler *m_slave_handler; ///< Actual sockethandler while detached
+#endif
+};
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+
+#endif // _SOCKETS_Socket_H
+
diff --git a/dep/include/sockets/SocketAddress.h b/dep/include/sockets/SocketAddress.h
new file mode 100644
index 00000000000..d5a56433ba7
--- /dev/null
+++ b/dep/include/sockets/SocketAddress.h
@@ -0,0 +1,95 @@
+/**
+ **	\file SocketAddress.h
+ **	\date  2006-09-21
+ **	\author grymse@alhem.net
+**/
+/*
+Copyright (C) 2007  Anders Hedstrom
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_SocketAddress_H
+#define _SOCKETS_SocketAddress_H
+
+#include "sockets-config.h"
+#include <string>
+#include <memory>
+#include "socket_include.h"
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+
+/**
+   This class and its subclasses is intended to be used as replacement
+   for the internal data type 'ipaddr_t' and various implementations of
+   IPv6 addressing found throughout the library.
+   'ipaddr_t' is an IPv4 address in network byte order.
+   'port_t' is the portnumber in host byte order.
+   'struct in6_addr' is an IPv6 address.
+   'struct in_addr' is an IPv4 address.
+   \ingroup basic
+*/
+class SocketAddress
+{
+public:
+	virtual ~SocketAddress() {}
+
+	/** Get a pointer to the address struct. */
+	virtual operator struct sockaddr *() = 0;
+
+	/** Get length of address struct. */
+	virtual operator socklen_t() = 0;
+
+	/** Compare two addresses. */
+	virtual bool operator==(SocketAddress&) = 0;
+
+	/** Set port number.
+		\param port Port number in host byte order */
+	virtual void SetPort(port_t port) = 0;
+
+	/** Get port number.
+		\return Port number in host byte order. */
+	virtual port_t GetPort() = 0;
+
+	/** Set socket address.
+		\param sa Pointer to either 'struct sockaddr_in' or 'struct sockaddr_in6'. */
+	virtual void SetAddress(struct sockaddr *sa) = 0;
+
+	/** Convert address to text. */
+	virtual std::string Convert(bool include_port) = 0;
+
+	/** Reverse lookup of address. */
+	virtual std::string Reverse() = 0;
+
+	/** Get address family. */
+	virtual int GetFamily() = 0;
+
+	/** Address structure is valid. */
+	virtual bool IsValid() = 0;
+
+	/** Get a copy of this SocketAddress object. */
+	virtual std::auto_ptr<SocketAddress> GetCopy() = 0;
+};
+
+
+
+
+#ifdef SOCKETS_NAMESPACE
+} // namespace SOCKETS_NAMESPACE {
+#endif
+#endif // _SOCKETS_SocketAddress_H
+
diff --git a/dep/include/sockets/SocketHandler.h b/dep/include/sockets/SocketHandler.h
new file mode 100644
index 00000000000..c7e20dfde82
--- /dev/null
+++ b/dep/include/sockets/SocketHandler.h
@@ -0,0 +1,266 @@
+/** \file SocketHandler.h
+ **	\date  2004-02-13
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_SocketHandler_H
+#define _SOCKETS_SocketHandler_H
+
+#include "sockets-config.h"
+#include <map>
+#include <list>
+
+#include "socket_include.h"
+#include "ISocketHandler.h"
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+
+class Socket;
+#ifdef ENABLE_RESOLVER
+class ResolvServer;
+#endif
+class Mutex;
+
+/** Socket container class, event generator. 
+	\ingroup basic */
+class SocketHandler : public ISocketHandler
+{
+protected:
+	/** Map type for holding file descriptors/socket object pointers. */
+	typedef std::map<SOCKET,Socket *> socket_m;
+
+public:
+	/** SocketHandler constructor.
+		\param log Optional log class pointer */
+	SocketHandler(StdLog *log = NULL);
+
+	/** SocketHandler threadsafe constructor.
+		\param mutex Externally declared mutex variable
+		\param log Optional log class pointer */
+	SocketHandler(Mutex& mutex,StdLog *log = NULL);
+
+	~SocketHandler();
+
+	/** Get mutex reference for threadsafe operations. */
+	Mutex& GetMutex() const;
+
+	/** Register StdLog object for error callback. 
+		\param log Pointer to log class */
+	void RegStdLog(StdLog *log);
+
+	/** Log error to log class for print out / storage. */
+	void LogError(Socket *p,const std::string& user_text,int err,const std::string& sys_err,loglevel_t t = LOG_LEVEL_WARNING);
+
+	/** Add socket instance to socket map. Removal is always automatic. */
+	void Add(Socket *);
+
+	/** Get status of read/write/exception file descriptor set for a socket. */
+	void Get(SOCKET s,bool& r,bool& w,bool& e);
+
+	/** Set read/write/exception file descriptor sets (fd_set). */
+	void Set(SOCKET s,bool bRead,bool bWrite,bool bException = true);
+
+	/** Wait for events, generate callbacks. */
+	int Select(long sec,long usec);
+
+	/** This method will not return until an event has been detected. */
+	int Select();
+
+	/** Wait for events, generate callbacks. */
+	int Select(struct timeval *tsel);
+
+	/** Check that a socket really is handled by this socket handler. */
+	bool Valid(Socket *);
+
+	/** Return number of sockets handled by this handler.  */
+	size_t GetCount();
+
+	/** Override and return false to deny all incoming connections. 
+		\param p ListenSocket class pointer (use GetPort to identify which one) */
+	bool OkToAccept(Socket *p);
+
+	/** Called by Socket when a socket changes state. */
+	void AddList(SOCKET s,list_t which_one,bool add);
+
+	// Connection pool
+#ifdef ENABLE_POOL
+	/** Find available open connection (used by connection pool). */
+	ISocketHandler::PoolSocket *FindConnection(int type,const std::string& protocol,SocketAddress&);
+	/** Enable connection pool (by default disabled). */
+	void EnablePool(bool x = true);
+	/** Check pool status. 
+		\return true if connection pool is enabled */
+	bool PoolEnabled();
+#endif // ENABLE_POOL
+
+	// Socks4
+#ifdef ENABLE_SOCKS4
+	/** Set socks4 server ip that all new tcp sockets should use. */
+	void SetSocks4Host(ipaddr_t);
+	/** Set socks4 server hostname that all new tcp sockets should use. */
+	void SetSocks4Host(const std::string& );
+	/** Set socks4 server port number that all new tcp sockets should use. */
+	void SetSocks4Port(port_t);
+	/** Set optional socks4 userid. */
+	void SetSocks4Userid(const std::string& );
+	/** If connection to socks4 server fails, immediately try direct connection to final host. */
+	void SetSocks4TryDirect(bool x = true);
+	/** Get socks4 server ip. 
+		\return socks4 server ip */
+	ipaddr_t GetSocks4Host();
+	/** Get socks4 port number.
+		\return socks4 port number */
+	port_t GetSocks4Port();
+	/** Get socks4 userid (optional).
+		\return socks4 userid */
+	const std::string& GetSocks4Userid();
+	/** Check status of socks4 try direct flag.
+		\return true if direct connection should be tried if connection to socks4 server fails */
+	bool Socks4TryDirect();
+#endif // ENABLE_SOCKS4
+
+	// DNS resolve server
+#ifdef ENABLE_RESOLVER
+	/** Enable asynchronous DNS. 
+		\param port Listen port of asynchronous dns server */
+	void EnableResolver(port_t port = 16667);
+	/** Check resolver status.
+		\return true if resolver is enabled */
+	bool ResolverEnabled();
+	/** Queue a dns request.
+		\param host Hostname to be resolved
+		\param port Port number will be echoed in Socket::OnResolved callback */
+	int Resolve(Socket *,const std::string& host,port_t port);
+#ifdef ENABLE_IPV6
+	int Resolve6(Socket *,const std::string& host,port_t port);
+#endif
+	/** Do a reverse dns lookup. */
+	int Resolve(Socket *,ipaddr_t a);
+#ifdef ENABLE_IPV6
+	int Resolve(Socket *,in6_addr& a);
+#endif
+	/** Get listen port of asynchronous dns server. */
+	port_t GetResolverPort();
+	/** Resolver thread ready for queries. */
+	bool ResolverReady();
+	/** Returns true if the socket is waiting for a resolve event. */
+	bool Resolving(Socket *);
+#endif // ENABLE_RESOLVER
+
+#ifdef ENABLE_TRIGGERS
+	/** Fetch unique trigger id. */
+	int TriggerID(Socket *src);
+	/** Subscribe socket to trigger id. */
+	bool Subscribe(int id, Socket *dst);
+	/** Unsubscribe socket from trigger id. */
+	bool Unsubscribe(int id, Socket *dst);
+	/** Execute OnTrigger for subscribed sockets.
+		\param id Trigger ID
+		\param data Data passed from source to destination
+		\param erase Empty trigger id source and destination maps if 'true',
+			Leave them in place if 'false' - if a trigger should be called many times */
+	void Trigger(int id, Socket::TriggerData& data, bool erase = true);
+#endif // ENABLE_TRIGGERS
+
+#ifdef ENABLE_DETACH
+	/** Indicates that the handler runs under SocketThread. */
+	void SetSlave(bool x = true);
+	/** Indicates that the handler runs under SocketThread. */
+	bool IsSlave();
+#endif
+
+	/** Sanity check of those accursed lists. */
+	void CheckSanity();
+
+protected:
+	socket_m m_sockets; ///< Active sockets map
+	socket_m m_add; ///< Sockets to be added to sockets map
+	std::list<Socket *> m_delete; ///< Sockets to be deleted (failed when Add)
+
+protected:
+	StdLog *m_stdlog; ///< Registered log class, or NULL
+	Mutex& m_mutex; ///< Thread safety mutex
+	bool m_b_use_mutex; ///< Mutex correctly initialized
+
+private:
+	void CheckList(socket_v&,const std::string&); ///< Used by CheckSanity
+	/** Remove socket from socket map, used by Socket class. */
+	void Remove(Socket *);
+	SOCKET m_maxsock; ///< Highest file descriptor + 1 in active sockets list
+	fd_set m_rfds; ///< file descriptor set monitored for read events
+	fd_set m_wfds; ///< file descriptor set monitored for write events
+	fd_set m_efds; ///< file descriptor set monitored for exceptions
+	int m_preverror; ///< debug select() error
+	int m_errcnt; ///< debug select() error
+	time_t m_tlast; ///< timeout control
+
+	// state lists
+	socket_v m_fds; ///< Active file descriptor list
+	socket_v m_fds_erase; ///< File descriptors that are to be erased from m_sockets
+	socket_v m_fds_callonconnect; ///< checklist CallOnConnect
+#ifdef ENABLE_DETACH
+	socket_v m_fds_detach; ///< checklist Detach
+#endif
+	socket_v m_fds_timeout; ///< checklist timeout
+	socket_v m_fds_retry; ///< checklist retry client connect
+	socket_v m_fds_close; ///< checklist close and delete
+
+#ifdef ENABLE_SOCKS4
+	ipaddr_t m_socks4_host; ///< Socks4 server host ip
+	port_t m_socks4_port; ///< Socks4 server port number
+	std::string m_socks4_userid; ///< Socks4 userid
+	bool m_bTryDirect; ///< Try direct connection if socks4 server fails
+#endif
+#ifdef ENABLE_RESOLVER
+	int m_resolv_id; ///< Resolver id counter
+	ResolvServer *m_resolver; ///< Resolver thread pointer
+	port_t m_resolver_port; ///< Resolver listen port
+	std::map<Socket *, bool> m_resolve_q; ///< resolve queue
+#endif
+#ifdef ENABLE_POOL
+	bool m_b_enable_pool; ///< Connection pool enabled if true
+#endif
+#ifdef ENABLE_TRIGGERS
+	int m_next_trigger_id; ///< Unique trigger id counter
+	std::map<int, Socket *> m_trigger_src; ///< mapping trigger id to source socket
+	std::map<int, std::map<Socket *, bool> > m_trigger_dst; ///< mapping trigger id to destination sockets
+#endif
+#ifdef ENABLE_DETACH
+	bool m_slave; ///< Indicates that this is a ISocketHandler run in SocketThread
+#endif
+};
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // _SOCKETS_SocketHandler_H
+
diff --git a/dep/include/sockets/StdLog.h b/dep/include/sockets/StdLog.h
new file mode 100644
index 00000000000..c07037bbd4f
--- /dev/null
+++ b/dep/include/sockets/StdLog.h
@@ -0,0 +1,74 @@
+/** \file StdLog.h
+ **	\date  2004-06-01
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_StdLog_H
+#define _SOCKETS_StdLog_H
+
+#include "sockets-config.h"
+#include <string>
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+/** error level enum. */
+typedef enum
+{
+	LOG_LEVEL_WARNING = 0,
+	LOG_LEVEL_ERROR,
+	LOG_LEVEL_FATAL,
+	LOG_LEVEL_INFO
+} loglevel_t;
+
+
+class ISocketHandler;
+class Socket;
+
+/** \defgroup logging Log help classes */
+/** Log class interface. 
+	\ingroup logging */
+class StdLog
+{
+public:
+	virtual ~StdLog() {}
+
+	virtual void error(ISocketHandler *,Socket *,
+		const std::string& user_text,
+		int err,
+		const std::string& sys_err,
+		loglevel_t = LOG_LEVEL_WARNING) = 0;
+};
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // _SOCKETS_StdLog_H
+
diff --git a/dep/include/sockets/StdoutLog.h b/dep/include/sockets/StdoutLog.h
new file mode 100644
index 00000000000..5f96b340dc2
--- /dev/null
+++ b/dep/include/sockets/StdoutLog.h
@@ -0,0 +1,57 @@
+/** \file StdoutLog.h
+ **	\date  2004-06-01
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_StdoutLog_H
+#define _SOCKETS_StdoutLog_H
+
+#include "sockets-config.h"
+#include "StdLog.h"
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+
+/** StdLog implementation, logs to stdout. 
+	\ingroup logging */
+class StdoutLog : public StdLog
+{
+public:
+	void error(ISocketHandler *,Socket *,const std::string& call,int err,const std::string& sys_err,loglevel_t);
+};
+
+
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // _SOCKETS_StdoutLog_H
+
diff --git a/dep/include/sockets/StreamSocket.h b/dep/include/sockets/StreamSocket.h
new file mode 100644
index 00000000000..3c248110b88
--- /dev/null
+++ b/dep/include/sockets/StreamSocket.h
@@ -0,0 +1,127 @@
+#ifndef _StreamSocket_H
+#define _StreamSocket_H
+
+#include "Socket.h"
+
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+
+/** SOCK_STREAM Socket base class.
+	\ingroup basic */
+class StreamSocket : public Socket
+{
+public:
+	StreamSocket(ISocketHandler& );
+	~StreamSocket();
+
+	/** Socket should Check Connect on next write event from select(). */
+	void SetConnecting(bool = true);
+
+	/** Check connecting flag.
+		\return true if the socket is still trying to connect */
+	bool Connecting();
+
+	/** Returns true when socket file descriptor is valid,
+		socket connection is established, and socket is not about to
+		be closed. */
+	bool Ready();
+
+	/** Set timeout to use for connection attempt.
+		\param x Timeout in seconds */
+	void SetConnectTimeout(int x);
+
+	/** Return number of seconds to wait for a connection.
+		\return Connection timeout (seconds) */
+	int GetConnectTimeout();
+
+	/** Set flush before close to make a tcp socket completely empty its
+		output buffer before closing the connection. */
+	void SetFlushBeforeClose(bool = true);
+
+	/** Check flush before status.
+		\return true if the socket should send all data before closing */
+	bool GetFlushBeforeClose();
+
+	/** Define number of connection retries (tcp only).
+	    n = 0 - no retry
+	    n > 0 - number of retries
+	    n = -1 - unlimited retries */
+	void SetConnectionRetry(int n);
+
+	/** Get number of maximum connection retries (tcp only). */
+	int GetConnectionRetry();
+
+	/** Increase number of actual connection retries (tcp only). */
+	void IncreaseConnectionRetries();
+
+	/** Get number of actual connection retries (tcp only). */
+	int GetConnectionRetries();
+
+	/** Reset actual connection retries (tcp only). */
+	void ResetConnectionRetries();
+
+	// LIST_CALLONCONNECT
+
+	/** Instruct socket to call OnConnect callback next sockethandler cycle. */
+	void SetCallOnConnect(bool x = true);
+
+	/** Check call on connect flag.
+		\return true if OnConnect() should be called a.s.a.p */
+	bool CallOnConnect();
+
+	// LIST_RETRY
+
+	/** Set flag to initiate a connection attempt after a connection timeout. */
+	void SetRetryClientConnect(bool x = true);
+
+	/** Check if a connection attempt should be made.
+		\return true when another attempt should be made */
+	bool RetryClientConnect();
+
+	/** Called after OnRead if socket is in line protocol mode.
+		\sa SetLineProtocol */
+	/** Enable the OnLine callback. Do not create your own OnRead
+	 * callback when using this. */
+	virtual void SetLineProtocol(bool = true);
+
+	/** Check line protocol mode.
+		\return true if socket is in line protocol mode */
+	bool LineProtocol();
+
+	/** Set shutdown status. */
+	void SetShutdown(int);
+
+	/** Get shutdown status. */
+	int GetShutdown();
+
+	/** Returns IPPROTO_TCP or IPPROTO_SCTP */
+	virtual int Protocol() = 0;
+
+protected:
+	StreamSocket(const StreamSocket& ) {} // copy constructor
+
+private:
+	StreamSocket& operator=(const StreamSocket& ) { return *this; } // assignment operator
+
+	bool m_bConnecting; ///< Flag indicating connection in progress
+	int m_connect_timeout; ///< Connection timeout (seconds)
+	bool m_flush_before_close; ///< Send all data before closing (default true)
+	int m_connection_retry; ///< Maximum connection retries (tcp)
+	int m_retries; ///< Actual number of connection retries (tcp)
+	bool m_call_on_connect; ///< OnConnect will be called next ISocketHandler cycle if true
+	bool m_b_retry_connect; ///< Try another connection attempt next ISocketHandler cycle
+	bool m_line_protocol; ///< Line protocol mode flag
+	int m_shutdown; ///< Shutdown status
+};
+
+
+#ifdef SOCKETS_NAMESPACE
+} // namespace SOCKETS_NAMESPACE {
+#endif
+
+
+#endif // _StreamSocket_H
+
diff --git a/dep/include/sockets/TcpSocket.h b/dep/include/sockets/TcpSocket.h
new file mode 100644
index 00000000000..515f5aa6cc7
--- /dev/null
+++ b/dep/include/sockets/TcpSocket.h
@@ -0,0 +1,358 @@
+/** \file TcpSocket.h
+ **	\date  2004-02-13
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_TcpSocket_H
+#define _SOCKETS_TcpSocket_H
+#include "sockets-config.h"
+#include "StreamSocket.h"
+#ifdef HAVE_OPENSSL
+#include <openssl/ssl.h>
+#include "SSLInitializer.h"
+#endif
+
+#include <string.h>
+
+#define TCP_BUFSIZE_READ 16400
+#define TCP_OUTPUT_CAPACITY 1024000
+
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+class SocketAddress;
+
+
+/** Socket implementation for TCP. 
+	\ingroup basic */
+class TcpSocket : public StreamSocket
+{
+	/** \defgroup internal Internal utility */
+protected:
+	/** Buffer class containing one read/write circular buffer. 
+		\ingroup internal */
+	class CircularBuffer
+	{
+	public:
+		CircularBuffer(size_t size);
+		~CircularBuffer();
+
+		/** append l bytes from p to buffer */
+		bool Write(const char *p,size_t l);
+		/** copy l bytes from buffer to dest */
+		bool Read(char *dest,size_t l);
+        /** copy l bytes from buffer to dest, dont touch buffer pointers */
+        bool SoftRead(char *dest, size_t l);
+		/** skip l bytes from buffer */
+		bool Remove(size_t l);
+		/** read l bytes from buffer, returns as string. */
+		std::string ReadString(size_t l);
+
+		/** total buffer length */
+		size_t GetLength();
+		/** pointer to circular buffer beginning */
+		const char *GetStart();
+		/** return number of bytes from circular buffer beginning to buffer physical end */
+		size_t GetL();
+		/** return free space in buffer, number of bytes until buffer overrun */
+		size_t Space();
+
+		/** return total number of bytes written to this buffer, ever */
+		unsigned long ByteCounter(bool clear = false);
+
+	private:
+		CircularBuffer(const CircularBuffer& /*s*/) {}
+		CircularBuffer& operator=(const CircularBuffer& ) { return *this; }
+		char *buf;
+		size_t m_max;
+		size_t m_q;
+		size_t m_b;
+		size_t m_t;
+		unsigned long m_count;
+	};
+	/** Output buffer struct.
+		\ingroup internal */
+	struct OUTPUT {
+		OUTPUT() : _b(0), _t(0), _q(0) {}
+		OUTPUT(const char *buf, size_t len) : _b(0), _t(len), _q(len) {
+			memcpy(_buf, buf, len);
+		}
+		size_t Space() {
+			return TCP_OUTPUT_CAPACITY - _t;
+		}
+		void Add(const char *buf, size_t len) {
+			memcpy(_buf + _t, buf, len);
+			_t += len;
+			_q += len;
+		}
+		size_t Remove(size_t len) {
+			_b += len;
+			_q -= len;
+			return _q;
+		}
+		const char *Buf() {
+			return _buf + _b;
+		}
+		size_t Len() {
+			return _q;
+		}
+		size_t _b;
+		size_t _t;
+		size_t _q;
+		char _buf[TCP_OUTPUT_CAPACITY];
+	};
+	typedef std::list<OUTPUT *> output_l;
+
+public:
+	/** Constructor with standard values on input/output buffers. */
+	TcpSocket(ISocketHandler& );
+	/** Constructor with custom values for i/o buffer. 
+		\param h ISocketHandler reference
+		\param isize Input buffer size
+		\param osize Output buffer size */
+	TcpSocket(ISocketHandler& h,size_t isize,size_t osize);
+	~TcpSocket();
+
+	/** Open a connection to a remote server.
+	    If you want your socket to connect to a server, 
+	    always call Open before Add'ing a socket to the sockethandler.
+	    If not, the connection attempt will not be monitored by the
+	    socket handler... 
+		\param ip IP address
+		\param port Port number
+		\param skip_socks Do not use socks4 even if configured */
+	bool Open(ipaddr_t ip,port_t port,bool skip_socks = false);
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+	/** Open connection. 
+		\param ip Ipv6 address
+		\param port Port number
+		\param skip_socks Do not use socks4 even if configured */
+	bool Open(in6_addr ip,port_t port,bool skip_socks = false);
+#endif
+#endif
+	bool Open(SocketAddress&,bool skip_socks = false);
+	bool Open(SocketAddress&,SocketAddress& bind_address,bool skip_socks = false);
+	/** Open connection. 
+		\param host Hostname
+		\param port Port number */
+	bool Open(const std::string &host,port_t port);
+
+	/** Connect timeout callback. */
+	void OnConnectTimeout();
+#ifdef _WIN32
+	/** Connection failed reported as exception on win32 */
+	void OnException();
+#endif
+
+	/** Close file descriptor - internal use only. 
+		\sa SetCloseAndDelete */
+	int Close();
+
+	/** Send a string. 
+		\param s String to send 
+		\param f Dummy flags -- not used */
+	void Send(const std::string &s,int f = 0);
+	/** Send string using printf formatting. */
+	void Sendf(const char *format, ...);
+	/** Send buffer of bytes.
+		\param buf Buffer pointer
+		\param len Length of data
+		\param f Dummy flags -- not used */
+	void SendBuf(const char *buf,size_t len,int f = 0);
+	/** This callback is executed after a successful read from the socket.
+		\param buf Pointer to the data
+		\param len Length of the data */
+	virtual void OnRawData(const char *buf,size_t len);
+
+	/** Called when output buffer has been sent.
+	    Note: Will only be called IF the output buffer has been used.
+	    Send's that was successful without needing the output buffer
+	    will not generate a call to this method. */
+	virtual void OnWriteComplete();
+	/** Number of bytes in input buffer. */
+	size_t GetInputLength();
+	/** Number of bytes in output buffer. */
+	size_t GetOutputLength();
+
+	/** Callback fires when a socket in line protocol has read one full line. 
+		\param line Line read */
+	void OnLine(const std::string& line);
+	/** Get counter of number of bytes received. */
+	uint64_t GetBytesReceived(bool clear = false);
+	/** Get counter of number of bytes sent. */
+	uint64_t GetBytesSent(bool clear = false);
+
+	/** Socks4 specific callback. */
+	void OnSocks4Connect();
+	/** Socks4 specific callback. */
+	void OnSocks4ConnectFailed();
+	/** Socks4 specific callback.
+		\return 'need_more' */
+	bool OnSocks4Read();
+
+#ifdef ENABLE_RESOLVER
+	/** Callback executed when resolver thread has finished a resolve request. */
+	void OnResolved(int id,ipaddr_t a,port_t port);
+#ifdef ENABLE_IPV6
+	void OnResolved(int id,in6_addr& a,port_t port);
+#endif
+#endif
+#ifdef HAVE_OPENSSL
+	/** Callback for 'New' ssl support - replaces SSLSocket. Internal use. */
+	void OnSSLConnect();
+	/** Callback for 'New' ssl support - replaces SSLSocket. Internal use. */
+	void OnSSLAccept();
+	/** This method must be implemented to initialize 
+		the ssl context for an outgoing connection. */
+	virtual void InitSSLClient();
+	/** This method must be implemented to initialize 
+		the ssl context for an incoming connection. */
+	virtual void InitSSLServer();
+#endif
+
+#ifdef ENABLE_RECONNECT
+	/** Flag that says a broken connection will try to reconnect. */
+	void SetReconnect(bool = true);
+	/** Check reconnect on lost connection flag status. */
+	bool Reconnect();
+	/** Flag to determine if a reconnect is in progress. */
+	void SetIsReconnect(bool x = true);
+	/** Socket is reconnecting. */
+	bool IsReconnect();
+#endif
+
+	void DisableInputBuffer(bool = true);
+
+	void OnOptions(int,int,int,SOCKET);
+
+	void SetLineProtocol(bool = true);
+
+	// TCP options
+	bool SetTcpNodelay(bool = true);
+
+	virtual int Protocol();
+
+	/** Trigger limit for callback OnTransferLimit. */
+	void SetTransferLimit(size_t sz);
+	/** This callback fires when the output buffer drops below the value
+	    set by SetTransferLimit. Default: 0 (disabled). */
+	virtual void OnTransferLimit();
+
+protected:
+	TcpSocket(const TcpSocket& );
+	void OnRead();
+	void OnRead( char *buf, size_t n );
+	void OnWrite();
+#ifdef HAVE_OPENSSL
+	/** SSL; Initialize ssl context for a client socket. 
+		\param meth_in SSL method */
+	void InitializeContext(const std::string& context, SSL_METHOD *meth_in = NULL);
+	/** SSL; Initialize ssl context for a server socket. 
+		\param keyfile Combined private key/certificate file 
+		\param password Password for private key 
+		\param meth_in SSL method */
+	void InitializeContext(const std::string& context, const std::string& keyfile, const std::string& password, SSL_METHOD *meth_in = NULL);
+	/** SSL; Initialize ssl context for a server socket. 
+		\param certfile Separate certificate file
+		\param keyfile Combined private key/certificate file 
+		\param password Password for private key 
+		\param meth_in SSL method */
+	void InitializeContext(const std::string& context, const std::string& certfile, const std::string& keyfile, const std::string& password, SSL_METHOD *meth_in = NULL);
+	/** SSL; Password callback method. */
+static	int SSL_password_cb(char *buf,int num,int rwflag,void *userdata);
+	/** SSL; Get pointer to ssl context structure. */
+	virtual SSL_CTX *GetSslContext();
+	/** SSL; Get pointer to ssl structure. */
+	virtual SSL *GetSsl();
+	/** ssl; still negotiating connection. */
+	bool SSLNegotiate();
+	/** SSL; Get ssl password. */
+	const std::string& GetPassword();
+#endif
+
+	CircularBuffer ibuf; ///< Circular input buffer
+
+private:
+	TcpSocket& operator=(const TcpSocket& ) { return *this; }
+
+	/** the actual send() */
+	int TryWrite(const char *buf, size_t len);
+	/** add data to output buffer top */
+	void Buffer(const char *buf, size_t len);
+
+	//
+	bool m_b_input_buffer_disabled;
+	uint64_t m_bytes_sent;
+	uint64_t m_bytes_received;
+	bool m_skip_c; ///< Skip second char of CRLF or LFCR sequence in OnRead
+	char m_c; ///< First char in CRLF or LFCR sequence
+	std::string m_line; ///< Current line in line protocol mode
+#ifdef SOCKETS_DYNAMIC_TEMP
+	char *m_buf; ///< temporary read buffer
+#endif
+	output_l m_obuf; ///< output buffer
+	OUTPUT *m_obuf_top; ///< output buffer on top
+	size_t m_transfer_limit;
+	size_t m_output_length;
+
+#ifdef HAVE_OPENSSL
+static	SSLInitializer m_ssl_init;
+	SSL_CTX *m_ssl_ctx; ///< ssl context
+	SSL *m_ssl; ///< ssl 'socket'
+	BIO *m_sbio; ///< ssl bio
+	std::string m_password; ///< ssl password
+#endif
+
+#ifdef ENABLE_SOCKS4
+	int m_socks4_state; ///< socks4 support
+	char m_socks4_vn; ///< socks4 support, temporary variable
+	char m_socks4_cd; ///< socks4 support, temporary variable
+	unsigned short m_socks4_dstport; ///< socks4 support
+	unsigned long m_socks4_dstip; ///< socks4 support
+#endif
+
+#ifdef ENABLE_RESOLVER
+	int m_resolver_id; ///< Resolver id (if any) for current Open call
+#endif
+
+#ifdef ENABLE_RECONNECT
+	bool m_b_reconnect; ///< Reconnect on lost connection flag
+	bool m_b_is_reconnect; ///< Trying to reconnect
+#endif
+
+};
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // _SOCKETS_TcpSocket_H
+
diff --git a/dep/include/sockets/Thread.h b/dep/include/sockets/Thread.h
new file mode 100644
index 00000000000..d784a1594f6
--- /dev/null
+++ b/dep/include/sockets/Thread.h
@@ -0,0 +1,100 @@
+/** \file Thread.h
+ **	\date  2004-10-30
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_Thread_H
+#define _SOCKETS_Thread_H
+
+#include "sockets-config.h"
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+#ifdef _WIN32
+// to be
+//typedef DWORD  threadfunc_t;
+//typedef LPVOID threadparam_t;
+//#define STDPREFIX WINAPI
+typedef unsigned threadfunc_t;
+typedef void * threadparam_t;
+#define STDPREFIX __stdcall
+#else
+#include <pthread.h>
+
+typedef void * threadfunc_t;
+typedef void * threadparam_t;
+#define STDPREFIX
+#endif
+
+/** \defgroup threading Threading */
+/** Thread base class. 
+The Thread class is used by the resolver (ResolvServer) and running a detached socket (SocketThread). 
+When you know some processing will take a long time and will freeze up a socket, there is always the 
+possibility to call Detach() on that socket before starting the processing.
+When the OnDetached() callback is later called the processing can continue, now in its own thread.
+	\ingroup threading */
+class Thread
+{
+public:
+	Thread(bool release = true);
+	virtual ~Thread();
+
+	static threadfunc_t STDPREFIX StartThread(threadparam_t);
+
+	virtual void Run() = 0;
+
+	bool IsRunning();
+	void SetRunning(bool x);
+	bool IsReleased();
+	void SetRelease(bool x);
+	bool DeleteOnExit();
+	void SetDeleteOnExit(bool x = true);
+	bool IsDestructor();
+
+private:
+	Thread(const Thread& ) {}
+	Thread& operator=(const Thread& ) { return *this; }
+#ifdef _WIN32
+	HANDLE m_thread;
+	unsigned m_dwThreadId;
+#else
+	pthread_t m_thread;
+#endif
+	bool m_running;
+	bool m_release;
+	bool m_b_delete_on_exit;
+	bool m_b_destructor;
+};
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // _SOCKETS_Thread_H
+
diff --git a/dep/include/sockets/UdpSocket.h b/dep/include/sockets/UdpSocket.h
new file mode 100644
index 00000000000..d32aabf67aa
--- /dev/null
+++ b/dep/include/sockets/UdpSocket.h
@@ -0,0 +1,215 @@
+/** \file UdpSocket.h
+ **	\date  2004-02-13
+ **	\author grymse@alhem.net
+**/
+/*
+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
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_UdpSocket_H
+#define _SOCKETS_UdpSocket_H
+
+#include "sockets-config.h"
+#include "Socket.h"
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+/** Socket implementation for UDP.
+	\ingroup basic */
+class UdpSocket : public Socket
+{
+public:
+	/** Constructor.
+		\param h ISocketHandler reference
+		\param ibufsz Maximum size of receive message (extra bytes will be truncated)
+		\param ipv6 'true' if this is an ipv6 socket */
+	UdpSocket(ISocketHandler& h,int ibufsz = 16384,bool ipv6 = false, int retries = 0);
+	~UdpSocket();
+
+	/** Called when incoming data has been received.
+		\param buf Pointer to data
+		\param len Length of data
+		\param sa Pointer to sockaddr struct of sender
+		\param sa_len Length of sockaddr struct */
+	virtual void OnRawData(const char *buf,size_t len,struct sockaddr *sa,socklen_t sa_len);
+
+	/** Called when incoming data has been received and read timestamp is enabled.
+		\param buf Pointer to data
+		\param len Length of data
+		\param sa Pointer to sockaddr struct of sender
+		\param sa_len Length of sockaddr struct
+		\param ts Timestamp from message */
+	virtual void OnRawData(const char *buf,size_t len,struct sockaddr *sa,socklen_t sa_len,struct timeval *ts);
+
+	/** To receive incoming data, call Bind to setup an incoming port.
+		\param port Incoming port number
+		\param range Port range to try if ports already in use
+		\return 0 if bind succeeded */
+	int Bind(port_t& port,int range = 1);
+	/** To receive data on a specific interface:port, use this.
+		\param intf Interface ip/hostname
+		\param port Port number
+		\param range Port range
+		\return 0 if bind succeeded */
+	int Bind(const std::string& intf,port_t& port,int range = 1);
+	/** To receive data on a specific interface:port, use this.
+		\param a Ip address
+		\param port Port number
+		\param range Port range
+		\return 0 if bind succeeded */
+	int Bind(ipaddr_t a,port_t& port,int range = 1);
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+	/** To receive data on a specific interface:port, use this.
+		\param a Ipv6 address
+		\param port Port number
+		\param range Port range
+		\return 0 if bind succeeded */
+	int Bind(in6_addr a,port_t& port,int range = 1);
+#endif
+#endif
+	/** To receive data on a specific interface:port, use this.
+		\param ad Socket address
+		\param range Port range
+		\return 0 if bind succeeded */
+	int Bind(SocketAddress& ad,int range = 1);
+
+	/** Define remote host.
+		\param l Address of remote host
+		\param port Port of remote host
+		\return true if successful */
+	bool Open(ipaddr_t l,port_t port);
+	/** Define remote host.
+		\param host Hostname
+		\param port Port number
+		\return true if successful */
+	bool Open(const std::string& host,port_t port);
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+	/** Define remote host.
+		\param a Address of remote host, ipv6
+		\param port Port of remote host
+		\return true if successful */
+	bool Open(struct in6_addr& a,port_t port);
+#endif
+#endif
+	/** Define remote host.
+		\param ad Socket address
+		\return true if successful */
+	bool Open(SocketAddress& ad);
+
+	/** Send to specified host */
+	void SendToBuf(const std::string& ,port_t,const char *data,int len,int flags = 0);
+	/** Send to specified address */
+	void SendToBuf(ipaddr_t,port_t,const char *data,int len,int flags = 0);
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+	/** Send to specified ipv6 address */
+	void SendToBuf(in6_addr,port_t,const char *data,int len,int flags = 0);
+#endif
+#endif
+	/** Send to specified socket address */
+	void SendToBuf(SocketAddress& ad,const char *data,int len,int flags = 0);
+
+	/** Send string to specified host */
+	void SendTo(const std::string&,port_t,const std::string&,int flags = 0);
+	/** Send string to specified address */
+	void SendTo(ipaddr_t,port_t,const std::string&,int flags = 0);
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+	/** Send string to specified ipv6 address */
+	void SendTo(in6_addr,port_t,const std::string&,int flags = 0);
+#endif
+#endif
+	/** Send string to specified socket address */
+	void SendTo(SocketAddress& ad,const std::string&,int flags = 0);
+
+	/** Send to connected address */
+	void SendBuf(const char *data,size_t,int flags = 0);
+	/** Send string to connected address. */
+	void Send(const std::string& ,int flags = 0);
+
+	/** Set broadcast */
+	void SetBroadcast(bool b = true);
+	/** Check broadcast flag.
+		\return true broadcast is enabled. */
+	bool IsBroadcast();
+
+	/** multicast */
+	void SetMulticastTTL(int ttl = 1);
+	int GetMulticastTTL();
+	void SetMulticastLoop(bool = true);
+	bool IsMulticastLoop();
+	void AddMulticastMembership(const std::string& group,const std::string& intf = "0.0.0.0",int if_index = 0);
+	void DropMulticastMembership(const std::string& group,const std::string& intf = "0.0.0.0",int if_index = 0);
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+	/** multicast, ipv6 only */
+	void SetMulticastHops(int = -1);
+	/** multicast, ipv6 only */
+	int GetMulticastHops();
+#endif
+#endif
+	/** Returns true if Bind succeeded. */
+	bool IsBound();
+	/** Return Bind port number */
+	port_t GetPort();
+
+	void OnOptions(int,int,int,SOCKET) {}
+
+	int GetLastSizeWritten();
+
+	/** Also read timestamp information from incoming message */
+	void SetTimestamp(bool = true);
+
+protected:
+	UdpSocket(const UdpSocket& s) : Socket(s) {}
+	void OnRead();
+#if defined(LINUX) || defined(MACOSX)
+	/** This method emulates socket recvfrom, but uses messages so we can get the timestamp */
+	int ReadTS(char *ioBuf, int inBufSize, struct sockaddr *from, socklen_t fromlen, struct timeval *ts);
+#endif
+
+private:
+	UdpSocket& operator=(const UdpSocket& ) { return *this; }
+	/** create before using sendto methods */
+	void CreateConnection();
+	char *m_ibuf; ///< Input buffer
+	int m_ibufsz; ///< Size of input buffer
+	bool m_bind_ok; ///< Bind completed successfully
+	port_t m_port; ///< Bind port number
+	int m_last_size_written;
+	int m_retries;
+	bool m_b_read_ts;
+};
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // _SOCKETS_UdpSocket_H
+
diff --git a/dep/include/sockets/Utility.h b/dep/include/sockets/Utility.h
new file mode 100644
index 00000000000..0fbccd3dfa3
--- /dev/null
+++ b/dep/include/sockets/Utility.h
@@ -0,0 +1,186 @@
+/** \file Utility.h
+ **	\date  2004-02-13
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_Utility_H
+#define _SOCKETS_Utility_H
+
+#include "sockets-config.h"
+#include <ctype.h>
+#include <string.h>
+#include <memory>
+#include "socket_include.h"
+#include <map>
+#include <string>
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+#define TWIST_LEN     624
+
+class SocketAddress;
+
+/** Conversion utilities. 
+	\ingroup util */
+class Utility
+{
+	/**
+		The Mersenne Twister
+		http://www.math.keio.ac.jp/~matumoto/emt.html
+	*/
+	class Rng {
+	public:
+		Rng(unsigned long seed);
+
+		unsigned long Get();
+
+	private:
+		int m_value;
+		unsigned long m_tmp[TWIST_LEN];
+	};
+	class ncmap_compare {
+	public:
+		bool operator()(const std::string& x, const std::string& y) const {
+			return strcasecmp(x.c_str(), y.c_str()) < 0;
+		}
+	};
+public:
+	template<typename Y> class ncmap : public std::map<std::string, Y, ncmap_compare> {
+	public:
+		ncmap() {}
+	};
+public:
+	static std::string base64(const std::string& str_in);
+	static std::string base64d(const std::string& str_in);
+	static std::string l2string(long l);
+	static std::string bigint2string(uint64_t l);
+	static uint64_t atoi64(const std::string& str);
+	static unsigned int hex2unsigned(const std::string& str);
+	static std::string rfc1738_encode(const std::string& src);
+	static std::string rfc1738_decode(const std::string& src);
+
+	/** Checks whether a string is a valid ipv4/ipv6 ip number. */
+	static bool isipv4(const std::string&);
+	/** Checks whether a string is a valid ipv4/ipv6 ip number. */
+	static bool isipv6(const std::string&);
+
+	/** Hostname to ip resolution ipv4, not asynchronous. */
+	static bool u2ip(const std::string&, ipaddr_t&);
+	static bool u2ip(const std::string&, struct sockaddr_in& sa, int ai_flags = 0);
+
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+	/** Hostname to ip resolution ipv6, not asynchronous. */
+	static bool u2ip(const std::string&, struct in6_addr&);
+	static bool u2ip(const std::string&, struct sockaddr_in6& sa, int ai_flags = 0);
+#endif
+#endif
+
+	/** Reverse lookup of address to hostname */
+	static bool reverse(struct sockaddr *sa, socklen_t sa_len, std::string&, int flags = 0);
+	static bool reverse(struct sockaddr *sa, socklen_t sa_len, std::string& hostname, std::string& service, int flags = 0);
+
+	static bool u2service(const std::string& name, int& service, int ai_flags = 0);
+
+	/** Convert binary ip address to string: ipv4. */
+	static void l2ip(const ipaddr_t,std::string& );
+	static void l2ip(const in_addr&,std::string& );
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+	/** Convert binary ip address to string: ipv6. */
+	static void l2ip(const struct in6_addr&,std::string& ,bool mixed = false);
+
+	/** ipv6 address compare. */
+	static int in6_addr_compare(in6_addr,in6_addr);
+#endif
+#endif
+	/** ResolveLocal (hostname) - call once before calling any GetLocal method. */
+	static void ResolveLocal();
+	/** Returns local hostname, ResolveLocal must be called once before using.
+		\sa ResolveLocal */
+	static const std::string& GetLocalHostname();
+	/** Returns local ip, ResolveLocal must be called once before using.
+		\sa ResolveLocal */
+	static ipaddr_t GetLocalIP();
+	/** Returns local ip number as string.
+		\sa ResolveLocal */
+	static const std::string& GetLocalAddress();
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+	/** Returns local ipv6 ip.
+		\sa ResolveLocal */
+	static const struct in6_addr& GetLocalIP6();
+	/** Returns local ipv6 address.
+		\sa ResolveLocal */
+	static const std::string& GetLocalAddress6();
+#endif
+#endif
+	/** Set environment variable.
+		\param var Name of variable to set
+		\param value Value */
+	static void SetEnv(const std::string& var,const std::string& value);
+	/** Convert sockaddr struct to human readable string.
+		\param sa Ptr to sockaddr struct */
+	static std::string Sa2String(struct sockaddr *sa);
+
+	/** Get current time in sec/microseconds. */
+	static void GetTime(struct timeval *);
+
+	static std::auto_ptr<SocketAddress> CreateAddress(struct sockaddr *,socklen_t);
+
+	static unsigned long ThreadID();
+
+	static std::string ToLower(const std::string& str);
+	static std::string ToUpper(const std::string& str);
+
+	static std::string ToString(double d);
+
+	/** Returns a random 32-bit integer */
+	static unsigned long Rnd();
+
+private:
+	static std::string m_host; ///< local hostname
+	static ipaddr_t m_ip; ///< local ip address
+	static std::string m_addr; ///< local ip address in string format
+#ifdef ENABLE_IPV6
+#ifdef IPPROTO_IPV6
+	static struct in6_addr m_local_ip6; ///< local ipv6 address
+#endif
+	static std::string m_local_addr6; ///< local ipv6 address in string format
+#endif
+	static bool m_local_resolved; ///< ResolveLocal has been called if true
+};
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // _SOCKETS_Utility_H
+
diff --git a/dep/include/sockets/socket_include.h b/dep/include/sockets/socket_include.h
new file mode 100644
index 00000000000..34e7a8ca5d1
--- /dev/null
+++ b/dep/include/sockets/socket_include.h
@@ -0,0 +1,299 @@
+/** \file socket_include.h
+ **	\date  2005-04-12
+ **	\author grymse@alhem.net
+**/
+/*
+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 
+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.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_socket_include_H
+#define _SOCKETS_socket_include_H
+#include "sockets-config.h"
+
+#ifdef _MSC_VER
+#pragma warning(disable:4514)
+#endif
+
+// common defines affecting library and applications using library
+
+/* Define SOCKETS_DYNAMIC_TEMP to use dynamically allocated buffers
+   in read operations - helps on ECOS */
+#define SOCKETS_DYNAMIC_TEMP
+
+
+// platform specific stuff
+#if (defined(__unix__) || defined(unix)) && !defined(USG)
+#include <sys/param.h>
+#endif
+#include <list>
+
+// int64
+#ifdef _WIN32
+typedef unsigned __int64 uint64_t;
+#else
+#include <stdlib.h>
+#ifdef SOLARIS
+# include <sys/types.h>
+#else
+# include <stdint.h>
+#endif
+#endif
+
+#ifndef _WIN32 
+// ----------------------------------------
+// common unix includes / defines
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+//#include <netdb.h>
+
+// all typedefs in this file will be declared outside the sockets namespace,
+// because some os's will already have one or more of the type defined.
+typedef int SOCKET;
+#define Errno errno
+#define StrError strerror
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+
+// WIN32 adapt
+#define closesocket close
+#define INVALID_SOCKET -1
+#define SOCKET_ERROR -1
+
+#ifndef INADDR_NONE
+#define INADDR_NONE ((unsigned long) -1)
+#endif // INADDR_NONE
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#endif // !_WIN32
+
+
+// ----------------------------------------
+// Generic
+#ifndef SOL_IP
+#define SOL_IP IPPROTO_IP
+#endif
+
+
+// ----------------------------------------
+// OS specific adaptions
+
+#ifdef SOLARIS 
+// ----------------------------------------
+// Solaris
+typedef unsigned short port_t;
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+// no defs
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#define s6_addr16 _S6_un._S6_u8
+#define MSG_NOSIGNAL 0
+
+#elif defined __FreeBSD__
+// ----------------------------------------
+// FreeBSD
+# if __FreeBSD_version >= 400014
+#  define s6_addr16 __u6_addr.__u6_addr16
+#  if !defined(MSG_NOSIGNAL)
+#   define MSG_NOSIGNAL 0
+#  endif
+#  include <netinet/in.h>
+typedef	in_addr_t ipaddr_t;
+typedef	in_port_t port_t;
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+// no defs
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#  define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
+#  define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
+# else
+#  error FreeBSD versions prior to 400014 does not support ipv6
+# endif
+
+#elif defined __NetBSD__  
+#  if !defined(MSG_NOSIGNAL)  
+#   define MSG_NOSIGNAL 0  
+#  endif  
+#  include <netinet/in.h>  
+typedef in_addr_t ipaddr_t;  
+typedef in_port_t port_t;  
+#elif defined MACOSX 
+// ----------------------------------------
+// Mac OS X
+#include <string.h>
+#ifdef __DARWIN_UNIX03
+typedef unsigned short port_t;
+#else
+#include <mach/port.h>
+#endif // __DARWIN_UNIX03
+typedef unsigned long ipaddr_t;
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+// no defs
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#define s6_addr16 __u6_addr.__u6_addr16
+#define MSG_NOSIGNAL 0 // oops - thanks Derek
+#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
+#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
+
+#elif defined _WIN32 
+// ----------------------------------------
+// Win32
+#ifdef _MSC_VER
+#pragma comment(lib, "wsock32.lib")
+#endif
+#define strcasecmp _stricmp
+
+typedef unsigned long ipaddr_t;
+typedef unsigned short port_t;
+typedef int socklen_t;
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+// no defs
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+// 1.8.6: define FD_SETSIZE to something bigger than 64 if there are a lot of
+// simultaneous connections (must be done before including winsock.h)
+#define FD_SETSIZE 1024
+
+// windows 2000 with ipv6 preview installed:
+//    http://msdn.microsoft.com/downloads/sdks/platform/tpipv6.asp
+// see the FAQ on how to install
+#define WIN32_LEAN_AND_MEAN
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#if _MSC_VER < 1200
+#ifndef __CYGWIN__
+#ifdef ENABLE_IPV6
+#include <tpipv6.h>  // For IPv6 Tech Preview.
+#endif
+#endif
+#endif // _MSC_VER < 1200
+
+
+#define MSG_NOSIGNAL 0
+//#define SHUT_RDWR 2
+#define SHUT_WR 1
+
+#define Errno WSAGetLastError()
+const char *StrError(int x);
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+
+
+// class WSAInitializer is a part of the Socket class (on win32)
+// as a static instance - so whenever an application uses a Socket,
+// winsock is initialized
+class WSAInitializer // Winsock Initializer
+{
+public:
+	WSAInitializer() {
+		if (WSAStartup(0x101,&m_wsadata)) 
+		{
+			exit(-1);
+		}
+	}
+	~WSAInitializer() {
+		WSACleanup();
+	}
+private:
+	WSADATA m_wsadata;
+};
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+#else 
+// ----------------------------------------
+// LINUX 
+typedef unsigned long ipaddr_t;
+typedef unsigned short port_t;
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+// no defs
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+
+#endif
+
+#ifdef SOCKETS_NAMESPACE
+namespace SOCKETS_NAMESPACE {
+#endif
+	/** List type containing file descriptors. */
+	typedef std::list<SOCKET> socket_v;
+
+
+#ifdef SOCKETS_NAMESPACE
+}
+#endif
+
+
+// getaddrinfo / getnameinfo replacements
+#ifdef NO_GETADDRINFO
+#ifndef AI_NUMERICHOST
+#define AI_NUMERICHOST 1
+#endif
+#ifndef NI_NUMERICHOST
+#define NI_NUMERICHOST 1
+#endif
+#endif
+
+
+#endif // _SOCKETS_socket_include_H
+
diff --git a/dep/include/sockets/sockets-config.h b/dep/include/sockets/sockets-config.h
new file mode 100644
index 00000000000..fffc2bbe7f1
--- /dev/null
+++ b/dep/include/sockets/sockets-config.h
@@ -0,0 +1,101 @@
+/**
+ **	\file sockets-config.h
+ **	\date  2007-04-14
+ **	\author grymse@alhem.net
+**/
+/*
+Copyright (C) 2007  Anders Hedstrom
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+#ifndef _SOCKETS_CONFIG_H
+#define _SOCKETS_CONFIG_H
+
+#ifndef _RUN_DP
+/* First undefine symbols if already defined. */
+#undef HAVE_OPENSSL
+#undef ENABLE_IPV6
+#undef USE_SCTP
+#undef NO_GETADDRINFO
+#undef ENABLE_POOL
+#undef ENABLE_SOCKS4
+#undef ENABLE_RESOLVER
+#undef ENABLE_RECONNECT
+#undef ENABLE_DETACH
+#undef ENABLE_TRIGGERS
+#undef ENABLE_EXCEPTIONS
+#endif // _RUN_DP
+
+// define MACOSX for internal socket library checks
+#if defined(__APPLE__) && defined(__MACH__) && !defined(MACOSX)
+#define MACOSX
+#endif
+
+/* OpenSSL support. */
+//#define HAVE_OPENSSL
+
+
+/* Ipv6 support. */
+//#define ENABLE_IPV6
+
+
+/* SCTP support. */
+//#define USE_SCTP
+
+
+/* Define NO_GETADDRINFO if your operating system does not support
+   the "getaddrinfo" and "getnameinfo" function calls. */
+#define NO_GETADDRINFO
+
+
+/* Connection pool support. */
+#define ENABLE_POOL
+
+
+/* Socks4 client support. */
+//#define ENABLE_SOCKS4
+
+
+/* Asynchronous resolver. */
+#define ENABLE_RESOLVER
+
+
+/* Enable TCP reconnect on lost connection.
+	Socket::OnReconnect
+	Socket::OnDisconnect
+*/
+#define ENABLE_RECONNECT
+
+
+/* Enable socket thread detach functionality. */
+#define ENABLE_DETACH
+
+
+/* Enable socket to socket triggers. Not yet in use. */
+//#define ENABLE_TRIGGERS
+
+
+/* Enabled exceptions. */
+//#define ENABLE_EXCEPTIONS
+
+
+/* Resolver uses the detach function so either enable both or disable both. */
+#ifndef ENABLE_DETACH
+#undef ENABLE_RESOLVER
+#endif
+
+
+#endif // _SOCKETS_CONFIG_H
+