CAsyncSocket Class Reference

#include <AsyncSocket.h>

Inheritance diagram for CAsyncSocket:

[legend]

Collaboration diagram for CAsyncSocket:

[legend]

List of all members.

Classes
class	CAsyncShutdown
Public Types
enum	_AsyncEvents { aeReceive = 1, aeSend = 2, aeOOB = 4, aeClose = 8 }
typedef enum CAsyncSocket::_AsyncEvents	AsyncEvents
typedef MapProc	LPMapProc
typedef BOOL(*	MapProc )()
Public Member Functions
void	DetachedSocketThread ()
void	DisableBlockingSend ()
BOOL	SetLocalThreadManager (CSocketThreadManagerImp *pManager)
CSocketThreadManagerImp *	GetThreadManager () const
CSocketThreadManager::TimerID	RegisterTimeout (int iMS, CSocketThreadManagerImp::LPTimeoutProc pProc, LPVOID pData, BOOL bClearTimeout=FALSE, CSocketThreadManagerImp::TimerID *pTimer=NULL)
BOOL	HasTimeout () const
void	DisableEvents (unsigned char ucEvents)
BOOL	IsDeleting () const
void	SetDeleting ()
BOOL	IsClosing () const
void	ForceReceiveEvent ()
virtual void	DeleteSocketFromThread ()
virtual void	DeleteSocketFromThread (DWORD dwTimeToWait)
virtual void	DeleteSocketFromThreadWait ()
void	AllowBlockedBuffer (BOOL bAllow)
virtual BOOL	ReAsync ()
virtual BOOL	ReBlock ()
void	FreezeThread ()
BOOL	DisableAsync ()
BOOL	KillTimer ()
BOOL	SetTimeout (int iMs)
	CAsyncSocket ()
virtual	~CAsyncSocket ()
Static Public Member Functions
static void	SetCleanTimeout (DWORD dwTimeout)
static CSocketThreadManagerImp *	CloneThreadManager (unsigned long ulThreads)
static void	SimpleMessageMap ()
static void	SimpleMessageMap (DWORD dwRunTimeMS)
static void	SimpleMessageMap (LPMapProc pProc, BOOL bStopWhenTRUE, DWORD dwSleep)
static char	SimpleMessageMapKey (DWORD dwSleep)
static void	Initialize ()
static void	Shutdown ()
static void	SetInstance (HINSTANCE hInst)
Protected Member Functions
virtual BOOL	OnSocketTimeout ()=0
virtual BOOL	OnSocketConnect (int iErrorCode)=0
virtual BOOL	OnSocketAccept (int iErrorCode)=0
virtual BOOL	OnSocketClose (int iErrorCode)=0
virtual BOOL	OnSocketOOB (int iErrorCode)=0
virtual BOOL	OnSocketWrite (int iErrorCode)=0
virtual BOOL	OnSocketReceive (int iErrorCode)=0
BOOL	IsBlocking () const
int	InternalWSAAsyncSelect (unsigned int wMsg, long lEvent)
void	SocketClosing ()
int	GetSocketID () const
HWND	GetWindowHandle () const
virtual SOCKET	GetAsyncHandle () const =0
virtual BOOL	SetAsync ()=0
void	RemoveSocketFromList ()
void	AddSocketToList ()
BOOL	IsTimeout () const
BOOL	Block ()
virtual BOOL	SendBlockedBuffer (const CBlockedBuffer::CBlockedData &rData)
CBlockedBuffer *	GetBlockedBuffer () const
virtual BOOL	SocketConnected (int iErrorCode, BOOL bNoEvent=FALSE)
virtual BOOL	SocketClosed (int iErrorCode, BOOL bNoEvent=FALSE)
virtual BOOL	SocketWrite (int iErrorCode)
virtual BOOL	SocketReceive (int iErrorCode, BOOL bNoEvent=FALSE)
virtual BOOL	SocketAccept (int iErrorCode, BOOL bNoEvent=FALSE)
virtual void	SystemTimeout ()
BOOL	SetSystemTimeout (int iMS)
BOOL	KillSystemTimer ()
BOOL	HasSystemTimer () const
virtual void	OnSocketDelete (CGenericEvent *pEvent=NULL)
virtual void	SocketCreated ()
virtual BOOL	ClearEvents ()
BOOL	IsBlockSend () const
BOOL	IsInThread () const
BOOL	WaitForBlockEvent () const
void	ResetEvent ()
int	GetLastError () const
virtual void	NotifyShutdown ()
void	RegisterShutdown (CSocketBase *pBase)
void	SetLastError (const std::string &rMethod) const
void	SetLastError (const std::string &, int iErrorCode) const
void	SetLocalLog (CErrorLog *pLog, bool bWriteToMain=false)
void	WriteError (const std::string &rClass, const std::string &rMethod, const std::string &rError) const
void	WriteMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage) const
void	WriteMessage (const std::string &rMethod, const std::string &rMessage) const
const std::string &	GetClassName () const
virtual void	ReportError (const std::string &rMethod) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, const std::string &rAdditionalData) const
virtual void	ReportError (const std::string &rMethod, int iErrorCode) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, int iErrorCode) const
virtual void	ReportErrorOS (const std::string &rMethod, const std::string &rMessage) const
void	SetName (const std::string &rName) const
Static Protected Member Functions
static CSocketThreadManagerImp *	GetSocketThreadManager ()
static int	GetErrorCode ()
static int	GetSystemLastError ()
static BOOL	IsInitialized ()
static unsigned long	StringToLong (const std::string &rAddress)
static char FAR *	LongToString (unsigned long ulAddr)
static std::string	LongToStdString (unsigned long ulAddr)
static BOOL	InitializeSockets (BOOL bMultiThreaded=TRUE, unsigned long ulNumberOfThreads=10)
static BOOL	ShutdownSockets ()
static unsigned long	GetNumberOfThreads ()
static BOOL	IsMultiThreaded ()
static CGenericCriticalSection *	GetGlobalCriticalSection ()
static unsigned long	ResolveDNS (const std::string &rAddress)
static BOOL	ValidAddress (const std::string &rAddress)
static CErrorHandler *	GetSecondaryLog ()
static CErrorHandler *	GetThirdLog ()
static void	ClearStaticLogs ()
static std::string	GetCurrentDateTime ()
static std::string	ErrorCodeToString (DWORD dwErrorCode)
static void	RegisterError (DWORD dwErrorCode, const std::string &rDescription)
static void	SetLog (CErrorLog *pLog)
static void	WriteStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rError)
static void	WriteStaticMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)
static std::string	FormatData (const std::string &rClass, const std::string &rMethod, const std::string &rMsgOrError, bool bError=true)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData)
static void	ReportStaticErrorOS (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)
Static Protected Attributes
static CGenericCriticalSection *	m_pCSection = NULL

---

Detailed Description

Definition at line 77 of file AsyncSocket.h.

---

Member Typedef Documentation

typedef enum CAsyncSocket::_AsyncEvents CAsyncSocket::AsyncEvents

typedef MapProc CAsyncSocket::LPMapProc

Definition at line 93 of file AsyncSocket.h.

typedef BOOL(* CAsyncSocket::MapProc)()

---

Member Enumeration Documentation

enum CAsyncSocket::_AsyncEvents

Enumerator:

aeReceive
aeSend
aeOOB
aeClose

Definition at line 83 of file AsyncSocket.h.

    {
        aeReceive=1,
        aeSend=2,
        aeOOB=4,
        aeClose=8
    } AsyncEvents;

---

Constructor & Destructor Documentation

CAsyncSocket::CAsyncSocket

(

)

