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
BOOL	HasTimeout () const
void	DisableEvents (unsigned char ucEvents)
BOOL	IsClosing () const
void	ForceReceiveEvent ()
virtual void	DeleteSocketFromThread ()
virtual void	DeleteSocketFromThread (DWORD dwTimeToWait)
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	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 Types
enum	_LogPriority { lpDebug, lpMessage, lpCritical, lpError }
typedef enum CErrorHandler::_LogPriority	LogPriority
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)
virtual BOOL	SocketClosed (int iErrorCode)
virtual BOOL	SocketWrite (int iErrorCode)
virtual void	SystemTimeout ()
BOOL	SetSystemTimeout (int iMS)
BOOL	KillSystemTimer ()
BOOL	HasSystemTimer () const
virtual void	OnSocketDelete ()
virtual void	SocketCreated ()
int	GetSystemLastError () const
int	GetLastError () const
virtual void	NotifyShutdown ()
void	RegisterShutdown (CSpoofBase *pBase)
void	SetLastError (const std::string &rMethod) const
void	SetLastError (const std::string &, int iErrorCode) const
void	SetLocalLog (CErrorLog *pLog)
const std::string &	GetClassName () const
void	WriteMessage (const std::string &rMethod, const std::string &rMessage, LogPriority aPriority=lpMessage)
void	WriteMessage (const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData, LogPriority aPriority=lpMessage)
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, 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 CSocketThreadManager *	GetSocketThreadManager ()
static int	GetErrorCode ()
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	InitializeSocketsNoMap (BOOL bMultiThreaded=TRUE, unsigned long ulNumberOfThreads=10)
static BOOL	ShutdownSockets ()
static unsigned long	GetNumberOfThreads ()
static BOOL	IsMultiThreaded ()
static CGenericCriticalSection *	GetGlobalCriticalSection ()
static std::string	GetCurrentDateTime ()
static std::string	ErrorCodeToString (DWORD dwErrorCode)
static void	SetLog (CErrorLog *pLog)
static void	WriteStaticMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, LogPriority aPriority=lpMessage)
static void	WriteStaticMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData, LogPriority aPriority=lpMessage)
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)

---

Detailed Description

Definition at line 78 of file AsyncSocket.h.

---

Member Typedef Documentation

typedef enum CAsyncSocket::_AsyncEvents CAsyncSocket::AsyncEvents

typedef enum CErrorHandler::_LogPriority CErrorHandler::LogPriority [inherited]

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;

enum CErrorHandler::_LogPriority [inherited]

Enumerator:

lpDebug
lpMessage
lpCritical
lpError

Definition at line 53 of file ErrorHandler.h.

    {
        lpDebug,
        lpMessage,
        lpCritical,
        lpError
    } LogPriority;

---

Constructor & Destructor Documentation

CAsyncSocket::CAsyncSocket

(

)

Definition at line 78 of file AsyncSocket.cpp.

                           : CSpoofBase(),
                               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)
{
    try
    {
        //Initialize all data
        Initialize();

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

CAsyncSocket::~CAsyncSocket

(

)

[virtual]

Definition at line 103 of file AsyncSocket.cpp.

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

        if (m_aDeleteTimerID.iTimerID)
            m_pThreadManager->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);

        //Delete the blocked buffer
        delete m_pBlockedBuffer;
    }
    ERROR_HANDLER("~CAsyncSocket")
}

---

Member Function Documentation

void CAsyncSocket::AddSocketToList

(

)

[protected]

Definition at line 184 of file AsyncSocket.cpp.

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

        //Do we have a CS
        if (m_pCSection)
        {
            //Enter the CS
            CCriticalAutoRelease aRelease(m_pCSection);

            //Add socket to list
            m_iSocketID=GetAsyncHandle();
            m_aSocketMap.insert(SocketMap::value_type(m_iSocketID,this));

            //Added to list
            m_bList=TRUE;
        }
        else
            ReportError("AddSocketToList","Critical section not initialized");
    }
    ERROR_HANDLER("AddSocketToList")
}

void CAsyncSocket::AllowBlockedBuffer

(

BOOL

bAllow

)

Definition at line 865 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 818 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)
}

void CAsyncSocket::DeleteSocketFromThread

(

DWORD

dwTimeToWait

)

[virtual]

Definition at line 1232 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=m_pThreadManager->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 1212 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")
}

BOOL CAsyncSocket::DisableAsync

(

)

Definition at line 630 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::DisableEvents

(

unsigned char

ucEvents

)

