SocketHandler Class Reference
[Basic sockets]

Socket container class, event generator. More...

#include <SocketHandler.h>

Inheritance diagram for SocketHandler:

[legend]

Collaboration diagram for SocketHandler:

[legend]

List of all members.

Public Member Functions
	SocketHandler (StdLog *log=NULL)
	SocketHandler constructor.
	SocketHandler (IMutex &mutex, StdLog *log=NULL)
	SocketHandler threadsafe constructor.
	~SocketHandler ()
IMutex &	GetMutex () const
	Get mutex reference for threadsafe operations.
void	RegStdLog (StdLog *log)
	Register StdLog object for error callback.
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	Add (Socket *)
	Add socket instance to socket map.
void	Get (SOCKET s, bool &r, bool &w, bool &e)
	Get status of read/write/exception file descriptor set for a socket.
void	Set (SOCKET s, bool bRead, bool bWrite, bool bException=true)
	Set read/write/exception file descriptor sets (fd_set).
int	Select (long sec, long usec)
	Wait for events, generate callbacks.
int	Select ()
	This method will not return until an event has been detected.
int	Select (struct timeval *tsel)
	Wait for events, generate callbacks.
bool	Valid (Socket *)
	Check that a socket really is handled by this socket handler.
size_t	GetCount ()
	Return number of sockets handled by this handler.
bool	OkToAccept (Socket *p)
	Override and return false to deny all incoming connections.
void	AddList (SOCKET s, list_t which_one, bool add)
	Called by Socket when a socket changes state.
ISocketHandler::PoolSocket *	FindConnection (int type, const std::string &protocol, SocketAddress &)
	Find available open connection (used by connection pool).
void	EnablePool (bool x=true)
	Enable connection pool (by default disabled).
bool	PoolEnabled ()
	Check pool status.
void	SetSocks4Host (ipaddr_t)
	Set socks4 server ip that all new tcp sockets should use.
void	SetSocks4Host (const std::string &)
	Set socks4 server hostname that all new tcp sockets should use.
void	SetSocks4Port (port_t)
	Set socks4 server port number that all new tcp sockets should use.
void	SetSocks4Userid (const std::string &)
	Set optional socks4 userid.
void	SetSocks4TryDirect (bool x=true)
	If connection to socks4 server fails, immediately try direct connection to final host.
ipaddr_t	GetSocks4Host ()
	Get socks4 server ip.
port_t	GetSocks4Port ()
	Get socks4 port number.
const std::string &	GetSocks4Userid ()
	Get socks4 userid (optional).
bool	Socks4TryDirect ()
	Check status of socks4 try direct flag.
void	EnableResolver (port_t port=16667)
	Enable asynchronous DNS.
bool	ResolverEnabled ()
	Check resolver status.
int	Resolve (Socket *, const std::string &host, port_t port)
	Queue a dns request.
int	Resolve (Socket *, ipaddr_t a)
	Do a reverse dns lookup.
port_t	GetResolverPort ()
	Get listen port of asynchronous dns server.
bool	ResolverReady ()
	Resolver thread ready for queries.
bool	Resolving (Socket *)
	Returns true if the socket is waiting for a resolve event.
void	SetSlave (bool x=true)
	Indicates that the handler runs under SocketThread.
bool	IsSlave ()
	Indicates that the handler runs under SocketThread.
void	CheckSanity ()
	Sanity check of those accursed lists.
Protected Types
typedef std::map< SOCKET, Socket * >	socket_m
	Map type for holding file descriptors/socket object pointers.
Protected Member Functions
void	Remove (Socket *)
	Remove socket from socket map, used by Socket class.
Protected Attributes
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).
StdLog *	m_stdlog
	Registered log class, or NULL.
IMutex &	m_mutex
	Thread safety mutex.
bool	m_b_use_mutex
	Mutex correctly initialized.
Private Member Functions
void	CheckList (socket_v &, const std::string &)
	Used by CheckSanity.