Definition at line 101 of file AsyncSocket.cpp.

                           : CSocketBase(),
                               m_bList(FALSE),
                               m_bTimeout(FALSE),
                               m_pLocalThreadManager(NULL),
                               m_hLocalWindowHandle(0),
                               m_bFreeze(FALSE),
                               m_bBlocking(FALSE),
                               m_iMsg(0),
                               m_lEvent(0),
                               m_iSocketID(0),
                               m_pBlockedBuffer(NULL),
                               m_bClosing(FALSE),
                               m_ucEvents(0),
                               m_pSendEvent(NULL),
                               m_bBlockSend(TRUE),
                               m_pThread(NULL),
                               m_bDeleting(FALSE),
                               m_bDetached(FALSE)
{
    try
    {
        //Create the event
        m_pSendEvent=COSManager::CreateEvent();

        //Initialize all data
        Initialize();

        //We are created
        SocketCreated();
    }
    ERROR_HANDLER("CAsyncSocket")
}

CAsyncSocket::~CAsyncSocket

(

)

[virtual]

Definition at line 134 of file AsyncSocket.cpp.

{
    try
    {
        //Do we have any timers ?
        //Can't have
        if (m_aTimerID.iTimerID)
            GetThreadManager()->RemoveTimeout(m_aTimerID);

        if (m_aDeleteTimerID.iTimerID)
            GetThreadManager()->RemoveTimeout(m_aDeleteTimerID);

        //If we have a thread manager remove ourselves from it
        if (GetThreadManager())
            //Remove from the thread manager
            GetThreadManager()->DecreaseSocketCount(GetWindowHandle(),
                                                    m_bFreeze);

        //Are we a detached socket?
        if (m_bDetached)
            delete GetThreadManager();

        //Delete the blocked buffer
        delete m_pBlockedBuffer;

        //Delete the event
        delete m_pSendEvent;
    }
    ERROR_HANDLER("~CAsyncSocket")
}

---

Member Function Documentation

void CAsyncSocket::AddSocketToList

(

)

[protected]

Definition at line 233 of file AsyncSocket.cpp.

{
    try
    {
        //Allocate our window
        AllocateHandle();

        //We are in the list
        m_bList=TRUE;
    }
    ERROR_HANDLER("AddSocketToList")
}

void CAsyncSocket::AllowBlockedBuffer

(

BOOL

bAllow

)

Definition at line 681 of file AsyncSocket.cpp.

{
    try
    {
        //Do we have a buffer
        if (bAllow && 
            !m_pBlockedBuffer)
            m_pBlockedBuffer=new CBlockedBuffer(this);
        else if (!bAllow && 
                 m_pBlockedBuffer)
        {
            //Delete and reset the blocked buffer
            delete m_pBlockedBuffer;
            m_pBlockedBuffer=NULL;
        }
    }
    ERROR_HANDLER("AllowBlockedBuffer")
}

BOOL CAsyncSocket::Block

(

)

[protected]

Definition at line 634 of file AsyncSocket.cpp.

{
    try
    {
        //First disable the events
        int iResult;
        iResult=WSAAsyncSelect(GetAsyncHandle(),
                               GetWindowHandle(),
                               0,
                               0);

        if (iResult)
        {
            //Report it
            SetLastError("Block");

            //Exit
            return FALSE;
        }

        unsigned long ulBlocking;
        ulBlocking=0;

        //And return to non-blocking
        iResult=ioctlsocket(GetAsyncHandle(),
                            FIONBIO,
                            &ulBlocking);

        if (iResult)
        {
            //Report it
            SetLastError("Block");

            //Exit
            return FALSE;
        }

        return TRUE;
    }
    ERROR_HANDLER_RETURN("Block",FALSE)
}

BOOL CAsyncSocket::ClearEvents

(

)

[protected, virtual]

Definition at line 584 of file AsyncSocket.cpp.

{
    try
    {
        //Quit if not ok
        if (!CheckAsyncSocketValid())
            return FALSE;

        //Do it
        return !InternalWSAAsyncSelect(0,0);
    }
    ERROR_HANDLER_RETURN("ClearEvents",FALSE)
}

void CErrorHandler::ClearStaticLogs

(

)

[static, inherited]

Definition at line 680 of file ErrorHandler.cpp.

{
    //Delete the logs
    delete m_pSecondLevelLog;
    m_pSecondLevelLog=NULL;

    delete m_pThirdLevelLog;
    m_pThirdLevelLog=NULL;
}

CSocketThreadManagerImp * CAsyncSocket::CloneThreadManager

(

unsigned long

ulThreads

)

[static]

Definition at line 1269 of file AsyncSocket.cpp.

{
    try
    {
        //Do we have a thread manager?
        if (!m_pThreadManager ||
            !m_pThreadManager->IsInitialized())
        {
            //Report it
            ReportStaticError(CAsyncSocket_Class,"SetLocalThreadManager","Manager is either null or not initialized!");

            //Exit
            return NULL;
        }

        //Which thread count
        unsigned long ulThreadCount;
        if (!ulThreads)
            ulThreadCount=m_pThreadManager->GetNumberOfThreads();
        else
            ulThreadCount=ulThreads;

        //Clone it
        CSocketThreadManagerImp* pManager;
        pManager=new CSocketThreadManagerImp(m_hInstance);
        if (!pManager->Initialize(ulThreads))
        {
            //Report it
            ReportStaticError(CAsyncSocket_Class,"CloneThreadManager","Failed to initialize the thread manager!");

            //Delete it
            delete pManager;

            //Exit
            return NULL;
        }
        else
            return pManager;
    }
    ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"CloneThreadManager",NULL)
}

void CAsyncSocket::DeleteSocketFromThread

(

DWORD

dwTimeToWait

)

[virtual]

Definition at line 1100 of file AsyncSocket.cpp.

{
    try
    {
        if (!dwTimeToWait)
            DeleteSocketFromThread();
        else
        {
            //We are closing
            SocketClosing();

            //Are we valid ?
            //And do we have a window
            if (!m_bList)
                OnSocketDelete();
            else
            {
                //Create a timer
                m_aDeleteTimerID=GetThreadManager()->RegisterTimeout(dwTimeToWait,
                                                                     DeleteTimerProc,
                                                                     (LPVOID)this,
                                                                     TRUE,
                                                                     GetWindowHandle(),
                                                                     &m_aDeleteTimerID);

                //Do we have the timer ?
                if (!m_aDeleteTimerID.iTimerID)
                {
                    //Report it
                    ReportError("DeleteSocketFromThread","Failed to create timeout!");

                    //Run regular delete
                    DeleteSocketFromThread();
                }
            }
        }
    }
    ERROR_HANDLER("OnSocketDelete")
}

void CAsyncSocket::DeleteSocketFromThread

(

)

[virtual]

Definition at line 1080 of file AsyncSocket.cpp.

{
    try
    {
        //We are closing
        SocketClosing();

        //Are we valid ?
        //And do we have a window
        if (!m_bList)
            OnSocketDelete();
        else
            PostMessage(GetWindowHandle(),
                        WM_SOCKET_DELETE,
                        (WPARAM)GetAsyncHandle(),
                        0);
    }
    ERROR_HANDLER("OnSocketDelete")
}

void CAsyncSocket::DeleteSocketFromThreadWait

(

)

[virtual]

Definition at line 1140 of file AsyncSocket.cpp.