Definition at line 1303 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 122 of file ErrorHandler.cpp.

{
    try
    {
        //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;
        sMessage+=(char*)lpMsgBuf;
        
        //Release the buffer
        LocalFree(lpMsgBuf);

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

void CAsyncSocket::ForceReceiveEvent

(

)

Definition at line 1195 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")
}

void CAsyncSocket::FreezeThread

(

)

Definition at line 713 of file AsyncSocket.cpp.

{
    m_bFreeze=TRUE;
}

virtual SOCKET CAsyncSocket::GetAsyncHandle

(

)

const [protected, pure virtual]

Implemented in CICMPSocketAsync, CSniffSocket, CTCPSocketAsync, and CUDPSocketAsync.

CBlockedBuffer * CAsyncSocket::GetBlockedBuffer

(

)

const [protected]

Definition at line 884 of file AsyncSocket.cpp.

{
    return m_pBlockedBuffer;
}

const std::string & CErrorHandler::GetClassName

(

)

const [protected, inherited]

Reimplemented in CSocketThreadManager.

Definition at line 516 of file ErrorHandler.cpp.

{
    return m_sClassName;
}

std::string CErrorHandler::GetCurrentDateTime

(

)

[static, inherited]

Definition at line 521 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 CSpoofBase::GetErrorCode

(

)

[static, inherited]

Definition at line 488 of file SpoofBase.cpp.

{
    return SOCKET_ERROR;
}

CGenericCriticalSection * CSpoofBase::GetGlobalCriticalSection

(

)

[static, inherited]

Definition at line 483 of file SpoofBase.cpp.

{
    return m_pCSection;
}

int CSpoofBase::GetLastError

(

)

const [inherited]

Definition at line 138 of file SpoofBase.cpp.

{
    return m_iLastError;
}

unsigned long CSpoofBase::GetNumberOfThreads

(

)

[static, inherited]

Definition at line 463 of file SpoofBase.cpp.

{
    return m_ulNumberOfThreads;
}

int CAsyncSocket::GetSocketID

(

)

const [protected]

Definition at line 210 of file AsyncSocket.cpp.

{
    return m_iSocketID;
}

CSocketThreadManager * CAsyncSocket::GetSocketThreadManager

(

)

[static, protected]

Definition at line 895 of file AsyncSocket.cpp.

{
    return m_pThreadManager;
}

int CSpoofBase::GetSystemLastError

(

)

const [inherited]

Definition at line 478 of file SpoofBase.cpp.

{
    return WSAGetLastError();
}

HWND CAsyncSocket::GetWindowHandle

(

)

const [protected]

Definition at line 297 of file AsyncSocket.cpp.

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

BOOL CAsyncSocket::HasSystemTimer

(

)

const [protected]

Definition at line 1180 of file AsyncSocket.cpp.

{
    return m_aTimerID.iTimerID!=0;
}

BOOL CAsyncSocket::HasTimeout

(

)

const

Definition at line 1313 of file AsyncSocket.cpp.

{
    return m_bTimeout;
}

void CAsyncSocket::Initialize

(

)

[static]

Definition at line 485 of file AsyncSocket.cpp.

{
    try
    {
        //Initialize all data
        if (!m_bInitialized && 
            CSpoofBase::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 CSpoofBase::InitializeSockets	(	BOOL	bMultiThreaded = TRUE,
		unsigned long	ulNumberOfThreads = 10
	)			[static, inherited]

Definition at line 279 of file SpoofBase.cpp.

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

        //Exit
        return TRUE;
    }

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

        //Exit
        return FALSE;
    }

    //Do we have threads at all
    if (bMultiThreaded &&
        !ulNumberOfThreads)
    {
        //Report it
        ReportStaticError(CSpoofBase_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();

        //And we are initialized
        m_bInitialized=TRUE;

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

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

Definition at line 202 of file SpoofBase.cpp.

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

        //Exit
        return TRUE;
    }

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

        //Exit
        return FALSE;
    }

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

        //Exit
        return FALSE;
    }

    try
    {
        //Create the thread data
        ThreadData* pThreadData;
        pThreadData=new ThreadData;

        //Populate the data
        pThreadData->pEvent=COSManager::CreateEvent();
        pThreadData->bMultiThreaded=bMultiThreaded;
        pThreadData->ulNumberOfThreads=ulNumberOfThreads;

        //Create the thread
        m_pThread=new CManagedThread(InitProc);
        m_pThread->Start((LPVOID)pThreadData);

        //Wait on the event
        if (pThreadData->pEvent->Wait(THREAD_TIMEOUT))
        {
            //Report it
            ReportStaticError(CSpoofBase_Class,"InitializeSocketsNoMap","Timeout waiting for thread");

            //Delete the thread
            delete m_pThread;
            m_pThread=NULL;

            //Exit
            return FALSE;
        }

        //Are we initialized
        if (!IsInitialized())
        {
            //Delete the thread
            delete m_pThread;
            m_pThread=NULL;
        }

        //Done
        return IsInitialized();
    }
    ERROR_HANDLER_STATIC_RETURN(CSpoofBase_Class,"InitializeSocketsNoMap",FALSE)
}

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

