CRealIPResolver Class Reference

#include <RealIPResolver.h>

Inheritance diagram for CRealIPResolver:

[legend]

Collaboration diagram for CRealIPResolver:

[legend]

List of all members.

Public Member Functions
IP	Resolve (IP aInternetIP=83974850, const std::string &rTestURL="www.google.com", unsigned short usPort=80)
BOOL	IsNATAddress (IP aIP) const
	CRealIPResolver ()
virtual	~CRealIPResolver ()
void	SetLocalLog (CErrorLog *pLog)
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 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 std::string	FormatData (const std::string &rClass, const std::string &rMethod, const std::string &rMsgOrError, bool bError=true)
Protected Member Functions
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)

---

Detailed Description

Definition at line 52 of file RealIPResolver.h.

---

Constructor & Destructor Documentation

CRealIPResolver::CRealIPResolver

(

)

Definition at line 56 of file RealIPResolver.cpp.

                                 : CErrorHandler()
{
    try
    {
        //Set our name
        SetName(CRealIPResolver_Class);
    }
    ERROR_HANDLER_RETHROW("CRealIPResolver")
}

CRealIPResolver::~CRealIPResolver

(

)

[virtual]

Definition at line 66 of file RealIPResolver.cpp.

{
}

---

Member Function Documentation

std::string CErrorHandler::ErrorCodeToString

(

DWORD

dwErrorCode

)

[static, inherited]

Definition at line 218 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 140 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;
}

const std::string & CErrorHandler::GetClassName

(

)

const [protected, inherited]

Reimplemented in CSocketThreadManager.

Definition at line 567 of file ErrorHandler.cpp.

{
    return m_sClassName;
}

std::string CErrorHandler::GetCurrentDateTime

(

)

[static, inherited]

Definition at line 572 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","")
}

BOOL CRealIPResolver::IsNATAddress

(

IP

aIP

)

const

Definition at line 317 of file RealIPResolver.cpp.

{
    try
    {
        //Our NAT addresses data
        static const iNatCount=4;
        static const std::string sNat[iNatCount*2]={"10.0.0.0","10.255.255.255",
                                                    "127.0.0.0","127.255.255.255",
                                                    "172.16.0.0","172.31.255.255",
                                                    "192.168.0.0","192.168.255.255"};

        //Our address
        IP aTestIP;
        aTestIP=htonl(aIP);

        //Run a test
        for (int iCount=0;
             iCount<iNatCount;
             ++iCount)
        {
            //Translate the addresses
            IP aFromIP;
            aFromIP=htonl(CSocketBase::StringToLong(sNat[iCount*2]));

            //To address
            IP aToIP;
            aToIP=htonl(CSocketBase::StringToLong(sNat[iCount*2+1]));

            //Is it NAT
            if (aFromIP<=aTestIP &&
                aToIP>=aTestIP)
                return TRUE;
        }

        //Not NAT
        return FALSE;
    }
    ERROR_HANDLER_RETURN("IsNATAddress",FALSE)
}

void CErrorHandler::RegisterError	(	DWORD	dwErrorCode,
		const std::string &	rDescription
	)			[static, inherited]

Definition at line 597 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 CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage,
		int	iErrorCode
	)			const [protected, virtual, inherited]

Definition at line 271 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 300 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 416 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 438 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 327 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 470 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 378 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
        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 540 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 523 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 503 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 343 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")
}

IP CRealIPResolver::Resolve	(	IP	aInternetIP = 83974850,
		const std::string &	rTestURL = "www.google.com",
		unsigned short	usPort = 80
	)

Definition at line 70 of file RealIPResolver.cpp.