{
    try
    {
        //We are closing
        SocketClosing();

        //Are we valid ?
        //And do we have a window
        if (!m_bList)
            OnSocketDelete();
        else
        {
            //Create the event
            CGenericEvent* pEvent;
            pEvent=COSManager::CreateEvent();

            //Post the message
            PostMessage(GetWindowHandle(),
                        WM_SOCKET_DELETE,
                        (WPARAM)GetAsyncHandle(),
                        (LPARAM)pEvent);

            //Wait for the event
            if (pEvent->Wait(15000))
                //Report it
                ReportStaticError(CAsyncSocket_Class,"DeleteSocketFromThreadWait","Timeout waiting for event!");
            else
                delete pEvent;
        }
    }
    ERROR_HANDLER("OnSocketDelete")
}

void CAsyncSocket::DetachedSocketThread

(

)

Definition at line 165 of file AsyncSocket.cpp.

{
    try
    {
        //Create a new socket imp
        CSocketThreadManagerImp* pClone;
        pClone=CloneThreadManager(1);

        //Do we have it?
        if (!pClone)
            //Report it
            ReportError("DetachedSocketThread","Failed to create detach manager, will resume as normal!");
        else
        {
            //Set it as local
            if (!SetLocalThreadManager(pClone))
                ReportError("DetachedSocketThread","Failed to set manager!");
            else
                //Set we are detahced
                m_bDetached=TRUE;
        }
    }
    ERROR_HANDLER("DetachedSocketThread")
}

BOOL CAsyncSocket::DisableAsync

(

)

Definition at line 426 of file AsyncSocket.cpp.

{
    try
    {
        //Quit if not ok
        if (!CheckAsyncSocketValid())
            return FALSE;

        //Set event to read / write / close / oob
        int iResult;

        iResult=WSAAsyncSelect(GetAsyncHandle(),
                               GetWindowHandle(),
                               0,
                               0);
        if (iResult)
        {
            //Report it
            SetLastError("DisableAsync");

            //Exit
            return FALSE;
        }
        
        return TRUE;
    }
    ERROR_HANDLER_RETURN("DisableAsync",FALSE)
}

void CAsyncSocket::DisableBlockingSend

(

)

Definition at line 1343 of file AsyncSocket.cpp.

{
    m_bBlockSend=FALSE;
}

void CAsyncSocket::DisableEvents

(

unsigned char

ucEvents

)

Definition at line 1205 of file AsyncSocket.cpp.

{
    try
    {
        //Save the events
        m_ucEvents=ucEvents;
    }
    ERROR_HANDLER("DisableEvents")
}

std::string CErrorHandler::ErrorCodeToString

(

DWORD

dwErrorCode

)

[static, inherited]

Definition at line 251 of file ErrorHandler.cpp.

{
    try
    {
        //Try to look it in the errors
        if (!CErrorsRepository::GetInstance().GetErrorsMap().empty())
        {
            //Search
            CErrorsRepository::ErrorMap::const_iterator aIterator;
            aIterator=CErrorsRepository::GetInstance().GetErrorsMap().find(dwErrorCode);

            //Do we have it
            if (aIterator!=CErrorsRepository::GetInstance().GetErrorsMap().end())
                return aIterator->second;
        }

        //Get the error string
        LPVOID lpMsgBuf;
        FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | 
                      FORMAT_MESSAGE_FROM_SYSTEM | 
                      FORMAT_MESSAGE_IGNORE_INSERTS,
                      NULL,
                      dwErrorCode,
                      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                      (LPTSTR) &lpMsgBuf,
                      0,
                      NULL);

        //Save it
        std::string sMessage;

        //Do we have the message?
        if (lpMsgBuf)
        {
            //Save it
            sMessage=(char*)lpMsgBuf;
            
            //Release the buffer
            LocalFree(lpMsgBuf);
        }
        else
            //Failed to find
            sMessage="No error description found!";

        //Done
        return sMessage;
    }
    catch (...)
    {
        return "Unknown";
    }
}

void CAsyncSocket::ForceReceiveEvent

(

)

Definition at line 1063 of file AsyncSocket.cpp.

{
    try
    {
        //Are we valid ?
        //And do we have a window
        if (!m_bList)
            OnSocketDelete();
        else
            PostMessage(GetWindowHandle(),
                        WM_SOCKET_FORCED,
                        (WPARAM)GetAsyncHandle(),
                        0);
    }
    ERROR_HANDLER("ForceReceiveEvent")
}

std::string CErrorHandler::FormatData	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMsgOrError,
		bool	bError = true
	)			[static, inherited]

Definition at line 145 of file ErrorHandler.cpp.

{
    //Our message
    std::string sMsg;

    //Is it an error?
    if (bError)
        sMsg="*** Error *** ";
    else
        sMsg="###  Msg  ### ";

    //Add the data now
    sMsg+="in "+rClass;
    sMsg+="::"+rMethod;
    sMsg+=" - " + rMsgOrError;

    //Done
    return sMsg;
}

void CAsyncSocket::FreezeThread

(

)

Definition at line 512 of file AsyncSocket.cpp.

{
    m_bFreeze=TRUE;
}

virtual SOCKET CAsyncSocket::GetAsyncHandle

(

)

const [protected, pure virtual]

Implemented in CTCPSocketAsync, and CUDPSocketAsync.

CBlockedBuffer * CAsyncSocket::GetBlockedBuffer

(

)

const [protected]

Definition at line 700 of file AsyncSocket.cpp.

{
    return m_pBlockedBuffer;
}

const std::string & CErrorHandler::GetClassName

(

)

const [protected, inherited]

Reimplemented in CSocketThreadManager.

Definition at line 617 of file ErrorHandler.cpp.

{
    return m_sClassName;
}

std::string CErrorHandler::GetCurrentDateTime

(

)

[static, inherited]

Definition at line 622 of file ErrorHandler.cpp.

{
    try
    {
        //Our string
        std::string sDate;

        //Our tmp buf
        char cTmp[128];

        //Get date
        _strdate(cTmp);
        sDate=cTmp;
        sDate+=' ';

        //Get time
        _strtime(cTmp);
        sDate+=cTmp;

        //Done
        return sDate;
    }
    ERROR_HANDLER_STATIC_RETURN(CErrorHandler_Class,"GetCurrentDateTime","")
}

int CSocketBase::GetErrorCode

(

)

[static, inherited]

Definition at line 368 of file SocketBase.cpp.

{
    return SOCKET_ERROR;
}

CGenericCriticalSection * CSocketBase::GetGlobalCriticalSection

(

)

[static, inherited]

Definition at line 363 of file SocketBase.cpp.

{
    return m_pCSection;
}

int CSocketBase::GetLastError

(

)

const [inherited]

Definition at line 141 of file SocketBase.cpp.

{
    return m_iLastError;
}

unsigned long CSocketBase::GetNumberOfThreads

(

)

[static, inherited]

Definition at line 334 of file SocketBase.cpp.

{
    return m_ulNumberOfThreads;
}

CErrorHandler * CErrorHandler::GetSecondaryLog

(

)

[static, inherited]

Definition at line 658 of file ErrorHandler.cpp.

{
    //Do we have log
    if (!m_pSecondLevelLog)
        //Create it
        m_pSecondLevelLog=new CErrorHandler;

    //Return it
    return m_pSecondLevelLog;
}

int CAsyncSocket::GetSocketID

(

)

const [protected]

Definition at line 246 of file AsyncSocket.cpp.

{
    return m_iSocketID;
}

CSocketThreadManagerImp * CAsyncSocket::GetSocketThreadManager

(

)

[static, protected]

Definition at line 711 of file AsyncSocket.cpp.

{
    return m_pThreadManager;
}

int CSocketBase::GetSystemLastError

(

)

[static, inherited]

Definition at line 358 of file SocketBase.cpp.

{
    return WSAGetLastError();
}

CErrorHandler * CErrorHandler::GetThirdLog

(

)

[static, inherited]

Definition at line 669 of file ErrorHandler.cpp.

