KomodiaDNS::CDNSSocket Class Reference

#include <DNSSocket.h>

Inheritance diagram for KomodiaDNS::CDNSSocket:

[legend]

Collaboration diagram for KomodiaDNS::CDNSSocket:

[legend]

List of all members.

Classes
struct	_ParseThreadData
struct	_WaitingRequests
Public Types
enum	_LogPriority { lpDebug, lpMessage, lpCritical, lpError }
typedef enum CErrorHandler::_LogPriority	LogPriority
Public Member Functions
CThreadPool *	GetThreadManager () const
CDNSAnswers *	Receive ()
BOOL	Initialize ()
void	SetMultithreaded (int iThreadNumber)
void	SetMultithreaded (CThreadPool *pThreadManager)
CDNSAnswers *	SocketReceive (char *pBuffer, int iBufferLengh, BOOL bTCP=FALSE)
CDNSAnswers *	ParseAnswer (char *pBuffer, char *pOriginalBuffer, int iBufferLengh, BOOL bFromThread=FALSE, BOOL bTCP=FALSE)
BOOL	SetConnectionTimeout (int iMS)
BOOL	Send (const char *pBuffer, unsigned short bufLen, LPVOID lpLocalIDData)
	CDNSSocket (CDNSManager *pFather, const std::string strDNSServer, BOOL bTCP, BOOL bAsync, BOOL bAsyncConnect)
virtual	~CDNSSocket ()
void	SetLocalLog (CErrorLog *pLog)
Static Public Member Functions
static std::string	GetCurrentDateTime ()
static std::string	ErrorCodeToString (DWORD dwErrorCode)
static void	SetLog (CErrorLog *pLog)
Protected Member Functions
const std::string &	GetClassName () const
void	WriteMessage (const std::string &rMethod, const std::string &rMessage, LogPriority aPriority=lpMessage)
void	WriteMessage (const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData, LogPriority aPriority=lpMessage)
virtual void	ReportError (const std::string &rMethod) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData) const
virtual void	ReportError (const std::string &rMethod, int iErrorCode) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, int iErrorCode) const
virtual void	ReportErrorOS (const std::string &rMethod, const std::string &rMessage) const
void	SetName (const std::string &rName) const
Static Protected Member Functions
static void	WriteStaticMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, LogPriority aPriority=lpMessage)
static void	WriteStaticMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData, LogPriority aPriority=lpMessage)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData)
Friends
class	CDNSTCPSocket
class	CDNSUDPSocket

---

Detailed Description

Definition at line 63 of file DNSSocket.h.

---

Member Typedef Documentation

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

---

Member Enumeration Documentation

enum CErrorHandler::_LogPriority [inherited]

Enumerator:

lpDebug
lpMessage
lpCritical
lpError

Definition at line 53 of file ErrorHandler.h.

    {
        lpDebug,
        lpMessage,
        lpCritical,
        lpError
    } LogPriority;

---

Constructor & Destructor Documentation

KomodiaDNS::CDNSSocket::CDNSSocket	(	CDNSManager *	pFather,
		const std::string	strDNSServer,
		BOOL	bTCP,
		BOOL	bAsync,
		BOOL	bAsyncConnect
	)

Definition at line 62 of file DNSSocket.cpp.

                                           : CErrorHandler(),
                                             m_pFather(pFather),
                                             m_bUseTCP(bTCP),
                                             m_bAsync(bAsync),
                                             m_strDNSServer(strDNSServer),
                                             m_pThreadManager(NULL),
                                             m_pTCP(NULL),
                                             m_pUDP(NULL),
                                             m_pCSection(NULL),
                                             m_bOwners(FALSE),
                                             m_bAsyncConnect(bAsyncConnect),
                                             m_aConnectionStatus(csNone),
                                             m_pCSectionDeque(NULL)
{
    try
    {
        //Set our name
        SetName(CDNSSocket_Class);

        //The timeout
        m_iTimeout=INITIAL_TIMEOUT;

        //Create the CS
        m_pCSection=COSManager::CreateCriticalSection();
        m_pCSectionDeque=COSManager::CreateCriticalSection();
    }
    ERROR_HANDLER("CDNSSocket")
}

KomodiaDNS::CDNSSocket::~CDNSSocket

(

)

[virtual]

Definition at line 95 of file DNSSocket.cpp.

