CTCPOptions Class Reference

#include <TCPSocket.h>

Inheritance diagram for CTCPOptions:

[legend]

Collaboration diagram for CTCPOptions:

[legend]

List of all members.

Public Member Functions
void	AddOption_SegmentSize (unsigned short usMax)
void	Reset ()
void	SetAutoPad (BOOL bAutoPAD)
virtual void	AddOption_ENDLIST ()
int	GetBufferLength () const
const char *	GetBuffer () const
virtual void	AddOption_Nothing ()
	CTCPOptions ()
	CTCPOptions (const CTCPOptions &rOptions)
virtual	~CTCPOptions ()
Protected Types
typedef unsigned char	OptionType
typedef struct CIPOptions::_IPOption	IPOption
typedef struct CIPOptions::_Routing	Routing
enum	_LogPriority { lpDebug, lpMessage, lpCritical, lpError }
typedef enum CErrorHandler::_LogPriority	LogPriority
Protected Member Functions
void	AddOption_Route (OptionType aRouteType, Routing aRoute)
void	AddToBuffer (const char *pBuffer, int iBufLength)
OptionType	GetOption (unsigned char ucCopyFlag, unsigned char ucClassFlag, unsigned char ucTypeFlag)
void	AddOption_Timestamp (OptionType tFlags, int iMaxStamps)
void	AddOption_LooseRoute (Routing tRoute)
void	AddOption_RecordRoute (int iMaxRoutes)
void	AddOption_StrictRoute (Routing tRoute)
void	AddOption_Stream (unsigned short usStreamID)
virtual void	AddOption_Security (unsigned short usType)
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 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)
Static Protected Attributes
static CGenericCriticalSection *	m_pCSection = NULL

---

Detailed Description

Definition at line 88 of file TCPSocket.h.

---

Member Typedef Documentation

typedef struct CIPOptions::_IPOption CIPOptions::IPOption [inherited]

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

typedef unsigned char CIPOptions::OptionType [inherited]

Definition at line 359 of file SpoofSocket.h.

typedef struct CIPOptions::_Routing CIPOptions::Routing [inherited]

---

Member Enumeration Documentation

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

CTCPOptions::CTCPOptions

(

)

Definition at line 124 of file TCPSocket.cpp.

                         : CIPOptions()
{
    try
    {
        SetName(CTCPOptions_LOGNAME);
    }
    ERROR_HANDLER("CTCPOptions")
}

CTCPOptions::CTCPOptions

(

const CTCPOptions &

rOptions

)

Definition at line 133 of file TCPSocket.cpp.

                                                    : CIPOptions(rOptions)
{
    try
    {
        SetName(CTCPOptions_LOGNAME);
    }
    ERROR_HANDLER("CTCPOptions")
}

CTCPOptions::~CTCPOptions

(

)

[virtual]

Definition at line 142 of file TCPSocket.cpp.

{
}

---

Member Function Documentation

void CTCPOptions::AddOption_ENDLIST

(

)

[virtual]

Reimplemented from CIPOptions.

Definition at line 74 of file TCPSocket.cpp.

{
    try
    {
        //Add option end list
        OptionType aOptionType;

        //Get the option
        aOptionType=TCPOptions_END;

        //Add it to buffer
        AddToBuffer((char*)&aOptionType,sizeof(aOptionType));
    }
    ERROR_HANDLER("AddOption_ENDLIST")
}

void CIPOptions::AddOption_LooseRoute

(

Routing

tRoute

)

[inherited]

Definition at line 377 of file SpoofSocket.cpp.

{
    try
    {
        AddOption_Route(IPOption_LOOSE_ROUTING,tRoute);
    }
    ERROR_HANDLER("AddOption_LooseRoute")
}

void CTCPOptions::AddOption_Nothing

(

)

[virtual]

Reimplemented from CIPOptions.

Definition at line 108 of file TCPSocket.cpp.

{
    try
    {
        //Add option do nothing
        OptionType aOptionType;

        //Get the option
        aOptionType=TCPOptions_NO_OPERATION;

        //Add it to buffer
        AddToBuffer((char*)&aOptionType,sizeof(aOptionType));
    }
    ERROR_HANDLER("AddOption_Nothing")
}