{
    //Do we have log
    if (!m_pThirdLevelLog)
        //Create it
        m_pThirdLevelLog=new CErrorHandler;

    //Return it
    return m_pThirdLevelLog;
}

CSocketThreadManagerImp * CAsyncSocket::GetThreadManager

(

)

const

Definition at line 393 of file AsyncSocket.cpp.

{
    if (!m_pLocalThreadManager)
        return m_pThreadManager;
    else
        return m_pLocalThreadManager;
}

HWND CAsyncSocket::GetWindowHandle

(

)

const [protected]

Definition at line 256 of file AsyncSocket.cpp.

{
    //Check if we are multithreaded ?
    return m_hLocalWindowHandle;
}

BOOL CAsyncSocket::HasSystemTimer

(

)

const [protected]

Definition at line 1044 of file AsyncSocket.cpp.

{
    return m_aTimerID.iTimerID!=0;
}

BOOL CAsyncSocket::HasTimeout

(

)

const

Definition at line 1215 of file AsyncSocket.cpp.

{
    return m_bTimeout;
}

void CAsyncSocket::Initialize

(

)

[static]

Definition at line 361 of file AsyncSocket.cpp.

{
    try
    {
        //Initialize all data
        if (!m_bInitialized && 
            CSocketBase::IsInitialized())
        {
            //Create the CS
            m_pCSection=COSManager::CreateCriticalSection();

            //Create handlers
            if (!SetHandlers())
            {
                //Report it
                ReportStaticError(CAsyncSocket_Class,"CAsyncSocket","Failed to init handlers!");

                //Exit
                return;
            }

            //Create a new socket to do the shutdown
            CAsyncShutdown* pShutdown;
            pShutdown=new CAsyncShutdown;

            //The class registers itself
            m_bInitialized=TRUE;
        }
    }
    ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Initialize")
}

BOOL CSocketBase::InitializeSockets	(	BOOL	bMultiThreaded = TRUE,
		unsigned long	ulNumberOfThreads = 10
	)			[static, inherited]

Definition at line 146 of file SocketBase.cpp.

{
    //To avoid double initialize
    if (m_bInitialized)
    {
        //Report it
        ReportStaticError(CSocketBase_Class,"InitializeSockets","Already initialized!");

        //Exit
        return TRUE;
    }

    //Check that the number of threads are OK?
    if (ulNumberOfThreads>CLibConfig::GetInstance().GetMaxThreads())
    {
        //Report it
        ReportStaticError(CSocketBase_Class,"InitializeSockets","Too many threads!");

        //Exit
        return FALSE;
    }

    //Do we have threads at all
    if (bMultiThreaded &&
        !ulNumberOfThreads)
    {
        //Report it
        ReportStaticError(CSocketBase_Class,"InitializeSockets","Didn't receive any threads!");

        //Exit
        return FALSE;
    }

    try
    {
        //Initialize the sockets
        WORD wVersionRequested;
        wVersionRequested=MAKEWORD(2,2);
 
        //Try to initialize
        WSADATA wsaData;
        int iErr;
        iErr=WSAStartup(wVersionRequested, 
                        &wsaData);

        //Did we succeed?
        if (iErr!=0)
            /* Tell the user that we could not find a usable */
            /* WinSock DLL.                                  */
            return FALSE;
 
        /* Confirm that the WinSock DLL supports 2.2.*/
        /* Note that if the DLL supports versions greater    */
        /* than 2.2 in addition to 2.2, it will still return */
        /* 2.2 in wVersion since that is the version we      */
        /* requested.                                        */
 
        if (LOBYTE(wsaData.wVersion)!=2 || 
            HIBYTE(wsaData.wVersion)!=2)
        {
            /* Tell the user that we could not find a usable */
            /* WinSock DLL.                                  */
            WSACleanup();

            //Exit
            return FALSE;
        }

        //Save the threading information
        m_bMultiThreaded=bMultiThreaded;
        m_ulNumberOfThreads=ulNumberOfThreads;

        //Create the critical section
        m_pCSection=COSManager::CreateCriticalSection();
        m_pCSectionDNS=COSManager::CreateCriticalSection();

        //And we are initialized
        m_bInitialized=TRUE;

        return TRUE;
    }
    ERROR_HANDLER_STATIC_RETURN(CSocketBase_Class,"InitializeSockets",FALSE)
}

int CAsyncSocket::InternalWSAAsyncSelect	(	unsigned int	wMsg,
		long	lEvent
	)			[protected]

Definition at line 538 of file AsyncSocket.cpp.

{
    try
    {
        //Cache the values
        m_iMsg=wMsg;
        m_lEvent=lEvent;

        //Message pairs
        typedef struct _MsgPair
        {
            unsigned int    uiMsg;
            AsyncEvents     aEvents;
        } MsgPair;

        //Our max events
        static const int iMaxEvents=4;

        //Our events data
        static const MsgPair aMsgPair[iMaxEvents]={{FD_READ,aeReceive},
                                                   {FD_WRITE,aeSend},
                                                   {FD_OOB,aeOOB},
                                                   {FD_CLOSE,aeClose}};

        //Check if the messages are allowed
        for (int iCounter=0;
             iCounter<iMaxEvents;
             ++iCounter)
            if ((m_lEvent & aMsgPair[iCounter].uiMsg) &&
                (m_ucEvents & ((unsigned char)aMsgPair[iCounter].aEvents)))
                //Remove it
                m_lEvent^=aMsgPair[iCounter].uiMsg;

        if (m_bBlocking)
            return 0;
        else
            //And call the async select
            return WSAAsyncSelect(GetAsyncHandle(),
                                  GetWindowHandle(),
                                  wMsg,
                                  lEvent);
    }
    ERROR_HANDLER_RETURN("InternalWSAAsyncSelect",GetErrorCode())
}

BOOL CAsyncSocket::IsBlocking

(

)

const [protected]

Definition at line 676 of file AsyncSocket.cpp.

{
    return m_bBlocking;
}

BOOL CAsyncSocket::IsBlockSend

(

)

const [protected]

Definition at line 1311 of file AsyncSocket.cpp.

{
    return m_bBlockSend;
}

BOOL CAsyncSocket::IsClosing

(

)

const

Definition at line 1200 of file AsyncSocket.cpp.

{
    return m_bClosing;
}

BOOL CAsyncSocket::IsDeleting

(

)

const

Definition at line 1348 of file AsyncSocket.cpp.

{
    return m_bDeleting;
}

BOOL CSocketBase::IsInitialized

(

)

[static, inherited]

Definition at line 339 of file SocketBase.cpp.

{
    return m_bInitialized;
}

BOOL CAsyncSocket::IsInThread

(

)

const [protected]

Definition at line 1316 of file AsyncSocket.cpp.

{
    try
    {
        //Do we have the thread?
        if (m_pThread)
            return m_pThread->IsInThread();
        else
            return FALSE;
    }
    ERROR_HANDLER_RETURN("IsInThread",FALSE)
}

BOOL CSocketBase::IsMultiThreaded

(

)

[static, inherited]

Definition at line 329 of file SocketBase.cpp.

{
    return m_bMultiThreaded;
}

BOOL CAsyncSocket::IsTimeout

(

)

const [protected]

Definition at line 356 of file AsyncSocket.cpp.

{
    return m_bTimeout;
}

BOOL CAsyncSocket::KillSystemTimer

(

)

[protected]

Definition at line 993 of file AsyncSocket.cpp.

{
    try
    {
        //Only if we have one
        if (!m_aTimerID.iTimerID)
            return TRUE;

        return GetThreadManager()->RemoveTimeout(m_aTimerID);
    }
    ERROR_HANDLER_RETURN("KillSystemTimer",FALSE)
}