Definition at line 739 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 860 of file AsyncSocket.cpp.

{
    return m_bBlocking;
}

BOOL CAsyncSocket::IsClosing

(

)

const

Definition at line 1298 of file AsyncSocket.cpp.

{
    return m_bClosing;
}

BOOL CSpoofBase::IsInitialized

(

)

[static, inherited]

Definition at line 468 of file SpoofBase.cpp.

{
    return m_bInitialized;
}

BOOL CSpoofBase::IsMultiThreaded

(

)

[static, inherited]

Definition at line 458 of file SpoofBase.cpp.

{
    return m_bMultiThreaded;
}

BOOL CAsyncSocket::IsTimeout

(

)

const [protected]

Reimplemented in CPingSocket.

Definition at line 480 of file AsyncSocket.cpp.

{
    return m_bTimeout;
}

BOOL CAsyncSocket::KillSystemTimer

(

)

[protected]

Definition at line 1129 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 344 of file AsyncSocket.cpp.

{
    try
    {
        HWND hWindowHandle;
        hWindowHandle=GetWindowHandle();

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

        //No timer in any case
        m_bTimeout=FALSE;

        BOOL bResult;
        bResult=::KillTimer(hWindowHandle,
                            GetAsyncHandle());

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

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

std::string CSpoofBase::LongToStdString

(

unsigned long

ulAddr

)

[static, inherited]

Definition at line 420 of file SpoofBase.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(CSpoofBase_Class,"LongToStdString","0.0.0.0")
}

char FAR * CSpoofBase::LongToString

(

unsigned long

ulAddr

)

[static, inherited]

Definition at line 439 of file SpoofBase.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(CSpoofBase_Class,"LongToString",NULL)
}

void CSpoofBase::NotifyShutdown

(

)

[protected, virtual, inherited]

Definition at line 402 of file SpoofBase.cpp.

{
}

virtual BOOL CAsyncSocket::OnSocketAccept

(

int

iErrorCode

)

[protected, pure virtual]

virtual BOOL CAsyncSocket::OnSocketClose

(

int

iErrorCode

)

[protected, pure virtual]

Implemented in CSocketPoolSocket, CWhoisSocket, and KomodiaDNS::CDNSTCPSocket.

virtual BOOL CAsyncSocket::OnSocketConnect

(

int

iErrorCode

)

[protected, pure virtual]

Implemented in CSocketPoolSocket, CUDPSocketAsync, CWhoisSocket, and KomodiaDNS::CDNSTCPSocket.

void CAsyncSocket::OnSocketDelete

(

)

[protected, virtual]

Definition at line 1185 of file AsyncSocket.cpp.

{
    try
    {
        //Delete ourselves
        delete this;
    }
    ERROR_HANDLER_STATIC(CAsyncSocket_Class,"OnSocketDelete")
}

virtual BOOL CAsyncSocket::OnSocketOOB

(

int

iErrorCode

)

[protected, pure virtual]

virtual BOOL CAsyncSocket::OnSocketReceive

(

int

iErrorCode

)

[protected, pure virtual]

Implemented in CICMPSocketAsync, CPingSocket, CWhoisSocket, KomodiaDNS::CDNSTCPSocket, and KomodiaDNS::CDNSUDPSocket.

virtual BOOL CAsyncSocket::OnSocketTimeout

(

)

[protected, pure virtual]

Implemented in CPingSocket, CRealTimeTraceRouteSocket, and CWhoisSocket.

virtual BOOL CAsyncSocket::OnSocketWrite

(

int

iErrorCode

)

[protected, pure virtual]

BOOL CAsyncSocket::ReAsync

(

)

[virtual]

Definition at line 782 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 718 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 CSpoofBase::RegisterShutdown

(

CSpoofBase *

pBase

)

[protected, inherited]

Definition at line 406 of file SpoofBase.cpp.

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

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

