Retail products


Traffic interception SDK

Control every TCP/IP network connection

  • Route connections via proxy
  • Redirect connections and modify the data
  • Block connections and applications
SSL interception SDK

View SSL in plaintext and modify it

  • View the SSL stream decrypted in plaintext
  • Redirect SSL connection and modify decrypted data
  • Browser shows "SSL lock" without warnings

Documentation


KomodiaDNS::CDNSQuery Class Reference

#include <DNSQuery.h>

Inheritance diagram for KomodiaDNS::CDNSQuery:
Collaboration diagram for KomodiaDNS::CDNSQuery:

List of all members.


Public Types

enum  _DnsQueryTypes {
  A = 1, NS = 2, MD = 3, MF = 4,
  CNAME = 5, SOA = 6, MB = 7, MG = 8,
  MR = 9, NLL = 10, WKS = 11, PTR = 12,
  HINFO = 13, MINFO = 14, MX = 15, TXT = 16,
  ERR = 17
}
typedef enum
KomodiaDNS::CDNSQuery::_DnsQueryTypes 
DNSQueryTypes

Public Member Functions

const DnsQuestionHeaderGetQuery (int iIndex) const
std::string GetQueryString (int iIndex) const
int GetQueryCount () const
DNSQueryTypes GetFirstQueryType () const
int Parse (const char *pBuffer, int iNumber)
unsigned short GetQuestionCount () const
void AddQuery (const std::string &rDomain, DNSQueryTypes aType)
unsigned short GetSerializationSize () const
unsigned short SerializeQuery (char *pBuffer) const
CDNSQueryoperator= (const CDNSQuery &rQuery)
 CDNSQuery ()
 CDNSQuery (const CDNSQuery &rQuery)
virtual ~CDNSQuery ()
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)

Detailed Description

Definition at line 62 of file DNSQuery.h.


Member Typedef Documentation


Member Enumeration Documentation

Enumerator:
A 
NS 
MD 
MF 
CNAME 
SOA 
MB 
MG 
MR 
NLL 
WKS 
PTR 
HINFO 
MINFO 
MX 
TXT 
ERR 

Definition at line 65 of file DNSQuery.h.

00066     {
00067         A=1,        //a host address
00068         NS=2,       //an authoritative name server
00069         MD=3,       //a mail destination (Obsolete - use MX)
00070         MF=4,       //a mail forwarder (Obsolete - use MX)
00071         CNAME=5,    //the canonical name for an alias
00072         SOA=6,      //marks the start of a zone of authority
00073         MB=7,       //a mailbox domain name (EXPERIMENTAL)
00074         MG=8,       //a mail group member (EXPERIMENTAL)
00075         MR=9,       //a mail rename domain name (EXPERIMENTAL)
00076         NLL=10, //a null RR (EXPERIMENTAL)
00077         WKS=11,     //a well known service description
00078         PTR=12,     //a domain name pointer
00079         HINFO=13,   //host information
00080         MINFO=14,   //mailbox or mail list information
00081         MX=15,      //mail exchange
00082         TXT=16,     //text strings,
00083         ERR=17      //Internal error, not part of DNS
00084     } DNSQueryTypes;

enum CErrorHandler::_LogPriority [inherited]

Enumerator:
lpDebug 
lpMessage 
lpCritical 
lpError 

Definition at line 53 of file ErrorHandler.h.

00054     {
00055         lpDebug,
00056         lpMessage,
00057         lpCritical,
00058         lpError
00059     } LogPriority;


Constructor & Destructor Documentation

KomodiaDNS::CDNSQuery::CDNSQuery (  ) 

Definition at line 55 of file DNSQuery.cpp.

00055                      : CErrorHandler()
00056 {
00057     try
00058     {
00059         //Set our name
00060         SetName(CDNSQuery_Class);
00061     }
00062     ERROR_HANDLER("CDNSQuery")
00063 }

KomodiaDNS::CDNSQuery::CDNSQuery ( const CDNSQuery rQuery  ) 

Definition at line 65 of file DNSQuery.cpp.

00065                                             : CErrorHandler(rQuery),
00066                                                 m_aQueries(rQuery.m_aQueries)
00067 {
00068     try
00069     {
00070         //Set our name
00071         SetName(CDNSQuery_Class);
00072     }
00073     ERROR_HANDLER("CDNSQuery")
00074 }

KomodiaDNS::CDNSQuery::~CDNSQuery (  )  [virtual]

Definition at line 76 of file DNSQuery.cpp.