BOOL CAsyncSocket::KillTimer

(

)

Definition at line 303 of file AsyncSocket.cpp.

{
    try
    {
        //Get the handle
        HWND hWindowHandle;
        hWindowHandle=GetWindowHandle();

        if (!hWindowHandle || 
            !m_bTimeout)
            return FALSE;

        //No timer in any case
        m_bTimeout=FALSE;

        //Try to kill the timer
        BOOL bResult;
        bResult=::KillTimer(hWindowHandle,
                            GetAsyncHandle());

        if (!bResult)
            //Fire an error
            ReportError("KillTimer");

        return bResult;
    }
    ERROR_HANDLER_RETURN("KillTimer",FALSE)
}

std::string CSocketBase::LongToStdString

(

unsigned long

ulAddr

)

[static, inherited]

Definition at line 291 of file SocketBase.cpp.

{
    try
    {
        //First create the address
        in_addr addr;

        //Assign it
        addr.S_un.S_addr=ulAddr;

        //Enter the critical section
        CCriticalAutoRelease aRelease(m_pCSection);

        //Return the value
        return inet_ntoa(addr);
    }
    ERROR_HANDLER_STATIC_RETURN(CSocketBase_Class,"LongToStdString","0.0.0.0")
}

char FAR * CSocketBase::LongToString

(

unsigned long

ulAddr

)

[static, inherited]

Definition at line 310 of file SocketBase.cpp.

{
    try
    {
        //First create the address
        in_addr addr;

        //Assign it
        addr.S_un.S_addr=ulAddr;

        //Enter the critical section
        CCriticalAutoRelease aRelease(m_pCSection);

        //Return the value
        return inet_ntoa(addr);
    }
    ERROR_HANDLER_STATIC_RETURN(CSocketBase_Class,"LongToString",NULL)
}

void CSocketBase::NotifyShutdown

(

)

[protected, virtual, inherited]

Definition at line 273 of file SocketBase.cpp.

{
}

virtual BOOL CAsyncSocket::OnSocketAccept

(

int

iErrorCode

)

[protected, pure virtual]

virtual BOOL CAsyncSocket::OnSocketClose

(

int

iErrorCode

)

[protected, pure virtual]

Implemented in CSocketPoolSocket.

virtual BOOL CAsyncSocket::OnSocketConnect

(

int

iErrorCode

)

[protected, pure virtual]

Implemented in CSocketPoolSocket, and CUDPSocketAsync.

void CAsyncSocket::OnSocketDelete

(

CGenericEvent *

pEvent = NULL

)

[protected, virtual]

Definition at line 1049 of file AsyncSocket.cpp.

{
    try
    {
        //Delete ourselves
        delete this;

        //Do we have an event?
        if (pEvent)
            pEvent->Set();
    }
    ERROR_HANDLER_STATIC(CAsyncSocket_Class,"OnSocketDelete")
}

virtual BOOL CAsyncSocket::OnSocketOOB

(

int

iErrorCode

)

[protected, pure virtual]

virtual BOOL CAsyncSocket::OnSocketReceive

(

int

iErrorCode

)

[protected, pure virtual]

virtual BOOL CAsyncSocket::OnSocketTimeout

(

)

[protected, pure virtual]

virtual BOOL CAsyncSocket::OnSocketWrite

(

int

iErrorCode

)

[protected, pure virtual]

BOOL CAsyncSocket::ReAsync

(

)

[virtual]

Definition at line 598 of file AsyncSocket.cpp.

{
    if (!m_bBlocking)
        return TRUE;

    try
    {
        //Quit if not ok
        if (!CheckAsyncSocketValid())
            return FALSE;

        //First disable the events
        int iResult;
        iResult=WSAAsyncSelect(GetAsyncHandle(),
                               GetWindowHandle(),
                               m_iMsg,
                               m_lEvent);

        if (iResult)
        {
            //Report it
            SetLastError("ReAsync");

            //Exit
            return FALSE;
        }

        //Set to async
        m_bBlocking=FALSE;

        //And quit
        return TRUE;
    }
    ERROR_HANDLER_RETURN("ReAsync",FALSE)
}

BOOL CAsyncSocket::ReBlock

(

)

[virtual]

Definition at line 517 of file AsyncSocket.cpp.

{
    if (m_bBlocking)
        return TRUE;

    try
    {
        //Quit if not ok
        if (!CheckAsyncSocketValid())
            return FALSE;

        if (Block())
            //Set to reblock
            m_bBlocking=TRUE;

        //And quit
        return TRUE;
    }
    ERROR_HANDLER_RETURN("ReBlock",FALSE)
}

void CErrorHandler::RegisterError	(	DWORD	dwErrorCode,
		const std::string &	rDescription
	)			[static, inherited]

Definition at line 647 of file ErrorHandler.cpp.

{
    try
    {
        //Add the error
        CErrorsRepository::GetInstance().GetErrorsMap().insert(CErrorsRepository::ErrorMap::value_type(dwErrorCode,rDescription));
    }
    ERROR_HANDLER_STATIC(CErrorHandler_Class,"RegisterError")
}

void CSocketBase::RegisterShutdown

(

CSocketBase *

pBase

)

[protected, inherited]

Definition at line 277 of file SocketBase.cpp.

{
    try
    {
        //Check if we already have a class
        if (m_pShutdownClass)
            delete m_pShutdownClass;

        //Take it
        m_pShutdownClass=pBase;
    }
    ERROR_HANDLER("RegisterShutdown")
}

CSocketThreadManagerImp::TimerID CAsyncSocket::RegisterTimeout	(	int	iMS,
		CSocketThreadManagerImp::LPTimeoutProc	pProc,
		LPVOID	pData,
		BOOL	bClearTimeout = FALSE,
		CSocketThreadManagerImp::TimerID *	pTimer = NULL
	)

Definition at line 1220 of file AsyncSocket.cpp.

{
    //Delegate the call
    return GetThreadManager()->RegisterTimeout(iMS,
                                               pProc,
                                               pData,
                                               bClearTimeout,
                                               GetWindowHandle(),
                                               pTimer);
}

void CAsyncSocket::RemoveSocketFromList

(

)

[protected]

Definition at line 262 of file AsyncSocket.cpp.

{
    try
    {
        if (m_bList)
        {
            //Remove from thread manager
            GetThreadManager()->RemoveSocket(this);

            //Not in list
            m_bList=FALSE;

            //Deallocate the handle
            DeAllocateHandle();
        }
    }
    ERROR_HANDLER("RemoveSocketFromList")
}

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage,
		int	iErrorCode
	)			const [protected, virtual, inherited]

Definition at line 304 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Convert the error code
        char aTmp[11];
        sprintf(aTmp,"%d",iErrorCode);

        //Get the string for it
        std::string sError;
        sError=rMessage;
        sError+=", and Socket error: ";
        sError+=aTmp;
        sError+=", ";
        sError+=ErrorCodeToString(iErrorCode);

        //Report to the log
        WriteError(m_sClassName,
                   rMethod,
                   sError);
    }
    ERROR_UNKNOWN("ReportError")
}

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		int	iErrorCode
	)			const [protected, virtual, inherited]

Definition at line 333 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Convert the error code
        char aTmp[11];
        sprintf(aTmp,"%d",iErrorCode);

        //Get the string for it
        std::string sError;
        sError="Socket error: ";
        sError+=aTmp;
        sError+=", ";
        sError+=ErrorCodeToString(iErrorCode);

        //Report to the log
        WriteError(m_sClassName,
                   rMethod,
                   sError);
    }
    ERROR_UNKNOWN("ReportError")
}

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage,
		const std::string &	rAdditionalData
	)			const [protected, virtual, inherited]

