Replace tabs with spaces in more files.

--HG--
branch : trunk

1 files changed, 151 insertions, 151 deletions

diff --git a/dep/include/sockets/SocketHandler.h b/dep/include/sockets/SocketHandler.h
index c7e20dfde82..a28d2b5311a 100644
--- a/dep/include/sockets/SocketHandler.h
+++ b/dep/include/sockets/SocketHandler.h
@@ -1,6 +1,6 @@
 /** \file SocketHandler.h
- **	\date  2004-02-13
- **	\author grymse@alhem.net
+ ** \date  2004-02-13
+ ** \author grymse@alhem.net
 **/
 /*
 Copyright (C) 2004-2007  Anders Hedstrom
@@ -8,7 +8,7 @@ Copyright (C) 2004-2007  Anders Hedstrom
 This library is made available under the terms of the GNU GPL.
 
 If you would like to use this library in a closed-source application,
-a separate license agreement is available. For information about 
+a separate license agreement is available. For information about
 the closed-source license agreement for the C++ sockets library,
 please visit http://www.alhem.net/Sockets/license.html and/or
 email license@alhem.net.
@@ -48,212 +48,212 @@ class ResolvServer;
 #endif
 class Mutex;
 
-/** Socket container class, event generator. 
-	\ingroup basic */
+/** 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;
+    /** 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 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 threadsafe constructor.
+        \param mutex Externally declared mutex variable
+        \param log Optional log class pointer */
+    SocketHandler(Mutex& mutex,StdLog *log = NULL);
 
-	~SocketHandler();
+    ~SocketHandler();
 
-	/** Get mutex reference for threadsafe operations. */
-	Mutex& GetMutex() const;
+    /** 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);
+    /** 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);
+    /** 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 *);
+    /** 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);
+    /** 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);
+    /** 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);
+    /** Wait for events, generate callbacks. */
+    int Select(long sec,long usec);
 
-	/** This method will not return until an event has been detected. */
-	int Select();
+    /** This method will not return until an event has been detected. */
+    int Select();
 
-	/** Wait for events, generate callbacks. */
-	int Select(struct timeval *tsel);
+    /** Wait for events, generate callbacks. */
+    int Select(struct timeval *tsel);
 
-	/** Check that a socket really is handled by this socket handler. */
-	bool Valid(Socket *);
+    /** 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();
+    /** 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);
+    /** 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);
+    /** Called by Socket when a socket changes state. */
+    void AddList(SOCKET s,list_t which_one,bool add);
 
-	// Connection pool
+    // 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();
+    /** 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
+    // 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();
+    /** 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
+    // 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);
+    /** 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);
+    int Resolve6(Socket *,const std::string& host,port_t port);
 #endif
-	/** Do a reverse dns lookup. */
-	int Resolve(Socket *,ipaddr_t a);
+    /** Do a reverse dns lookup. */
+    int Resolve(Socket *,ipaddr_t a);
 #ifdef ENABLE_IPV6
-	int Resolve(Socket *,in6_addr& a);
+    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 *);
+    /** 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);
+    /** 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();
+    /** 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();
+    /** 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)
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    bool m_slave; ///< Indicates that this is a ISocketHandler run in SocketThread
 #endif
 };