CTCPSocket Class Reference

#include <TCPSocket.h>

Inheritance diagram for CTCPSocket:

[legend]

Collaboration diagram for CTCPSocket:

[legend]

List of all members.

Public Types
enum	_SocketShutdown { ssReceive, ssSend, ssBoth }
typedef enum CSpoofSocket::_SocketShutdown	SocketShutdown
Public Member Functions
BOOL	SetNagle (BOOL bNagle)
virtual BOOL	Close ()
BOOL	IsConnected () const
virtual int	Send (const char *pBuffer, unsigned long ulBufferLength)
BOOL	Accept (CTCPSocket *pNewSocket)
CTCPSocket *	Accept ()
virtual BOOL	Listen (unsigned long ulBackLog=5)
CTCPOptions *	GetTCPOptions () const
virtual BOOL	Connect (unsigned short usSourcePort, IP aDestinationAddress, unsigned short usDestinationPort)
virtual BOOL	Connect (unsigned short usSourcePort, const std::string &rDestinationAddress, unsigned short usDestinationPort)
virtual BOOL	Connect (IP aDestinationAddress, unsigned short usDestinationPort)
virtual BOOL	Connect (const std::string &rDestinationAddress, unsigned short usDestinationPort)
virtual BOOL	Create ()
void	SetTCPOptions (BOOL bOptions)
	CTCPSocket (BOOL bRawSocket)
virtual	~CTCPSocket ()
BOOL	SetReceiveTimeout (unsigned long ulMS)
SOCKET	GetHandle () const
BOOL	SetBroadcast (BOOL bBroadcast)
BOOL	IsCreated () const
BOOL	CanWrite () const
BOOL	CanRead () const
unsigned short	GetPeerPort () const
BOOL	Shutdown (SocketShutdown eHow)
long	GetPeerAddress () const
virtual BOOL	Sniff (BOOL bSniff)
virtual int	Receive (char *pBuffer, unsigned long ulBufferLength)
CIPOptions *	GetOptions () const
void	SetOptions (BOOL bOptions)
void	SetTTL (unsigned char ucTTL)
unsigned short	CalculatePseudoChecksum (const char *pBuffer, int iBufferLength, IP aDestinationAddress, int iPacketLength) const
virtual void	SetSourceAddress (IP aSourceAddress)
virtual void	SetSourceAddress (const std::string &rSourceAddress)
virtual BOOL	Bind (const std::string &rSourceAddress, unsigned short usPort)
virtual BOOL	Bind (IP aSourceAddress, unsigned short usPort)
virtual int	Send (IP aDestinationAddress, const char *pBuffer, unsigned long ulBufferLength, unsigned short usDestinationPort=0)
virtual int	Send (const std::string &rDestinationAddress, const char *pBuffer, unsigned long ulBufferLength, unsigned short usDestinationPort=0)
virtual int	SendRawBuffer (IP aDestinationAddress, const char *pBuffer, unsigned long ulBufferLength, unsigned short usDestinationPort)
BOOL	Create (int iProtocol)
bool	operator== (const CSpoofSocket &rSocket) const
bool	operator< (const CSpoofSocket &rSocket) const
int	GetSystemLastError () const
int	GetLastError () const
void	SetLocalLog (CErrorLog *pLog)
Static Public Member Functions
static long	ResolveDNS (const std::string &rAddress)
static BOOL	ValidAddress (const std::string &rAddress)
static LPIpHeader	ConstructStaticIPHeader (unsigned char ucProtocol, unsigned short usFragmentationFlags, unsigned char ucTTL, unsigned short usIdentification, unsigned char ucHeaderLength)
static unsigned short	CalculateChecksum (const unsigned short *pBuffer, int iSize)
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)
Protected Member Functions
virtual void	BeforeAccept ()
virtual BOOL	IsAsyncClass () const
void	SetConnectionStatus (BOOL bConnected)
virtual void	Accepted ()
virtual LPTCPHeader	ConstructTCPHeader (unsigned short usSourcePort, unsigned short usDestinationPort, unsigned char ucHeaderLength) const
virtual void	FinalTCPHeader (LPTCPHeader lpHead) const
virtual int	SendRaw (unsigned short usSourcePort, IP aDestinationAddress, unsigned short usDestinationPort, const char *pBuffer, unsigned long ulBufferLength, unsigned char ucFlags=0)
virtual int	SendRaw (unsigned short usSourcePort, const std::string &rDestinationAddress, unsigned short usDestinationPort, const char *pBuffer, unsigned long ulBufferLength, unsigned char ucFlags=0)
void	SetConnectedTo (const sockaddr_in &rAddress)
IP	GetSourceAddress () const
unsigned char	GetTTL () const
unsigned char	GetProtocol () const
BOOL	HasOptions () const
virtual LPIpHeader	ConstructIPHeader (unsigned char ucProtocol, unsigned short usFragmentationFlags, unsigned char ucTTL, unsigned short usIdentification, unsigned char ucHeaderLength) const
BOOL	CheckSocketValid () const
void	AssignSocket (SOCKET aNewSocket, unsigned char ucProtocol=IPPROTO_TCP)
BOOL	IsRaw () const
void	SetProtocol (unsigned char iProtocol)
BOOL	ValidSocket () const
virtual void	InitializeIP ()
virtual void	SetIPHeaderAddress (LPIpHeader lpHead, IP aSourceAddress, IP aDestinationAddress) const
virtual void	FinalIPHeader (LPIpHeader lpHead) const
virtual int	ReceiveFrom (char *pBuffer, unsigned long ulBufferLength, IP &rIP, unsigned short &rSourcePort)
virtual void	NotifyShutdown ()
void	RegisterShutdown (CSpoofBase *pBase)
void	SetLastError (const std::string &rMethod) const
void	SetLastError (const std::string &, int iErrorCode) const
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 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
Friends
class	CIPCrafter

---

Detailed Description

Definition at line 121 of file TCPSocket.h.

---

Member Typedef Documentation

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