void CAsyncSocket::RemoveSocketFromList

(

)

[protected]

Definition at line 303 of file AsyncSocket.cpp.

{
    try
    {
        if (m_bList)
            if (m_pCSection)
            {
                //Enter the CS
                CCriticalAutoRelease aRelease(m_pCSection);

                //Erase it
                m_aSocketMap.erase(GetSocketID());
            }
            else
                ReportError("RemoveSocketFromList","Critical section not initialized");
    }
    ERROR_HANDLER("RemoveSocketFromList")
}

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

Definition at line 154 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Get the log
        CErrorLog* pLog;
        pLog=GetLog();

        //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
        pLog->ReportError(m_sClassName,
                          rMethod,
                          sError);
    }
    ERROR_UNKNOWN("ReportError")
}

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

Definition at line 187 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Get the log
        CErrorLog* pLog;
        pLog=GetLog();

        //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
        pLog->ReportError(m_sClassName,
                          rMethod,
                          sError);
    }
    ERROR_UNKNOWN("ReportError")
}

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

Definition at line 275 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Get the log
        CErrorLog* pLog;
        pLog=GetLog();

        //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
        pLog->ReportError(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 218 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        CErrorLog* pLog;
        pLog=GetLog();

        //Report to the log
        pLog->ReportError(m_sClassName,
                          rMethod,
                          rMessage);
    }
    ERROR_UNKNOWN("ReportError")
}

void CErrorHandler::ReportError

(

const std::string &

rMethod

)

const [protected, virtual, inherited]

Definition at line 311 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

        //Report the error
        GetLog()->ReportError(m_sClassName,
                              rMethod,
                              ErrorCodeToString(dwLastError));

#else
        GetLog()->ReportCatchError(m_sClassName,
                                   rMethod,
                                   "Unknown error!");
#endif
    }
    ERROR_UNKNOWN("ReportError")
}

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

Definition at line 237 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);
        
        //Get the log
        CErrorLog* pLog;
        pLog=GetLog();

        //Report to the log
        pLog->ReportError(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 489 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
        m_pLog->ReportError(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 472 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

    try
    {
        //Report to the log
        m_pLog->ReportError(rClass,
                            rMethod,
                            rMessage);
    }
    ERROR_UNKNOWN("ReportStaticError")
}

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

Definition at line 446 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

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

        //Report the error
        m_pLog->ReportError(rClass,
                            rMethod,
                            ErrorCodeToString(dwLastError));
#else
        m_pLog->ReportError(rClass,
                            rMethod,
                            "Unknown error!");
#endif
    }
    ERROR_UNKNOWN("ReportStaticError")
}

BOOL CAsyncSocket::SendBlockedBuffer

(

const CBlockedBuffer::CBlockedData &

rData

)

[protected, virtual]

Reimplemented in CTCPSocketAsync.

Definition at line 889 of file AsyncSocket.cpp.

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

virtual BOOL CAsyncSocket::SetAsync

(

)

[protected, pure virtual]

Implemented in CICMPSocketAsync, CSniffSocket, CTCPSocketAsync, and CUDPSocketAsync.

void CAsyncSocket::SetInstance

(

HINSTANCE

hInst

)

[static]

Definition at line 275 of file AsyncSocket.cpp.

{
    m_hInstance=hInst;
}

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

Definition at line 122 of file SpoofBase.cpp.

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

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

void CSpoofBase::SetLastError

(

const std::string &

rMethod

)

const [protected, inherited]

Definition at line 103 of file SpoofBase.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,
                        m_iLastError);
    }
    ERROR_HANDLER("SetLastError")
}

void CErrorHandler::SetLocalLog

(

CErrorLog *

pLog

)

[inherited]

Definition at line 441 of file ErrorHandler.cpp.

{
    m_pLocalLog=pLog;
}

void CErrorHandler::SetLog

(

CErrorLog *

pLog

)

[static, inherited]

Definition at line 305 of file ErrorHandler.cpp.

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

void CErrorHandler::SetName

(

const std::string &

rName

)

const [protected, inherited]

Definition at line 116 of file ErrorHandler.cpp.

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

BOOL CAsyncSocket::SetSystemTimeout

(

int

iMS

)

[protected]

