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 CSocket::_SocketShutdown	SocketShutdown
Public Member Functions
BOOL	SetNagle (BOOL bNagle)
virtual BOOL	Close ()
BOOL	IsConnected () const
virtual int	Send (const char *pBuffer, unsigned long ulBufferLength)
virtual BOOL	Accept (CTCPSocket *pNewSocket)
CTCPSocket *	Accept ()
virtual BOOL	Listen (unsigned long ulBackLog=5)
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 ()
	CTCPSocket (BOOL bRawSocket=false)
virtual	~CTCPSocket ()
unsigned char	GetProtocol () const
void	SetProtocol (unsigned char iProtocol)
BOOL	IsRaw () const
BOOL	SetReceiveTimeout (unsigned long ulMS)
SOCKET	GetHandle () const
virtual SOCKET	Detach ()
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 int	Receive (char *pBuffer, unsigned long ulBufferLength)
virtual int	Peek (char *pBuffer, unsigned long ulBufferLength)
void	SetTTL (unsigned char ucTTL)
virtual void	SetSourceAddress (IP aSourceAddress)
virtual void	SetSourceAddress (const std::string &rSourceAddress)
virtual IP	GetBindAddress () const
virtual unsigned short	GetBindPort () const
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)
BOOL	Create (int iProtocol)
bool	operator== (const CSocket &rSocket) const
bool	operator< (const CSocket &rSocket) const
int	GetLastError () const
void	SetLocalLog (CErrorLog *pLog, bool bWriteToMain=false)
void	WriteError (const std::string &rClass, const std::string &rMethod, const std::string &rError) const
void	WriteMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage) const
Static Public Member Functions
static int	GetErrorCode ()
static int	GetSystemLastError ()
static BOOL	IsInitialized ()
static unsigned long	StringToLong (const std::string &rAddress)
static char FAR *	LongToString (unsigned long ulAddr)
static std::string	LongToStdString (unsigned long ulAddr)
static BOOL	InitializeSockets (BOOL bMultiThreaded=TRUE, unsigned long ulNumberOfThreads=10)
static BOOL	ShutdownSockets ()
static unsigned long	GetNumberOfThreads ()
static BOOL	IsMultiThreaded ()
static CGenericCriticalSection *	GetGlobalCriticalSection ()
static unsigned long	ResolveDNS (const std::string &rAddress)
static BOOL	ValidAddress (const std::string &rAddress)
static CErrorHandler *	GetSecondaryLog ()
static CErrorHandler *	GetThirdLog ()
static void	ClearStaticLogs ()
static std::string	GetCurrentDateTime ()
static std::string	ErrorCodeToString (DWORD dwErrorCode)
static void	RegisterError (DWORD dwErrorCode, const std::string &rDescription)
static void	SetLog (CErrorLog *pLog)
static void	WriteStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rError)
static void	WriteStaticMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)
static std::string	FormatData (const std::string &rClass, const std::string &rMethod, const std::string &rMsgOrError, bool bError=true)
Protected Member Functions
virtual void	BeforeAccept ()
virtual BOOL	IsAsyncClass () const
void	SetConnectionStatus (BOOL bConnected)
virtual void	Accepted ()
void	SetAcceptance (CTCPSocket *pNewSocket, SOCKET aSocket, sockaddr_in aAddress) const
void	SetConnectedTo (const sockaddr_in &rAddress)
IP	GetSourceAddress () const
unsigned char	GetTTL () const
BOOL	CheckSocketValid () const
void	AssignSocket (SOCKET aNewSocket, unsigned char ucProtocol=IPPROTO_TCP)
BOOL	ValidSocket () const
virtual void	InitializeIP ()
virtual int	ReceiveFrom (char *pBuffer, unsigned long ulBufferLength, IP &rIP, unsigned short &rSourcePort)
virtual void	NotifyShutdown ()
void	RegisterShutdown (CSocketBase *pBase)
void	SetLastError (const std::string &rMethod) const
void	SetLastError (const std::string &, int iErrorCode) const
void	WriteMessage (const std::string &rMethod, const std::string &rMessage) const
const std::string &	GetClassName () const
virtual void	ReportError (const std::string &rMethod) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, const std::string &rAdditionalData) const
virtual void	ReportError (const std::string &rMethod, int iErrorCode) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, int iErrorCode) const
virtual void	ReportErrorOS (const std::string &rMethod, const std::string &rMessage) const
void	SetName (const std::string &rName) const
Static Protected Member Functions
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData)
static void	ReportStaticErrorOS (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)
Static Protected Attributes
static CGenericCriticalSection *	m_pCSection = NULL
Friends
class	CIPCrafter