typedef enum CSpoofSocket::_SocketShutdown CSpoofSocket::SocketShutdown [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;

enum CSpoofSocket::_SocketShutdown [inherited]

Enumerator:

ssReceive
ssSend
ssBoth

Definition at line 444 of file SpoofSocket.h.

    {
        ssReceive,
        ssSend,
        ssBoth
    } SocketShutdown;

---

Constructor & Destructor Documentation

CTCPSocket::CTCPSocket

(

BOOL

bRawSocket

)

Definition at line 182 of file TCPSocket.cpp.

                                      : CSpoofSocket(bRawSocket)
{
    try
    {
        //Set our name
        SetName(CTCPSocket_LOGNAME);

        //Initialize the TCP
        InitializeTCP();
    }
    ERROR_HANDLER("CTCPSocket")
}

CTCPSocket::~CTCPSocket

(

)

[virtual]

Definition at line 208 of file TCPSocket.cpp.

{
    try
    {
        //Delete the options
        SetTCPOptions(FALSE);
    }
    ERROR_HANDLER("~CTCPSocket")
}

---

Member Function Documentation

CTCPSocket * CTCPSocket::Accept

(

)

Definition at line 458 of file TCPSocket.cpp.

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

        //First accept the socket
        SOCKET aSocket;
        
        //Where we are connected to
        sockaddr_in aConnected;
        
        //Size of the structure
        int iSize;
        iSize=sizeof(aConnected);

        //Accept it
        aSocket=accept(GetHandle(),
                       (sockaddr*)&aConnected,
                       &iSize);

        //Is all OK
        if (aSocket!=INVALID_SOCKET)
        {
            //Create the new tcp socket
            CTCPSocket* pSocket;
            pSocket=new CTCPSocket(aSocket);

            //Set the address
            pSocket->SetConnectedTo(aConnected);
            pSocket->SetConnectionStatus(TRUE);

            //Done
            return pSocket;
        }
        else
        {
            //Error
            SetLastError("Accept");

            //Exit
            return NULL;
        }
    }
    ERROR_HANDLER_RETURN("Accept",NULL)
}

BOOL CTCPSocket::Accept

(

CTCPSocket *

pNewSocket

)

Definition at line 521 of file TCPSocket.cpp.

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

        //First accept the socket
        SOCKET aNewSocket;
        
        //Where we are connected to
        sockaddr_in aAddress;
        
        //Size of the structure
        int iSize;
        iSize=sizeof(aAddress);

        //Accept it
        aNewSocket=accept(GetHandle(),
                          (sockaddr*)&aAddress,
                          &iSize);

        //Is it OK
        if (aNewSocket!=INVALID_SOCKET)
        {
            //Call before accept routing
            pNewSocket->BeforeAccept();

            //Set the socket data
            pNewSocket->SetConnectedTo(aAddress);
            pNewSocket->AssignSocket(aNewSocket);
            pNewSocket->SetConnectionStatus(TRUE);
            pNewSocket->Accepted();

            //Exit
            return TRUE;
        }
        else
        {
            //Error
            SetLastError("Accept");

            //Exit
            return FALSE;
        }
    }
    ERROR_HANDLER_RETURN("Accept",FALSE)
}

void CTCPSocket::Accepted

(

)

[protected, virtual]

Definition at line 600 of file TCPSocket.cpp.

{
}

void CSpoofSocket::AssignSocket	(	SOCKET	aNewSocket,
		unsigned char	ucProtocol = IPPROTO_TCP
	)			[protected, inherited]

Definition at line 1127 of file SpoofSocket.cpp.

{
    try
    {
        //Sets the protocol
        m_ucProtocol=ucProtocol;

        //Binds to a socket
        m_aSpoofSocket=aNewSocket;
    }
    ERROR_HANDLER("AssignSocket")
}

void CTCPSocket::BeforeAccept

(

)

[protected, virtual]

Definition at line 868 of file TCPSocket.cpp.

{
}

BOOL CSpoofSocket::Bind	(	IP	aSourceAddress,
		unsigned short	usPort
	)			[virtual, inherited]

Definition at line 852 of file SpoofSocket.cpp.

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

        //Create the local address
        sockaddr_in soSrc;

        //Set to 0
        memset(&soSrc,0,sizeof(soSrc));
        soSrc.sin_family=AF_INET;

        //Populate the connection data
        if (aSourceAddress)
            soSrc.sin_addr.s_addr=aSourceAddress;
        else
            soSrc.sin_addr.s_addr=ADDR_ANY ;

        soSrc.sin_port=htons(usPort);

        //Now we need to bind it
        if (bind(GetHandle(),
                 (sockaddr*)&soSrc,
                 sizeof(soSrc)))
        {
            //Error
            SetLastError("Bind");

            //Exit
            return FALSE;
        }
        else
            //Save the address
            m_aConnectedTo=soSrc;

        //If already has a source address then don't change it
        if (!m_ulSourceAddress)
            //Save it as the source address (spoofing options only)
            m_ulSourceAddress=aSourceAddress;

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

BOOL CSpoofSocket::Bind	(	const std::string &	rSourceAddress,
		unsigned short	usPort
	)			[virtual, inherited]

Definition at line 901 of file SpoofSocket.cpp.

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

        if (rSourceAddress.empty())
            return Bind((IP)0,
                        usPort);
        else
            return Bind(inet_addr(rSourceAddress.c_str()),
                        usPort);
    }
    ERROR_HANDLER_RETURN("Bind",FALSE)
}

unsigned short CSpoofSocket::CalculateChecksum	(	const unsigned short *	pBuffer,
		int	iSize
	)			[static, inherited]

Definition at line 824 of file SpoofSocket.cpp.

{
    try
    {
        unsigned long usChksum=0;

        //Calculate the checksum
        while (iSize>1)
        {
            usChksum+=*pBuffer++;
            iSize-=sizeof(unsigned short);
        }

        //If we have one char left
        if (iSize)
            usChksum+=*(unsigned char*)pBuffer;

        //Complete the calculations
        usChksum=(usChksum >> 16) + (usChksum & 0xffff);
        usChksum+=(usChksum >> 16);

        //Return the value (inversed)
        return (unsigned short)(~usChksum);
    }
    ERROR_HANDLER_STATIC_RETURN(CSpoofSocket_LOGNAME,"CalculateChecksum",0)
}

unsigned short CSpoofSocket::CalculatePseudoChecksum	(	const char *	pBuffer,
		int	iBufferLength,
		IP	aDestinationAddress,
		int	iPacketLength
	)			const [inherited]

Definition at line 997 of file SpoofSocket.cpp.

{
    try
    {
        //Calculate the checksum
        LPPseudoHeader lpPseudo;
        lpPseudo=new PseudoHeader;

        //Protect it
        std::auto_ptr<PseudoHeader> pProtection(lpPseudo);

        //Set the values
        lpPseudo->ulDestinationAddress=aDestinationAddress;
        lpPseudo->ulSourceAddress=m_ulSourceAddress;
        lpPseudo->ucZeros=0;
        lpPseudo->ucPTCL=m_ucProtocol;
        lpPseudo->usLength=htons(iPacketLength);

        //Calculate checksum of all
        int iTotalLength;
        iTotalLength=PseudoHeaderLength+iBufferLength;

        //Allocate the buffer
        char* pNewBuffer;
        pNewBuffer=new char[iTotalLength];

        //Protect the new buffer
        CArray_ptr<char> pBufferProtection(pNewBuffer);

        //Copy pseudo
        memcpy(pNewBuffer,lpPseudo,PseudoHeaderLength);

        //Copy header
        memcpy(pNewBuffer+PseudoHeaderLength,
               pBuffer,
               iBufferLength);

        //Calculate the checksum
        unsigned short usChecksum;
        usChecksum=CalculateChecksum((unsigned short*)pNewBuffer,iTotalLength);

        //Return checksum
        return usChecksum;
    }
    ERROR_HANDLER_RETURN("CalculatePseudoChecksum",0)
}