Definition at line 1092 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 322 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 371 of file AsyncSocket.cpp.

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

        if (!m_pCSection)
        {
            //Report it
            ReportStaticError(CAsyncSocket_Class,"Shutdown","Critical section not initialized");

            //Exit
            return;
        }

        //Enter the CS
        CCriticalAutoRelease aRelease(m_pCSection);

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

        //Our vector of sockets
        typedef std::vector<CAsyncSocket*> SocketVector;
        SocketVector aVector;

        //Clear the map
        SocketMap::iterator aIterator;
        aIterator=m_aSocketMap.begin();

        //While not end of the map
        while (aIterator!=m_aSocketMap.end())
        {
            //Add the socket
            aVector.push_back(aIterator->second);

            //Next data
            ++aIterator;
        }

        //Exit the CS
        aRelease.Exit();

        //Iterate the vector
        while (!aVector.empty())
        {
            //Get the socket
            CAsyncSocket* pSocket;
            pSocket=aVector.back();

            //Remove the socket
            aVector.pop_back();

            //Try to delete it
            try
            {
                delete pSocket;
            }
            ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Shutdown - Deletion")
        }

        //Wait for clean up
        Sleep(1000);

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

        //Remove the handlers
        RemoveHandlers();

        //Delete the CS
        delete m_pCSection;
        m_pCSection=NULL;
    }
    ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Shutdown")
}

BOOL CSpoofBase::ShutdownSockets

(

)

[static, inherited]

Definition at line 363 of file SpoofBase.cpp.

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

    try
    {
        //Do we have a thread?
        if (m_pThread)
        {
            //Delete it
            delete m_pThread;
            m_pThread=NULL;
        }

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

        //Notify shutdown class
        if (m_pShutdownClass)
        {
            m_pShutdownClass->NotifyShutdown();
            delete m_pShutdownClass;
        }

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

        //Not initialized anymore
        m_bInitialized=FALSE;

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

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

Definition at line 1002 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 966 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 941 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 1054 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::SocketClosed

(

int

iErrorCode

)

[protected, virtual]

Definition at line 921 of file AsyncSocket.cpp.

{
    try
    {
        //Call user data
        return OnSocketClose(iErrorCode);
    }
    ERROR_HANDLER_RETURN("SocketClosed",FALSE)
}

void CAsyncSocket::SocketClosing

(

)

[protected]

Definition at line 679 of file AsyncSocket.cpp.

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

        //Indicate we are closing
        m_bClosing=TRUE;

        //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

)

[protected, virtual]

Definition at line 900 of file AsyncSocket.cpp.

{
    try
    {
        //Did we have an error
        if (iErrorCode)
            return OnSocketConnect(iErrorCode);

        //Save the connect value
        BOOL bConnectValue;
        bConnectValue=OnSocketConnect(0);

        //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 1272 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::SocketWrite

(

int

iErrorCode

)

[protected, virtual]

Definition at line 931 of file AsyncSocket.cpp.

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

unsigned long CSpoofBase::StringToLong

(

const std::string &

rAddress

)

[static, inherited]

Definition at line 473 of file SpoofBase.cpp.

{
    return inet_addr(rAddress.c_str());
}

void CAsyncSocket::SystemTimeout

(

)

[protected, virtual]

Definition at line 1142 of file AsyncSocket.cpp.

{
    //Nothing to do
}

void CErrorHandler::WriteMessage	(	const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData,
		LogPriority	aPriority = lpMessage
	)			[protected, inherited]

Definition at line 355 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;

        //Delegate the call
        GetLog()->WriteMessage(m_sClassName,
                               rMethod,
                               sNewMessage,
                               aPriority);
    }
    ERROR_UNKNOWN("WriteMessage")
}

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

Definition at line 337 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Delegate the call
        GetLog()->WriteMessage(m_sClassName,
                               rMethod,
                               rMessage,
                               aPriority);
    }
    ERROR_UNKNOWN("WriteMessage")
}

void CErrorHandler::WriteStaticMessage	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData,
		LogPriority	aPriority = lpMessage
	)			[static, protected, inherited]

Definition at line 403 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;

        //Delegate the call
        m_pLog->WriteMessage(rClass,
                             rMethod,
                             sNewMessage,
                             aPriority);
    }
    ERROR_UNKNOWN("WriteStaticMessage")
}

void CErrorHandler::WriteStaticMessage	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage,
		LogPriority	aPriority = lpMessage
	)			[static, protected, inherited]

Definition at line 383 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

    try
    {
        //Delegate the call
        m_pLog->WriteMessage(rClass,
                             rMethod,
                             rMessage,
                             aPriority);
    }
    ERROR_UNKNOWN("WriteStaticMessage")
}

---

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

• AsyncSocket.h
• AsyncSocket.cpp