---

Detailed Description

Definition at line 47 of file TCPSocket.h.

---

Member Typedef Documentation

typedef enum CSocket::_SocketShutdown CSocket::SocketShutdown [inherited]

---

Member Enumeration Documentation

enum CSocket::_SocketShutdown [inherited]

Enumerator:

ssReceive
ssSend
ssBoth

Definition at line 51 of file Socket.h.

    {
        ssReceive,
        ssSend,
        ssBoth
    } SocketShutdown;

---

Constructor & Destructor Documentation

CTCPSocket::CTCPSocket

(

BOOL

bRawSocket = false

)

Definition at line 54 of file TCPSocket.cpp.

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

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

CTCPSocket::~CTCPSocket

(

)

[virtual]

Definition at line 80 of file TCPSocket.cpp.

{
}

---

Member Function Documentation

CTCPSocket * CTCPSocket::Accept

(

)

Definition at line 242 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

)

[virtual]

Reimplemented in CTCPSocketAsyncSSL, and CTCPSocketAsync.

Definition at line 301 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)
        {
            //Delegate
            SetAcceptance(pNewSocket,
                          aNewSocket,
                          aAddress);

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

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

void CTCPSocket::Accepted

(

)

[protected, virtual]

Definition at line 390 of file TCPSocket.cpp.

{
}

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

Definition at line 500 of file Socket.cpp.

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

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

void CTCPSocket::BeforeAccept

(

)

[protected, virtual]

Definition at line 469 of file TCPSocket.cpp.

{
}

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

Reimplemented in CTCPSocketAsync.

Definition at line 269 of file Socket.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;

        //Save new addresses
        if (aSourceAddress &&
            !m_ulSourceAddress)
            m_ulSourceAddress=aSourceAddress;

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

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

Definition at line 318 of file Socket.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)
}

BOOL CSocket::CanRead

(

)

const [inherited]

Definition at line 721 of file Socket.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 CSocket::CanWrite

(

)

const [inherited]

Definition at line 767 of file Socket.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 CSocket::CheckSocketValid

(

)

const [protected, inherited]

Definition at line 387 of file Socket.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)
}

void CErrorHandler::ClearStaticLogs

(

)

[static, inherited]

Definition at line 680 of file ErrorHandler.cpp.

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

    delete m_pThirdLevelLog;
    m_pThirdLevelLog=NULL;
}

BOOL CTCPSocket::Close

(

)

[virtual]

Reimplemented from CSocket.

Reimplemented in CTCPSocketAsync.

Definition at line 446 of file TCPSocket.cpp.

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

        //Check if the father can close
        if (CSocket::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 115 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 103 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 196 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]

Definition at line 127 of file TCPSocket.cpp.

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

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

BOOL CSocket::Create

(

int

iProtocol

)

[inherited]

Definition at line 98 of file Socket.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_aSocket=socket(AF_INET,
                                      SOCK_RAW,
                                      iProtocol);
            else
                if (iProtocol==IPPROTO_TCP)
                    m_aSocket=socket(AF_INET,
                                          SOCK_STREAM,
                                          iProtocol);
                else if (iProtocol==IPPROTO_UDP)
                    m_aSocket=socket(AF_INET,
                                          SOCK_DGRAM,
                                          iProtocol);
        }
        else
        {
            //Here we create the raw socket
            if (m_bRaw || iProtocol==IPPROTO_ICMP)
                m_aSocket=WSASocket(AF_INET,
                                         SOCK_RAW,
                                         iProtocol,
                                         NULL,
                                         NULL,
                                         WSA_FLAG_OVERLAPPED);
            else
                if (iProtocol==IPPROTO_TCP)
                    m_aSocket=WSASocket(AF_INET,
                                             SOCK_STREAM,
                                             iProtocol,
                                             NULL,
                                             NULL,
                                             WSA_FLAG_OVERLAPPED);
                else if (iProtocol==IPPROTO_UDP)
                    m_aSocket=WSASocket(AF_INET,
                                             SOCK_DGRAM,
                                             iProtocol,
                                             NULL,
                                             NULL,
                                             WSA_FLAG_OVERLAPPED);
        }

        //Check for socket validity
        if (m_aSocket==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_aSocket,
                          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 CTCPSocketAsyncSSL, and CTCPSocketAsync.

Definition at line 84 of file TCPSocket.cpp.

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

        //Create it
        SetProtocol(IPPROTO_TCP);

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

SOCKET CSocket::Detach

(

)

[virtual, inherited]

Reimplemented in CTCPSocketAsync.

Definition at line 374 of file Socket.cpp.

{
    //Save the socket
    SOCKET aTmp;
    aTmp=m_aSocket;

    //Erase it
    m_aSocket=INVALID_SOCKET;

    //Return the original
    return aTmp;
}

std::string CErrorHandler::ErrorCodeToString

(

DWORD

dwErrorCode

)

[static, inherited]

Definition at line 251 of file ErrorHandler.cpp.

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

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

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

        //Save it
        std::string sMessage;

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

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

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

Definition at line 145 of file ErrorHandler.cpp.

{
    //Our message
    std::string sMsg;

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

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

    //Done
    return sMsg;
}

IP CSocket::GetBindAddress

(

)

const [virtual, inherited]

Reimplemented in CTCPSocketAsync.

Definition at line 902 of file Socket.cpp.

{
    return m_ulSourceAddress;
}

unsigned short CSocket::GetBindPort

(

)

const [virtual, inherited]

Reimplemented in CTCPSocketAsync.

Definition at line 337 of file Socket.cpp.

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

        //Create the local address
        sockaddr_in soSrc;

        //Buffer size
        int iSize;
        iSize=sizeof(soSrc);

        //Try to get it
        if (getsockname(GetHandle(),
                        (sockaddr*)&soSrc,
                        &iSize))
        {
            //Error
            SetLastError("Bind");

            //Exit
            return 0;
        }
        else
            return htons(soSrc.sin_port);
    }
    ERROR_HANDLER_RETURN("GetBindPort",0)
}