BOOL CSpoofSocket::CanRead

(

)

const [inherited]

Definition at line 1437 of file SpoofSocket.cpp.

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

        //Create our structure
        fd_set aDescriptor;
        FD_ZERO(&aDescriptor);

        //Add our socket
        FD_SET(GetHandle(),&aDescriptor);

        //And create the timeval
        timeval aTime;
        aTime.tv_sec=0;
        aTime.tv_usec=0;

        //And run the select
        int iRetVal;
        iRetVal=select(NULL,&aDescriptor,NULL,NULL,&aTime);

        //Check if we had an error
        if (iRetVal==GetErrorCode())
        {
            //Report it
            SetLastError("CanRead");

            //Exit
            return FALSE;
        }
        else
            //Check is our socket set
            return FD_ISSET(GetHandle(),&aDescriptor);
    }
    ERROR_HANDLER_RETURN("CanRead",FALSE)
}

BOOL CSpoofSocket::CanWrite

(

)

const [inherited]

Definition at line 1477 of file SpoofSocket.cpp.

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

        //Create our structure
        fd_set aDescriptor;
        FD_ZERO(&aDescriptor);

        //Add our socket
        FD_SET(GetHandle(),&aDescriptor);

        //And create the timeval
        timeval aTime;
        aTime.tv_sec=0;
        aTime.tv_usec=0;

        //And run the select
        int iRetVal;
        iRetVal=select(NULL,NULL,&aDescriptor,NULL,&aTime);

        //Check if we had an error
        if (iRetVal==GetErrorCode())
        {
            //Report it
            SetLastError("CanWrite");

            //Exit
            return FALSE;
        }
        else
            //Check is our socket set
            return FD_ISSET(GetHandle(),&aDescriptor);
    }
    ERROR_HANDLER_RETURN("CanWrite",FALSE)
}

BOOL CSpoofSocket::CheckSocketValid

(

)

const [protected, inherited]

Definition at line 925 of file SpoofSocket.cpp.

{
    try
    {
        //Check if socket is invalid
        if (!ValidSocket())
        {
            //Report it
            ReportError("CheckSocketValid","Operation made on non existant socket!");

            //Exit
            return FALSE;
        }   

        //OK
        return TRUE;
    }
    ERROR_HANDLER_RETURN("CheckSocketValid",FALSE)
}

BOOL CTCPSocket::Close

(

)

[virtual]

Reimplemented from CSpoofSocket.

Reimplemented in CTCPSocketAsync.

Definition at line 845 of file TCPSocket.cpp.

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

        //Check if the father can close
        if (CSpoofSocket::Close())
        {
            //Set the connection status
            SetConnectionStatus(FALSE);

            //And exit
            return TRUE;
        }
        else
            return FALSE;
    }
    ERROR_HANDLER_RETURN("Close",FALSE)
}

BOOL CTCPSocket::Connect	(	const std::string &	rDestinationAddress,
		unsigned short	usDestinationPort
	)			[virtual]

Definition at line 249 of file TCPSocket.cpp.

{
    try
    {
        return Connect(0,
                       rDestinationAddress,
                       usDestinationPort);
    }
    ERROR_HANDLER_RETURN("Connect",FALSE)
}

BOOL CTCPSocket::Connect	(	IP	aDestinationAddress,
		unsigned short	usDestinationPort
	)			[virtual]

Definition at line 237 of file TCPSocket.cpp.

{
    try
    {
        return Connect(0,
                       aDestinationAddress,
                       usDestinationPort);
    }
    ERROR_HANDLER_RETURN("Connect",FALSE)
}

BOOL CTCPSocket::Connect	(	unsigned short	usSourcePort,
		const std::string &	rDestinationAddress,
		unsigned short	usDestinationPort
	)			[virtual]

Definition at line 341 of file TCPSocket.cpp.

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

        //Delegate the call
        return Connect(usSourcePort,
                       StringToLong(rDestinationAddress),
                       usDestinationPort);
    }
    ERROR_HANDLER_RETURN("Connect",FALSE)
}

BOOL CTCPSocket::Connect	(	unsigned short	usSourcePort,
		IP	aDestinationAddress,
		unsigned short	usDestinationPort
	)			[virtual]

Special handling for raw sockets

Definition at line 261 of file TCPSocket.cpp.

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

        ///Special handling for raw sockets
        if (IsRaw())
            return SendRaw(usSourcePort,
                           aDestinationAddress,
                           usDestinationPort,
                           NULL,
                           0,
                           TCPFlag_SYN);
        else
        {
            //Set async notification
            int iResult;
            
            //Create the address
            sockaddr_in aSrc;
        
            //Set to 0
            memset(&aSrc,
                   0,
                   sizeof(aSrc));
            aSrc.sin_family=AF_INET;
            aSrc.sin_addr.s_addr=aDestinationAddress;
            aSrc.sin_port=htons(usDestinationPort);

            //Connect
            iResult=connect(GetHandle(),
                            (sockaddr*)&aSrc,
                            sizeof(aSrc));

            //Did we have a blocked error
            BOOL bBlocked;
            bBlocked=FALSE;

            //Check the result
            if (iResult==GetErrorCode())
            {
                //Check is it blocking error so we can ignore
                if (WSAGetLastError()!=WSAEWOULDBLOCK)
                    SetLastError("Connect");
                else
                {
                    //Indicate it's blocked error
                    bBlocked=TRUE;
                    iResult=!GetErrorCode();
                }
            }
            else
                //Report the error
                SetLastError("Connect");
            
            if (iResult!=GetErrorCode())
            {
                //Check if we are a sync socket
                if (!IsAsyncClass())
                    SetConnectionStatus(TRUE);

                //Save where we are connected
                SetConnectedTo(aSrc);
            }

            //Done
            if (!bBlocked)
                return iResult!=GetErrorCode();
            else
                return FALSE;
        }
    }
    ERROR_HANDLER_RETURN("Connect",FALSE)
}

LPIpHeader CSpoofSocket::ConstructIPHeader	(	unsigned char	ucProtocol,
		unsigned short	usFragmentationFlags,
		unsigned char	ucTTL,
		unsigned short	usIdentification,
		unsigned char	ucHeaderLength
	)			const [protected, virtual, inherited]