00077 {
00078 }


Member Function Documentation

void KomodiaDNS::CDNSQuery::AddQuery ( const std::string &  rDomain,
DNSQueryTypes  aType 
)

Definition at line 90 of file DNSQuery.cpp.

00092 {
00093     try
00094     {
00095         //Construct the structure
00096         DnsQuestionHeader aData;
00097 
00098         //Start putting the data
00099         aData.sName=CDNSManager::ParseAddress(rDomain);
00100         aData.usType=htons(aType);
00101         aData.usClass=htons(DNS_CLASS_INTERNET);
00102 
00103         //Add to the vector
00104         m_aQueries.push_back(aData);
00105     }
00106     ERROR_HANDLER("AddQuery")
00107 }

std::string CErrorHandler::ErrorCodeToString ( DWORD  dwErrorCode  )  [static, inherited]

Definition at line 122 of file ErrorHandler.cpp.

00123 {
00124     try
00125     {
00126         //Get the error string
00127         LPVOID lpMsgBuf;
00128         FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | 
00129                       FORMAT_MESSAGE_FROM_SYSTEM | 
00130                       FORMAT_MESSAGE_IGNORE_INSERTS,
00131                       NULL,
00132                       dwErrorCode,
00133                       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
00134                       (LPTSTR) &lpMsgBuf,
00135                       0,
00136                       NULL);
00137 
00138         //Save it
00139         std::string sMessage;
00140         sMessage+=(char*)lpMsgBuf;
00141         
00142         //Release the buffer
00143         LocalFree(lpMsgBuf);
00144 
00145         //Done
00146         return sMessage;
00147     }
00148     catch (...)
00149     {
00150         return "Unknown";
00151     }
00152 }

const std::string & CErrorHandler::GetClassName (  )  const [protected, inherited]

Reimplemented in CSocketThreadManager.

Definition at line 516 of file ErrorHandler.cpp.

00517 {
00518     return m_sClassName;
00519 }

std::string CErrorHandler::GetCurrentDateTime (  )  [static, inherited]

Definition at line 521 of file ErrorHandler.cpp.

00522 {
00523     try
00524     {
00525         //Our string
00526         std::string sDate;
00527 
00528         //Our tmp buf
00529         char cTmp[128];
00530 
00531         //Get date
00532         _strdate(cTmp);
00533         sDate=cTmp;
00534         sDate+=' ';
00535 
00536         //Get time
00537         _strtime(cTmp);
00538         sDate+=cTmp;
00539 
00540         //Done
00541         return sDate;
00542     }
00543     ERROR_HANDLER_STATIC_RETURN(CErrorHandler_Class,"GetCurrentDateTime","")
00544 }

CDNSQuery::DNSQueryTypes KomodiaDNS::CDNSQuery::GetFirstQueryType (  )  const

Definition at line 259 of file DNSQuery.cpp.

00260 {
00261     try
00262     {
00263         //Do we have the data
00264         if (m_aQueries.empty())
00265             return ERR;
00266         else
00267             return (DNSQueryTypes)m_aQueries.front().usType;
00268     }
00269     ERROR_HANDLER_RETURN("GetFirstQueryType",ERR)
00270 }

const DnsQuestionHeader & KomodiaDNS::CDNSQuery::GetQuery ( int  iIndex  )  const

Definition at line 277 of file DNSQuery.cpp.

00278 {
00279     return m_aQueries[iIndex];
00280 }

int KomodiaDNS::CDNSQuery::GetQueryCount (  )  const

Definition at line 272 of file DNSQuery.cpp.

00273 {
00274     return m_aQueries.size();
00275 }

std::string KomodiaDNS::CDNSQuery::GetQueryString ( int  iIndex  )  const

Definition at line 282 of file DNSQuery.cpp.

00283 {
00284     try
00285     {
00286         //Get the string
00287         std::string sName;
00288         sName=m_aQueries[iIndex].sName;
00289 
00290         //Convert it
00291         return CDNSParser::ConvertName(sName);
00292     }
00293     ERROR_HANDLER_RETURN("GetQueryString","")
00294 }

unsigned short KomodiaDNS::CDNSQuery::GetQuestionCount (  )  const

Definition at line 109 of file DNSQuery.cpp.

00110 {
00111     return m_aQueries.size();
00112 }

unsigned short KomodiaDNS::CDNSQuery::GetSerializationSize (  )  const

Definition at line 178 of file DNSQuery.cpp.