const std::string & CErrorHandler::GetClassName

(

)

const [protected, inherited]

Reimplemented in CSocketThreadManager.

Definition at line 617 of file ErrorHandler.cpp.

{
    return m_sClassName;
}

std::string CErrorHandler::GetCurrentDateTime

(

)

[static, inherited]

Definition at line 622 of file ErrorHandler.cpp.

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

        //Our tmp buf
        char cTmp[128];

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

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

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

int CSocketBase::GetErrorCode

(

)

[static, inherited]

Definition at line 368 of file SocketBase.cpp.

{
    return SOCKET_ERROR;
}

CGenericCriticalSection * CSocketBase::GetGlobalCriticalSection

(

)

[static, inherited]

Definition at line 363 of file SocketBase.cpp.

{
    return m_pCSection;
}

SOCKET CSocket::GetHandle

(

)

const [inherited]

Definition at line 369 of file Socket.cpp.

{
    return m_aSocket;
}

int CSocketBase::GetLastError

(

)

const [inherited]

Definition at line 141 of file SocketBase.cpp.

{
    return m_iLastError;
}

unsigned long CSocketBase::GetNumberOfThreads

(

)

[static, inherited]

Definition at line 334 of file SocketBase.cpp.

{
    return m_ulNumberOfThreads;
}

long CSocket::GetPeerAddress

(

)

const [inherited]

Definition at line 677 of file Socket.cpp.

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

unsigned short CSocket::GetPeerPort

(

)

const [inherited]

Definition at line 716 of file Socket.cpp.

{
    return htons(m_aConnectedTo.sin_port);
}

unsigned char CSocket::GetProtocol

(

)

const [inherited]

Definition at line 855 of file Socket.cpp.

{
    return m_ucProtocol;
}

CErrorHandler * CErrorHandler::GetSecondaryLog

(

)

[static, inherited]

Definition at line 658 of file ErrorHandler.cpp.

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

    //Return it
    return m_pSecondLevelLog;
}

IP CSocket::GetSourceAddress

(

)

const [protected, inherited]

Definition at line 850 of file Socket.cpp.

{
    return m_ulSourceAddress;
}

int CSocketBase::GetSystemLastError

(

)

[static, inherited]

Definition at line 358 of file SocketBase.cpp.

{
    return WSAGetLastError();
}

CErrorHandler * CErrorHandler::GetThirdLog

(

)

[static, inherited]

Definition at line 669 of file ErrorHandler.cpp.

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

    //Return it
    return m_pThirdLevelLog;
}

unsigned char CSocket::GetTTL

(

)

const [protected, inherited]

Definition at line 845 of file Socket.cpp.

{
    return m_ucTTL;
}

void CSocket::InitializeIP

(

)

[protected, virtual, inherited]

Definition at line 476 of file Socket.cpp.

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

        //More invalids
        m_ulSourceAddress=0;

        //Some defaults
        m_ucTTL=64;

        //We are not overlapped
        m_bOverlapped=FALSE;

        //Not connected
        memset(&m_aConnectedTo,
               0,
               sizeof(m_aConnectedTo));
    }
    ERROR_HANDLER("InitializeIP")
}

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