{
    try
    {
        //Deletet the data
        std::for_each(m_aPendingData.begin(),
                      m_aPendingData.end(),
                      DeleteProc);

        //Clear it
        m_aPendingData.clear();

        //Delete the sockets
        //Do we have these sockets ?
        if (m_pTCP)
            m_pTCP->DeleteSocketFromThread();

        if (m_pUDP)
            m_pUDP->DeleteSocketFromThread();

        if (m_bOwners)
            //Delete the thread manager
            delete m_pThreadManager;

        //Delete the CS
        delete m_pCSection;
        delete m_pCSectionDeque;
    }
    ERROR_HANDLER("~CDNSSocket")
}

---

Member Function Documentation

std::string CErrorHandler::ErrorCodeToString

(

DWORD

dwErrorCode

)

[static, inherited]

Definition at line 122 of file ErrorHandler.cpp.

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

        //Save it
        std::string sMessage;
        sMessage+=(char*)lpMsgBuf;
        
        //Release the buffer
        LocalFree(lpMsgBuf);

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

const std::string & CErrorHandler::GetClassName

(

)

const [protected, inherited]

Reimplemented in CSocketThreadManager.

Definition at line 516 of file ErrorHandler.cpp.

{
    return m_sClassName;
}

std::string CErrorHandler::GetCurrentDateTime

(

)

[static, inherited]

Definition at line 521 of file ErrorHandler.cpp.

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

        //Our tmp buf
        char cTmp[128];

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

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

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

CThreadPool * KomodiaDNS::CDNSSocket::GetThreadManager

(

)

const

Definition at line 237 of file DNSSocket.cpp.

{
    return m_pThreadManager;
}

BOOL KomodiaDNS::CDNSSocket::Initialize

(

)

Definition at line 135 of file DNSSocket.cpp.

{
    try
    {
        //Initialize our sockets
        //if TCP
        if (m_bUseTCP)
        {
            //Do we have the socket
            if (m_pTCP)
                delete m_pTCP;

            //Create the socket
            m_pTCP=new CDNSTCPSocket(this);

            //Try to create it
            if (!m_pTCP->Create())
            {
                //Write the error
                ReportError("Initialize","Failed to create socket!");

                //Exit
                return FALSE;
            }

            //Set the blocking mode
            if (!m_bAsync)
                if (!m_pTCP->ReBlock())
                {
                    //Write an error
                    ReportError("Initialize","Failed to switch socket to blocking mode!");

                    //And exit
                    return FALSE;
                }
                else
                    ;
            else
                //Set it to have buffer
                m_pTCP->AllowBlockedBuffer(TRUE);
        }
        else
        {
            //Do we have it
            if (m_pUDP)
                delete m_pUDP;

            //Create the socket
            m_pUDP=new CDNSUDPSocket(this);

            //Try to create it
            if (!m_pUDP->Create())
            {
                //Write the error
                ReportError("Initialize","Failed to create socket!");

                //Exit
                return FALSE;
            }

            //Set the blocking mode
            if (!m_bAsync)
                if (!m_pUDP->ReBlock())
                {
                    //Write an error
                    ReportError("Initialize","Failed to switch socket to blocking mode!");

                    //And exit
                    return FALSE;
                }
                else
                    ;
            else
                if (!m_pUDP->Listen())
                {
                    //Write an error
                    ReportError("Initialize","Failed to listen on socket to blocking mode!");

                    //And exit
                    return FALSE;
                }
        }

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

CDNSAnswers * KomodiaDNS::CDNSSocket::ParseAnswer	(	char *	pBuffer,
		char *	pOriginalBuffer,
		int	iBufferLengh,
		BOOL	bFromThread = FALSE,
		BOOL	bTCP = FALSE
	)

Definition at line 556 of file DNSSocket.cpp.

{
    try
    {
        //Check if we have a thread manager
        if (m_pThreadManager && 
            !bFromThread)
        {
            //Check the buf len
            if (iBufferLengh<=0)
            {
                //Report it
                ReportError("ParseAnswer","Invalid buffer length!");

                //Exit
                return NULL;
            }

            //Create a job
            ParseThreadData* pData;
            pData=new ParseThreadData;

            //Set the data
            pData->pData=pBuffer;
            pData->pOriginalData=pOriginalBuffer;
            pData->iDataSize=iBufferLengh;
            pData->pSocket=this;
            pData->bTCP=bTCP;

            //Submit
            m_pThreadManager->SubmitJob(ThreadProc,
                                        (LPVOID)pData);

            //Exit
            return NULL;
        }

        //Parse the answer
        CDNSAnswers* pAnswers;
        pAnswers=new CDNSAnswers;

        //Try to parse
        int iResult;
        iResult=pAnswers->Parse(pBuffer,
                                iBufferLengh);

        if (!iResult)
        {
            //Delete it, and set to null
            delete pAnswers;
            pAnswers=NULL;

            //Write the error
            ReportError("ParseAnswer","Failed to parse answers");

            //Delete the memory
            delete [] pOriginalBuffer;

            //And exit
            return NULL;
        }

        if (m_bAsync)
            //Inform the manager
            m_pFather->OnDNSReceive(pAnswers);

        if (iResult<iBufferLengh)
        {
            //Check if TCP
            if (bTCP)
                iResult+=2;

            //Change the data and do again
            iBufferLengh-=iResult;
            pBuffer+=iResult;

            //And parse again
            return ParseAnswer(pBuffer,
                               pOriginalBuffer,
                               iBufferLengh,
                               TRUE,
                               bTCP);
        }
        else
            delete [] pOriginalBuffer;

        //Done
        return pAnswers;
    }
    ERROR_HANDLER_RETURN("ParseAnswer",NULL)
}

CDNSAnswers * KomodiaDNS::CDNSSocket::Receive

(

)

Definition at line 500 of file DNSSocket.cpp.

{
    if (m_bAsync)
        return NULL; //We will receive it later
    
    try
    {
        //Here we initialize the receive of the DNS
        char* pBuffer;
        pBuffer=new char[2000];

        //How much data did we receive
        int iReceived=0;

        if (m_bUseTCP)
            iReceived=m_pTCP->Receive(pBuffer,
                                      2000);
        else
            iReceived=m_pUDP->Receive(pBuffer,
                                      2000);

        //Check if we had errors
        if (iReceived==CSpoofBase::GetErrorCode() ||
            !iReceived)
        {
            //Delete the memory
            delete [] pBuffer;

            //Done
            return FALSE;
        }

        //Parse it
        return SocketReceive(pBuffer,
                             iReceived,
                             m_bUseTCP);
    }
    ERROR_HANDLER_RETURN("Receive",NULL)
}

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

Definition at line 154 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

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

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

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

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

Definition at line 187 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

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

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

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

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

Definition at line 275 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

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

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

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

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

Definition at line 218 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

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

void CErrorHandler::ReportError

(

const std::string &

rMethod

)

const [protected, virtual, inherited]

Definition at line 311 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

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

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

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

Definition at line 237 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

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

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

        //Add it again
        sMessage+=aTmp;
        sMessage+=" ";
        sMessage+=ErrorCodeToString(dwLastError);
        
        //Get the log
        CErrorLog* pLog;
        pLog=GetLog();

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

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

Definition at line 489 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

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

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

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

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

Definition at line 472 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

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

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

Definition at line 446 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

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

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

BOOL KomodiaDNS::CDNSSocket::Send	(	const char *	pBuffer,
		unsigned short	bufLen,
		LPVOID	lpLocalIDData
	)

Definition at line 242 of file DNSSocket.cpp.

{
    try
    {
        //Error indicator
        int iError;
        iError=0;

        //Are we TCP
        if (m_bUseTCP)
        {
            //Reconnection status
            BOOL bReconnect;
            bReconnect=FALSE;

            //Enter the CS
            CCriticalAutoRelease aRelease(m_pCSection);

            //Are we disconnected
            if (m_aConnectionStatus==csDisconnected)
                //Try to reinitialize
                if (!Initialize())
                {
                    //Write the error
                    ReportError("Send","Failed to reinitialize!");

                    //Done
                    return FALSE;
                }
                else
                    m_aConnectionStatus=csNone;

            //What kind of use ?
            if (m_aConnectionStatus==csNone)
            {
                //Set connection to pending
                SetConnectionStatus(csPending);

                //Exit the CS
                aRelease.Exit();

                //connect
                BOOL bResult;
                bResult=m_pTCP->Connect(0,
                                        m_strDNSServer.c_str(),
                                        53,
                                        !m_bAsyncConnect ||
                                        bReconnect);

                //Check for error
                if (!bResult)
                {
                    //Set the connection status
                    SetConnectionStatus(csNone);

                    //Write the error
                    ReportError("Send","Failed to connect!");

                    //Get the error
                    iError=m_pTCP->GetSystemLastError();
                }
                else if (!m_bAsyncConnect ||
                         !m_bAsync ||
                         bReconnect)
                    //Set the connection status
                    SetConnectionStatus(csConnected);
            }
            else
                aRelease.Exit();

            //Do we need to add to the pool
            if (m_aConnectionStatus!=csConnected &&
                !iError)
                //Add to queue
                AddData(pBuffer,
                        bufLen,
                        lpLocalIDData);
            //Can we send the data
            else if (!iError &&
                     m_aConnectionStatus==csConnected)
            {
                //Try to flush the data
                if (!Flush())
                {
                    //Write the error
                    ReportError("Send","Failed to flush!");

                    //Get the error
                    iError=1;
                }
                else if (!m_pTCP->Send(pBuffer,bufLen))
                {
                    //Write the error
                    ReportError("Send","Failed to send!");

                    //Get the error
                    iError=m_pTCP->GetSystemLastError();
                }
            }
        }
        else if (m_pUDP->Send(0,
                 m_strDNSServer.c_str(),
                 53,
                 pBuffer,
                 bufLen)==CSpoofBase::GetErrorCode())
        {
            //Write the error
            ReportError("Send","Failed to send UDP packet!");

            //Get the error
            iError=m_pUDP->GetSystemLastError();
        }

        //Did we have an error ?
        if (iError)
            //Exit
            return FALSE;
        else
            //Parse the data
            return TRUE;
    }
    ERROR_HANDLER_RETURN("Send",FALSE)
}

BOOL KomodiaDNS::CDNSSocket::SetConnectionTimeout

(

int

iMS

)

Definition at line 540 of file DNSSocket.cpp.

{
    try
    {
        //Save it
        m_iTimeout=iMS;

        //Which socket we use
        if (m_bUseTCP)
            return m_pTCP->SetConnectionTimeout(iMS);
        else
            return TRUE;
    }
    ERROR_HANDLER_RETURN("SetTimeout",FALSE)
}

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 KomodiaDNS::CDNSSocket::SetMultithreaded

(

CThreadPool *

pThreadManager

)

Definition at line 723 of file DNSSocket.cpp.

{
    try
    {
        //Delete an old manager, if we have it
        if (m_pThreadManager)
            delete m_pThreadManager;

        //Save it
        m_pThreadManager=pThreadManager;

        //We don't own the thread manager
        m_bOwners=FALSE;
    }
    ERROR_HANDLER("SetMultithreaded")
}

void KomodiaDNS::CDNSSocket::SetMultithreaded

(

int

iThreadNumber

)

Definition at line 706 of file DNSSocket.cpp.

{
    try
    {
        //Do we have a thread manager
        if (m_pThreadManager)
            return;

        //Create it
        m_pThreadManager=new CThreadPool(iThreadNumber);

        //We own the thread manager
        m_bOwners=TRUE;
    }
    ERROR_HANDLER("SetMultithreaded")
}

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

CDNSAnswers * KomodiaDNS::CDNSSocket::SocketReceive	(	char *	pBuffer,
		int	iBufferLengh,
		BOOL	bTCP = FALSE
	)

Definition at line 673 of file DNSSocket.cpp.

{
    try
    {
        //Save the buffer
        char* pOriginalBuffer;
        pOriginalBuffer=pBuffer;

        //Check is it TCP
        if (bTCP)
        {
            //Adjust the buffer
            pBuffer+=2;
            iBufferLengh-=2;

            //Try to flush, if we have any ?
            if (!Flush())
                //Report it
                ReportError("SocketReceive","Failed to flush!");
        }

        //Parse the answer
        return ParseAnswer(pBuffer,
                           pOriginalBuffer,
                           iBufferLengh,
                           !m_bAsync,
                           bTCP);
    }
    ERROR_HANDLER_RETURN("SocketReceive",NULL)  
}

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 CDNSTCPSocket [friend]

Definition at line 65 of file DNSSocket.h.

friend class CDNSUDPSocket [friend]

Definition at line 66 of file DNSSocket.h.

---

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

• DNSSocket.h
• DNSSocket.cpp