void CIPOptions::AddOption_RecordRoute

(

int

iMaxRoutes

)

[inherited]

Definition at line 308 of file SpoofSocket.cpp.

{
    try
    {
        //Option for strict routine
        //Add option strict route
        OptionType aOptionType;

        //Get the option
        aOptionType=GetOption(IPOption_DONT_COPY,
                              IPOption_CONTROL,
                              IPOption_RECORD_ROUTE);

        //Add it to buffer
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));

        //Add the length
        aOptionType=iMaxRoutes*4+IPOption_STRICT_ROUTING_LENGTH;
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));
        
        //Add the pointer
        aOptionType=IPOption_STRICT_ROUTING_POINTER;
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));
        
        char cNothing[IPOption_SIZE]="";
        AddToBuffer(cNothing,
                    iMaxRoutes*4);
    }
    ERROR_HANDLER("AddOption_RecordRoute")
}

void CIPOptions::AddOption_Route	(	OptionType	aRouteType,
		Routing	aRoute
	)			[protected, inherited]

Definition at line 342 of file SpoofSocket.cpp.

{
    try
    {
        //Option for strict routine
        //Add option strict route
        OptionType aOptionType;

        //Get the option
        aOptionType=GetOption(IPOption_COPY,
                              IPOption_CONTROL,
                              aRouteType);

        //Add it to buffer
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));

        //Add the length
        aOptionType=aRoute.iRoutes*4+IPOption_STRICT_ROUTING_LENGTH;
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));
        
        //Add the pointer
        aOptionType=IPOption_STRICT_ROUTING_POINTER;
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));
        
        //Add the routing table
        AddToBuffer((char*)aRoute.ulRoutes,
                    aRoute.iRoutes*4);
    }
    ERROR_HANDLER("AddOption_Route")
}

void CIPOptions::AddOption_Security

(

unsigned short

usType

)

[virtual, inherited]

Definition at line 216 of file SpoofSocket.cpp.

{
    try
    {
        //Add option security
        OptionType aOptionType;

        //Get the option
        aOptionType=GetOption(IPOption_COPY,
                              IPOption_CONTROL,
                              IPOption_SECURITY);

        //Add it to buffer
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));

        //Add length
        aOptionType=IPOption_SECURITY_LENGTH;
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));

        //Add options
        AddToBuffer((char*)&usType,
                    sizeof(usType));

        //Add zeros
        unsigned short usZeros;
        usZeros=0;
        unsigned char ucZeros;
        ucZeros=0;

        //A hacker would enumarate these values, according to the RFC
        //Compartments
        AddToBuffer((char*)&usZeros,
                    sizeof(usZeros));

        //Handling restrictions
        AddToBuffer((char*)&usZeros,
                    sizeof(usZeros));

        //Transmition control code (TCC)
        AddToBuffer((char*)&usZeros,
                    sizeof(usZeros));
        AddToBuffer((char*)&ucZeros,
                    sizeof(ucZeros));

        //Done
    }
    ERROR_HANDLER("AddOption_Security")
}

void CTCPOptions::AddOption_SegmentSize

(

unsigned short

usMax

)

Definition at line 146 of file TCPSocket.cpp.

{
    try
    {
        //Add option Max segment
        OptionType aOptionType;

        //Get the option
        aOptionType=TCPOptions_MAX_Segment;

        //Add it to buffer
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));

        //Add length
        aOptionType=TCPOptions_MAX_Segment_Length;
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));

        //Add segment size
        unsigned short usOT;
        usOT=htons(usMax);

        //Add it
        AddToBuffer((char*)&usOT,
                    sizeof(usOT));
    }
    ERROR_HANDLER("AddOption_SegmentSize")
}

void CIPOptions::AddOption_Stream

(

unsigned short

usStreamID

)

[inherited]

Definition at line 267 of file SpoofSocket.cpp.

{
    try
    {
        //Add option security
        OptionType aOptionType;

        //Get the option
        aOptionType=GetOption(IPOption_COPY,
                              IPOption_CONTROL,
                              IPOption_STREAM);

        //Add it to buffer
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));

        //Add length
        aOptionType=IPOption_STREAM_LENGTH;
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));
        
        //Convert endian format
        unsigned short usnStreamID;
        usnStreamID=htons(usStreamID);
        
        //Add options
        AddToBuffer((char*)&usnStreamID,
                    sizeof(usnStreamID));
    }
    ERROR_HANDLER("AddOption_Stream")
}