00179 {
00180     try
00181     {
00182         //Our size counter
00183         unsigned short usSize;
00184         usSize=0;
00185 
00186         //Iterate the vector
00187         QueryVector::const_iterator aIterator;
00188         aIterator=m_aQueries.begin();
00189 
00190         //Start the loop
00191         while (aIterator!=m_aQueries.end())
00192         {
00193             //Calculate the struct size
00194             usSize+=aIterator->sName.length()+1;
00195             usSize+=sizeof(unsigned short)*2;
00196 
00197             //Next data
00198             ++aIterator;
00199         }
00200 
00201         //Done
00202         return usSize;
00203     }
00204     ERROR_HANDLER_RETURN("GetSerializationSize",0)
00205 }

CDNSQuery & KomodiaDNS::CDNSQuery::operator= ( const CDNSQuery rQuery  ) 

Definition at line 80 of file DNSQuery.cpp.

00081 {
00082     //Copy the vetor
00083     QueryVector aTmp(rQuery.m_aQueries);
00084     m_aQueries.swap(aTmp);
00085 
00086     //Done
00087     return *this;
00088 }

int KomodiaDNS::CDNSQuery::Parse ( const char *  pBuffer,
int  iNumber 
)

Definition at line 114 of file DNSQuery.cpp.

00116 {
00117     try
00118     {
00119         //Our backup buffer for iterations
00120         const char* pBackupBuffer;
00121         pBackupBuffer=pBuffer;
00122 
00123         //Start to iterate the data
00124         for (int iCount=0;iCount<iNumber;++iCount)
00125         {
00126             //Try to parse the name
00127             std::string sParsedName;
00128 
00129             //The parsed length
00130             unsigned short usLength;
00131 
00132             //Parse it
00133             sParsedName=CDNSParser::ParseName(pBuffer,
00134                                               pBuffer,
00135                                               usLength);
00136 
00137             //Check the length
00138             if (!usLength)
00139             {
00140                 //Report it
00141                 ReportError("Parse","Received zero length!");
00142 
00143                 //Exit
00144                 return NULL;
00145             }
00146 
00147             //Add it to our header
00148             DnsQuestionHeader aData;
00149 
00150             //Set the string name
00151             aData.sName=sParsedName;
00152 
00153             //Increase backup length
00154             pBackupBuffer+=usLength;
00155 
00156             //Get the rest of the data
00157             memcpy(&aData.usType,
00158                    pBackupBuffer,
00159                    DnsQuestionCopyHeader);
00160 
00161             //Reverse the two filds
00162             aData.usClass=htons(aData.usClass);
00163             aData.usType=htons(aData.usType);
00164 
00165             //Add it to the question vector
00166             m_aQueries.push_back(aData);
00167 
00168             //Increase the buffer
00169             pBackupBuffer+=DnsQuestionCopyHeader;
00170         }
00171 
00172         //Done
00173         return pBackupBuffer-pBuffer;
00174     }
00175     ERROR_HANDLER_RETURN("Parse",0)
00176 }

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.

00157 {
00158     if (!GetLog())
00159         return;
00160 
00161     try
00162     {
00163         //Get the log
00164         CErrorLog* pLog;
00165         pLog=GetLog();
00166 
00167         //Convert the error code
00168         char aTmp[11];
00169         sprintf(aTmp,"%d",iErrorCode);
00170 
00171         //Get the string for it
00172         std::string sError;
00173         sError=rMessage;
00174         sError+=", and Socket error: ";
00175         sError+=aTmp;
00176         sError+=", ";
00177         sError+=ErrorCodeToString(iErrorCode);
00178 
00179         //Report to the log
00180         pLog->ReportError(m_sClassName,
00181                           rMethod,
00182                           sError);
00183     }
00184     ERROR_UNKNOWN("ReportError")
00185 }

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

Definition at line 187 of file ErrorHandler.cpp.

00189 {
00190     if (!GetLog())
00191         return;
00192 
00193     try
00194     {
00195         //Get the log
00196         CErrorLog* pLog;
00197         pLog=GetLog();
00198 
00199         //Convert the error code
00200         char aTmp[11];
00201         sprintf(aTmp,"%d",iErrorCode);
00202 
00203         //Get the string for it
00204         std::string sError;
00205         sError="Socket error: ";
00206         sError+=aTmp;
00207         sError+=", ";
00208         sError+=ErrorCodeToString(iErrorCode);
00209 
00210         //Report to the log
00211         pLog->ReportError(m_sClassName,
00212                           rMethod,
00213                           sError);
00214     }
00215     ERROR_UNKNOWN("ReportError")
00216 }

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.