{
    try
    {
        //Get it
        DWORD dwResult;
        DWORD dwIndex;
        dwResult=GetBestInterface(aInternetIP,
                                  &dwIndex);

        //Did we manage?
        if (dwResult!=NO_ERROR)
        {
            //Report it
            ReportErrorOS("Resolve","Failed to call routing command! (GetBestInterface)");

            //Exit
            return 0;
        }

        //Get the length of data
        DWORD dwLength;
        dwLength=0;
        dwResult=GetInterfaceInfo(NULL,
                                  &dwLength);
        
        if (dwResult!=NO_ERROR &&
            dwResult!=ERROR_INSUFFICIENT_BUFFER)
        {
            //Report it
            ReportErrorOS("Resolve","Failed to call routing command! (GetInterfaceInfo, NULL)");

            //Exit
            return 0;
        }

        //Allocate the data
        char* pData;
        pData=new char[dwLength];

        //Protect it
        CArray_ptr<char> pProtection(pData);

        //Recall
        if (GetInterfaceInfo((PIP_INTERFACE_INFO)pData,
                             &dwLength)!=NO_ERROR)
        {
            //Report it
            ReportErrorOS("Resolve","Failed to call routing command! (GetInterfaceInfo)");

            //Exit
            return 0;
        }

        //The Interface name
        WCHAR pName[MAX_ADAPTER_NAME];
        pName[0]=0;
        pName[1]=0;

        //Get the data
        PIP_INTERFACE_INFO pInfo;
        pInfo=(PIP_INTERFACE_INFO)pData;

        //Start to iterate the interfaces
        for (int iCount=0;
             iCount<pInfo->NumAdapters;
             ++iCount)
            if (pInfo->Adapter[iCount].Index==dwIndex)
            {
                //Copy the data
                wcscpy(pName,
                       pInfo->Adapter[iCount].Name);

                //Exit
                break;
            }

        //Do we have it?
        if (!pName[0])
            //Nop
            return 0;

        //Further iterations
        //Now get adapters information
        dwLength=0;
        dwResult=GetAdaptersInfo(NULL,
                                 &dwLength);

        if (dwResult!=NO_ERROR &&
            dwResult!=ERROR_BUFFER_OVERFLOW)
        {
            //Report it
            ReportErrorOS("Resolve","Failed to call routing command! (GetAdaptersInfo, NULL)");

            //Exit
            return 0;
        }

        //Reallocate the data
        char* pAdapterRawInfo;
        pAdapterRawInfo=new char[dwLength];

        //Protect it
        CArray_ptr<char> pProtection2(pAdapterRawInfo);

        //And get it
        if (GetAdaptersInfo((PIP_ADAPTER_INFO)pAdapterRawInfo,
                            &dwLength)!=NO_ERROR)
        {
            //Report it
            ReportErrorOS("Resolve","Failed to call routing command! (GetAdaptersInfo)");

            //Exit
            return 0;
        }

        //Get the name we want
        std::string sSymbolicToFind;
        sSymbolicToFind=ConvertSymbolic((const char*)pName);

        //Our info
        PIP_ADAPTER_INFO pAdapterInfo;
        pAdapterInfo=(PIP_ADAPTER_INFO)pAdapterRawInfo;

        //The IP we want
        IPVector aVector;

        do
        {
            //Get the symbolic
            std::string sSymbolic;
            sSymbolic=pAdapterInfo->AdapterName;

            //Is it?
            if (sSymbolic==sSymbolicToFind)
            {
                //Get the IPs
                aVector=ExtractIP((const void*)pAdapterInfo);

                //Exit the loop
                break;
            }

            //Next
            pAdapterInfo=pAdapterInfo->Next;
        } while (pInfo);

        //Do we have addresses?
        if (aVector.empty())
            return 0;

        //Do we have only one address?
        if (aVector.size()==1)
            //Do we need to test it?
            if (!rTestURL.empty())
                if (TestAddress(aVector[0],
                                CSocketBase::StringToLong(rTestURL),
                                usPort))
                    return aVector[0];
                else
                    return 0;
            else
                return aVector[0];

        //We need to traverse the vetor
        return 0;

    }
    ERROR_HANDLER_RETURN("Resolve",0)
}

void CErrorHandler::SetLocalLog

(

CErrorLog *

pLog

)

[inherited]

Definition at line 498 of file ErrorHandler.cpp.

{
    m_pLocalLog=pLog;
}

void CErrorHandler::SetLog

(

CErrorLog *

pLog

)

[static, inherited]

Definition at line 464 of file ErrorHandler.cpp.

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

void CErrorHandler::SetName

(

const std::string &

rName

)

const [protected, inherited]

Definition at line 134 of file ErrorHandler.cpp.

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

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

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

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

Definition at line 199 of file ErrorHandler.cpp.

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

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

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

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

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

---

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

• RealIPResolver.h
• RealIPResolver.cpp