Private Attributes
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
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
socket_v	m_fds_detach
	checklist Detach
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
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.
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
bool	m_b_enable_pool
	Connection pool enabled if true.
bool	m_slave
	Indicates that this is a ISocketHandler run in SocketThread.

---

Detailed Description

Socket container class, event generator.

Definition at line 53 of file SocketHandler.h.

---

Member Typedef Documentation

typedef std::map<SOCKET,Socket *> SocketHandler::socket_m [protected]

Map type for holding file descriptors/socket object pointers.

Definition at line 57 of file SocketHandler.h.

---

Constructor & Destructor Documentation

SocketHandler::SocketHandler

(

StdLog *

log = NULL

)

SocketHandler constructor.

Parameters:

log

Optional log class pointer

Definition at line 59 of file SocketHandler.cpp.

References m_efds, m_rfds, and m_wfds.

:m_stdlog(p)
,m_mutex(m_mutex)
,m_b_use_mutex(false)
,m_maxsock(0)
,m_preverror(-1)
,m_errcnt(0)
,m_tlast(0)
#ifdef ENABLE_SOCKS4
,m_socks4_host(0)
,m_socks4_port(0)
,m_bTryDirect(false)
#endif
#ifdef ENABLE_RESOLVER
,m_resolv_id(0)
,m_resolver(NULL)
#endif
#ifdef ENABLE_POOL
,m_b_enable_pool(false)
#endif
#ifdef ENABLE_TRIGGERS
,m_next_trigger_id(0)
#endif
#ifdef ENABLE_DETACH
,m_slave(false)
#endif
{
        FD_ZERO(&m_rfds);
        FD_ZERO(&m_wfds);
        FD_ZERO(&m_efds);
}

SocketHandler::SocketHandler	(	IMutex &	mutex,
		StdLog *	log = NULL
	)

SocketHandler threadsafe constructor.

Parameters:

	mutex	Externally declared mutex variable
	log	Optional log class pointer

Definition at line 92 of file SocketHandler.cpp.

References IMutex::Lock(), m_efds, m_mutex, m_rfds, and m_wfds.

:m_stdlog(p)
,m_mutex(mutex)
,m_b_use_mutex(true)
,m_maxsock(0)
,m_preverror(-1)
,m_errcnt(0)
,m_tlast(0)
#ifdef ENABLE_SOCKS4
,m_socks4_host(0)
,m_socks4_port(0)
,m_bTryDirect(false)
#endif
#ifdef ENABLE_RESOLVER
,m_resolv_id(0)
,m_resolver(NULL)
#endif
#ifdef ENABLE_POOL
,m_b_enable_pool(false)
#endif
#ifdef ENABLE_TRIGGERS
,m_next_trigger_id(0)
#endif
#ifdef ENABLE_DETACH
,m_slave(false)
#endif
{
        m_mutex.Lock();
        FD_ZERO(&m_rfds);
        FD_ZERO(&m_wfds);
        FD_ZERO(&m_efds);
}

SocketHandler::~SocketHandler

(

)

Definition at line 126 of file SocketHandler.cpp.

References DEB, ENABLE_DETACH, ENABLE_RESOLVER, m_b_use_mutex, m_mutex, m_resolver, m_slave, m_sockets, and IMutex::Unlock().