void CIPOptions::AddOption_StrictRoute

(

Routing

tRoute

)

[inherited]

Definition at line 299 of file SpoofSocket.cpp.

{
    try
    {
        AddOption_Route(IPOption_STRICT_ROUTING,tRoute);
    }
    ERROR_HANDLER("AddOption_StrictRoute")
}

void CIPOptions::AddOption_Timestamp	(	OptionType	tFlags,
		int	iMaxStamps
	)			[inherited]

Definition at line 386 of file SpoofSocket.cpp.

{
    try
    {
        //Add option for timestamp
        OptionType aOptionType;

        //Get the option
        aOptionType=GetOption(IPOption_DONT_COPY,
                              IPOption_DEBUGGING,
                              IPOption_TIMESTAMP);

        //Add it to buffer
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));

        //Add the length
        aOptionType=iMaxStamps*IPOption_TIMESTAMP_SIZE+IPOption_TIMESTAMP_LENGTH-1;
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));
        
        //Add the pointer
        aOptionType=IPOption_TIMESTAMP_LENGTH;
        AddToBuffer((char*)&aOptionType,
                    sizeof(aOptionType));

        //Add the flags
        AddToBuffer((char*)&tFlags,
                    sizeof(tFlags));

        //Add the empty buffer
        char cNothing[IPOption_SIZE]="";
        AddToBuffer(cNothing,
                    iMaxStamps*IPOption_TIMESTAMP_SIZE);
    }
    ERROR_HANDLER("AddOption_Timestamp")
}

void CIPOptions::AddToBuffer	(	const char *	pBuffer,
		int	iBufLength
	)			[protected, inherited]

Definition at line 137 of file SpoofSocket.cpp.

{
    if (m_iBufferLength<IPOption_SIZE)
    {
        //Add our option to the buffer
        memcpy(m_pBuffer+m_iBufferLength,
               pBuffer,
               iBufLength);

        //Adjust the size
        m_iBufferLength+=iBufLength;
    }
}

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";
    }
}

const char * CTCPOptions::GetBuffer

(

)

const

Reimplemented from CIPOptions.

Definition at line 99 of file TCPSocket.cpp.

{
    try
    {
        return CIPOptions::GetBuffer();
    }
    ERROR_HANDLER_RETURN("GetBuffer",NULL)
}

int CTCPOptions::GetBufferLength

(

)

const

Reimplemented from CIPOptions.

Definition at line 90 of file TCPSocket.cpp.

{
    try
    {
        return CIPOptions::GetBufferLength();
    }
    ERROR_HANDLER_RETURN("GetBufferLength",0)
}

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;
}

CIPOptions::OptionType CIPOptions::GetOption	(	unsigned char	ucCopyFlag,
		unsigned char	ucClassFlag,
		unsigned char	ucTypeFlag
	)			[protected, inherited]

Definition at line 127 of file SpoofSocket.cpp.

{
    //Return a single option type
    return ucCopyFlag | 
           ucClassFlag | 
           ucTypeFlag;
}

int CSpoofBase::GetSystemLastError

(

)

const [inherited]

Definition at line 478 of file SpoofBase.cpp.

{
    return WSAGetLastError();
}

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)
}

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;
}

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.

{
}

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 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")
}

void CTCPOptions::Reset

(

)

Reimplemented from CIPOptions.

Definition at line 56 of file TCPSocket.cpp.

{
    try
    {
        CIPOptions::Reset();
    }
    ERROR_HANDLER("Reset")
}

void CTCPOptions::SetAutoPad

(

BOOL

bAutoPAD

)

Reimplemented from CIPOptions.

Definition at line 65 of file TCPSocket.cpp.

{
    try
    {
        CIPOptions::SetAutoPad(bAutoPAD);
    }
    ERROR_HANDLER("SetAutoPad")
}

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 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)
}

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 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")
}

---

Member Data Documentation

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

Definition at line 124 of file SpoofBase.h.

---

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

• TCPSocket.h
• TCPSocket.cpp