00278 {
00279     if (!GetLog())
00280         return;
00281 
00282     try
00283     {
00284         //Get the log
00285         CErrorLog* pLog;
00286         pLog=GetLog();
00287 
00288         //Convert the number
00289         char aTmp[11];
00290         ltoa(dwAdditionalData,aTmp,10);
00291 
00292         //Create the new message
00293         std::string sNewMessage(rMessage);
00294         sNewMessage+="Additional data: ";
00295         sNewMessage+=aTmp;
00296 
00297         //Report to the log
00298         pLog->ReportError(m_sClassName,
00299                           rMethod,
00300                           sNewMessage);
00301     }
00302     ERROR_UNKNOWN("ReportError")
00303 }

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

Definition at line 218 of file ErrorHandler.cpp.

00220 {
00221     if (!GetLog())
00222         return;
00223 
00224     try
00225     {
00226         CErrorLog* pLog;
00227         pLog=GetLog();
00228 
00229         //Report to the log
00230         pLog->ReportError(m_sClassName,
00231                           rMethod,
00232                           rMessage);
00233     }
00234     ERROR_UNKNOWN("ReportError")
00235 }

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

Definition at line 311 of file ErrorHandler.cpp.

00312 {
00313     if (!GetLog())
00314         return;
00315 
00316     try
00317     {
00318 #ifdef WIN32
00319         //Get the last error
00320         DWORD dwLastError;
00321         dwLastError=GetLastError();
00322 
00323         //Report the error
00324         GetLog()->ReportError(m_sClassName,
00325                               rMethod,
00326                               ErrorCodeToString(dwLastError));
00327 
00328 #else
00329         GetLog()->ReportCatchError(m_sClassName,
00330                                    rMethod,
00331                                    "Unknown error!");
00332 #endif
00333     }
00334     ERROR_UNKNOWN("ReportError")
00335 }

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

Definition at line 237 of file ErrorHandler.cpp.

00239 {
00240     if (!GetLog())
00241         return;
00242 
00243     try
00244     {
00245         //Get the last error
00246         DWORD dwLastError;
00247         dwLastError=GetLastError();
00248 
00249         //Format the message
00250         std::string sMessage;
00251         sMessage=rMessage;
00252         sMessage+=", with error code: ";
00253 
00254         //Convert the error code
00255         char aTmp[11];
00256         itoa(dwLastError,aTmp,10);
00257 
00258         //Add it again
00259         sMessage+=aTmp;
00260         sMessage+=" ";
00261         sMessage+=ErrorCodeToString(dwLastError);
00262         
00263         //Get the log
00264         CErrorLog* pLog;
00265         pLog=GetLog();
00266 
00267         //Report to the log
00268         pLog->ReportError(m_sClassName,
00269                           rMethod,
00270                           sMessage);
00271     }
00272     ERROR_UNKNOWN("ReportErrorOS")
00273 }

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.

00493 {
00494     if (!m_pLog)
00495         return;
00496 
00497     try
00498     {
00499         //Convert the number
00500         char aTmp[11];
00501         ltoa(dwAdditionalData,aTmp,10);
00502 
00503         //Create the new message
00504         std::string sNewMessage(rMessage);
00505         sNewMessage+="Additional data: ";
00506         sNewMessage+=aTmp;
00507 
00508         //Report to the log
00509         m_pLog->ReportError(rClass,
00510                             rMethod,
00511                             sNewMessage);
00512     }
00513     ERROR_UNKNOWN("ReportStaticError")
00514 }

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.

00475 {
00476     if (!m_pLog)
00477         return;
00478 
00479     try
00480     {
00481         //Report to the log
00482         m_pLog->ReportError(rClass,
00483                             rMethod,
00484                             rMessage);
00485     }
00486     ERROR_UNKNOWN("ReportStaticError")
00487 }

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

Definition at line 446 of file ErrorHandler.cpp.

00448 {
00449     if (!m_pLog)
00450         return;
00451 
00452     try
00453     {
00454 #ifdef WIN32
00455         //Get the last error
00456         DWORD dwLastError;
00457         dwLastError=GetLastError();
00458 
00459         //Report the error
00460         m_pLog->ReportError(rClass,
00461                             rMethod,
00462                             ErrorCodeToString(dwLastError));
00463 #else
00464         m_pLog->ReportError(rClass,
00465                             rMethod,
00466                             "Unknown error!");
00467 #endif
00468     }
00469     ERROR_UNKNOWN("ReportStaticError")
00470 }