Definition at line 146 of file SocketBase.cpp.

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

        //Exit
        return TRUE;
    }

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

        //Exit
        return FALSE;
    }

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

        //Exit
        return FALSE;
    }

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

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

            //Exit
            return FALSE;
        }

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

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

        //And we are initialized
        m_bInitialized=TRUE;

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

BOOL CTCPSocket::IsAsyncClass

(

)

const [protected, virtual]

Reimplemented in CTCPSocketAsync.

Definition at line 404 of file TCPSocket.cpp.

{
    return FALSE;
}

BOOL CTCPSocket::IsConnected

(

)

const

Definition at line 399 of file TCPSocket.cpp.

{
    return m_bConnected;
}

BOOL CSocket::IsCreated

(

)

const [inherited]

Definition at line 813 of file Socket.cpp.

{
    return ValidSocket();
}

BOOL CSocketBase::IsInitialized

(

)

[static, inherited]

Definition at line 339 of file SocketBase.cpp.

{
    return m_bInitialized;
}

BOOL CSocketBase::IsMultiThreaded

(

)

[static, inherited]

Definition at line 329 of file SocketBase.cpp.

{
    return m_bMultiThreaded;
}

BOOL CSocket::IsRaw

(

)

const [inherited]

Definition at line 471 of file Socket.cpp.

{
    return m_bRaw;
}

BOOL CTCPSocket::Listen

(

unsigned long

ulBackLog = 5

)

[virtual]

Reimplemented in CTCPSocketAsync.

Definition at line 214 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 CSocketBase::LongToStdString

(

unsigned long

ulAddr

)

[static, inherited]

Definition at line 291 of file SocketBase.cpp.

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

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

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

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

char FAR * CSocketBase::LongToString

(

unsigned long

ulAddr

)

[static, inherited]

Definition at line 310 of file SocketBase.cpp.

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

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

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

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

void CSocketBase::NotifyShutdown

(

)

[protected, virtual, inherited]

Definition at line 273 of file SocketBase.cpp.

{
}

bool CSocket::operator<

(

const CSocket &

rSocket

)

const [inherited]

Definition at line 892 of file Socket.cpp.

{
    return m_aSocket<rSocket.m_aSocket;
}

bool CSocket::operator==

(

const CSocket &

rSocket

)

const [inherited]

Definition at line 887 of file Socket.cpp.

{
    return m_aSocket==rSocket.m_aSocket;
}

int CSocket::Peek	(	char *	pBuffer,
		unsigned long	ulBufferLength
	)			[virtual, inherited]

Reimplemented in CTCPSocketAsyncSSL, and CTCPSocketAsync.

Definition at line 665 of file Socket.cpp.

{
    try
    {
        return LocalReceive(pBuffer,
                            ulBufferLength,
                            TRUE);
    }
    ERROR_HANDLER_RETURN("Peek",GetErrorCode())
}

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

Reimplemented in CTCPSocketAsyncSSL, CTCPSocketAsync, and CUDPSocket.

Definition at line 653 of file Socket.cpp.

{
    try
    {
        return LocalReceive(pBuffer,
                            ulBufferLength,
                            FALSE);
    }
    ERROR_HANDLER_RETURN("Receive",GetErrorCode())
}

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

Definition at line 514 of file Socket.cpp.

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

        //Receive data
        int iResult;

        //Receive
        if (m_ucProtocol!=IPPROTO_TCP)
        {
            //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 CErrorHandler::RegisterError	(	DWORD	dwErrorCode,
		const std::string &	rDescription
	)			[static, inherited]

Definition at line 647 of file ErrorHandler.cpp.

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

void CSocketBase::RegisterShutdown

(

CSocketBase *

pBase

)

[protected, inherited]

Definition at line 277 of file SocketBase.cpp.

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

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

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

Definition at line 304 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

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

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

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

Definition at line 333 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

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

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

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

Definition at line 461 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

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

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

Definition at line 483 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

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

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

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

Definition at line 376 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

void CErrorHandler::ReportError

(

const std::string &

rMethod

)

const [protected, virtual, inherited]

Definition at line 515 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

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

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

Definition at line 427 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

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

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

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

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

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

Definition at line 590 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

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

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

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

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

Definition at line 573 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

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

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

Definition at line 553 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

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

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

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

Definition at line 392 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

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

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

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

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

unsigned long CSocketBase::ResolveDNS

(

const std::string &

rAddress

)