Reimplemented in CICMPCrafter, CTCPCrafter, and CUDPCrafter.

Definition at line 778 of file SpoofSocket.cpp.

{
    return ConstructStaticIPHeader(ucProtocol,
                                   usFragmentationFlags,
                                   ucTTL,
                                   usIdentification,
                                   ucHeaderLength);                
}

LPIpHeader CSpoofSocket::ConstructStaticIPHeader	(	unsigned char	ucProtocol,
		unsigned short	usFragmentationFlags,
		unsigned char	ucTTL,
		unsigned short	usIdentification,
		unsigned char	ucHeaderLength
	)			[static, inherited]

Definition at line 1398 of file SpoofSocket.cpp.

{
    try
    {
        //Need to construct the IP header
        LPIpHeader lpHead=new _IpHeader;

        //Header length (in 32 bits)
        lpHead->ucHeaderLength_Version=(ucHeaderLength >> 2) |
                                       (IpVersion << 4);

        //Protocol
        lpHead->ucProtocol=ucProtocol;

        //Fragmentation flags
        lpHead->usFragmentationFlags=htons(usFragmentationFlags);

        //Time to live
        lpHead->ucTTL=ucTTL;

        //Checksum - set to 0
        lpHead->usChecksum=0;

        //Identification
        lpHead->usIdentification=htons(usIdentification);

        //Precedence
        lpHead->ucTypeOfService=IpService_ROUTINE;

        //Return IP to user
        return lpHead;
    }
    ERROR_HANDLER_STATIC_RETURN(CSpoofSocket_LOGNAME,"ConstructIPHeader",NULL)
}

LPTCPHeader CTCPSocket::ConstructTCPHeader	(	unsigned short	usSourcePort,
		unsigned short	usDestinationPort,
		unsigned char	ucHeaderLength
	)			const [protected, virtual]

Reimplemented in CTCPCrafter.

Definition at line 359 of file TCPSocket.cpp.

{
    try
    {
        //Construct the header
        LPTCPHeader lpHead=new _TCPHeader;
        
        //Set source and destination port
        lpHead->usSourcePort=htons(usSourcePort);
        lpHead->usDestinationPort=htons(usDestinationPort);

        //No checksums yet
        lpHead->usChecksum=0;

        //Set windows to 3.0k
        lpHead->usWindows=htons(512);

        //Set the packet number
        lpHead->ulAcknowledgeNumber=0;

        //And the sequence
        lpHead->ulSequenceNumber=htonl(m_uiSequence++);

        //Data offset
        lpHead->ucDataOffset=(ucHeaderLength >> 2) << 4;

        //Flags
        lpHead->ucFlags=0;

        //Urgent pointer
        lpHead->usUrgentPointer=0;

        //Return it to the user
        return lpHead;
    }
    ERROR_HANDLER_RETURN("ConstructTCPHeader",NULL)
}

BOOL CSpoofSocket::Create

(

int

iProtocol

)

[inherited]

Definition at line 475 of file SpoofSocket.cpp.

{
    //Close the socket if open
    if (ValidSocket())
        Close();

    try
    {
        //Are we overlapped
        if (!m_bOverlapped)
        {
            //Here we create the raw socket
            if (m_bRaw || iProtocol==IPPROTO_ICMP)
                m_aSpoofSocket=socket(AF_INET,
                                      SOCK_RAW,
                                      iProtocol);
            else
                if (iProtocol==IPPROTO_TCP)
                    m_aSpoofSocket=socket(AF_INET,
                                          SOCK_STREAM,
                                          iProtocol);
                else if (iProtocol==IPPROTO_UDP)
                    m_aSpoofSocket=socket(AF_INET,
                                          SOCK_DGRAM,
                                          iProtocol);
        }
        else
        {
            //Here we create the raw socket
            if (m_bRaw || iProtocol==IPPROTO_ICMP)
                m_aSpoofSocket=WSASocket(AF_INET,
                                         SOCK_RAW,
                                         iProtocol,
                                         NULL,
                                         NULL,
                                         WSA_FLAG_OVERLAPPED);
            else
                if (iProtocol==IPPROTO_TCP)
                    m_aSpoofSocket=WSASocket(AF_INET,
                                             SOCK_STREAM,
                                             iProtocol,
                                             NULL,
                                             NULL,
                                             WSA_FLAG_OVERLAPPED);
                else if (iProtocol==IPPROTO_UDP)
                    m_aSpoofSocket=WSASocket(AF_INET,
                                             SOCK_DGRAM,
                                             iProtocol,
                                             NULL,
                                             NULL,
                                             WSA_FLAG_OVERLAPPED);
        }

        //Check for socket validity
        if (m_aSpoofSocket==INVALID_SOCKET)
        {
            //Error
            SetLastError("Create");

            //Done
            return FALSE;
        }

        if (m_bRaw)
        {
            //Set that the application will send the IP header
            unsigned int iTrue=1;

            if(setsockopt(m_aSpoofSocket,
                          IPPROTO_IP,
                          IP_HDRINCL,
                          (char*)&iTrue,
                          sizeof(iTrue))==GetErrorCode())
            {
                //Check for options error
                SetLastError("Create");

                //Exit
                return FALSE;
            }
        }

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

BOOL CTCPSocket::Create

(

)

[virtual]

Reimplemented in CTCPSocketAsync, and CWhoisSocket.

Definition at line 218 of file TCPSocket.cpp.

{
    try
    {
        //Initialize our data
        InitializeTCP();

        //Create it
        SetProtocol(IPPROTO_TCP);

        //Are we raw?
        if (IsRaw())
            return CSpoofSocket::Create(IPPROTO_IP); //Can't create working raw TCP socket
        else
            return CSpoofSocket::Create(IPPROTO_TCP);
    }
    ERROR_HANDLER_RETURN("Create",FALSE)
}

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 CSpoofSocket::FinalIPHeader

(

LPIpHeader

lpHead

)

const [protected, virtual, inherited]

Reimplemented in CICMPCrafter, CTCPCrafter, and CUDPCrafter.

Definition at line 1393 of file SpoofSocket.cpp.

{
    //We don't do anything
}

void CTCPSocket::FinalTCPHeader

(

LPTCPHeader

lpHead

)

const [protected, virtual]

Reimplemented in CTCPCrafter.

Definition at line 604 of file TCPSocket.cpp.

{
}

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

SOCKET CSpoofSocket::GetHandle

(

)

const [inherited]

Definition at line 920 of file SpoofSocket.cpp.

{
    return m_aSpoofSocket;
}

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 * CSpoofSocket::GetOptions

(

)

const [inherited]

Definition at line 196 of file SpoofSocket.cpp.

{
    return m_pIPOptions;
}

long CSpoofSocket::GetPeerAddress

(

)

const [inherited]

Definition at line 1349 of file SpoofSocket.cpp.

{
    //Get the address we are connected to
    return m_aConnectedTo.sin_addr.S_un.S_addr;
}

unsigned short CSpoofSocket::GetPeerPort

(

)

const [inherited]

Definition at line 1388 of file SpoofSocket.cpp.

{
    return htons(m_aConnectedTo.sin_port);
}

unsigned char CSpoofSocket::GetProtocol

(

)

const [protected, inherited]

Definition at line 1564 of file SpoofSocket.cpp.

{
    return m_ucProtocol;
}

IP CSpoofSocket::GetSourceAddress

(

)

const [protected, inherited]

Definition at line 1554 of file SpoofSocket.cpp.

{
    return m_ulSourceAddress;
}

int CSpoofBase::GetSystemLastError

(

)

const [inherited]

Definition at line 478 of file SpoofBase.cpp.

{
    return WSAGetLastError();
}

CTCPOptions * CTCPSocket::GetTCPOptions

(

)

const

Definition at line 425 of file TCPSocket.cpp.

{
    return m_pTCPOptions;
}

unsigned char CSpoofSocket::GetTTL

(

)

const [protected, inherited]

Reimplemented in CPingSocket.

Definition at line 1549 of file SpoofSocket.cpp.

{
    return m_ucTTL;
}

BOOL CSpoofSocket::HasOptions

(

)

const [protected, inherited]

Definition at line 1559 of file SpoofSocket.cpp.

{
    return m_bOptions;
}

void CSpoofSocket::InitializeIP

(

)

[protected, virtual, inherited]

Definition at line 1094 of file SpoofSocket.cpp.

{
    try
    {
        //Invalid the socket
        m_aSpoofSocket=INVALID_SOCKET;

        //More invalids
        m_ulSourceAddress=0;

        //Some defaults
        m_ucTTL=IP_DEF_TTL;

        //Set our options
        m_pIPOptions=NULL;

        //Not sniffing
        m_bSniffing=FALSE;

        //We are not overlapped
        m_bOverlapped=FALSE;

        //Not connected
        memset(&m_aConnectedTo,
               0,
               sizeof(m_aConnectedTo));

        //Set options to false
        SetOptions(FALSE);
    }
    ERROR_HANDLER("InitializeIP")
}

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 CTCPSocket::IsAsyncClass

(

)

const [protected, virtual]

Reimplemented in CTCPSocketAsync.

Definition at line 803 of file TCPSocket.cpp.

{
    return FALSE;
}

BOOL CTCPSocket::IsConnected

(

)

const

Definition at line 798 of file TCPSocket.cpp.

{
    return m_bConnected;
}

BOOL CSpoofSocket::IsCreated

(

)

const [inherited]

Definition at line 1517 of file SpoofSocket.cpp.

{
    return ValidSocket();
}

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 CSpoofSocket::IsRaw

(

)

const [protected, inherited]

Definition at line 1089 of file SpoofSocket.cpp.

{
    return m_bRaw;
}

BOOL CTCPSocket::Listen

(

unsigned long

ulBackLog = 5

)

[virtual]

Reimplemented in CTCPSocketAsync.

Definition at line 430 of file TCPSocket.cpp.

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

        //Try to listen
        int iResult;
        iResult=listen(GetHandle(),
                       ulBackLog);

        //Is all OK
        if (iResult)
        {
            //Report it
            SetLastError("Listen");

            //Exit
            return FALSE;
        }
        else
            return TRUE;
    }
    ERROR_HANDLER_RETURN("Listen",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.

{
}

bool CSpoofSocket::operator<

(

const CSpoofSocket &

rSocket

)

const [inherited]

Definition at line 1601 of file SpoofSocket.cpp.

{
    return m_aSpoofSocket<rSocket.m_aSpoofSocket;
}

bool CSpoofSocket::operator==

(

const CSpoofSocket &

rSocket

)

const [inherited]

Definition at line 1596 of file SpoofSocket.cpp.

{
    return m_aSpoofSocket==rSocket.m_aSpoofSocket;
}

int CSpoofSocket::Receive	(	char *	pBuffer,
		unsigned long	ulBufferLength
	)			[virtual, inherited]

Reimplemented in CTCPSocketAsync, and CUDPSocket.

Definition at line 1210 of file SpoofSocket.cpp.

{
    try
    {
        if (!ValidSocket() ||
            !pBuffer ||
            !ulBufferLength)
            return GetErrorCode();

        //Receive data
        int iResult;

        //Receive
        if (m_ucProtocol!=IPPROTO_TCP && 
            !m_bSniffing)
        {
            //Get the remote address
            sockaddr saConnected;

            int iTmp;
            iTmp=sizeof(saConnected);

            //Accept it
            iResult=recvfrom(GetHandle(),
                             pBuffer,
                             ulBufferLength,
                             NULL,
                             &saConnected,
                             &iTmp);

            //If OK set it
            if (iResult!=GetErrorCode())
                //Take the connected to data
                memcpy(&m_aConnectedTo,
                       &saConnected,
                       sizeof(saConnected));
        }
        else
            //Do a regular receive
            iResult=recv(GetHandle(),
                         pBuffer,
                         ulBufferLength,
                         NULL);

        //Check if error
        if (iResult==GetErrorCode() &&
            GetSystemLastError()!=WSAEWOULDBLOCK)
            //Error
            SetLastError("Receive");

        //Number of bytes received
        return iResult;
    }
    ERROR_HANDLER_RETURN("Receive",GetErrorCode())
}

int CSpoofSocket::ReceiveFrom	(	char *	pBuffer,
		unsigned long	ulBufferLength,
		IP &	rIP,
		unsigned short &	rSourcePort
	)			[protected, virtual, inherited]

Definition at line 1140 of file SpoofSocket.cpp.

{
    try
    {
        if (!ValidSocket() ||
            !pBuffer ||
            !ulBufferLength)
            return GetErrorCode();

        //Receive data
        int iResult;

        //Receive
        if (m_ucProtocol!=IPPROTO_TCP && 
            !m_bSniffing)
        {
            //Get the remote address
            sockaddr saConnected;

            int iTmp;
            iTmp=sizeof(saConnected);

            //Accept it
            iResult=recvfrom(GetHandle(),
                             pBuffer,
                             ulBufferLength,
                             NULL,
                             &saConnected,
                             &iTmp);

            //If OK set it
            if (iResult!=GetErrorCode())
            {
                //Address
                rIP=((sockaddr_in*)&saConnected)->sin_addr.S_un.S_addr;

                //Port
                rSourcePort=htons(((sockaddr_in*)&saConnected)->sin_port);

                //Done
                return iResult;
            }
            else
            {
                //Error
                SetLastError("Receive");

                //Reset the data
                rIP=0;
                rSourcePort=0;

                //Done
                return iResult;
            }
        }
        else
        {
            //Report it
            ReportError("Receive","Can't run on TCP socket!");

            //Exit
            return GetErrorCode();
        }
    }
    ERROR_HANDLER_RETURN("Receive",GetErrorCode())
}

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

long CSpoofSocket::ResolveDNS

(

const std::string &

rAddress

)

[static, inherited]

Definition at line 1300 of file SpoofSocket.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(CSpoofSocket_LOGNAME,"ResolveDNS",0)
}

int CSpoofSocket::Send	(	const std::string &	rDestinationAddress,
		const char *	pBuffer,
		unsigned long	ulBufferLength,
		unsigned short	usDestinationPort = 0
	)			[virtual, inherited]

Definition at line 759 of file SpoofSocket.cpp.

{
    try
    {
        //Quit if not ok
        if (!CheckSocketValid())
            return GetErrorCode();

        return Send(inet_addr(rDestinationAddress.c_str()),
                    pBuffer,
                    ulBufferLength,
                    usDestinationPort);
    }
    ERROR_HANDLER_RETURN("Send",GetErrorCode())
}

int CSpoofSocket::Send	(	IP	aDestinationAddress,
		const char *	pBuffer,
		unsigned long	ulBufferLength,
		unsigned short	usDestinationPort = 0
	)			[virtual, inherited]

Definition at line 604 of file SpoofSocket.cpp.

{
    try
    {
        //Quit if not ok
        if (!CheckSocketValid())
            return GetErrorCode();

        //Is it a valid size
        if (ulBufferLength &&
            !pBuffer)
            return GetErrorCode();

        //Define the target address
        sockaddr_in aTargetAddress;
        memset(&aTargetAddress,
               0,
               sizeof(aTargetAddress));

        aTargetAddress.sin_family=AF_INET;
        aTargetAddress.sin_addr.s_addr=aDestinationAddress;
        aTargetAddress.sin_port=htons(usDestinationPort);

        //packet send status ?
        int iResult;

        //Only if allowing raw headers !!
        if (m_bRaw)
        {
            //Header length
            unsigned char ucHeaderLength;
            ucHeaderLength=IpHeaderLength;

            //Do we have options?
            if (m_bOptions)
                ucHeaderLength+=m_pIPOptions->GetBufferLength();
            
            //First construct the packet
            LPIpHeader lpHead=ConstructIPHeader(m_ucProtocol,
                                                IpFragFlag_DONT_FRAG,
                                                m_ucTTL,
                                                (unsigned short)GetCurrentProcessId(),
                                                ucHeaderLength);

            //Protect the header
            std::auto_ptr<IpHeader> pProtection(lpHead);

            //Set the address
            SetIPHeaderAddress(lpHead,
                               m_ulSourceAddress,
                               aDestinationAddress);

            //Now add some more options
            int iTotalLength;
            iTotalLength=ucHeaderLength+ulBufferLength;

            //Set the header
            lpHead->usTotalLength=htons(iTotalLength);

            //Need to construct a new packet
            char* pNewBuffer;
            pNewBuffer=new char[iTotalLength];

            //Protect the buffer
            CArray_ptr<char> pBufferProtection(pNewBuffer);

            //Copy two buffers
            memcpy(pNewBuffer,
                   lpHead,
                   IpHeaderLength);

            //Do we need to copy options ?
            if (m_bOptions)
                memcpy(pNewBuffer+IpHeaderLength,
                       m_pIPOptions->GetBuffer(),
                       m_pIPOptions->GetBufferLength());

            //Only if not null
            if (pBuffer)
                memcpy(pNewBuffer+ucHeaderLength,
                       pBuffer,
                       ulBufferLength);
            
            //Calculate the checksum
            lpHead->usChecksum=CalculateChecksum((unsigned short*)pNewBuffer,
                                                 ucHeaderLength);

            //Alert everyone this is the final header
            FinalIPHeader(lpHead);

            //Recopy the ip
            memcpy(pNewBuffer,
                   lpHead,
                   IpHeaderLength);
            
            //Send the data
            iResult=sendto(GetHandle(),
                           (const char*)pNewBuffer,
                           iTotalLength,
                           0,
                           (sockaddr*)&aTargetAddress,
                           sizeof(aTargetAddress));

            //Is all OK
            if (iResult==GetErrorCode() &&
                GetSystemLastError()!=WSAEWOULDBLOCK)
                //Set the error
                SetLastError("Send - Raw");
        }
        else
        {
            //Set to no error
            iResult=!GetErrorCode();

            //Insert options
            /*if (m_bOptions)
                iResult=setsockopt(GetHandle(),
                                   IPPROTO_IP,
                                   IP_OPTIONS,
                                   m_pIPOptions->GetBuffer(),
                                   m_pIPOptions->GetBufferLength());
            else
                //No options
                iResult=setsockopt(GetHandle(),
                                   IPPROTO_IP,
                                   IP_OPTIONS,
                                   NULL,
                                   0);*/

            //Check if we had an error
            if (iResult!=GetErrorCode())
                //Use regular send !!!
                iResult=sendto(GetHandle(),
                               (const char*)pBuffer,
                               ulBufferLength,
                               0,
                               (sockaddr*)&aTargetAddress,
                               sizeof(aTargetAddress));
            
            //Is all OK?
            if (iResult==GetErrorCode() &&
                GetSystemLastError()!=WSAEWOULDBLOCK)
                //Set the error
                SetLastError("Send");
        }
        
        //Done
        return iResult;
    }
    ERROR_HANDLER_RETURN("Send",GetErrorCode())
}

int CTCPSocket::Send	(	const char *	pBuffer,
		unsigned long	ulBufferLength
	)			[virtual]

Reimplemented in CTCPSocketAsync.

Definition at line 571 of file TCPSocket.cpp.

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

        //Send the data
        int iResult;

        //And send it
        iResult=send(GetHandle(),
                     pBuffer,
                     ulBufferLength,
                     NULL);

        //Did we succeed ?
        if (iResult==GetErrorCode())
            //Set the error code
            SetLastError("Send");

        //Done
        return iResult;
    }
    ERROR_HANDLER_RETURN("Send",FALSE)
}

int CTCPSocket::SendRaw	(	unsigned short	usSourcePort,
		const std::string &	rDestinationAddress,
		unsigned short	usDestinationPort,
		const char *	pBuffer,
		unsigned long	ulBufferLength,
		unsigned char	ucFlags = 0
	)			[protected, virtual]

Reimplemented in CTCPCrafter.

Definition at line 608 of file TCPSocket.cpp.

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

        return SendRaw(usSourcePort,
                       StringToLong(rDestinationAddress),
                       usDestinationPort,
                       pBuffer,
                       ulBufferLength,
                       ucFlags);
    }
    ERROR_HANDLER_RETURN("SendRaw",GetErrorCode())
}

int CTCPSocket::SendRaw	(	unsigned short	usSourcePort,
		IP	aDestinationAddress,
		unsigned short	usDestinationPort,
		const char *	pBuffer,
		unsigned long	ulBufferLength,
		unsigned char	ucFlags = 0
	)			[protected, virtual]

Reimplemented in CTCPCrafter.

Definition at line 631 of file TCPSocket.cpp.

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

        if (IsRaw())
        {
            //Let's try our first attack
            LPTCPHeader lpHead;

            //Header length
            int iHeaderLength;
            iHeaderLength=TCPHeaderLength;

            //If we have TCP options
            if (m_bOptions)
                iHeaderLength+=m_pTCPOptions->GetBufferLength();

            //Create the header
            lpHead=ConstructTCPHeader(usSourcePort,
                                      usDestinationPort,
                                      iHeaderLength);

            //Protect the header
            std::auto_ptr<TCPHeader> pProtection(lpHead);

            //Set the flags
            if (ucFlags)
                //Set the flags
                SetHeaderFlag(lpHead,ucFlags);
            
            //Result 
            int iResult;

            //Construct diffrently if we have options
            if (m_bOptions)
            {
                //Allocate the data
                char* pOptionBuffer;
                pOptionBuffer=new char[iHeaderLength+ulBufferLength];

                //Protect the buffer
                CArray_ptr<char> pBufferProtection(pOptionBuffer);

                //Copy header
                memcpy(pOptionBuffer,
                       lpHead,
                       TCPHeaderLength);
            
                //Copy options
                memcpy(pOptionBuffer+TCPHeaderLength,
                       m_pTCPOptions->GetBuffer(),
                       m_pTCPOptions->GetBufferLength());

                //Do we have the buffer
                if (ulBufferLength)
                    //Copy the data
                    memcpy(pOptionBuffer+
                             TCPHeaderLength+
                             m_pTCPOptions->GetBufferLength(),
                           pBuffer,
                           ulBufferLength);

                //Calculate the total length
                int iTotalLength;
                iTotalLength=iHeaderLength+ulBufferLength;

                //Change the header
                lpHead->ucDataOffset=(iTotalLength >> 2) << 4;

                //Checksum it
                lpHead->usChecksum=CalculatePseudoChecksum(pOptionBuffer,
                                                           iTotalLength,
                                                           aDestinationAddress,
                                                           iTotalLength);
                
                //Last change to the header
                FinalTCPHeader(lpHead);

                //Recopy header
                memcpy(pOptionBuffer,
                       lpHead,
                       TCPHeaderLength);

                //Send the data
                iResult=CSpoofSocket::Send(aDestinationAddress,
                                           pOptionBuffer,
                                           iHeaderLength,
                                           usDestinationPort);
            }
            else
            {
                //Our total length
                unsigned long ulTotalLength;
                ulTotalLength=iHeaderLength+ulBufferLength;

                //Allocate the buffer
                char* pNewBuffer;
                pNewBuffer=new char[ulTotalLength];

                //Protect the buffer
                CArray_ptr<char> pBufferProtection(pNewBuffer);

                //Copy the header
                memcpy(pNewBuffer,
                       lpHead,
                       ulTotalLength);

                //Copy the data
                if (ulBufferLength)
                    //Copy the data
                    memcpy(pNewBuffer+iHeaderLength,
                           pBuffer,
                           ulBufferLength);

                //Calculate the checksum
                lpHead->usChecksum=CalculatePseudoChecksum(pNewBuffer,
                                                           ulTotalLength,
                                                           aDestinationAddress,
                                                           ulTotalLength);

                //Last change to the header
                FinalTCPHeader(lpHead);

                //Copy the header
                memcpy(pNewBuffer,
                       lpHead,
                       iHeaderLength);

                //Send the data
                iResult=CSpoofSocket::Send(aDestinationAddress,
                                           pNewBuffer,
                                           ulTotalLength,
                                           usDestinationPort);
            }

            //Set the last error
            SetLastError("Connect");

            //Exit
            return iResult;
        }
        else
        {
            //Report it
            ReportError("SendRaw","Packet not in raw mode!");

            //Exit
            return GetErrorCode();
        }
    }
    ERROR_HANDLER_RETURN("SendRaw",GetErrorCode())
}