{
#ifdef ENABLE_RESOLVER
        if (m_resolver)
        {
                m_resolver -> Quit();
        }
#endif
        {
                while (m_sockets.size())
                {
DEB(                    fprintf(stderr, "Emptying sockets list in SocketHandler destructor, %d instances\n", (int)m_sockets.size());)
                        socket_m::iterator it = m_sockets.begin();
                        Socket *p = it -> second;
                        if (p)
                        {
DEB(                            fprintf(stderr, "  fd %d\n", p -> GetSocket());)
                                p -> Close();
DEB(                            fprintf(stderr, "  fd closed %d\n", p -> GetSocket());)
//                              p -> OnDelete(); // hey, I turn this back on. what's the worst that could happen??!!
                                // MinionSocket breaks, calling MinderHandler methods in OnDelete -
                                // MinderHandler is already gone when that happens...

                                // only delete socket when controlled
                                // ie master sockethandler can delete non-detached sockets
                                // and a slave sockethandler can only delete a detach socket
                                if (p -> DeleteByHandler()
#ifdef ENABLE_DETACH
                                        && !(m_slave ^ p -> IsDetached()) 
#endif
                                        )
                                {
                                        p -> SetErasedByHandler();
                                        delete p;
                                }
                                m_sockets.erase(it);
                        }
                        else
                        {
                                m_sockets.erase(it);
                        }
DEB(                    fprintf(stderr, "next\n");)
                }
DEB(            fprintf(stderr, "/Emptying sockets list in SocketHandler destructor, %d instances\n", (int)m_sockets.size());)
        }
#ifdef ENABLE_RESOLVER
        if (m_resolver)
        {
                delete m_resolver;
        }
#endif
        if (m_b_use_mutex)
        {
                m_mutex.Unlock();
        }
}

---

Member Function Documentation

IMutex & SocketHandler::GetMutex

(

)

const [virtual]

Get mutex reference for threadsafe operations.

Implements ISocketHandler.

Definition at line 184 of file SocketHandler.cpp.

References m_mutex.

{
        return m_mutex; 
}

void SocketHandler::RegStdLog

(

StdLog *

log

)

[virtual]

Register StdLog object for error callback.

Parameters:

log

Pointer to log class

Implements ISocketHandler.

Definition at line 204 of file SocketHandler.cpp.

References m_stdlog.

{
        m_stdlog = log;
}

void SocketHandler::LogError	(	Socket *	p,
		const std::string &	user_text,
		int	err,
		const std::string &	sys_err,
		loglevel_t	t = LOG_LEVEL_WARNING
	)			[virtual]

Log error to log class for print out / storage.

Implements ISocketHandler.

Definition at line 210 of file SocketHandler.cpp.

References m_stdlog.

Referenced by Add(), AddList(), Remove(), Resolve(), and Select().

{
        if (m_stdlog)
        {
                m_stdlog -> error(this, p, user_text, err, sys_err, t);
        }
}

void SocketHandler::Add

(

Socket *

p

)

[virtual]

Add socket instance to socket map.

Removal is always automatic.

Implements ISocketHandler.

Reimplemented in EventHandler.

Definition at line 219 of file SocketHandler.cpp.

References INVALID_SOCKET, LOG_LEVEL_FATAL, LOG_LEVEL_WARNING, LogError(), m_add, and m_delete.

Referenced by EventHandler::Add(), Resolve(), Socket::SocketThread::Run(), ResolvServer::Run(), and Select().

{
        if (p -> GetSocket() == INVALID_SOCKET)
        {
                LogError(p, "Add", -1, "Invalid socket", LOG_LEVEL_WARNING);
                if (p -> CloseAndDelete())
                {
                        m_delete.push_back(p);
                }
                return;
        }
        if (m_add.find(p -> GetSocket()) != m_add.end())
        {
                LogError(p, "Add", (int)p -> GetSocket(), "Attempt to add socket already in add queue", LOG_LEVEL_FATAL);
                m_delete.push_back(p);
                return;
        }
        m_add[p -> GetSocket()] = p;
}

void SocketHandler::Get	(	SOCKET	s,
		bool &	r,
		bool &	w,
		bool &	e
	)			[virtual]

Get status of read/write/exception file descriptor set for a socket.

Implements ISocketHandler.

Definition at line 240 of file SocketHandler.cpp.

References m_efds, m_rfds, and m_wfds.