[static, inherited]

Definition at line 431 of file SocketBase.cpp.

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

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

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

Definition at line 245 of file Socket.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 CSocket::Send	(	IP	aDestinationAddress,
		const char *	pBuffer,
		unsigned long	ulBufferLength,
		unsigned short	usDestinationPort = 0
	)			[virtual, inherited]

Definition at line 191 of file Socket.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;

        //Set to no error
        iResult=!GetErrorCode();

        //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 CTCPSocketAsyncSSL, and CTCPSocketAsync.

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

void CTCPSocket::SetAcceptance	(	CTCPSocket *	pNewSocket,
		SOCKET	aSocket,
		sockaddr_in	aAddress
	)			const [protected]

Definition at line 347 of file TCPSocket.cpp.

{
    //Call before accept routing
    pNewSocket->BeforeAccept();

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

BOOL CSocket::SetBroadcast

(

BOOL

bBroadcast

)

[inherited]

Definition at line 818 of file Socket.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 CSocket::SetConnectedTo

(

const sockaddr_in &

rAddress

)

[protected, inherited]

Definition at line 897 of file Socket.cpp.

{
    m_aConnectedTo=rAddress;
}

void CTCPSocket::SetConnectionStatus

(

BOOL

bConnected

)

[protected]

Definition at line 394 of file TCPSocket.cpp.

{
    m_bConnected=bConnected;
}

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

Definition at line 124 of file SocketBase.cpp.

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

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

void CSocketBase::SetLastError

(

const std::string &

rMethod

)

const [protected, inherited]

Definition at line 104 of file SocketBase.cpp.

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

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

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

Definition at line 543 of file ErrorHandler.cpp.

{
    //Save the log
    m_pLocalLog=pLog;

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

void CErrorHandler::SetLog

(

CErrorLog *

pLog

)

[static, inherited]

Definition at line 509 of file ErrorHandler.cpp.

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

BOOL CTCPSocket::SetNagle

(

BOOL

bNagle

)

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

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

void CSocket::SetProtocol

(

unsigned char

iProtocol

)

[inherited]

Definition at line 186 of file Socket.cpp.

{
    m_ucProtocol=ucProtocol;
}

BOOL CSocket::SetReceiveTimeout

(

unsigned long

ulMS

)

[inherited]

Definition at line 860 of file Socket.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 CSocket::SetSourceAddress

(

const std::string &

rSourceAddress

)

[virtual, inherited]

Definition at line 440 of file Socket.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 CSocket::SetSourceAddress

(

IP

aSourceAddress

)

[virtual, inherited]

Definition at line 435 of file Socket.cpp.

{
    m_ulSourceAddress=aSourceAddress;
}

void CSocket::SetTTL

(

unsigned char

ucTTL

)

[inherited]

Definition at line 453 of file Socket.cpp.

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

        if(setsockopt(GetHandle(),
                      IPPROTO_IP,
                      IP_TTL,
                      (const char*)&ucTTL,
                      sizeof(ucTTL)))
            SetLastError("SetTTL");
    }
    ERROR_HANDLER("SetTTL")
}

BOOL CSocket::Shutdown

(

SocketShutdown

eHow

)

[inherited]

Definition at line 683 of file Socket.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 CSocketBase::ShutdownSockets

(

)

[static, inherited]

Definition at line 231 of file SocketBase.cpp.

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

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

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

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

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

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

        //Not initialized anymore
        m_bInitialized=FALSE;

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

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

unsigned long CSocketBase::StringToLong

(

const std::string &

rAddress

)

[static, inherited]

Definition at line 344 of file SocketBase.cpp.

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

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

BOOL CSocketBase::ValidAddress

(

const std::string &

rAddress

)

[static, inherited]

Definition at line 373 of file SocketBase.cpp.

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

BOOL CSocket::ValidSocket

(

)

const [protected, inherited]

Definition at line 264 of file Socket.cpp.

{
    return m_aSocket!=INVALID_SOCKET;
}

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

Definition at line 168 of file ErrorHandler.cpp.

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

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

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

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

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

Definition at line 360 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

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

Definition at line 226 of file ErrorHandler.cpp.

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

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

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

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

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

Definition at line 192 of file ErrorHandler.cpp.

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

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

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

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

Definition at line 210 of file ErrorHandler.cpp.

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

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

---

Friends And Related Function Documentation

friend class CIPCrafter [friend, inherited]

Definition at line 59 of file Socket.h.

---

Member Data Documentation

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

Definition at line 122 of file SocketBase.h.

---

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

• TCPSocket.h
• TCPSocket.cpp