Definition at line 461 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Create the new message
        std::string sNewMessage(rMessage);
        sNewMessage+=", Additional data: ";
        sNewMessage+=rAdditionalData;

        //Report to the log
        WriteError(m_sClassName,
                   rMethod,
                   sNewMessage);
    }
    ERROR_UNKNOWN("ReportError")
}

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData
	)			const [protected, virtual, inherited]

Definition at line 483 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Convert the number
        char aTmp[11];
        ltoa(dwAdditionalData,aTmp,10);

        //Create the new message
        std::string sNewMessage(rMessage);
        sNewMessage+=", Additional data: ";
        sNewMessage+=aTmp;

        //Report to the log
        WriteError(m_sClassName,
                   rMethod,
                   sNewMessage);
    }
    ERROR_UNKNOWN("ReportError")
}

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage
	)			const [protected, virtual, inherited]

Definition at line 376 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Report to the log
        WriteError(m_sClassName,
                   rMethod,
                   rMessage);
    }
    ERROR_UNKNOWN("ReportError")
}

void CErrorHandler::ReportError

(

const std::string &

rMethod

)

const [protected, virtual, inherited]

Definition at line 515 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Get the last error
        DWORD dwLastError;
        dwLastError=GetLastError();

        //Report the error
        WriteError(m_sClassName,
                   rMethod,
                   ErrorCodeToString(dwLastError));
    }
    ERROR_UNKNOWN("ReportError")
}

void CErrorHandler::ReportErrorOS	(	const std::string &	rMethod,
		const std::string &	rMessage
	)			const [protected, virtual, inherited]

Definition at line 427 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Get the last error
        DWORD dwLastError;
        dwLastError=GetLastError();

        //Format the message
        std::string sMessage;
        sMessage=rMessage;
        sMessage+=", with error code: ";

        //Convert the error code
        char aTmp[11];
        itoa(dwLastError,aTmp,10);

        //Add it again
        sMessage+=aTmp;
        sMessage+=" ";
        sMessage+=ErrorCodeToString(dwLastError);

        //Report to the log
        WriteError(m_sClassName,
                   rMethod,
                   sMessage);
    }
    ERROR_UNKNOWN("ReportErrorOS")
}

void CErrorHandler::ReportStaticError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData
	)			[static, protected, inherited]

Definition at line 590 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

    try
    {
        //Convert the number
        char aTmp[11];
        ltoa(dwAdditionalData,aTmp,10);

        //Create the new message
        std::string sNewMessage(rMessage);
        sNewMessage+=", Additional data: ";
        sNewMessage+=aTmp;

        //Report to the log
        WriteStaticError(rClass,
                         rMethod,
                         sNewMessage);
    }
    ERROR_UNKNOWN("ReportStaticError")
}

void CErrorHandler::ReportStaticError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage
	)			[static, protected, inherited]

Definition at line 573 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

    try
    {
        //Report to the log
        WriteStaticError(rClass,
                         rMethod,
                         rMessage);
    }
    ERROR_UNKNOWN("ReportStaticError")
}

void CErrorHandler::ReportStaticError	(	const std::string &	rClass,
		const std::string &	rMethod
	)			[static, protected, inherited]

Definition at line 553 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

    try
    {
        //Get the last error
        DWORD dwLastError;
        dwLastError=GetLastError();

        //Report the error
        WriteStaticError(rClass,
                          rMethod,
                          ErrorCodeToString(dwLastError));
    }
    ERROR_UNKNOWN("ReportStaticError")
}

void CErrorHandler::ReportStaticErrorOS	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage
	)			[static, protected, inherited]

Definition at line 392 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

    try
    {
        //Get the last error
        DWORD dwLastError;
        dwLastError=GetLastError();

        //Format the message
        std::string sMessage;
        sMessage=rMessage;
        sMessage+=", with error code: ";

        //Convert the error code
        char aTmp[11];
        itoa(dwLastError,aTmp,10);

        //Add it again
        sMessage+=aTmp;
        sMessage+=" ";
        sMessage+=ErrorCodeToString(dwLastError);
        
        //Report to the log
        WriteStaticError(rClass,
                         rMethod,
                         sMessage);
    }
    ERROR_UNKNOWN("ReportStaticError")
}

void CAsyncSocket::ResetEvent

(

)

[protected]

Definition at line 1338 of file AsyncSocket.cpp.

{
    m_pSendEvent->Reset();
}

unsigned long CSocketBase::ResolveDNS

(

const std::string &

rAddress

)

[static, inherited]

Definition at line 431 of file SocketBase.cpp.

{
    try
    {
        //Resolve the DNS
        sockaddr_in aAddr;
        aAddr=InternalResolveDNS(rAddress.c_str());

        //Check if valid
        if (aAddr.sin_addr.S_un.S_addr==0)
            //Error
            return 0;
        else
            return aAddr.sin_addr.S_un.S_addr;
    }
    ERROR_HANDLER_STATIC_RETURN(CSocketBase_Class,"ResolveDNS",0)
}

BOOL CAsyncSocket::SendBlockedBuffer

(

const CBlockedBuffer::CBlockedData &

rData

)

[protected, virtual]

Reimplemented in CTCPSocketAsync.

Definition at line 705 of file AsyncSocket.cpp.

{
    //No implemented at this level
    return FALSE;
}

virtual BOOL CAsyncSocket::SetAsync

(

)

[protected, pure virtual]

Implemented in CTCPSocketAsync, and CUDPSocketAsync.

void CAsyncSocket::SetCleanTimeout

(

DWORD

dwTimeout

)

[static]

Definition at line 1358 of file AsyncSocket.cpp.

{
    //Change the thread manager
    if (m_pThreadManager)
        m_pThreadManager->SetCleanTimeout(dwTimeout);
}

void CAsyncSocket::SetDeleting

(

)

Definition at line 1353 of file AsyncSocket.cpp.

{
    m_bDeleting=TRUE;
}

void CAsyncSocket::SetInstance

(

HINSTANCE

hInst

)

[static]

Definition at line 251 of file AsyncSocket.cpp.

{
    m_hInstance=hInst;
}

void CSocketBase::SetLastError	(	const std::string &	rMethod,
		int	iErrorCode
	)			const [protected, inherited]

Definition at line 124 of file SocketBase.cpp.

{
    try
    {
        //First set the error
        m_iLastError=iErrorCode;

        //Check if there is an error
        if (m_iLastError)
            ReportError(rMethod,
                        "Through SetLastError",
                        m_iLastError);
    }
    ERROR_HANDLER("SetLastError")
}

void CSocketBase::SetLastError

(

const std::string &

rMethod

)

const [protected, inherited]

Definition at line 104 of file SocketBase.cpp.

{
    try
    {
#ifdef WIN32
        //First set the error
        m_iLastError=WSAGetLastError();
#else
        m_iLastError=errno();
#endif

        //Check if there is an error
        if (m_iLastError)
            ReportError(rMethod,
                        "Through SetLastError",
                        m_iLastError);
    }
    ERROR_HANDLER("SetLastError")
}

void CErrorHandler::SetLocalLog	(	CErrorLog *	pLog,
		bool	bWriteToMain = false
	)			[inherited]

Definition at line 543 of file ErrorHandler.cpp.

{
    //Save the log
    m_pLocalLog=pLog;

    //Save the write to main flag
    m_bWriteToMain=bWriteToMain;
}

BOOL CAsyncSocket::SetLocalThreadManager

(

CSocketThreadManagerImp *

pManager

)

Definition at line 1235 of file AsyncSocket.cpp.

