CTCPRelayHTTP Class Reference

#include <TCPRelayHTTP.h>

Inheritance diagram for CTCPRelayHTTP:

Collaboration diagram for CTCPRelayHTTP:


Public Types
typedef unsigned short	ConnectionID
enum	_LogPriority { lpDebug, lpMessage, lpCritical, lpError }
typedef enum CErrorHandler::_LogPriority	LogPriority
Public Member Functions
virtual BOOL	Relay (const std::string &rBindAddress, unsigned short usBindPort, const std::string &rDestinationAddress, unsigned short usDestinationPort)
virtual BOOL	Relay (IP aBindAddress, unsigned short usBindPort, IP aDestinationAddress, unsigned short usDestinationPort)
	CTCPRelayHTTP ()
virtual	~CTCPRelayHTTP ()
BOOL	IsRunning () const
virtual BOOL	Stop ()
void	SetTimeout (unsigned long ulTimeoutMS)
unsigned long	GetTimeout () const
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
virtual std::string	ModifyReceiveString (BOOL bIncoming, const char *pBuffer, unsigned short usBufferSize) const
IP	GetBindAddress () const
IP	GetTarget () const
const std::string &	GetClassName () const
void	WriteMessage (const std::string &rMethod, const std::string &rMessage, LogPriority aPriority=lpMessage)
void	WriteMessage (const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData, LogPriority aPriority=lpMessage)
virtual void	ReportError (const std::string &rMethod) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData) const
virtual void	ReportError (const std::string &rMethod, int iErrorCode) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, int iErrorCode) const
virtual void	ReportErrorOS (const std::string &rMethod, const std::string &rMessage) const
void	SetName (const std::string &rName) const
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 47 of file TCPRelayHTTP.h.

Member Typedef Documentation

typedef unsigned short CTCPRelay::ConnectionID [inherited]

Definition at line 57 of file TCPRelay.h.

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.

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

Constructor & Destructor Documentation

CTCPRelayHTTP::CTCPRelayHTTP ( )

Definition at line 51 of file TCPRelayHTTP.cpp.

00051                              : CTCPRelay()
00052 {
00053     try
00054     {
00055         //Set our name
00056         SetName(CTCPRelayHTTP_Class);
00057     }
00058     ERROR_HANDLER("CTCPRelayHTTP")
00059 }

CTCPRelayHTTP::~CTCPRelayHTTP ( ) [virtual]

Definition at line 61 of file TCPRelayHTTP.cpp.

00062 {
00063 }

Member Function Documentation

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 }

IP CTCPRelay::GetBindAddress ( ) const [protected, inherited]

Definition at line 535 of file TCPRelay.cpp.

00536 {
00537     return m_aBindAddress;
00538 }

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 }

IP CTCPRelay::GetTarget ( ) const [protected, inherited]

Definition at line 525 of file TCPRelay.cpp.

00526 {
00527     return m_aTarget;
00528 }

unsigned long CRelay::GetTimeout ( ) const [inherited]

Definition at line 71 of file Relay.cpp.

00072 {
00073     return m_ulTimeout;
00074 }

BOOL CTCPRelay::IsRunning ( ) const [inherited]

Definition at line 626 of file TCPRelay.cpp.

00627 {
00628     return m_bCreated;
00629 }

std::string CTCPRelayHTTP::ModifyReceiveString	(	BOOL	bIncoming,
		const char *	pBuffer,
		unsigned short	usBufferSize
	)			const `[protected, virtual]`

Reimplemented from CTCPRelay.

Definition at line 105 of file TCPRelayHTTP.cpp.

00108 {
00109     try
00110     {
00111         //Only incoming
00112         if (!bIncoming)
00113             return "";
00114 
00115         //Convert to string
00116         std::string sData;
00117         sData=pBuffer;
00118 
00119         //Modify count
00120         int iModifyCount;
00121         iModifyCount=0;
00122 
00123         //Start to modify it
00124         while (ReplaceString(sData))
00125             ++iModifyCount;
00126 
00127         //Did we modify it
00128         if (iModifyCount)
00129             return sData;
00130         else
00131             return "";
00132     }
00133     ERROR_HANDLER_RETURN("ModifyReceiveString","")
00134 }

BOOL CTCPRelayHTTP::Relay	(	IP	aBindAddress,
		unsigned short	usBindPort,
		IP	aDestinationAddress,
		unsigned short	usDestinationPort
	)			`[virtual]`

Reimplemented from CTCPRelay.

Definition at line 81 of file TCPRelayHTTP.cpp.

00085 {
00086     try
00087     {
00088         //Are we running
00089         if (IsRunning())
00090             return FALSE;
00091 
00092         //Save the addresses
00093         m_sBindAddress=CSpoofBase::LongToStdString(aBindAddress);
00094         m_sTargetAddress=CSpoofBase::LongToStdString(aDestinationAddress);
00095 
00096         //Delegate the call
00097         return CTCPRelay::Relay(aBindAddress,
00098                                 usBindPort,
00099                                 aDestinationAddress,
00100                                 usDestinationPort);
00101     }
00102     ERROR_HANDLER_RETURN("Relay",FALSE)
00103 }

BOOL CTCPRelayHTTP::Relay	(	const std::string &	rBindAddress,
		unsigned short	usBindPort,
		const std::string &	rDestinationAddress,
		unsigned short	usDestinationPort
	)			`[virtual]`

Reimplemented from CTCPRelay.

Definition at line 65 of file TCPRelayHTTP.cpp.

00069 {
00070     try
00071     {
00072         //Delegate
00073         return CTCPRelay::Relay(rBindAddress,
00074                                 usBindPort,
00075                                 rDestinationAddress,
00076                                 usDestinationPort);
00077     }
00078     ERROR_HANDLER_RETURN("Relay",FALSE)
00079 }

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 }

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 CRelay::SetTimeout ( unsigned long ulTimeoutMS ) [inherited]

Definition at line 66 of file Relay.cpp.

00067 {
00068     m_ulTimeout=ulTimeoutMS;
00069 }

BOOL CTCPRelay::Stop ( ) [virtual, inherited]

Implements CRelay.

Definition at line 631 of file TCPRelay.cpp.

00632 {
00633     try
00634     {
00635         //Are we created?
00636         if (!m_bCreated)
00637             return TRUE;
00638 
00639         //Delete the listener
00640         m_pSocket->DeleteSocketFromThread();
00641         m_pSocket=NULL;
00642 
00643         {
00644             //Lock
00645             CCriticalAutoRelease aRelease(m_pCSection);
00646 
00647             //Iterate the data
00648             ClientMap::iterator aIterator;
00649             aIterator=m_aClientMap.begin();
00650             while (aIterator!=m_aClientMap.end())
00651             {
00652                 //Signal the socket
00653                 aIterator->second.pIncomingConnection->Stop();
00654 
00655                 //Erase
00656                 aIterator=m_aClientMap.erase(aIterator);
00657             }
00658         }
00659 
00660         //We are not created
00661         m_bCreated=FALSE;
00662 
00663         //Done
00664         return TRUE;
00665     }
00666     ERROR_HANDLER_RETURN("Stop",FALSE)
00667 }

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:

Retail products

Documentation

CTCPRelayHTTP Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation