CUDPCrafter Class Reference

#include <UDPCrafter.h>

Inheritance diagram for CUDPCrafter:

[legend]

Collaboration diagram for CUDPCrafter:

[legend]

List of all members.

Public Types
enum	_SocketShutdown { ssReceive, ssSend, ssBoth }
typedef enum CSpoofSocket::_SocketShutdown	SocketShutdown
Public Member Functions
char *	GetCraftedPacket (unsigned short usSourcePort, unsigned long ulDestinationAddress, const char *pBuffer, unsigned long ulBufferSize, unsigned short usDestinationPort, unsigned short &usTotalSize) const
void	SetUDPUseDefaultChecksum (BOOL bDefault)
void	SetUDPChecksum (unsigned short usChecksum)
void	SetUDPDefault ()
	CUDPCrafter ()
virtual	~CUDPCrafter ()
virtual BOOL	Create ()
BOOL	Create (int iProtocol)
virtual int	Receive (char *pBuffer, unsigned long ulBufferLength)
virtual int	Receive (char *pBuffer, unsigned long ulBufferLength, IP &rIP, unsigned short &rSourcePort)
virtual BOOL	Send (IP aDestinationAddress, unsigned short usDestinationPort, const char *pBuffer, unsigned short usBufferLength)
virtual BOOL	Send (const std::string &rDestinationAddress, unsigned short usDestinationPort, const char *pBuffer, unsigned short usBufferLength)
virtual BOOL	Send (unsigned short usSourcePort, IP aDestinationAddress, unsigned short usDestinationPort, const char *pBuffer, unsigned short usBufferLength)
virtual BOOL	Send (unsigned short usSourcePort, const std::string &rDestinationAddress, unsigned short usDestinationPort, const char *pBuffer, unsigned short usBufferLength)
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)
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)
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	Close ()
virtual BOOL	Bind (const std::string &rSourceAddress, unsigned short usPort)
virtual BOOL	Bind (IP aSourceAddress, unsigned short usPort)
virtual int	SendRawBuffer (IP aDestinationAddress, const char *pBuffer, unsigned long ulBufferLength, unsigned short usDestinationPort)
bool	operator== (const CSpoofSocket &rSocket) const
bool	operator< (const CSpoofSocket &rSocket) const
int	GetSystemLastError () const
int	GetLastError () const
void	SetLocalLog (CErrorLog *pLog)
char *	GetCraftedPacket (const CSpoofSocket *pSocket, unsigned long ulDestinationAddress, const char *pBuffer, unsigned short usBufferSize, unsigned short &usTotalSize) const
void	SetUseDefaultChecksum (BOOL bDefault)
void	SetChecksum (unsigned short usChecksum)
void	SetDefault ()
void	SetTypeOfService (unsigned char ucTypeOfService)
void	SetHeaderLength (unsigned char ucHeaderLength)
void	SetIdentification (unsigned short usIdentification)
void	SetFragmentationFlags (unsigned short usFragmentationFlags)
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 LPIpHeader	ConstructIPHeader (unsigned char ucProtocol, unsigned short usFragmentationFlags, unsigned char ucTTL, unsigned short usIdentification, unsigned char ucHeaderLength) const
virtual void	FinalIPHeader (LPIpHeader lpHead) const
virtual void	FinalUDPHeader (LPUDPHeader lpHeader) const
void	SetConnectedTo (const sockaddr_in &rAddress)
IP	GetSourceAddress () const
unsigned char	GetTTL () const
unsigned char	GetProtocol () const
BOOL	HasOptions () 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 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
LPIpHeader	ConstructCraftedIPHeader (unsigned char ucProtocol, unsigned short usFragmentationFlags, unsigned char ucTTL, unsigned short usIdentification, unsigned char ucHeaderLength) 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)
Protected Attributes
unsigned short	m_usFragmentationFlags
unsigned short	m_usIdentification
unsigned char	m_ucHeaderLength
unsigned char	m_ucTypeOfService
unsigned short	m_usChecksum
BOOL	m_DefaultChecksum
Static Protected Attributes
static CGenericCriticalSection *	m_pCSection = NULL
Friends
class	CIPCrafter

---

Detailed Description

Definition at line 48 of file UDPCrafter.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

CUDPCrafter::CUDPCrafter

(

)

Definition at line 54 of file UDPCrafter.cpp.

                         : CUDPSocket(TRUE),
                             CIPCrafter()
{
    try
    {
        //Set our name
        CUDPSocket::SetName(CUDPCrafter_Class);

        //Set the default
        SetUDPDefault();

        //Set the protocol
        SetProtocol(IPPROTO_UDP);
    }
    ERROR_HANDLER("CUDPCrafter")
}

CUDPCrafter::~CUDPCrafter

(

)

[virtual]

Definition at line 71 of file UDPCrafter.cpp.

{
}

---

Member Function Documentation

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

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

(

)

[virtual, inherited]

Reimplemented in CICMPSocketAsync, CTCPSocket, CTCPSocketAsync, and CUDPSocketAsync.

Definition at line 945 of file SpoofSocket.cpp.

{
    try
    {
        //Close the socket
        //Quit if not ok
        if (!ValidSocket())
            return FALSE;

        //Close it
        if (closesocket(GetHandle())==GetErrorCode())
        {
            //Error in closing ?
            SetLastError("Close");

            //Exit
            return FALSE;
        }

        //Set the socket to invalid
        m_aSpoofSocket=INVALID_SOCKET;

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

LPIpHeader CIPCrafter::ConstructCraftedIPHeader	(	unsigned char	ucProtocol,
		unsigned short	usFragmentationFlags,
		unsigned char	ucTTL,
		unsigned short	usIdentification,
		unsigned char	ucHeaderLength
	)			const [protected, inherited]

Definition at line 115 of file IPCrafter.cpp.

{
    try
    {
        //Get the original header
        LPIpHeader lpHead;

        //Check what header length to pass
        unsigned char ucLength;

        if (m_ucHeaderLength==IPCRAFTER_DEFAULT_HEADER_SIZE)
            ucLength=ucHeaderLength;
        else
            ucLength=m_ucHeaderLength;

        //Get the header
        lpHead=CSpoofSocket::ConstructStaticIPHeader(ucProtocol,
                                                     m_usFragmentationFlags,
                                                     ucTTL,
                                                     m_usIdentification,
                                                     ucLength);

        //Check we have it
        if (!lpHead)
            return NULL;

        //Set the type of service
        //Precedence
        lpHead->ucTypeOfService=m_ucTypeOfService;

        //Done
        return lpHead;
    }
    ERROR_HANDLER_RETURN("ConstructCraftedIPHeader",NULL)
}

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

Reimplemented from CSpoofSocket.

Definition at line 75 of file UDPCrafter.cpp.

{
    return ConstructCraftedIPHeader(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)
}

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 CUDPSocket::Create

(

)

[virtual, inherited]

Reimplemented in CUDPSocketAsync.

Definition at line 68 of file UDPSocket.cpp.

{
    try
    {
        //Set to UDP
        SetProtocol(IPPROTO_UDP);

        //Try to create
        return CSpoofSocket::Create(IPPROTO_UDP);
    }
    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 CUDPCrafter::FinalIPHeader

(

LPIpHeader

lpHead

)

const [protected, virtual]

Reimplemented from CSpoofSocket.

Definition at line 88 of file UDPCrafter.cpp.

{
    try
    {
        //Check if we need to modify the header
        if (!m_DefaultChecksum)
            lpHead->usChecksum=htons(m_usChecksum);
    }
    ERROR_HANDLER("FinalIPHeader")
}

void CUDPCrafter::FinalUDPHeader

(

LPUDPHeader

lpHeader

)

const [protected, virtual]

Reimplemented from CUDPSocket.

Definition at line 119 of file UDPCrafter.cpp.

{
    if (!m_UDPDefaultChecksum)
        lpHeader->usChecksum=htons(m_usUDPChecksum);
}

const std::string & CErrorHandler::GetClassName

(

)

const [protected, inherited]

Reimplemented in CSocketThreadManager.

Definition at line 516 of file ErrorHandler.cpp.

{
    return m_sClassName;
}

char * CIPCrafter::GetCraftedPacket	(	const CSpoofSocket *	pSocket,
		unsigned long	ulDestinationAddress,
		const char *	pBuffer,
		unsigned short	usBufferSize,
		unsigned short &	usTotalSize
	)			const [inherited]

Definition at line 155 of file IPCrafter.cpp.

{
    try
    {
        //Check if the length is too big
        if (IpHeaderLength+(long)usBufferSize>65535)
        {
            //Report it
            ReportError("GetCraftedPacket","Packet can't be greater then 65k!");

            //Exit
            return NULL;
        }

        //Header length
        unsigned char ucHeaderLength=IpHeaderLength;

        if (pSocket->HasOptions())
            ucHeaderLength+=pSocket->GetOptions()->GetBufferLength();
        
        //First construct the packet
        LPIpHeader lpHead=pSocket->ConstructIPHeader(pSocket->GetProtocol(),
                                                     IpFragFlag_DONT_FRAG,
                                                     pSocket->GetTTL(),
                                                     (unsigned short)GetCurrentProcessId(),
                                                     ucHeaderLength);

        //Set the address
        pSocket->SetIPHeaderAddress(lpHead,
                                    pSocket->GetSourceAddress(),
                                    ulDestinationAddress);

        //Now add some more options
        unsigned short usTotalLength;
        usTotalLength=ucHeaderLength+usBufferSize;

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

        //Need to construct a new packet
        char* pNewBuf;
        pNewBuf=new char[usTotalLength];

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

        //Do we need to copy options ?
        if (pSocket->HasOptions())
            memcpy(pNewBuf+IpHeaderLength,
                   pSocket->GetOptions()->GetBuffer(),
                   pSocket->GetOptions()->GetBufferLength());

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

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

        //Recopy the ip
        memcpy(pNewBuf,
               lpHead,
               IpHeaderLength);
            
        //Set the total size
        usTotalSize=usTotalLength;

        //Return to the user
        return pNewBuf;
    }
    ERROR_HANDLER_RETURN("GetCraftedPacket",NULL)
}

char * CUDPCrafter::GetCraftedPacket	(	unsigned short	usSourcePort,
		unsigned long	ulDestinationAddress,
		const char *	pBuffer,
		unsigned long	ulBufferSize,
		unsigned short	usDestinationPort,
		unsigned short &	usTotalSize
	)			const

Definition at line 125 of file UDPCrafter.cpp.

{
    try
    {
        //Create the header
        UDPHeader aHeader;

        //Set the ports
        aHeader.usSourcePort=htons(usSourcePort);
        aHeader.usDestinationPort=htons(usDestinationPort);

        //Check sum
        aHeader.usChecksum=0;

        //Set the total size
        unsigned long ulTotalLength;
        ulTotalLength=UDPHeaderLength+ulBufferSizeBufferSize;

        //Set the length
        aHeader.usLength=htons(ulTotalLength);

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

        //Protect the data
        CArray_ptr<char> pProtection(pNewBuffer);

        //Copy original header
        memcpy(pNewBuffer,
               &aHeader,
               UDPHeaderLength);

        //Do we have data ?
        if (ulBufferSizeBufferSize)
            memcpy(pNewBuffer+UDPHeaderLength,
                   pBuffer,
                   ulBufferSizeBufferSize);

        //Get the checksum
        aHeader.usChecksum=CalculatePseudoChecksum(pNewBuffer,
                                                   ulTotalLength,
                                                   ulDestinationAddress,
                                                   ulTotalLength);

        //Recopy it
        memcpy(pNewBuffer,
               &aHeader,
               UDPHeaderLength);

        //Set the new checksum (if applicateable)
        FinalUDPHeader((LPUDPHeader)pNewBuffer);

        //And return what we have from the IP
        return CIPCrafter::GetCraftedPacket(this,
                                            ulDestinationAddress,
                                            pNewBuffer,
                                            ulTotalLength,
                                            usTotalSize);
    }
    ERROR_HANDLER_RETURN("GetCraftedPacket",NULL)
}

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

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

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 CUDPSocket::Receive	(	char *	pBuffer,
		unsigned long	ulBufferLength,
		IP &	rIP,
		unsigned short &	rSourcePort
	)			[virtual, inherited]

Definition at line 258 of file UDPSocket.cpp.

{
    try
    {
        //Delegate call
        return ReceiveFrom(pBuffer,
                           ulBufferLength,
                           rIP,
                           rSourcePort);
    }
    ERROR_HANDLER_RETURN("Receive",GetErrorCode())
}

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

Reimplemented from CSpoofSocket.

Definition at line 246 of file UDPSocket.cpp.

{
    try
    {
        //Delegate call
        return CSpoofSocket::Receive(pBuffer,
                                     ulBufferLength);
    }
    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())
}

BOOL CUDPSocket::Send	(	unsigned short	usSourcePort,
		const std::string &	rDestinationAddress,
		unsigned short	usDestinationPort,
		const char *	pBuffer,
		unsigned short	usBufferLength
	)			[virtual, inherited]

Reimplemented in CUDPSocketAsync.

Definition at line 190 of file UDPSocket.cpp.

{
    try
    {
        //Delegate the call
        return Send(usSourcePort,
                    StringToLong(rDestinationAddress),
                    usDestinationPort,
                    pBuffer,
                    usBufferLength);
    }
    ERROR_HANDLER_RETURN("Send",GetErrorCode())
}

BOOL CUDPSocket::Send	(	unsigned short	usSourcePort,
		IP	aDestinationAddress,
		unsigned short	usDestinationPort,
		const char *	pBuffer,
		unsigned short	usBufferLength
	)			[virtual, inherited]

Reimplemented in CUDPSocketAsync.

Definition at line 81 of file UDPSocket.cpp.

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

        //Are we raw?
        if (IsRaw())
        {
            //We can construct the UDP here
            UDPHeader aHeader;

            //Set the ports
            aHeader.usSourcePort=htons(usSourcePort);
            aHeader.usDestinationPort=htons(usDestinationPort);

            //Set the length
            aHeader.usLength=htons(UDPHeaderLength);

            //Check sum
            aHeader.usChecksum=0;

            //Result flag
            int iResult;

            //Do we have a buffer ?
            if (usBufferLength)
            {
                //Create the buffer
                unsigned long ulTotalLength;
                ulTotalLength=UDPHeaderLength+usBufferLength;

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

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

                //Set the length
                aHeader.usLength=htons(ulTotalLength);

                //Copy the UDP header
                memcpy(pNewBuffer,
                       &aHeader,
                       UDPHeaderLength);

                //Copy the data
                memcpy(pNewBuffer+UDPHeaderLength,
                       pBuffer,
                       usBufferLength);
                
                //Update it
                aHeader.usChecksum=CalculatePseudoChecksum(pNewBuffer,
                                                           ulTotalLength,
                                                           aDestinationAddress,
                                                           ulTotalLength);

                //Set the new checksum (if applicateable)
                FinalUDPHeader(&aHeader);

                //Recopy it
                memcpy(pNewBuffer,
                       &aHeader,
                       UDPHeaderLength);

                //Send it
                iResult=CSpoofSocket::Send(aDestinationAddress,
                                           pNewBuffer,
                                           ulTotalLength,
                                           usDestinationPort);
            }
            else
            {
                //Update it
                aHeader.usChecksum=CalculatePseudoChecksum((char*)&aHeader,
                                                           UDPHeaderLength,
                                                           aDestinationAddress,
                                                           UDPHeaderLength);

                //Set the new checksum (if applicateable)
                FinalUDPHeader(&aHeader);

                //Send it
                iResult=CSpoofSocket::Send(aDestinationAddress,
                                           (char*)&aHeader,
                                           UDPHeaderLength,
                                           usDestinationPort);
            }

            //Done
            return iResult;
        }
        else
            //Try a regular send
            return CSpoofSocket::Send(aDestinationAddress,
                                      pBuffer,
                                      usBufferLength,
                                      usDestinationPort);
    }
    ERROR_HANDLER_RETURN("Send",GetErrorCode())
}

BOOL CUDPSocket::Send	(	const std::string &	rDestinationAddress,
		unsigned short	usDestinationPort,
		const char *	pBuffer,
		unsigned short	usBufferLength
	)			[virtual, inherited]

Reimplemented in CUDPSocketAsync.

Definition at line 225 of file UDPSocket.cpp.

{
    try
    {
        //Delegate the call
        return Send(0,
                    rDestinationAddress,
                    usDestinationPort,
                    pBuffer,
                    usBufferLength);
    }
    ERROR_HANDLER_RETURN("Send",FALSE)
}

BOOL CUDPSocket::Send	(	IP	aDestinationAddress,
		unsigned short	usDestinationPort,
		const char *	pBuffer,
		unsigned short	usBufferLength
	)			[virtual, inherited]

Reimplemented in CUDPSocketAsync.

Definition at line 208 of file UDPSocket.cpp.

{
    try
    {
        //Delegate the call
        return Send(0,
                    aDestinationAddress,
                    usDestinationPort,
                    pBuffer,
                    usBufferLength);
    }
    ERROR_HANDLER_RETURN("Send",FALSE)
}

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 CIPCrafter::SetChecksum

(

unsigned short

usChecksum

)

[inherited]

Definition at line 105 of file IPCrafter.cpp.