{
        if (s >= 0)
        {
                r = FD_ISSET(s, &m_rfds) ? true : false;
                w = FD_ISSET(s, &m_wfds) ? true : false;
                e = FD_ISSET(s, &m_efds) ? true : false;
        }
}

void SocketHandler::Set	(	SOCKET	s,
		bool	bRead,
		bool	bWrite,
		bool	bException = true
	)			[virtual]

Set read/write/exception file descriptor sets (fd_set).

Implements ISocketHandler.

Definition at line 251 of file SocketHandler.cpp.

References DEB, m_efds, m_rfds, and m_wfds.

Referenced by Select().

{
DEB(    fprintf(stderr, "Set(%d, %s, %s, %s)\n", s, bRead ? "true" : "false", bWrite ? "true" : "false", bException ? "true" : "false");)
        if (s >= 0)
        {
                if (bRead)
                {
                        if (!FD_ISSET(s, &m_rfds))
                        {
                                FD_SET(s, &m_rfds);
                        }
                }
                else
                {
                        FD_CLR(s, &m_rfds);
                }
                if (bWrite)
                {
                        if (!FD_ISSET(s, &m_wfds))
                        {
                                FD_SET(s, &m_wfds);
                        }
                }
                else
                {
                        FD_CLR(s, &m_wfds);
                }
                if (bException)
                {
                        if (!FD_ISSET(s, &m_efds))
                        {
                                FD_SET(s, &m_efds);
                        }
                }
                else
                {
                        FD_CLR(s, &m_efds);
                }
        }
}

int SocketHandler::Select	(	long	sec,
		long	usec
	)			[virtual]

Wait for events, generate callbacks.

Implements ISocketHandler.

Definition at line 293 of file SocketHandler.cpp.

References Select().

Referenced by Socket::SocketThread::Run(), and ResolvServer::Run().

{
        struct timeval tv;
        tv.tv_sec = sec;
        tv.tv_usec = usec;
        return Select(&tv);
}

int SocketHandler::Select

(

)

[virtual]

This method will not return until an event has been detected.

Implements ISocketHandler.

Definition at line 302 of file SocketHandler.cpp.

References m_fds_callonconnect, m_fds_close, m_fds_detach, m_fds_erase, m_fds_retry, m_fds_timeout, and m_slave.

Referenced by EventHandler::EventLoop(), and Select().

{
        if (m_fds_callonconnect.size() ||
#ifdef ENABLE_DETACH
                (!m_slave && m_fds_detach.size()) ||
#endif
                m_fds_timeout.size() ||
                m_fds_retry.size() ||
                m_fds_close.size() ||
                m_fds_erase.size())
        {
                return Select(0, 200000);
        }
        return Select(NULL);
}

int SocketHandler::Select

(

struct timeval *

tsel

)

[virtual]

Wait for events, generate callbacks.

Todo:

rebuild fd_set's from active sockets list (m_sockets) here

Implements ISocketHandler.

Definition at line 319 of file SocketHandler.cpp.

References Add(), AddList(), DEB, ENABLE_DETACH, Errno, INVALID_SOCKET, LIST_CALLONCONNECT, IMutex::Lock(), LOG_LEVEL_ERROR, LOG_LEVEL_FATAL, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, LogError(), m_add, m_b_use_mutex, m_delete, m_efds, m_errcnt, m_fds, m_fds_callonconnect, m_fds_close, m_fds_detach, m_fds_erase, m_fds_retry, m_fds_timeout, m_maxsock, m_mutex, m_preverror, m_rfds, m_slave, m_sockets, m_tlast, m_wfds, Set(), StrError, IMutex::Unlock(), and Valid().