{
    try
    {
        //We can do it only if we are not created
        if (GetAsyncHandle()!=INVALID_SOCKET)
        {
            //Report it
            ReportError("SetLocalThreadManager","Can't switch after socket is created!");

            //Exit
            return FALSE;
        }

        //Is it a legal manager
        if (!pManager ||
            !pManager->IsInitialized())
        {
            //Report it
            ReportError("SetLocalThreadManager","Manager is either null or not initialized!");

            //Exit
            return FALSE;
        }

        //Save the new manager
        m_pLocalThreadManager=pManager;

        //Done
        return TRUE;
    }
    ERROR_HANDLER_RETURN("SetLocalThreadManager",FALSE)
}

void CErrorHandler::SetLog

(

CErrorLog *

pLog

)

[static, inherited]

Definition at line 509 of file ErrorHandler.cpp.

{
    //Save the new log
    m_pLog=pLog;
}

void CErrorHandler::SetName

(

const std::string &

rName

)

const [protected, inherited]

Definition at line 139 of file ErrorHandler.cpp.

{
    //Save the class name
    m_sClassName=rName;
}

BOOL CAsyncSocket::SetSystemTimeout

(

int

iMS

)

[protected]

Definition at line 956 of file AsyncSocket.cpp.

{
    try
    {
        //Do we have a timeout
        if (m_aTimerID.iTimerID)
        {
            //Report it
            ReportError("SetSystemTimeout","Please kill previous timer!");

            //Exit
            return FALSE;
        }

        //Create the timer
        m_aTimerID=GetThreadManager()->RegisterTimeout(iMS,
                                                       SystemTimerProc,
                                                       this,
                                                       TRUE,
                                                       GetWindowHandle(),
                                                       &m_aTimerID);

        //Do we have it
        if (!m_aTimerID.iTimerID)
        {
            //Report it
            ReportError("SetSystemTimeout","Failed creating the timer!");

            //Exit
            return FALSE;
        }
        else
            return TRUE;
    }
    ERROR_HANDLER_RETURN("SetSystemTimeout",FALSE)
}

BOOL CAsyncSocket::SetTimeout

(

int

iMs

)

Definition at line 281 of file AsyncSocket.cpp.

{
    try
    {
        //Get the window handle
        HWND hWindowHandle;
        hWindowHandle=GetWindowHandle();

        if (!hWindowHandle)
            return FALSE;

        //Set the timer
        m_bTimeout=SetTimer(hWindowHandle,
                            GetAsyncHandle(),
                            iMs,
                            NULL);

        return m_bTimeout;
    }
    ERROR_HANDLER_RETURN("SetTimeout",FALSE)
}

void CAsyncSocket::Shutdown

(

)

[static]

Definition at line 332 of file AsyncSocket.cpp.

{
    try
    {
        //Only if initialized
        if (!m_bInitialized)
            return;

        //Indicate we're shutting down
        m_bShuttingDown=TRUE;

        //Delete the thread manager
        if (m_pThreadManager)
        {
            delete m_pThreadManager;
            m_pThreadManager=NULL;
        }

        //Not initialized anymore
        m_bInitialized=FALSE;
    }
    ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Shutdown")
}

BOOL CSocketBase::ShutdownSockets

(

)

[static, inherited]

Definition at line 231 of file SocketBase.cpp.

{
    //Only if initialized
    if (!m_bInitialized)
        return TRUE;

    try
    {
        //Delete the CS
        delete m_pCSection;
        m_pCSection=NULL;

        //Delete the DNS CS
        delete m_pCSectionDNS;
        m_pCSectionDNS=NULL;

        //Clear the DNS map
        m_aDNSMap.clear();

        //Notify shutdown class
        if (m_pShutdownClass)
        {
            //Notify we are shuting down
            m_pShutdownClass->NotifyShutdown();

            //Delete it
            delete m_pShutdownClass;
            m_pShutdownClass=NULL;
        }

        //Not initialized anymore
        m_bInitialized=FALSE;

        if (WSACleanup()==GetErrorCode())
            return FALSE;

        //Done
        return TRUE;
    }
    ERROR_HANDLER_STATIC_RETURN(CSocketBase_Class,"ShutdownSockets",FALSE)
}

void CAsyncSocket::SimpleMessageMap	(	LPMapProc	pProc,
		BOOL	bStopWhenTRUE,
		DWORD	dwSleep
	)			[static]

Definition at line 866 of file AsyncSocket.cpp.

{
    try
    {
        //Check if we have the proc
        if (!pProc)
        {
            //Report it
            ReportStaticError(CAsyncSocket_Class,"SimpleMessageMap","Recieved null proc!");

            //Exit
            return;
        }

        //If there is no message map, then receive won't work
        MSG msg;

        //Set the message map to zeros
        memset(&msg,
               0,
               sizeof(msg));

        //Stop flag
        BOOL bStop;
        bStop=FALSE;

        //Start the loop
        while (!bStop &&
               (*pProc)()!=bStopWhenTRUE)
        {
            while (!(bStop=(*pProc)()==bStopWhenTRUE) &&
                   PeekMessage(&msg, 
                               NULL, 
                               0, 
                               0, 
                               PM_REMOVE))
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg); 
            }

            //Do we need to sleep?
            if (!bStop)
                //No messages
                Sleep(dwSleep);
        }
    }
    ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SimpleMessageMap")
}

void CAsyncSocket::SimpleMessageMap

(

DWORD

dwRunTimeMS

)

[static]

Definition at line 830 of file AsyncSocket.cpp.

{
    try
    {
        //If there is no message map, then receive won't work
        MSG msg;

        //Set the message map to zeros
        memset(&msg,
               0,
               sizeof(msg));

        //Start loop
        DWORD dwLoopStart;
        dwLoopStart=GetTickCount();

        //Until a key was hit
        while (GetTickCount()-dwLoopStart<dwRunTimeMS)
        {
            while (PeekMessage(&msg, 
                               NULL, 
                               0, 
                               0, 
                               PM_REMOVE))
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg); 
            }

            //Sleep so wont be hanged
            Sleep(1);
        }
    }
    ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SimpleMessageMap")
}

void CAsyncSocket::SimpleMessageMap

(

)

[static]

Definition at line 805 of file AsyncSocket.cpp.

{
    try
    {
        //If there is no message map, then receive won't work
        MSG msg;

        //Set the message map to zeros
        memset(&msg,
               0,
               sizeof(msg));

        while (GetMessage(&msg,
                          NULL,
                          0,
                          0))
        {
            //Dispatch the message
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SimpleMessageMap")
}

char CAsyncSocket::SimpleMessageMapKey

(

DWORD

dwSleep

)

[static]

Definition at line 918 of file AsyncSocket.cpp.

{
    try
    {
        //If there is no message map, then receive won't work
        MSG msg;

        //Set the message map to zeros
        memset(&msg,
               0,
               sizeof(msg));

        //Until a key was hit
        while (!kbhit())
        {
            while (!kbhit() &&
                   PeekMessage(&msg, 
                               NULL, 
                               0, 
                               0, 
                               PM_REMOVE))
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg); 
            }

            //Do we need to sleep
            if (!kbhit())
                //Sleep so wont be hanged
                Sleep(dwSleep);
        }
        
        //Return the char
        return getch();
    }
    ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"SimpleMessageMapKey",0)
}

BOOL CAsyncSocket::SocketAccept	(	int	iErrorCode,
		BOOL	bNoEvent = FALSE
	)			[protected, virtual]

Definition at line 758 of file AsyncSocket.cpp.

{
    try
    {
        //Do we need to call event?
        if (!bNoEvent)
            return OnSocketAccept(iErrorCode);
        else
            return FALSE;
    }
    ERROR_HANDLER_RETURN("SocketConnected",FALSE)
}