{
    m_usChecksum=usChecksum;
}

void CSpoofSocket::SetConnectedTo

(

const sockaddr_in &

rAddress

)

[protected, inherited]

Definition at line 1606 of file SpoofSocket.cpp.

{
    m_aConnectedTo=rAddress;
}

void CIPCrafter::SetDefault

(

)

[inherited]

Definition at line 90 of file IPCrafter.cpp.

{
    try
    {
        m_usFragmentationFlags=IpFragFlag_DONT_FRAG;
        m_usIdentification=(unsigned short)GetCurrentProcessId();
        m_ucHeaderLength=IPCRAFTER_DEFAULT_HEADER_SIZE; //Default size
        m_ucTypeOfService=IpService_ROUTINE;

        //Default checksum used
        m_DefaultChecksum=TRUE;
    }
    ERROR_HANDLER("SetDefault")
}

void CIPCrafter::SetFragmentationFlags

(

unsigned short

usFragmentationFlags

)

[inherited]

Definition at line 70 of file IPCrafter.cpp.

{
    m_usFragmentationFlags=usFragmentationFlags;
}

void CIPCrafter::SetHeaderLength

(

unsigned char

ucHeaderLength

)

[inherited]

Definition at line 80 of file IPCrafter.cpp.

{
    m_ucHeaderLength=ucHeaderLength;
}