int CSpoofSocket::SendRawBuffer	(	IP	aDestinationAddress,
		const char *	pBuffer,
		unsigned long	ulBufferLength,
		unsigned short	usDestinationPort
	)			[virtual, inherited]

Definition at line 563 of file SpoofSocket.cpp.

{
    try
    {
        //Quit if not ok
        //Make things the fastest
        if (m_aSpoofSocket==INVALID_SOCKET ||
            !m_bRaw)
            return FALSE;

        //Define the target address
        sockaddr_in m_TargetAddress;

        m_TargetAddress.sin_family=AF_INET;
        m_TargetAddress.sin_addr.s_addr=aDestinationAddress;
        m_TargetAddress.sin_port=htons(usDestinationPort);
        memset(&m_TargetAddress.sin_zero,0,sizeof(m_TargetAddress.sin_zero));

        //And send the data
        //Send the data
        int iResult;
        iResult=sendto(GetHandle(),
                       pBuffer,
                       ulBufferLength,
                       0,
                       (sockaddr*)&m_TargetAddress,
                       sizeof(m_TargetAddress));

        if (iResult==GetErrorCode())
            //Set the error
            SetLastError("SendRawBuffer");

        //Done
        return iResult;
    }
    ERROR_HANDLER_RETURN("SendRawBuffer",GetErrorCode())
}

BOOL CSpoofSocket::SetBroadcast

(

BOOL

bBroadcast

)

[inherited]

Definition at line 1522 of file SpoofSocket.cpp.

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

        //Set broadcast option
        if(setsockopt(GetHandle(),
                      SOL_SOCKET,
                      SO_BROADCAST,
                      (char*)&bBroadcast,
                      sizeof(bBroadcast))==GetErrorCode())
        {
            //Check for options error
            SetLastError("SetBroadcast");

            //Exit
            return FALSE;
        }   

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

void CSpoofSocket::SetConnectedTo

(

const sockaddr_in &

rAddress

)

[protected, inherited]

Definition at line 1606 of file SpoofSocket.cpp.