{
        size_t ignore = 0;
        while (m_add.size() > ignore)
        {
                if (m_sockets.size() >= FD_SETSIZE)
                {
                        LogError(NULL, "Select", (int)m_sockets.size(), "FD_SETSIZE reached", LOG_LEVEL_WARNING);
                        break;
                }
                socket_m::iterator it = m_add.begin();
                SOCKET s = it -> first;
                Socket *p = it -> second;
DEB(            fprintf(stderr, "Trying to add fd %d,  m_add.size() %d,  ignore %d\n", (int)s, (int)m_add.size(), (int)ignore);)
                //
                if (m_sockets.find(p -> GetSocket()) != m_sockets.end())
                {
                        LogError(p, "Add", (int)p -> GetSocket(), "Attempt to add socket already in controlled queue", LOG_LEVEL_FATAL);
                        // %! it's a dup, don't add to delete queue, just ignore it
                        m_delete.push_back(p);
                        m_add.erase(it);
//                      ignore++;
                        continue;
                }
                if (!p -> CloseAndDelete())
                {
                        StreamSocket *scp = dynamic_cast<StreamSocket *>(p);
                        if (scp && scp -> Connecting()) // 'Open' called before adding socket
                        {
                                Set(s,false,true);
                        }
                        else
                        {
                                TcpSocket *tcp = dynamic_cast<TcpSocket *>(p);
                                bool bWrite = tcp ? tcp -> GetOutputLength() != 0 : false;
                                if (p -> IsDisableRead())
                                {
                                        Set(s, false, bWrite);
                                }
                                else
                                {
                                        Set(s, true, bWrite);
                                }
                        }
                        m_maxsock = (s > m_maxsock) ? s : m_maxsock;
                }
                else
                {
                        LogError(p, "Add", (int)p -> GetSocket(), "Trying to add socket with SetCloseAndDelete() true", LOG_LEVEL_WARNING);
                }
                // only add to m_fds (process fd_set events) if
                //  slave handler and detached/detaching socket
                //  master handler and non-detached socket
#ifdef ENABLE_DETACH
                if (!(m_slave ^ p -> IsDetach()))
#endif
                {
                        m_fds.push_back(s);
                }
                m_sockets[s] = p;
                //
                m_add.erase(it);
        }
#ifdef MACOSX
        fd_set rfds;
        fd_set wfds;
        fd_set efds;
        FD_COPY(&m_rfds, &rfds);
        FD_COPY(&m_wfds, &wfds);
        FD_COPY(&m_efds, &efds);
#else
        fd_set rfds = m_rfds;
        fd_set wfds = m_wfds;
        fd_set efds = m_efds;
#endif
        int n;
        if (m_b_use_mutex)
        {
                m_mutex.Unlock();
                n = select( (int)(m_maxsock + 1),&rfds,&wfds,&efds,tsel);
                m_mutex.Lock();
        }
        else
        {
                n = select( (int)(m_maxsock + 1),&rfds,&wfds,&efds,tsel);
        }
        if (n == -1)
        {
                /*
                        EBADF  An invalid file descriptor was given in one of the sets.
                        EINTR  A non blocked signal was caught.
                        EINVAL n is negative. Or struct timeval contains bad time values (<0).
                        ENOMEM select was unable to allocate memory for internal tables.
                */
                if (Errno != m_preverror || m_errcnt++ % 10000 == 0)
                {
                        LogError(NULL, "select", Errno, StrError(Errno));
DEB(                    fprintf(stderr, "m_maxsock: %d\n", m_maxsock);
                        fprintf(stderr, "%s\n", Errno == EINVAL ? "EINVAL" :
                                Errno == EINTR ? "EINTR" :
                                Errno == EBADF ? "EBADF" :
                                Errno == ENOMEM ? "ENOMEM" : "<another>");
                        // test bad fd
                        for (SOCKET i = 0; i <= m_maxsock; i++)
                        {
                                bool t = false;
                                FD_ZERO(&rfds);
                                FD_ZERO(&wfds);
                                FD_ZERO(&efds);
                                if (FD_ISSET(i, &m_rfds))
                                {
                                        FD_SET(i, &rfds);
                                        t = true;
                                }
                                if (FD_ISSET(i, &m_wfds))
                                {
                                        FD_SET(i, &wfds);
                                        t = true;
                                }
                                if (FD_ISSET(i, &m_efds))
                                {
                                        FD_SET(i, &efds);
                                        t = true;
                                }
                                if (t && m_sockets.find(i) == m_sockets.end())
                                {
                                        fprintf(stderr, "Bad fd in fd_set: %d\n", i);
                                }
                        }
) // DEB
                        m_preverror = Errno;
                }
        }
        else
        if (!n)
        {
                m_preverror = -1;
        }
        else
        if (n > 0)
        {
                for (socket_v::iterator it2 = m_fds.begin(); it2 != m_fds.end() && n; it2++)
                {
                        SOCKET i = *it2;
                        if (FD_ISSET(i, &rfds))
                        {
                                socket_m::iterator itmp = m_sockets.find(i);
                                if (itmp != m_sockets.end()) // found
                                {
                                        Socket *p = itmp -> second;
                                        // new SSL negotiate method
#ifdef HAVE_OPENSSL
                                        if (p -> IsSSLNegotiate())
                                        {
                                                p -> SSLNegotiate();
                                        }
                                        else
#endif
                                        {
                                                p -> OnRead();
                                        }
                                }
                                else
                                {
                                        LogError(NULL, "GetSocket/handler/1", (int)i, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
                                }
                                n--;
                        }
                        if (FD_ISSET(i, &wfds))
                        {
                                socket_m::iterator itmp = m_sockets.find(i);
                                if (itmp != m_sockets.end()) // found
                                {
                                        Socket *p = itmp -> second;
                                        // new SSL negotiate method
#ifdef HAVE_OPENSSL
                                        if (p -> IsSSLNegotiate())
                                        {
                                                p -> SSLNegotiate();
                                        }
                                        else
#endif
                                        {
                                                p -> OnWrite();
                                        }
                                }
                                else
                                {
                                        LogError(NULL, "GetSocket/handler/2", (int)i, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
                                }
                                n--;
                        }
                        if (FD_ISSET(i, &efds))
                        {
                                socket_m::iterator itmp = m_sockets.find(i);
                                if (itmp != m_sockets.end()) // found
                                {
                                        Socket *p = itmp -> second;
                                        p -> OnException();
                                }
                                else
                                {
                                        LogError(NULL, "GetSocket/handler/3", (int)i, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
                                }
                                n--;
                        }
                } // m_fds loop
                m_preverror = -1;
        } // if (n > 0)

        // check CallOnConnect - EVENT
        if (m_fds_callonconnect.size())
        {
                socket_v tmp = m_fds_callonconnect;
                for (socket_v::iterator it = tmp.begin(); it != tmp.end(); it++)
                {
                        Socket *p = NULL;
                        {
                                socket_m::iterator itmp = m_sockets.find(*it);
                                if (itmp != m_sockets.end()) // found
                                {
                                        p = itmp -> second;
                                }
                                else
                                {
                                        LogError(NULL, "GetSocket/handler/4", (int)*it, "Did not find expected socket using file descriptor", LOG_LEVEL_WARNING);
                                }
                        }
                        if (p)
                        {
//                              if (p -> CallOnConnect() && p -> Ready() )
                                {
                                        p -> SetConnected(); // moved here from inside if (tcp) check below
#ifdef HAVE_OPENSSL
                                        if (p -> IsSSL()) // SSL Enabled socket
                                                p -> OnSSLConnect();
                                        else
#endif
#ifdef ENABLE_SOCKS4
                                        if (p -> Socks4())
                                                p -> OnSocks4Connect();
                                        else
#endif
                                        {
                                                TcpSocket *tcp = dynamic_cast<TcpSocket *>(p);
                                                if (tcp)
                                                {
                                                        if (tcp -> GetOutputLength())
                                                        {
                                                                p -> OnWrite();
                                                        }