BOOL CAsyncSocket::SocketClosed	(	int	iErrorCode,
		BOOL	bNoEvent = FALSE
	)			[protected, virtual]

Reimplemented in CTCPSocketAsync.

Definition at line 772 of file AsyncSocket.cpp.

{
    try
    {
        //Kill the timer
        CAsyncSocket::SocketClosing();

        //Remove from socket list
        RemoveSocketFromList();

        //Call user data
        if (!bNoEvent)
            return OnSocketClose(iErrorCode);
        else
            return TRUE;
    }
    ERROR_HANDLER_RETURN("SocketClosed",FALSE)
}

void CAsyncSocket::SocketClosing

(

)

[protected]

Definition at line 475 of file AsyncSocket.cpp.

{
    try
    {
        //Are we valid
        if (m_bClosing ||
            GetAsyncHandle()==INVALID_SOCKET)
            return;

        //Indicate we are closing
        m_bClosing=TRUE;

        //Signal the event
        m_pSendEvent->Set();

        //Do we have a regular timer
        if (m_bTimeout)
            KillTimer();

        //Do we have a system timer ?
        if (m_aTimerID.iTimerID)
            KillSystemTimer();

        //Kill all the messages
        m_iMsg=0;
        m_lEvent=0;

        //Set it
        if (WSAAsyncSelect(GetAsyncHandle(),
                           GetWindowHandle(),
                           0,
                           0))
            SetLastError("SocketClosing");
    }
    ERROR_HANDLER("SocketClosing")
}

BOOL CAsyncSocket::SocketConnected	(	int	iErrorCode,
		BOOL	bNoEvent = FALSE
	)			[protected, virtual]

Reimplemented in CTCPSocketAsyncSSL, and CTCPSocketAsync.

Definition at line 716 of file AsyncSocket.cpp.

{
    try
    {
        //Did we have an error
        if (iErrorCode)
            if (!bNoEvent)
                return OnSocketConnect(iErrorCode);
            else
                return FALSE;

        //Save the connect value
        BOOL bConnectValue;
        if (!bNoEvent)
            bConnectValue=OnSocketConnect(0);
        else
            bConnectValue=TRUE;

        //Try to set it to async
        if (!SetAsync())
            return FALSE;
        else
            return bConnectValue;
    }
    ERROR_HANDLER_RETURN("SocketConnected",FALSE)
}

void CAsyncSocket::SocketCreated

(

)

[protected, virtual]

Definition at line 1174 of file AsyncSocket.cpp.

{
    try
    {
        //No timer
        memset(&m_aTimerID,
               0,
               sizeof(m_aTimerID));

        //No delete timer
        memset(&m_aDeleteTimerID,
               0,
               sizeof(m_aDeleteTimerID));

        //Set values for new socket
        m_iSocketID=0;
        m_bBlocking=FALSE;
        m_bFreeze=FALSE;
        m_lEvent=0;
        m_hLocalWindowHandle=0;
        m_bList=FALSE;
        m_bClosing=FALSE;
    }
    ERROR_HANDLER("SocketCreated")
}

BOOL CAsyncSocket::SocketReceive	(	int	iErrorCode,
		BOOL	bNoEvent = FALSE
	)			[protected, virtual]

Reimplemented in CTCPSocketAsyncSSL, and CTCPSocketAsync.

Definition at line 744 of file AsyncSocket.cpp.

{
    try
    {
        //Do we need to call event?
        if (!bNoEvent)
            return OnSocketReceive(iErrorCode);
        else
            return FALSE;
    }
    ERROR_HANDLER_RETURN("SocketConnected",FALSE)
}

BOOL CAsyncSocket::SocketWrite

(

int

iErrorCode

)

[protected, virtual]

Reimplemented in CTCPSocketAsyncSSL, and CTCPSocketAsync.

Definition at line 792 of file AsyncSocket.cpp.

{
    try
    {
        //Notify the event
        m_pSendEvent->Set();

        //Call user data
        return OnSocketWrite(iErrorCode);
    }
    ERROR_HANDLER_RETURN("SocketWrite",FALSE)
}

unsigned long CSocketBase::StringToLong

(

const std::string &

rAddress

)

[static, inherited]

Definition at line 344 of file SocketBase.cpp.

{
    //Try to convert it
    unsigned long ulAddress;
    ulAddress=inet_addr(rAddress.c_str());

    //Is it valid
    if (ulAddress!=INADDR_NONE)
        return ulAddress;
    else
        //Try to resolve it
        return ResolveDNS(rAddress);
}

void CAsyncSocket::SystemTimeout

(

)

[protected, virtual]

Definition at line 1006 of file AsyncSocket.cpp.

{
    //Nothing to do
}

BOOL CSocketBase::ValidAddress

(

const std::string &

rAddress

)

[static, inherited]

Definition at line 373 of file SocketBase.cpp.

{
    try
    {
        return inet_addr(rAddress.c_str())!=INADDR_NONE;
    }
    ERROR_HANDLER_STATIC_RETURN(CSocketBase_Class,"ValidAddress",FALSE)
}

BOOL CAsyncSocket::WaitForBlockEvent

(

)

const [protected]

Definition at line 1329 of file AsyncSocket.cpp.

{
    //Wait for the event
    if (m_pSendEvent->Wait(5000))
        return TRUE;
    else
        return IsClosing();
}

void CErrorHandler::WriteError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rError
	)			const [inherited]

Definition at line 168 of file ErrorHandler.cpp.

{
    //Do we have a log?
    if (!GetLog())
        return;

    //Format the msg
    std::string sError;
    sError=FormatData(rClass,
                      rMethod,
                      rError);

    //Write it
    GetLog()->WriteError(sError);

    //Write to main
    if (m_bWriteToMain &&
        m_pLog)
        //Write it
        m_pLog->WriteError(sError);
}

void CErrorHandler::WriteMessage	(	const std::string &	rMethod,
		const std::string &	rMessage
	)			const [protected, inherited]

Definition at line 360 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Report to the log
        WriteMessage(m_sClassName,
                     rMethod,
                     rMessage);
    }
    ERROR_UNKNOWN("WriteMessage")
}

void CErrorHandler::WriteMessage	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage
	)			const [inherited]

Definition at line 226 of file ErrorHandler.cpp.

{
    //Do we have a log?
    if (!GetLog())
        return;

    //Format the msg
    std::string sMsg;
    sMsg=FormatData(rClass,
                    rMethod,
                    rMessage,
                    false);

    //Write it
    GetLog()->WriteMessage(sMsg);

    //Write to main
    if (m_bWriteToMain &&
        m_pLog)
        //Write it
        m_pLog->WriteMessage(sMsg);
}

void CErrorHandler::WriteStaticError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rError
	)			[static, inherited]

Definition at line 192 of file ErrorHandler.cpp.

{
    //Do we have a log?
    if (!m_pLog)
        return;

    //Format the msg
    std::string sError;
    sError=FormatData(rClass,
                      rMethod,
                      rError);

    //Write it
    m_pLog->WriteError(sError);
}

void CErrorHandler::WriteStaticMessage	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage
	)			[static, inherited]

Definition at line 210 of file ErrorHandler.cpp.

{
    //Do we have a log?
    if (!m_pLog)
        return;

    //Format the msg
    std::string sMsg;
    sMsg=FormatData(rClass,
                    rMethod,
                    rMessage,
                    false);
}

---

Member Data Documentation

CGenericCriticalSection * CSocketBase::m_pCSection = NULL [static, protected, inherited]

Definition at line 122 of file SocketBase.h.

---

The documentation for this class was generated from the following files:

• AsyncSocket.h
• AsyncSocket.cpp