unsigned short KomodiaDNS::CDNSQuery::SerializeQuery ( char *  pBuffer  )  const

Definition at line 207 of file DNSQuery.cpp.

00208 {
00209     try
00210     {
00211         //Our size counter
00212         unsigned short usSize;
00213         usSize=0;
00214 
00215         //Iterate the vector
00216         QueryVector::const_iterator aIterator;
00217         aIterator=m_aQueries.begin();
00218 
00219         //Start the loop
00220         while (aIterator!=m_aQueries.end())
00221         {
00222             //Calculate the struct size
00223             usSize+=aIterator->sName.length()+1;
00224             usSize+=sizeof(unsigned short)*2;
00225 
00226             //Copy the string
00227             memcpy(pBuffer,
00228                    aIterator->sName.c_str(),
00229                    aIterator->sName.length());
00230             pBuffer+=aIterator->sName.length();
00231 
00232             //Terminating null
00233             *pBuffer=0;
00234             pBuffer++;
00235 
00236             //Copy the data
00237             //Type
00238             memcpy(pBuffer,
00239                    &aIterator->usType,
00240                    sizeof(aIterator->usType));
00241             pBuffer+=sizeof(unsigned short);
00242 
00243             //Class
00244             memcpy(pBuffer,
00245                    &aIterator->usClass,
00246                    sizeof(aIterator->usClass));
00247             pBuffer+=sizeof(unsigned short);
00248 
00249             //Next data
00250             ++aIterator;
00251         }
00252 
00253         //Done
00254         return usSize;
00255     }
00256     ERROR_HANDLER_RETURN("SerializeQuery",0)
00257 }

void CErrorHandler::SetLocalLog ( CErrorLog pLog  )  [inherited]

Definition at line 441 of file ErrorHandler.cpp.

00442 {
00443     m_pLocalLog=pLog;
00444 }

void CErrorHandler::SetLog ( CErrorLog pLog  )  [static, inherited]

Definition at line 305 of file ErrorHandler.cpp.

00306 {
00307     //Save the new log
00308     m_pLog=pLog;
00309 }

void CErrorHandler::SetName ( const std::string &  rName  )  const [protected, inherited]

Definition at line 116 of file ErrorHandler.cpp.

00117 {
00118     //Save the class name
00119     m_sClassName=rName;
00120 }

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.

00359 {
00360     if (!GetLog())
00361         return;
00362 
00363     try
00364     {
00365         //Convert the number
00366         char aTmp[11];
00367         ltoa(dwAdditionalData,aTmp,10);
00368 
00369         //Create the new message
00370         std::string sNewMessage(rMessage);
00371         sNewMessage+="Additional data: ";
00372         sNewMessage+=aTmp;
00373 
00374         //Delegate the call
00375         GetLog()->WriteMessage(m_sClassName,
00376                                rMethod,
00377                                sNewMessage,
00378                                aPriority);
00379     }
00380     ERROR_UNKNOWN("WriteMessage")
00381 }

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

Definition at line 337 of file ErrorHandler.cpp.

00340 {
00341     if (!GetLog())
00342         return;
00343 
00344     try
00345     {
00346         //Delegate the call
00347         GetLog()->WriteMessage(m_sClassName,
00348                                rMethod,
00349                                rMessage,
00350                                aPriority);
00351     }
00352     ERROR_UNKNOWN("WriteMessage")
00353 }

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.

00408 {
00409     if (!m_pLog)
00410         return;
00411 
00412     try
00413     {
00414         //Convert the number
00415         char aTmp[11];
00416         ltoa(dwAdditionalData,aTmp,10);
00417 
00418         //Create the new message
00419         std::string sNewMessage(rMessage);
00420         sNewMessage+="Additional data: ";
00421         sNewMessage+=aTmp;
00422 
00423         //Delegate the call
00424         m_pLog->WriteMessage(rClass,
00425                              rMethod,
00426                              sNewMessage,
00427                              aPriority);
00428     }
00429     ERROR_UNKNOWN("WriteStaticMessage")
00430 }

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.

00388 {
00389     if (!m_pLog)
00390         return;
00391 
00392     try
00393     {
00394         //Delegate the call
00395         m_pLog->WriteMessage(rClass,
00396                              rMethod,
00397                              rMessage,
00398                              aPriority);
00399     }
00400     ERROR_UNKNOWN("WriteStaticMessage")
00401 }


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