void CIPCrafter::SetIdentification

(

unsigned short

usIdentification

)

[inherited]

Definition at line 75 of file IPCrafter.cpp.

{
    m_usIdentification=usIdentification;
}

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

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

void CIPCrafter::SetTypeOfService

(

unsigned char

ucTypeOfService

)

[inherited]

Definition at line 85 of file IPCrafter.cpp.

{
    m_ucTypeOfService=ucTypeOfService;
}

void CUDPCrafter::SetUDPChecksum

(

unsigned short

usChecksum

)

Definition at line 109 of file UDPCrafter.cpp.

{
    m_usUDPChecksum=usChecksum;
}

void CUDPCrafter::SetUDPDefault

(

)

Definition at line 99 of file UDPCrafter.cpp.

{
    try
    {
        //Default checksum used
        m_UDPDefaultChecksum=TRUE;
    }
    ERROR_HANDLER("SetUDPDefault")
}

void CUDPCrafter::SetUDPUseDefaultChecksum

(

BOOL

bDefault

)

Definition at line 114 of file UDPCrafter.cpp.

{
    m_UDPDefaultChecksum=bDefault;
}

void CIPCrafter::SetUseDefaultChecksum

(

BOOL

bDefault

)

[inherited]

Definition at line 110 of file IPCrafter.cpp.

{
    m_DefaultChecksum=bDefault;
}

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

BOOL CIPCrafter::m_DefaultChecksum [protected, inherited]

Definition at line 102 of file IPCrafter.h.

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

Definition at line 124 of file SpoofBase.h.

unsigned char CIPCrafter::m_ucHeaderLength [protected, inherited]

Definition at line 97 of file IPCrafter.h.

unsigned char CIPCrafter::m_ucTypeOfService [protected, inherited]

Definition at line 98 of file IPCrafter.h.

unsigned short CIPCrafter::m_usChecksum [protected, inherited]

Definition at line 101 of file IPCrafter.h.

unsigned short CIPCrafter::m_usFragmentationFlags [protected, inherited]

Definition at line 95 of file IPCrafter.h.

unsigned short CIPCrafter::m_usIdentification [protected, inherited]

Definition at line 96 of file IPCrafter.h.

---

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

• UDPCrafter.h
• UDPCrafter.cpp