{
    m_aConnectedTo=rAddress;
}

void CTCPSocket::SetConnectionStatus

(

BOOL

bConnected

)

[protected]

Definition at line 793 of file TCPSocket.cpp.

{
    m_bConnected=bConnected;
}

void CSpoofSocket::SetIPHeaderAddress	(	LPIpHeader	lpHead,
		IP	aSourceAddress,
		IP	aDestinationAddress
	)			const [protected, virtual, inherited]

Definition at line 791 of file SpoofSocket.cpp.

{
    try
    {
        //We need to place the header
        //If source is NULL then we need to use default source
        if (!aSourceAddress || !aDestinationAddress)
        {
            //Report it
            ReportError("SetIPHeaderAddress","Recieved empty source or destination address!");

            //Exit
            return;
        }

        //Place source address
        lpHead->ulSourceAddress=aSourceAddress;

        //Place destination address
        lpHead->ulDestinationAddress=aDestinationAddress;

        //Done
    }
    ERROR_HANDLER("SetIPHeaderAddress")
}

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

BOOL CTCPSocket::SetNagle

(

BOOL

bNagle

)

Definition at line 808 of file TCPSocket.cpp.

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

        //Invert the flag (convert to true bool)
        if (bNagle)
            bNagle=FALSE;
        else
            bNagle=TRUE;

        //Try to set the option
        if (setsockopt(GetHandle(),
                       IPPROTO_TCP,
                       TCP_NODELAY,
                       (const char*)&bNagle,
                       sizeof(bNagle))==GetErrorCode())
        {
            //Report it
            ReportError("SetNagle","Failed to set nagle");

            //Set it
            SetLastError("SetNagle");
        
            //Exit
            return FALSE;
        }

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

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

void CSpoofSocket::SetOptions

(

BOOL

bOptions

)

[inherited]

Definition at line 1068 of file SpoofSocket.cpp.

{
    try
    {
        //Do we want options, normaly not
        m_bOptions=bOptions;

        //Do we have older options?
        if (m_pIPOptions)
        {
            delete m_pIPOptions;
            m_pIPOptions=NULL;
        }

        //Do we need to reallocate the options
        if (bOptions)
            m_pIPOptions=new CIPOptions;
    }
    ERROR_HANDLER("SetOptions")
}

void CSpoofSocket::SetProtocol

(

unsigned char

iProtocol

)

[protected, inherited]

Definition at line 974 of file SpoofSocket.cpp.

{
    m_ucProtocol=ucProtocol;
}

BOOL CSpoofSocket::SetReceiveTimeout

(

unsigned long

ulMS

)

[inherited]

Definition at line 1569 of file SpoofSocket.cpp.

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

        //Set it
        if(setsockopt(GetHandle(),
                      SOL_SOCKET,
                      SO_RCVTIMEO,
                      (char*)&ulMS,
                      sizeof(ulMS))==GetErrorCode())
        {
            //Check for options error
            SetLastError("SetReceiveTimeout");

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

void CSpoofSocket::SetSourceAddress

(

const std::string &

rSourceAddress

)

[virtual, inherited]

Definition at line 984 of file SpoofSocket.cpp.

{
    try
    {
        //Set the source address, in case we want to spoof it
        if (rSourceAddress.empty())
            m_ulSourceAddress=0;
        else
            m_ulSourceAddress=inet_addr(rSourceAddress.c_str());
    }
    ERROR_HANDLER("SetSourceAddress")
}

void CSpoofSocket::SetSourceAddress

(

IP

aSourceAddress

)

[virtual, inherited]

Definition at line 979 of file SpoofSocket.cpp.

{
    m_ulSourceAddress=aSourceAddress;
}

void CTCPSocket::SetTCPOptions

(

BOOL

bOptions

)

Definition at line 405 of file TCPSocket.cpp.

{
    try
    {
        //Do we want options, normaly not
        m_bOptions=bOptions;

        //Do we need to delete old options
        if (m_pTCPOptions)
        {
            delete m_pTCPOptions;
            m_pTCPOptions=NULL;
        }

        if (bOptions)
            m_pTCPOptions=new CTCPOptions;
    }
    ERROR_HANDLER("SetTCPOptions")
}

void CSpoofSocket::SetTTL

(

unsigned char

ucTTL

)

[inherited]

Definition at line 1047 of file SpoofSocket.cpp.

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

        if (m_bRaw)
            //Set the ttl
            m_ucTTL=ucTTL;
        else if(setsockopt(GetHandle(),
                           IPPROTO_IP,
                           IP_TTL,
                           (const char*)&ucTTL,
                           sizeof(ucTTL)))
            SetLastError("SetTTL");
    }
    ERROR_HANDLER("SetTTL")
}

BOOL CSpoofSocket::Shutdown

(

SocketShutdown

eHow

)

[inherited]

Definition at line 1355 of file SpoofSocket.cpp.

{
    if (!CheckSocketValid())
        return FALSE;

    try
    {
        int iHow;

        //Convert the how to a real flag
        if (eHow==ssReceive)
            iHow=SD_RECEIVE;
        else if (eHow==ssSend)
            iHow=SD_SEND;
        else
            iHow=SD_BOTH;

        //Do it
        if (shutdown(GetHandle(),iHow))
        {
            //Report it
            SetLastError("Shutdown");

            //Exit
            return FALSE;
        }

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

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

BOOL CSpoofSocket::Sniff

(

BOOL

bSniff

)

[virtual, inherited]

Reimplemented in CSniffSocket.

Definition at line 1318 of file SpoofSocket.cpp.

{
    //Start sniffing
    if (!ValidSocket())
        return FALSE;

    try
    {
#ifdef WIN32
        unsigned long ulBytes;
        if (WSAIoctl(GetHandle(),SIO_RCVALL,&bSniff,sizeof(bSniff),NULL,0,&ulBytes,NULL,NULL))
        {
            //Error
            SetLastError("Sniff");

            //Exit
            return FALSE;
        }

        //Set sniffer status
        m_bSniffing=bSniff;

        //Done
        return TRUE;
#else
        return FALSE;
#endif
    }
    ERROR_HANDLER_RETURN("Sniff",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());
}

BOOL CSpoofSocket::ValidAddress

(

const std::string &

rAddress

)

[static, inherited]

Definition at line 1267 of file SpoofSocket.cpp.

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

BOOL CSpoofSocket::ValidSocket

(

)

const [protected, inherited]

Definition at line 819 of file SpoofSocket.cpp.

{
    return m_aSpoofSocket!=INVALID_SOCKET;
}

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

---

Friends And Related Function Documentation

friend class CIPCrafter [friend, inherited]

Definition at line 452 of file SpoofSocket.h.

---

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