CRealTimeTraceRouteSocket Class Reference
#include <RealTimeTraceRouteSocket.h>
Inheritance diagram for CRealTimeTraceRouteSocket:
Collaboration diagram for CRealTimeTraceRouteSocket:
Classes | |
| struct | _ResolveThreadData |
| struct | _TraceRouteData |
| class | CRealTimeDNSManager |
Public Types | |
| enum | _MaxHops { mhMaxHops = 40 } |
| typedef enum CRealTimeTraceRouteSocket::_MaxHops | MaxHops |
| typedef struct CRealTimeTraceRouteSocket::_TraceRouteData | TraceRouteData |
| typedef struct CRealTimeTraceRouteSocket::_ResolveThreadData | ResolveThreadData |
Public Member Functions | |
| void | FakeLastRequest () |
| void | SetResolveStatus (BOOL bResolve) |
| unsigned char | GetMaxHops () const |
| const TraceRouteData * | GetData () const |
| BOOL | IsInitialized () const |
| virtual BOOL | IsTraceDone () const |
| virtual BOOL | TraceRoute (const std::string &rDestinationAddress, DWORD dwTimeout) |
| virtual BOOL | TraceRoute (IP aDestinationAddress, DWORD dwTimeout) |
| CRealTimeTraceRouteSocket (std::string sDNSServer, BOOL bDNSTcp, BOOL bMultithreaded=TRUE) | |
| virtual | ~CRealTimeTraceRouteSocket () |
| void | SetID (unsigned short usID) |
| void | SetSequence (unsigned short usSequence) |
| void | SetUseSameID (BOOL bSameID) |
| int | GetDataSize () const |
| unsigned char | GetTTL () const |
| DWORD | GetTimeElapsed () const |
| BOOL | IsTimeout () const |
| IP | GetReplyingAddress () const |
| virtual BOOL | Ping (const std::string &rDestinationAddress, DWORD dwTimeout=3000) |
| virtual BOOL | Ping (IP aDestinationAddress, DWORD dwTimeout=3000) |
| BOOL | IsPingDone () const |
| virtual BOOL | Close () |
| virtual BOOL | Create () |
| BOOL | Create (int iProtocol) |
| void | SetSendBuffer (const char *pBuffer, unsigned short usSendSize) |
| const LPIpHeader | GetLastICMPIPHeader () const |
| const LPICMPHeader | GetLastICMPICMPHeader () const |
| unsigned long | GetLastDataSize () |
| const char * | GetLastData () const |
| const LPIpHeader | GetLastIPHeader () const |
| const LPICMPHeader | GetLastICMPHeader () const |
| BOOL | SendInformation (const std::string &rDestinationAddress, BOOL bReply, unsigned short usIdentifier, unsigned short usSequence) |
| BOOL | SendInformation (IP aDestinationAddress, BOOL bReply, unsigned short usIdentifier, unsigned short usSequence) |
| BOOL | SendTimestamp (const std::string &rDestinationAddress, BOOL bReply, unsigned short usIdentifier, unsigned short usSequence, unsigned long ulOriginateTimestamp, unsigned long ulReceiveTimestamp, unsigned long ulTransmitTimestamp) |
| BOOL | SendTimestamp (IP aDestinationAddress, BOOL bReply, unsigned short usIdentifier, unsigned short usSequence, unsigned long ulOriginateTimestamp, unsigned long ulReceiveTimestamp, unsigned long ulTransmitTimestamp) |
| BOOL | SendEcho (const std::string &rDestinationAddress, BOOL bReply, unsigned short usIdentifier, unsigned short usSequence, unsigned long ulData) |
| BOOL | SendEcho (IP aDestinationAddress, BOOL bReply, unsigned short usIdentifier, unsigned short usSequence, unsigned long ulData) |
| BOOL | SendRedirect (const std::string &rDestinationAddress, unsigned char ucType, const std::string &rGatewayAddress) |
| BOOL | SendRedirect (IP aDestinationAddress, unsigned char ucType, IP aGatewayAddress) |
| BOOL | SendQuench (const std::string &rDestinationAddress) |
| BOOL | SendQuench (IP aDestinationAddress) |
| BOOL | SendParameter (const std::string &rDestinationAddress, unsigned char ucError) |
| BOOL | SendParameter (IP aDestinationAddress, unsigned char ucError) |
| BOOL | SendTime (const std::string &rDestinationAddress, unsigned char ucType) |
| BOOL | SendTime (IP aDestinationAddress, unsigned char ucType) |
| BOOL | SendUnreachable (const std::string &rDestinationAddress, unsigned char ucType) |
| BOOL | SendUnreachable (IP aDestinationAddress, unsigned char ucType) |
| virtual int | Send (IP aDestinationAddress, const char *pBuffer, unsigned long ulBufferLength, unsigned short usDestinationPort=0) |
| virtual int | Send (const std::string &rDestinationAddress, const char *pBuffer, unsigned long ulBufferLength, unsigned short usDestinationPort=0) |
| BOOL | SetReceiveTimeout (unsigned long ulMS) |
| SOCKET | GetHandle () const |
| BOOL | SetBroadcast (BOOL bBroadcast) |
| BOOL | IsCreated () const |
| BOOL | CanWrite () const |
| BOOL | CanRead () const |
| unsigned short | GetPeerPort () const |
| BOOL | Shutdown (SocketShutdown eHow) |
| long | GetPeerAddress () const |
| virtual BOOL | Sniff (BOOL bSniff) |
| virtual int | Receive (char *pBuffer, unsigned long ulBufferLength) |
| CIPOptions * | GetOptions () const |
| void | SetOptions (BOOL bOptions) |
| void | SetTTL (unsigned char ucTTL) |
| unsigned short | CalculatePseudoChecksum (const char *pBuffer, int iBufferLength, IP aDestinationAddress, int iPacketLength) const |
| virtual void | SetSourceAddress (IP aSourceAddress) |
| virtual void | SetSourceAddress (const std::string &rSourceAddress) |
| virtual BOOL | Bind (const std::string &rSourceAddress, unsigned short usPort) |
| virtual BOOL | Bind (IP aSourceAddress, unsigned short usPort) |
| virtual int | SendRawBuffer (IP aDestinationAddress, const char *pBuffer, unsigned long ulBufferLength, unsigned short usDestinationPort) |
| bool | operator== (const CSpoofSocket &rSocket) const |
| bool | operator< (const CSpoofSocket &rSocket) const |
| int | GetSystemLastError () const |
| int | GetLastError () const |
| void | SetLocalLog (CErrorLog *pLog) |
| BOOL | HasTimeout () const |
| void | DisableEvents (unsigned char ucEvents) |
| BOOL | IsClosing () const |
| void | ForceReceiveEvent () |
| virtual void | DeleteSocketFromThread () |
| virtual void | DeleteSocketFromThread (DWORD dwTimeToWait) |
| void | AllowBlockedBuffer (BOOL bAllow) |
| virtual BOOL | ReAsync () |
| virtual BOOL | ReBlock () |
| void | FreezeThread () |
| BOOL | DisableAsync () |
| BOOL | KillTimer () |
| BOOL | SetTimeout (int iMs) |
Static Public Member Functions | |
| static void | Shutdown () |
| static long | ResolveDNS (const std::string &rAddress) |
| static BOOL | ValidAddress (const std::string &rAddress) |
| static LPIpHeader | ConstructStaticIPHeader (unsigned char ucProtocol, unsigned short usFragmentationFlags, unsigned char ucTTL, unsigned short usIdentification, unsigned char ucHeaderLength) |
| static unsigned short | CalculateChecksum (const unsigned short *pBuffer, int iSize) |
| static int | GetErrorCode () |
| static BOOL | IsInitialized () |
| static unsigned long | StringToLong (const std::string &rAddress) |
| static char FAR * | LongToString (unsigned long ulAddr) |
| static std::string | LongToStdString (unsigned long ulAddr) |
| static BOOL | InitializeSockets (BOOL bMultiThreaded=TRUE, unsigned long ulNumberOfThreads=10) |
| static BOOL | InitializeSocketsNoMap (BOOL bMultiThreaded=TRUE, unsigned long ulNumberOfThreads=10) |
| static BOOL | ShutdownSockets () |
| static unsigned long | GetNumberOfThreads () |
| static BOOL | IsMultiThreaded () |
| static CGenericCriticalSection * | GetGlobalCriticalSection () |
| static std::string | GetCurrentDateTime () |
| static std::string | ErrorCodeToString (DWORD dwErrorCode) |
| static void | SetLog (CErrorLog *pLog) |
| static void | SimpleMessageMap () |
| static void | SimpleMessageMap (DWORD dwRunTimeMS) |
| static void | SimpleMessageMap (LPMapProc pProc, BOOL bStopWhenTRUE, DWORD dwSleep) |
| static char | SimpleMessageMapKey (DWORD dwSleep) |
| static void | Initialize () |
| static void | SetInstance (HINSTANCE hInst) |
Protected Member Functions | |
| CRealTimeDNSManager * | GetDNSManager () const |
| virtual void | TraceDataForModify (TraceRouteData *pData, BOOL bResolved) |
| virtual void | TraceData (const TraceRouteData *pData, BOOL bResolved) |
| virtual BOOL | IsIDOK (unsigned short usID, unsigned short usSequence) const |
| virtual BOOL | OnSocketTimeout () |
| virtual void | TraceDone (BOOL bError) |
| virtual BOOL | OnSocketReceive (int iErrorCode) |
| virtual void | PingDone (BOOL bTimeout) |
| virtual BOOL | SetAsync () |
| virtual SOCKET | GetAsyncHandle () const |
| const char * | GetSendBuffer () const |
| int | GetBufferSize () const |
| virtual void | FinalICMPHeader (LPICMPHeader lpHead) const |
| BOOL | SendICMP (LPICMPHeader lpHead, const std::string &rDestinationAddress) |
| BOOL | SendICMP (LPICMPHeader lpHead, IP aDestinationAddress) |
| virtual LPICMPHeader | ConstructICMP () const |
| virtual BOOL | ProccessICMP (const char *pBuffer) |
| void | SetConnectedTo (const sockaddr_in &rAddress) |
| IP | GetSourceAddress () const |
| unsigned char | GetProtocol () const |
| BOOL | HasOptions () const |
| virtual LPIpHeader | ConstructIPHeader (unsigned char ucProtocol, unsigned short usFragmentationFlags, unsigned char ucTTL, unsigned short usIdentification, unsigned char ucHeaderLength) const |
| BOOL | CheckSocketValid () const |
| void | AssignSocket (SOCKET aNewSocket, unsigned char ucProtocol=IPPROTO_TCP) |
| BOOL | IsRaw () const |
| void | SetProtocol (unsigned char iProtocol) |
| BOOL | ValidSocket () const |
| virtual void | InitializeIP () |
| virtual void | SetIPHeaderAddress (LPIpHeader lpHead, IP aSourceAddress, IP aDestinationAddress) const |
| virtual void | FinalIPHeader (LPIpHeader lpHead) const |
| virtual int | ReceiveFrom (char *pBuffer, unsigned long ulBufferLength, IP &rIP, unsigned short &rSourcePort) |
| virtual void | NotifyShutdown () |
| void | RegisterShutdown (CSpoofBase *pBase) |
| void | SetLastError (const std::string &rMethod) const |
| void | SetLastError (const std::string &, int iErrorCode) 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 |
| virtual BOOL | OnSocketConnect (int iErrorCode)=0 |
| virtual BOOL | OnSocketAccept (int iErrorCode)=0 |
| virtual BOOL | OnSocketClose (int iErrorCode)=0 |
| virtual BOOL | OnSocketOOB (int iErrorCode)=0 |
| virtual BOOL | OnSocketWrite (int iErrorCode)=0 |
| BOOL | IsBlocking () const |
| int | InternalWSAAsyncSelect (unsigned int wMsg, long lEvent) |
| void | SocketClosing () |
| int | GetSocketID () const |
| HWND | GetWindowHandle () const |
| void | RemoveSocketFromList () |
| void | AddSocketToList () |
| BOOL | Block () |
| virtual BOOL | SendBlockedBuffer (const CBlockedBuffer::CBlockedData &rData) |
| CBlockedBuffer * | GetBlockedBuffer () const |
| virtual BOOL | SocketConnected (int iErrorCode) |
| virtual BOOL | SocketClosed (int iErrorCode) |
| virtual BOOL | SocketWrite (int iErrorCode) |
| virtual void | SystemTimeout () |
| BOOL | SetSystemTimeout (int iMS) |
| BOOL | KillSystemTimer () |
| BOOL | HasSystemTimer () const |
| virtual void | OnSocketDelete () |
| virtual void | SocketCreated () |
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) |
| static CSocketThreadManager * | GetSocketThreadManager () |
Friends | |
| class | CIPCrafter |
Detailed Description
Definition at line 52 of file RealTimeTraceRouteSocket.h.
Member Typedef Documentation
typedef enum CAsyncSocket::_AsyncEvents CAsyncSocket::AsyncEvents [inherited] |
typedef enum CErrorHandler::_LogPriority CErrorHandler::LogPriority [inherited] |
typedef MapProc CAsyncSocket::LPMapProc [inherited] |
Definition at line 93 of file AsyncSocket.h.
typedef BOOL(* CAsyncSocket::MapProc)() [inherited] |
| typedef struct CRealTimeTraceRouteSocket::_ResolveThreadData CRealTimeTraceRouteSocket::ResolveThreadData |
typedef enum CSpoofSocket::_SocketShutdown CSpoofSocket::SocketShutdown [inherited] |
Member Enumeration Documentation
enum CAsyncSocket::_AsyncEvents [inherited] |
Definition at line 83 of file AsyncSocket.h.
00084 { 00085 aeReceive=1, 00086 aeSend=2, 00087 aeOOB=4, 00088 aeClose=8 00089 } AsyncEvents;
enum CErrorHandler::_LogPriority [inherited] |
Definition at line 53 of file ErrorHandler.h.
00054 { 00055 lpDebug, 00056 lpMessage, 00057 lpCritical, 00058 lpError 00059 } LogPriority;
enum CSpoofSocket::_SocketShutdown [inherited] |
Definition at line 444 of file SpoofSocket.h.
00445 { 00446 ssReceive, 00447 ssSend, 00448 ssBoth 00449 } SocketShutdown;
Constructor & Destructor Documentation
| CRealTimeTraceRouteSocket::CRealTimeTraceRouteSocket | ( | std::string | sDNSServer, | |
| BOOL | bDNSTcp, | |||
| BOOL | bMultithreaded = TRUE | |||
| ) |
Definition at line 170 of file RealTimeTraceRouteSocket.cpp.
00172 : CPingSocket(), 00173 m_bTraceDone(TRUE), 00174 m_pManager(NULL), 00175 m_pCSection(NULL), 00176 m_bInitialized(FALSE), 00177 m_bResolveIPs(TRUE), 00178 m_pCSectionResolve(NULL), 00179 m_pCSectionGeneral(NULL), 00180 m_bFinishing(FALSE), 00181 m_bPartialDone(FALSE) 00182 { 00183 try 00184 { 00185 //Set our name 00186 SetName(CRealTimeTraceRouteSocket_Class); 00187 00188 //Same ping ID 00189 SetUseSameID(TRUE); 00190 00191 //Create the manager 00192 m_pManager=new CRealTimeDNSManager(this, 00193 sDNSServer, 00194 bDNSTcp); 00195 00196 //Create the CS 00197 m_pCSection=COSManager::CreateCriticalSection(); 00198 m_pCSectionResolve=COSManager::CreateCriticalSection(); 00199 m_pCSectionGeneral=COSManager::CreateCriticalSection(); 00200 00201 //Initialize it 00202 if (!(m_bInitialized=m_pManager->Initialize())) 00203 //Report it 00204 ReportError("CRealTimeTraceRouteSocket","Failed to initialize DNS!"); 00205 else 00206 { 00207 //Set the timeout of the DNS 00208 m_pManager->SetDNSTimeout(15000); 00209 00210 //Set the socket timeout 00211 m_pManager->SetConnectionTimeout(7500); 00212 00213 //Set it to be multithreaded 00214 if (bMultithreaded) 00215 m_pManager->ParseMultithreaded(10); 00216 } 00217 } 00218 ERROR_HANDLER("CRealTimeTraceRouteSocket") 00219 }
| CRealTimeTraceRouteSocket::~CRealTimeTraceRouteSocket | ( | ) | [virtual] |
Definition at line 221 of file RealTimeTraceRouteSocket.cpp.
00222 { 00223 try 00224 { 00225 //Delete the CS 00226 delete m_pCSection; 00227 delete m_pCSectionResolve; 00228 delete m_pCSectionGeneral; 00229 00230 //Delete the manager 00231 delete m_pManager; 00232 } 00233 ERROR_HANDLER("~CRealTimeTraceRouteSocket") 00234 }
Member Function Documentation
| void CAsyncSocket::AddSocketToList | ( | ) | [protected, inherited] |
Definition at line 184 of file AsyncSocket.cpp.
00185 { 00186 try 00187 { 00188 //Allocate our window 00189 AllocateHandle(); 00190 00191 //Do we have a CS 00192 if (m_pCSection) 00193 { 00194 //Enter the CS 00195 CCriticalAutoRelease aRelease(m_pCSection); 00196 00197 //Add socket to list 00198 m_iSocketID=GetAsyncHandle(); 00199 m_aSocketMap.insert(SocketMap::value_type(m_iSocketID,this)); 00200 00201 //Added to list 00202 m_bList=TRUE; 00203 } 00204 else 00205 ReportError("AddSocketToList","Critical section not initialized"); 00206 } 00207 ERROR_HANDLER("AddSocketToList") 00208 }
| void CAsyncSocket::AllowBlockedBuffer | ( | BOOL | bAllow | ) | [inherited] |
Definition at line 865 of file AsyncSocket.cpp.
00866 { 00867 try 00868 { 00869 //Do we have a buffer 00870 if (bAllow && 00871 !m_pBlockedBuffer) 00872 m_pBlockedBuffer=new CBlockedBuffer(this); 00873 else if (!bAllow && 00874 m_pBlockedBuffer) 00875 { 00876 //Delete and reset the blocked buffer 00877 delete m_pBlockedBuffer; 00878 m_pBlockedBuffer=NULL; 00879 } 00880 } 00881 ERROR_HANDLER("AllowBlockedBuffer") 00882 }
| void CSpoofSocket::AssignSocket | ( | SOCKET | aNewSocket, | |
| unsigned char | ucProtocol = IPPROTO_TCP | |||
| ) | [protected, inherited] |
Definition at line 1127 of file SpoofSocket.cpp.
01128 { 01129 try 01130 { 01131 //Sets the protocol 01132 m_ucProtocol=ucProtocol; 01133 01134 //Binds to a socket 01135 m_aSpoofSocket=aNewSocket; 01136 } 01137 ERROR_HANDLER("AssignSocket") 01138 }
| BOOL CSpoofSocket::Bind | ( | IP | aSourceAddress, | |
| unsigned short | usPort | |||
| ) | [virtual, inherited] |
Definition at line 852 of file SpoofSocket.cpp.
00854 { 00855 try 00856 { 00857 //Quit if not ok 00858 if (!CheckSocketValid()) 00859 return FALSE; 00860 00861 //Create the local address 00862 sockaddr_in soSrc; 00863 00864 //Set to 0 00865 memset(&soSrc,0,sizeof(soSrc)); 00866 soSrc.sin_family=AF_INET; 00867 00868 //Populate the connection data 00869 if (aSourceAddress) 00870 soSrc.sin_addr.s_addr=aSourceAddress; 00871 else 00872 soSrc.sin_addr.s_addr=ADDR_ANY ; 00873 00874 soSrc.sin_port=htons(usPort); 00875 00876 //Now we need to bind it 00877 if (bind(GetHandle(), 00878 (sockaddr*)&soSrc, 00879 sizeof(soSrc))) 00880 { 00881 //Error 00882 SetLastError("Bind"); 00883 00884 //Exit 00885 return FALSE; 00886 } 00887 else 00888 //Save the address 00889 m_aConnectedTo=soSrc; 00890 00891 //If already has a source address then don't change it 00892 if (!m_ulSourceAddress) 00893 //Save it as the source address (spoofing options only) 00894 m_ulSourceAddress=aSourceAddress; 00895 00896 return TRUE; 00897 } 00898 ERROR_HANDLER_RETURN("Bind",FALSE) 00899 }
| BOOL CSpoofSocket::Bind | ( | const std::string & | rSourceAddress, | |
| unsigned short | usPort | |||
| ) | [virtual, inherited] |
Definition at line 901 of file SpoofSocket.cpp.
00903 { 00904 try 00905 { 00906 //Quit if not ok 00907 if (!CheckSocketValid()) 00908 return FALSE; 00909 00910 if (rSourceAddress.empty()) 00911 return Bind((IP)0, 00912 usPort); 00913 else 00914 return Bind(inet_addr(rSourceAddress.c_str()), 00915 usPort); 00916 } 00917 ERROR_HANDLER_RETURN("Bind",FALSE) 00918 }
| BOOL CAsyncSocket::Block | ( | ) | [protected, inherited] |
Definition at line 818 of file AsyncSocket.cpp.
00819 { 00820 try 00821 { 00822 //First disable the events 00823 int iResult; 00824 iResult=WSAAsyncSelect(GetAsyncHandle(), 00825 GetWindowHandle(), 00826 0, 00827 0); 00828 00829 if (iResult) 00830 { 00831 //Report it 00832 SetLastError("Block"); 00833 00834 //Exit 00835 return FALSE; 00836 } 00837 00838 unsigned long ulBlocking; 00839 ulBlocking=0; 00840 00841 //And return to non-blocking 00842 iResult=ioctlsocket(GetAsyncHandle(), 00843 FIONBIO, 00844 &ulBlocking); 00845 00846 if (iResult) 00847 { 00848 //Report it 00849 SetLastError("Block"); 00850 00851 //Exit 00852 return FALSE; 00853 } 00854 00855 return TRUE; 00856 } 00857 ERROR_HANDLER_RETURN("Block",FALSE) 00858 }
| unsigned short CSpoofSocket::CalculateChecksum | ( | const unsigned short * | pBuffer, | |
| int | iSize | |||
| ) | [static, inherited] |
Definition at line 824 of file SpoofSocket.cpp.
00826 { 00827 try 00828 { 00829 unsigned long usChksum=0; 00830 00831 //Calculate the checksum 00832 while (iSize>1) 00833 { 00834 usChksum+=*pBuffer++; 00835 iSize-=sizeof(unsigned short); 00836 } 00837 00838 //If we have one char left 00839 if (iSize) 00840 usChksum+=*(unsigned char*)pBuffer; 00841 00842 //Complete the calculations 00843 usChksum=(usChksum >> 16) + (usChksum & 0xffff); 00844 usChksum+=(usChksum >> 16); 00845 00846 //Return the value (inversed) 00847 return (unsigned short)(~usChksum); 00848 } 00849 ERROR_HANDLER_STATIC_RETURN(CSpoofSocket_LOGNAME,"CalculateChecksum",0) 00850 }
| unsigned short CSpoofSocket::CalculatePseudoChecksum | ( | const char * | pBuffer, | |
| int | iBufferLength, | |||
| IP | aDestinationAddress, | |||
| int | iPacketLength | |||
| ) | const [inherited] |
Definition at line 997 of file SpoofSocket.cpp.
01001 { 01002 try 01003 { 01004 //Calculate the checksum 01005 LPPseudoHeader lpPseudo; 01006 lpPseudo=new PseudoHeader; 01007 01008 //Protect it 01009 std::auto_ptr<PseudoHeader> pProtection(lpPseudo); 01010 01011 //Set the values 01012 lpPseudo->ulDestinationAddress=aDestinationAddress; 01013 lpPseudo->ulSourceAddress=m_ulSourceAddress; 01014 lpPseudo->ucZeros=0; 01015 lpPseudo->ucPTCL=m_ucProtocol; 01016 lpPseudo->usLength=htons(iPacketLength); 01017 01018 //Calculate checksum of all 01019 int iTotalLength; 01020 iTotalLength=PseudoHeaderLength+iBufferLength; 01021 01022 //Allocate the buffer 01023 char* pNewBuffer; 01024 pNewBuffer=new char[iTotalLength]; 01025 01026 //Protect the new buffer 01027 CArray_ptr<char> pBufferProtection(pNewBuffer); 01028 01029 //Copy pseudo 01030 memcpy(pNewBuffer,lpPseudo,PseudoHeaderLength); 01031 01032 //Copy header 01033 memcpy(pNewBuffer+PseudoHeaderLength, 01034 pBuffer, 01035 iBufferLength); 01036 01037 //Calculate the checksum 01038 unsigned short usChecksum; 01039 usChecksum=CalculateChecksum((unsigned short*)pNewBuffer,iTotalLength); 01040 01041 //Return checksum 01042 return usChecksum; 01043 } 01044 ERROR_HANDLER_RETURN("CalculatePseudoChecksum",0) 01045 }
| BOOL CSpoofSocket::CanRead | ( | ) | const [inherited] |
Definition at line 1437 of file SpoofSocket.cpp.
01438 { 01439 try 01440 { 01441 //Quit if not ok 01442 if (!CheckSocketValid()) 01443 return FALSE; 01444 01445 //Create our structure 01446 fd_set aDescriptor; 01447 FD_ZERO(&aDescriptor); 01448 01449 //Add our socket 01450 FD_SET(GetHandle(),&aDescriptor); 01451 01452 //And create the timeval 01453 timeval aTime; 01454 aTime.tv_sec=0; 01455 aTime.tv_usec=0; 01456 01457 //And run the select 01458 int iRetVal; 01459 iRetVal=select(NULL,&aDescriptor,NULL,NULL,&aTime); 01460 01461 //Check if we had an error 01462 if (iRetVal==GetErrorCode()) 01463 { 01464 //Report it 01465 SetLastError("CanRead"); 01466 01467 //Exit 01468 return FALSE; 01469 } 01470 else 01471 //Check is our socket set 01472 return FD_ISSET(GetHandle(),&aDescriptor); 01473 } 01474 ERROR_HANDLER_RETURN("CanRead",FALSE) 01475 }
| BOOL CSpoofSocket::CanWrite | ( | ) | const [inherited] |
Definition at line 1477 of file SpoofSocket.cpp.
01478 { 01479 try 01480 { 01481 //Quit if not ok 01482 if (!CheckSocketValid()) 01483 return FALSE; 01484 01485 //Create our structure 01486 fd_set aDescriptor; 01487 FD_ZERO(&aDescriptor); 01488 01489 //Add our socket 01490 FD_SET(GetHandle(),&aDescriptor); 01491 01492 //And create the timeval 01493 timeval aTime; 01494 aTime.tv_sec=0; 01495 aTime.tv_usec=0; 01496 01497 //And run the select 01498 int iRetVal; 01499 iRetVal=select(NULL,NULL,&aDescriptor,NULL,&aTime); 01500 01501 //Check if we had an error 01502 if (iRetVal==GetErrorCode()) 01503 { 01504 //Report it 01505 SetLastError("CanWrite"); 01506 01507 //Exit 01508 return FALSE; 01509 } 01510 else 01511 //Check is our socket set 01512 return FD_ISSET(GetHandle(),&aDescriptor); 01513 } 01514 ERROR_HANDLER_RETURN("CanWrite",FALSE) 01515 }
| BOOL CSpoofSocket::CheckSocketValid | ( | ) | const [protected, inherited] |
Definition at line 925 of file SpoofSocket.cpp.
00926 { 00927 try 00928 { 00929 //Check if socket is invalid 00930 if (!ValidSocket()) 00931 { 00932 //Report it 00933 ReportError("CheckSocketValid","Operation made on non existant socket!"); 00934 00935 //Exit 00936 return FALSE; 00937 } 00938 00939 //OK 00940 return TRUE; 00941 } 00942 ERROR_HANDLER_RETURN("CheckSocketValid",FALSE) 00943 }
| BOOL CICMPSocketAsync::Close | ( | ) | [virtual, inherited] |
Reimplemented from CSpoofSocket.
Definition at line 160 of file ICMPSocketAsync.cpp.
00161 { 00162 try 00163 { 00164 //Quit if not ok 00165 if (!ValidSocket()) 00166 return FALSE; 00167 00168 //Kill the timer 00169 CAsyncSocket::SocketClosing(); 00170 00171 //Remove from socket list 00172 RemoveSocketFromList(); 00173 00174 return CICMPSocket::Close(); 00175 } 00176 ERROR_HANDLER_RETURN("Close",FALSE) 00177 }
| LPICMPHeader CICMPSocket::ConstructICMP | ( | ) | const [protected, virtual, inherited] |
Definition at line 121 of file ICMPSocket.cpp.
00122 { 00123 try 00124 { 00125 //Constructs a basic ICMP header 00126 LPICMPHeader lpHead; 00127 lpHead=new ICMPHeader; 00128 00129 //Set all as zeros 00130 memset(lpHead, 00131 0, 00132 ICMPHeaderLength); 00133 00134 //Set the timestamp 00135 lpHead->ulICMP_Originate_Timestamp=GetTickCount(); 00136 00137 //Return it 00138 return lpHead; 00139 } 00140 ERROR_HANDLER_RETURN("ConstructICMP",FALSE) 00141 }
| LPIpHeader CSpoofSocket::ConstructIPHeader | ( | unsigned char | ucProtocol, | |
| unsigned short | usFragmentationFlags, | |||
| unsigned char | ucTTL, | |||
| unsigned short | usIdentification, | |||
| unsigned char | ucHeaderLength | |||
| ) | const [protected, virtual, inherited] |
Reimplemented in CICMPCrafter, CTCPCrafter, and CUDPCrafter.
Definition at line 778 of file SpoofSocket.cpp.
00783 { 00784 return ConstructStaticIPHeader(ucProtocol, 00785 usFragmentationFlags, 00786 ucTTL, 00787 usIdentification, 00788 ucHeaderLength); 00789 }
| LPIpHeader CSpoofSocket::ConstructStaticIPHeader | ( | unsigned char | ucProtocol, | |
| unsigned short | usFragmentationFlags, | |||
| unsigned char | ucTTL, | |||
| unsigned short | usIdentification, | |||
| unsigned char | ucHeaderLength | |||
| ) | [static, inherited] |
Definition at line 1398 of file SpoofSocket.cpp.
01403 { 01404 try 01405 { 01406 //Need to construct the IP header 01407 LPIpHeader lpHead=new _IpHeader; 01408 01409 //Header length (in 32 bits) 01410 lpHead->ucHeaderLength_Version=(ucHeaderLength >> 2) | 01411 (IpVersion << 4); 01412 01413 //Protocol 01414 lpHead->ucProtocol=ucProtocol; 01415 01416 //Fragmentation flags 01417 lpHead->usFragmentationFlags=htons(usFragmentationFlags); 01418 01419 //Time to live 01420 lpHead->ucTTL=ucTTL; 01421 01422 //Checksum - set to 0 01423 lpHead->usChecksum=0; 01424 01425 //Identification 01426 lpHead->usIdentification=htons(usIdentification); 01427 01428 //Precedence 01429 lpHead->ucTypeOfService=IpService_ROUTINE; 01430 01431 //Return IP to user 01432 return lpHead; 01433 } 01434 ERROR_HANDLER_STATIC_RETURN(CSpoofSocket_LOGNAME,"ConstructIPHeader",NULL) 01435 }
| BOOL CSpoofSocket::Create | ( | int | iProtocol | ) | [inherited] |
Definition at line 475 of file SpoofSocket.cpp.
00476 { 00477 //Close the socket if open 00478 if (ValidSocket()) 00479 Close(); 00480 00481 try 00482 { 00483 //Are we overlapped 00484 if (!m_bOverlapped) 00485 { 00486 //Here we create the raw socket 00487 if (m_bRaw || iProtocol==IPPROTO_ICMP) 00488 m_aSpoofSocket=socket(AF_INET, 00489 SOCK_RAW, 00490 iProtocol); 00491 else 00492 if (iProtocol==IPPROTO_TCP) 00493 m_aSpoofSocket=socket(AF_INET, 00494 SOCK_STREAM, 00495 iProtocol); 00496 else if (iProtocol==IPPROTO_UDP) 00497 m_aSpoofSocket=socket(AF_INET, 00498 SOCK_DGRAM, 00499 iProtocol); 00500 } 00501 else 00502 { 00503 //Here we create the raw socket 00504 if (m_bRaw || iProtocol==IPPROTO_ICMP) 00505 m_aSpoofSocket=WSASocket(AF_INET, 00506 SOCK_RAW, 00507 iProtocol, 00508 NULL, 00509 NULL, 00510 WSA_FLAG_OVERLAPPED); 00511 else 00512 if (iProtocol==IPPROTO_TCP) 00513 m_aSpoofSocket=WSASocket(AF_INET, 00514 SOCK_STREAM, 00515 iProtocol, 00516 NULL, 00517 NULL, 00518 WSA_FLAG_OVERLAPPED); 00519 else if (iProtocol==IPPROTO_UDP) 00520 m_aSpoofSocket=WSASocket(AF_INET, 00521 SOCK_DGRAM, 00522 iProtocol, 00523 NULL, 00524 NULL, 00525 WSA_FLAG_OVERLAPPED); 00526 } 00527 00528 //Check for socket validity 00529 if (m_aSpoofSocket==INVALID_SOCKET) 00530 { 00531 //Error 00532 SetLastError("Create"); 00533 00534 //Done 00535 return FALSE; 00536 } 00537 00538 if (m_bRaw) 00539 { 00540 //Set that the application will send the IP header 00541 unsigned int iTrue=1; 00542 00543 if(setsockopt(m_aSpoofSocket, 00544 IPPROTO_IP, 00545 IP_HDRINCL, 00546 (char*)&iTrue, 00547 sizeof(iTrue))==GetErrorCode()) 00548 { 00549 //Check for options error 00550 SetLastError("Create"); 00551 00552 //Exit 00553 return FALSE; 00554 } 00555 } 00556 00557 //Done 00558 return TRUE; 00559 } 00560 ERROR_HANDLER_RETURN("Create",FALSE) 00561 }
| BOOL CICMPSocketAsync::Create | ( | ) | [virtual, inherited] |
Reimplemented from CICMPSocket.
Definition at line 132 of file ICMPSocketAsync.cpp.
00133 { 00134 try 00135 { 00136 //Try to create as an ICMP socket 00137 if (!CICMPSocket::Create()) 00138 { 00139 //Report it 00140 ReportError("Create","Failed to create ICMP socket!"); 00141 00142 //Exit 00143 return FALSE; 00144 } 00145 00146 //Add the socket to the asynch list 00147 AddSocketToList(); 00148 00149 //Set async status 00150 return SetAsync(); 00151 } 00152 ERROR_HANDLER_RETURN("Create",FALSE) 00153 }
| void CAsyncSocket::DeleteSocketFromThread | ( | DWORD | dwTimeToWait | ) | [virtual, inherited] |
Definition at line 1232 of file AsyncSocket.cpp.
01233 { 01234 try 01235 { 01236 if (!dwTimeToWait) 01237 DeleteSocketFromThread(); 01238 else 01239 { 01240 //We are closing 01241 SocketClosing(); 01242 01243 //Are we valid ? 01244 //And do we have a window 01245 if (!m_bList) 01246 OnSocketDelete(); 01247 else 01248 { 01249 //Create a timer 01250 m_aDeleteTimerID=m_pThreadManager->RegisterTimeout(dwTimeToWait, 01251 DeleteTimerProc, 01252 (LPVOID)this, 01253 TRUE, 01254 GetWindowHandle(), 01255 &m_aDeleteTimerID); 01256 01257 //Do we have the timer ? 01258 if (!m_aDeleteTimerID.iTimerID) 01259 { 01260 //Report it 01261 ReportError("DeleteSocketFromThread","Failed to create timeout!"); 01262 01263 //Run regular delete 01264 DeleteSocketFromThread(); 01265 } 01266 } 01267 } 01268 } 01269 ERROR_HANDLER("OnSocketDelete") 01270 }
| void CAsyncSocket::DeleteSocketFromThread | ( | ) | [virtual, inherited] |
Definition at line 1212 of file AsyncSocket.cpp.
01213 { 01214 try 01215 { 01216 //We are closing 01217 SocketClosing(); 01218 01219 //Are we valid ? 01220 //And do we have a window 01221 if (!m_bList) 01222 OnSocketDelete(); 01223 else 01224 PostMessage(GetWindowHandle(), 01225 WM_SOCKET_DELETE, 01226 (WPARAM)GetAsyncHandle(), 01227 0); 01228 } 01229 ERROR_HANDLER("OnSocketDelete") 01230 }
| BOOL CAsyncSocket::DisableAsync | ( | ) | [inherited] |
Definition at line 630 of file AsyncSocket.cpp.
00631 { 00632 try 00633 { 00634 //Quit if not ok 00635 if (!CheckAsyncSocketValid()) 00636 return FALSE; 00637 00638 //Set event to read / write / close / oob 00639 int iResult; 00640 00641 iResult=WSAAsyncSelect(GetAsyncHandle(), 00642 GetWindowHandle(), 00643 0, 00644 0); 00645 if (iResult) 00646 { 00647 //Report it 00648 SetLastError("DisableAsync"); 00649 00650 //Exit 00651 return FALSE; 00652 } 00653 00654 return TRUE; 00655 } 00656 ERROR_HANDLER_RETURN("DisableAsync",FALSE) 00657 }
| void CAsyncSocket::DisableEvents | ( | unsigned char | ucEvents | ) | [inherited] |
Definition at line 1303 of file AsyncSocket.cpp.
01304 { 01305 try 01306 { 01307 //Save the events 01308 m_ucEvents=ucEvents; 01309 } 01310 ERROR_HANDLER("DisableEvents") 01311 }
| 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 }
| void CRealTimeTraceRouteSocket::FakeLastRequest | ( | ) |
Definition at line 785 of file RealTimeTraceRouteSocket.cpp.
00786 { 00787 try 00788 { 00789 //Did we resolve target ? 00790 if (!m_aData[mhMaxHops].aReplyingAddress) 00791 { 00792 { 00793 //Lock the data 00794 CCriticalAutoRelease aRelease(m_aData[mhMaxHops].pCSection.get(),TRUE); 00795 00796 //Put the data 00797 m_aData[mhMaxHops].aReplyingAddress=m_aTracedAddress; 00798 m_aData[mhMaxHops].dwElapsedTime=0; 00799 m_aData[mhMaxHops].ucTTL=m_ucMaxHOP; 00800 m_aData[mhMaxHops].pDNS=m_pManager; 00801 } 00802 00803 //Do we need to send it ? 00804 if (m_bResolveIPs) 00805 { 00806 //Set the resolvers 00807 AdjustResolvers(1); 00808 00809 //Create the data 00810 ResolveThreadData* pThreadData; 00811 pThreadData=new ResolveThreadData; 00812 00813 //Populate it 00814 pThreadData->pClass=this; 00815 pThreadData->pData=&m_aData[mhMaxHops]; 00816 00817 //Add the reverse DNS 00818 m_pManager->GetThreadManager()->SubmitJob(ResolveData,(LPVOID)pThreadData); 00819 } 00820 00821 //Call it for modify 00822 TraceDataForModify(&m_aData[mhMaxHops], 00823 FALSE); 00824 00825 //Call user routing 00826 TraceData(&m_aData[mhMaxHops], 00827 FALSE); 00828 } 00829 } 00830 ERROR_HANDLER("FakeLastRequest") 00831 }
| void CICMPSocket::FinalICMPHeader | ( | LPICMPHeader | lpHead | ) | const [protected, virtual, inherited] |
| void CSpoofSocket::FinalIPHeader | ( | LPIpHeader | lpHead | ) | const [protected, virtual, inherited] |
Reimplemented in CICMPCrafter, CTCPCrafter, and CUDPCrafter.
Definition at line 1393 of file SpoofSocket.cpp.
| void CAsyncSocket::ForceReceiveEvent | ( | ) | [inherited] |
Definition at line 1195 of file AsyncSocket.cpp.
01196 { 01197 try 01198 { 01199 //Are we valid ? 01200 //And do we have a window 01201 if (!m_bList) 01202 OnSocketDelete(); 01203 else 01204 PostMessage(GetWindowHandle(), 01205 WM_SOCKET_FORCED, 01206 (WPARAM)GetAsyncHandle(), 01207 0); 01208 } 01209 ERROR_HANDLER("ForceReceiveEvent") 01210 }
| void CAsyncSocket::FreezeThread | ( | ) | [inherited] |
| SOCKET CICMPSocketAsync::GetAsyncHandle | ( | ) | const [protected, virtual, inherited] |
Implements CAsyncSocket.
Definition at line 155 of file ICMPSocketAsync.cpp.
00156 { 00157 return GetHandle(); 00158 }
| CBlockedBuffer * CAsyncSocket::GetBlockedBuffer | ( | ) | const [protected, inherited] |
| int CICMPSocket::GetBufferSize | ( | ) | const [protected, inherited] |
| const std::string & CErrorHandler::GetClassName | ( | ) | const [protected, inherited] |
| 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 }
| const CRealTimeTraceRouteSocket::TraceRouteData * CRealTimeTraceRouteSocket::GetData | ( | ) | const |
Definition at line 607 of file RealTimeTraceRouteSocket.cpp.
00608 { 00609 return (const TraceRouteData*)&m_aData; 00610 }
| int CPingSocket::GetDataSize | ( | ) | const [inherited] |
| CRealTimeTraceRouteSocket::CRealTimeDNSManager * CRealTimeTraceRouteSocket::GetDNSManager | ( | ) | const [protected] |
| int CSpoofBase::GetErrorCode | ( | ) | [static, inherited] |
| CGenericCriticalSection * CSpoofBase::GetGlobalCriticalSection | ( | ) | [static, inherited] |
| SOCKET CSpoofSocket::GetHandle | ( | ) | const [inherited] |
| const char * CICMPSocket::GetLastData | ( | ) | const [inherited] |
| unsigned long CICMPSocket::GetLastDataSize | ( | ) | [inherited] |
| int CSpoofBase::GetLastError | ( | ) | const [inherited] |
| const LPICMPHeader CICMPSocket::GetLastICMPHeader | ( | ) | const [inherited] |
| const LPICMPHeader CICMPSocket::GetLastICMPICMPHeader | ( | ) | const [inherited] |
| const LPIpHeader CICMPSocket::GetLastICMPIPHeader | ( | ) | const [inherited] |
| const LPIpHeader CICMPSocket::GetLastIPHeader | ( | ) | const [inherited] |
| unsigned char CRealTimeTraceRouteSocket::GetMaxHops | ( | ) | const |
| unsigned long CSpoofBase::GetNumberOfThreads | ( | ) | [static, inherited] |
| CIPOptions * CSpoofSocket::GetOptions | ( | ) | const [inherited] |
| long CSpoofSocket::GetPeerAddress | ( | ) | const [inherited] |
Definition at line 1349 of file SpoofSocket.cpp.
01350 { 01351 //Get the address we are connected to 01352 return m_aConnectedTo.sin_addr.S_un.S_addr; 01353 }
| unsigned short CSpoofSocket::GetPeerPort | ( | ) | const [inherited] |
| unsigned char CSpoofSocket::GetProtocol | ( | ) | const [protected, inherited] |
| IP CPingSocket::GetReplyingAddress | ( | ) | const [inherited] |
| const char * CICMPSocket::GetSendBuffer | ( | ) | const [protected, inherited] |
| int CAsyncSocket::GetSocketID | ( | ) | const [protected, inherited] |
| CSocketThreadManager * CAsyncSocket::GetSocketThreadManager | ( | ) | [static, protected, inherited] |
| IP CSpoofSocket::GetSourceAddress | ( | ) | const [protected, inherited] |
| int CSpoofBase::GetSystemLastError | ( | ) | const [inherited] |
| DWORD CPingSocket::GetTimeElapsed | ( | ) | const [inherited] |
| unsigned char CPingSocket::GetTTL | ( | ) | const [inherited] |
| HWND CAsyncSocket::GetWindowHandle | ( | ) | const [protected, inherited] |
| BOOL CSpoofSocket::HasOptions | ( | ) | const [protected, inherited] |
| BOOL CAsyncSocket::HasSystemTimer | ( | ) | const [protected, inherited] |
Definition at line 1180 of file AsyncSocket.cpp.
01181 { 01182 return m_aTimerID.iTimerID!=0; 01183 }
| BOOL CAsyncSocket::HasTimeout | ( | ) | const [inherited] |
| void CAsyncSocket::Initialize | ( | ) | [static, inherited] |
Definition at line 485 of file AsyncSocket.cpp.
00486 { 00487 try 00488 { 00489 //Initialize all data 00490 if (!m_bInitialized && 00491 CSpoofBase::IsInitialized()) 00492 { 00493 //Create the CS 00494 m_pCSection=COSManager::CreateCriticalSection(); 00495 00496 //Create handlers 00497 if (!SetHandlers()) 00498 { 00499 //Report it 00500 ReportStaticError(CAsyncSocket_Class,"CAsyncSocket","Failed to init handlers!"); 00501 00502 //Exit 00503 return; 00504 } 00505 00506 //Create a new socket to do the shutdown 00507 CAsyncShutdown* pShutdown; 00508 pShutdown=new CAsyncShutdown; 00509 00510 //The class registers itself 00511 m_bInitialized=TRUE; 00512 } 00513 } 00514 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Initialize") 00515 }
| void CSpoofSocket::InitializeIP | ( | ) | [protected, virtual, inherited] |
Definition at line 1094 of file SpoofSocket.cpp.
01095 { 01096 try 01097 { 01098 //Invalid the socket 01099 m_aSpoofSocket=INVALID_SOCKET; 01100 01101 //More invalids 01102 m_ulSourceAddress=0; 01103 01104 //Some defaults 01105 m_ucTTL=IP_DEF_TTL; 01106 01107 //Set our options 01108 m_pIPOptions=NULL; 01109 01110 //Not sniffing 01111 m_bSniffing=FALSE; 01112 01113 //We are not overlapped 01114 m_bOverlapped=FALSE; 01115 01116 //Not connected 01117 memset(&m_aConnectedTo, 01118 0, 01119 sizeof(m_aConnectedTo)); 01120 01121 //Set options to false 01122 SetOptions(FALSE); 01123 } 01124 ERROR_HANDLER("InitializeIP") 01125 }
| BOOL CSpoofBase::InitializeSockets | ( | BOOL | bMultiThreaded = TRUE, |
|
| unsigned long | ulNumberOfThreads = 10 | |||
| ) | [static, inherited] |
Definition at line 279 of file SpoofBase.cpp.
00281 { 00282 //To avoid double initialize 00283 if (m_bInitialized) 00284 { 00285 //Report it 00286 ReportStaticError(CSpoofBase_Class,"InitializeSockets","Already initialized!"); 00287 00288 //Exit 00289 return TRUE; 00290 } 00291 00292 //Check that the number of threads are OK? 00293 if (ulNumberOfThreads>CLibConfig::GetInstance().GetMaxThreads()) 00294 { 00295 //Report it 00296 ReportStaticError(CSpoofBase_Class,"InitializeSockets","Too many threads!"); 00297 00298 //Exit 00299 return FALSE; 00300 } 00301 00302 //Do we have threads at all 00303 if (bMultiThreaded && 00304 !ulNumberOfThreads) 00305 { 00306 //Report it 00307 ReportStaticError(CSpoofBase_Class,"InitializeSockets","Didn't receive any threads!"); 00308 00309 //Exit 00310 return FALSE; 00311 } 00312 00313 try 00314 { 00315 //Initialize the sockets 00316 WORD wVersionRequested; 00317 wVersionRequested=MAKEWORD(2,2); 00318 00319 //Try to initialize 00320 WSADATA wsaData; 00321 int iErr; 00322 iErr=WSAStartup(wVersionRequested, 00323 &wsaData); 00324 00325 //Did we succeed? 00326 if (iErr!=0) 00327 /* Tell the user that we could not find a usable */ 00328 /* WinSock DLL. */ 00329 return FALSE; 00330 00331 /* Confirm that the WinSock DLL supports 2.2.*/ 00332 /* Note that if the DLL supports versions greater */ 00333 /* than 2.2 in addition to 2.2, it will still return */ 00334 /* 2.2 in wVersion since that is the version we */ 00335 /* requested. */ 00336 00337 if (LOBYTE(wsaData.wVersion)!=2 || 00338 HIBYTE(wsaData.wVersion)!=2) 00339 { 00340 /* Tell the user that we could not find a usable */ 00341 /* WinSock DLL. */ 00342 WSACleanup(); 00343 00344 //Exit 00345 return FALSE; 00346 } 00347 00348 //Save the threading information 00349 m_bMultiThreaded=bMultiThreaded; 00350 m_ulNumberOfThreads=ulNumberOfThreads; 00351 00352 //Create the critical section 00353 m_pCSection=COSManager::CreateCriticalSection(); 00354 00355 //And we are initialized 00356 m_bInitialized=TRUE; 00357 00358 return TRUE; 00359 } 00360 ERROR_HANDLER_STATIC_RETURN(CSpoofBase_Class,"InitializeSockets",FALSE) 00361 }
| BOOL CSpoofBase::InitializeSocketsNoMap | ( | BOOL | bMultiThreaded = TRUE, |
|
| unsigned long | ulNumberOfThreads = 10 | |||
| ) | [static, inherited] |
Definition at line 202 of file SpoofBase.cpp.
00204 { 00205 //To avoid double initialize 00206 if (m_bInitialized) 00207 { 00208 //Report it 00209 ReportStaticError(CSpoofBase_Class,"InitializeSocketsNoMap","Already initialized!"); 00210 00211 //Exit 00212 return TRUE; 00213 } 00214 00215 //Check that the number of threads are OK? 00216 if (ulNumberOfThreads>CLibConfig::GetInstance().GetMaxThreads()) 00217 { 00218 //Report it 00219 ReportStaticError(CSpoofBase_Class,"InitializeSocketsNoMap","Too many threads!"); 00220 00221 //Exit 00222 return FALSE; 00223 } 00224 00225 //Do we have threads at all 00226 if (bMultiThreaded && 00227 !ulNumberOfThreads) 00228 { 00229 //Report it 00230 ReportStaticError(CSpoofBase_Class,"InitializeSocketsNoMap","Didn't receive any threads!"); 00231 00232 //Exit 00233 return FALSE; 00234 } 00235 00236 try 00237 { 00238 //Create the thread data 00239 ThreadData* pThreadData; 00240 pThreadData=new ThreadData; 00241 00242 //Populate the data 00243 pThreadData->pEvent=COSManager::CreateEvent(); 00244 pThreadData->bMultiThreaded=bMultiThreaded; 00245 pThreadData->ulNumberOfThreads=ulNumberOfThreads; 00246 00247 //Create the thread 00248 m_pThread=new CManagedThread(InitProc); 00249 m_pThread->Start((LPVOID)pThreadData); 00250 00251 //Wait on the event 00252 if (pThreadData->pEvent->Wait(THREAD_TIMEOUT)) 00253 { 00254 //Report it 00255 ReportStaticError(CSpoofBase_Class,"InitializeSocketsNoMap","Timeout waiting for thread"); 00256 00257 //Delete the thread 00258 delete m_pThread; 00259 m_pThread=NULL; 00260 00261 //Exit 00262 return FALSE; 00263 } 00264 00265 //Are we initialized 00266 if (!IsInitialized()) 00267 { 00268 //Delete the thread 00269 delete m_pThread; 00270 m_pThread=NULL; 00271 } 00272 00273 //Done 00274 return IsInitialized(); 00275 } 00276 ERROR_HANDLER_STATIC_RETURN(CSpoofBase_Class,"InitializeSocketsNoMap",FALSE) 00277 }
| int CAsyncSocket::InternalWSAAsyncSelect | ( | unsigned int | wMsg, | |
| long | lEvent | |||
| ) | [protected, inherited] |
Definition at line 739 of file AsyncSocket.cpp.
00740 { 00741 try 00742 { 00743 //Cache the values 00744 m_iMsg=wMsg; 00745 m_lEvent=lEvent; 00746 00747 //Message pairs 00748 typedef struct _MsgPair 00749 { 00750 unsigned int uiMsg; 00751 AsyncEvents aEvents; 00752 } MsgPair; 00753 00754 //Our max events 00755 static const int iMaxEvents=4; 00756 00757 //Our events data 00758 static const MsgPair aMsgPair[iMaxEvents]={{FD_READ,aeReceive}, 00759 {FD_WRITE,aeSend}, 00760 {FD_OOB,aeOOB}, 00761 {FD_CLOSE,aeClose}}; 00762 00763 //Check if the messages are allowed 00764 for (int iCounter=0;iCounter<iMaxEvents;++iCounter) 00765 if ((m_lEvent & aMsgPair[iCounter].uiMsg) && 00766 (m_ucEvents & ((unsigned char)aMsgPair[iCounter].aEvents))) 00767 //Remove it 00768 m_lEvent^=aMsgPair[iCounter].uiMsg; 00769 00770 if (m_bBlocking) 00771 return 0; 00772 else 00773 //And call the async select 00774 return WSAAsyncSelect(GetAsyncHandle(), 00775 GetWindowHandle(), 00776 wMsg, 00777 lEvent); 00778 } 00779 ERROR_HANDLER_RETURN("InternalWSAAsyncSelect",GetErrorCode()) 00780 }
| BOOL CAsyncSocket::IsBlocking | ( | ) | const [protected, inherited] |
| BOOL CAsyncSocket::IsClosing | ( | ) | const [inherited] |
| BOOL CSpoofSocket::IsCreated | ( | ) | const [inherited] |
| BOOL CRealTimeTraceRouteSocket::IsIDOK | ( | unsigned short | usID, | |
| unsigned short | usSequence | |||
| ) | const [protected, virtual] |
Reimplemented from CPingSocket.
Definition at line 481 of file RealTimeTraceRouteSocket.cpp.
00483 { 00484 return m_usPortStart==usSequence && 00485 usID<=mhMaxHops; 00486 }
| BOOL CSpoofBase::IsInitialized | ( | ) | [static, inherited] |
| BOOL CRealTimeTraceRouteSocket::IsInitialized | ( | ) | const |
| BOOL CSpoofBase::IsMultiThreaded | ( | ) | [static, inherited] |
| BOOL CPingSocket::IsPingDone | ( | ) | const [inherited] |
| BOOL CSpoofSocket::IsRaw | ( | ) | const [protected, inherited] |
| BOOL CPingSocket::IsTimeout | ( | ) | const [inherited] |
| BOOL CRealTimeTraceRouteSocket::IsTraceDone | ( | ) | const [virtual] |
| BOOL CAsyncSocket::KillSystemTimer | ( | ) | [protected, inherited] |
Definition at line 1129 of file AsyncSocket.cpp.
01130 { 01131 try 01132 { 01133 //Only if we have one 01134 if (!m_aTimerID.iTimerID) 01135 return TRUE; 01136 01137 return GetThreadManager()->RemoveTimeout(m_aTimerID); 01138 } 01139 ERROR_HANDLER_RETURN("KillSystemTimer",FALSE) 01140 }
| BOOL CAsyncSocket::KillTimer | ( | ) | [inherited] |
Definition at line 344 of file AsyncSocket.cpp.
00345 { 00346 try 00347 { 00348 HWND hWindowHandle; 00349 hWindowHandle=GetWindowHandle(); 00350 00351 if (!hWindowHandle || 00352 !m_bTimeout) 00353 return FALSE; 00354 00355 //No timer in any case 00356 m_bTimeout=FALSE; 00357 00358 BOOL bResult; 00359 bResult=::KillTimer(hWindowHandle, 00360 GetAsyncHandle()); 00361 00362 if (!bResult) 00363 //Fire an error 00364 ReportError("KillTimer"); 00365 00366 return bResult; 00367 } 00368 ERROR_HANDLER_RETURN("KillTimer",FALSE) 00369 }
| std::string CSpoofBase::LongToStdString | ( | unsigned long | ulAddr | ) | [static, inherited] |
Definition at line 420 of file SpoofBase.cpp.
00421 { 00422 try 00423 { 00424 //First create the address 00425 in_addr addr; 00426 00427 //Assign it 00428 addr.S_un.S_addr=ulAddr; 00429 00430 //Enter the critical section 00431 CCriticalAutoRelease aRelease(m_pCSection); 00432 00433 //Return the value 00434 return inet_ntoa(addr); 00435 } 00436 ERROR_HANDLER_STATIC_RETURN(CSpoofBase_Class,"LongToStdString","0.0.0.0") 00437 }
| char FAR * CSpoofBase::LongToString | ( | unsigned long | ulAddr | ) | [static, inherited] |
Definition at line 439 of file SpoofBase.cpp.
00440 { 00441 try 00442 { 00443 //First create the address 00444 in_addr addr; 00445 00446 //Assign it 00447 addr.S_un.S_addr=ulAddr; 00448 00449 //Enter the critical section 00450 CCriticalAutoRelease aRelease(m_pCSection); 00451 00452 //Return the value 00453 return inet_ntoa(addr); 00454 } 00455 ERROR_HANDLER_STATIC_RETURN(CSpoofBase_Class,"LongToString",NULL) 00456 }
| void CSpoofBase::NotifyShutdown | ( | ) | [protected, virtual, inherited] |
| virtual BOOL CAsyncSocket::OnSocketAccept | ( | int | iErrorCode | ) | [protected, pure virtual, inherited] |
| virtual BOOL CAsyncSocket::OnSocketClose | ( | int | iErrorCode | ) | [protected, pure virtual, inherited] |
Implemented in CSocketPoolSocket, CWhoisSocket, and KomodiaDNS::CDNSTCPSocket.
| virtual BOOL CAsyncSocket::OnSocketConnect | ( | int | iErrorCode | ) | [protected, pure virtual, inherited] |
Implemented in CSocketPoolSocket, CUDPSocketAsync, CWhoisSocket, and KomodiaDNS::CDNSTCPSocket.
| void CAsyncSocket::OnSocketDelete | ( | ) | [protected, virtual, inherited] |
Definition at line 1185 of file AsyncSocket.cpp.
01186 { 01187 try 01188 { 01189 //Delete ourselves 01190 delete this; 01191 } 01192 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"OnSocketDelete") 01193 }
| virtual BOOL CAsyncSocket::OnSocketOOB | ( | int | iErrorCode | ) | [protected, pure virtual, inherited] |
| BOOL CPingSocket::OnSocketReceive | ( | int | iErrorCode | ) | [protected, virtual, inherited] |
Reimplemented from CICMPSocketAsync.
Definition at line 73 of file PingSocket.cpp.
00074 { 00075 try 00076 { 00077 //Receive the data, and check if it's our ping 00078 if (CICMPSocketAsync::OnSocketReceive(iErrorCode)) 00079 { 00080 //Check if it is our ping 00081 if ((IsIDOK(GetLastICMPHeader()->sICMP.sUS.us1, 00082 GetLastICMPHeader()->sICMP.sUS.us2) && 00083 GetLastICMPHeader()->ucICMPType==ICMP_Echo_Reply) || 00084 GetLastICMPHeader()->ucICMPType==ICMP_Time) 00085 { 00086 //Do we have a timer ? 00087 if (m_dwTimeout) 00088 //Reset the timeout 00089 CAsyncSocket::KillTimer(); 00090 00091 //Save some data 00092 //Time it took 00093 m_dwTimeElapsed=GetTickCount()-m_dwLastTick; 00094 00095 //Save the TTL 00096 m_ucTTL=GetLastIPHeader()->ucTTL; 00097 00098 //Get the data size 00099 m_iDataSize=GetLastDataSize(); 00100 00101 //Replying address 00102 m_aReplyingAddress=GetLastIPHeader()->ulSourceAddress; 00103 00104 //Set ping done 00105 m_bPingDone=TRUE; 00106 00107 //No timeout 00108 m_bTimeout=FALSE; 00109 00110 //Ping is done 00111 PingDone(FALSE); 00112 00113 //What is the sequence 00114 unsigned short usSequence; 00115 if (GetLastICMPHeader()->ucICMPType==ICMP_Time) 00116 usSequence=GetLastICMPICMPHeader()->sICMP.sUS.us1; 00117 else 00118 usSequence=GetLastICMPHeader()->sICMP.sUS.us1; 00119 00120 //Ping is done with data 00121 PingDoneData(m_aReplyingAddress, 00122 m_ucTTL, 00123 m_dwTimeElapsed, 00124 m_iDataSize, 00125 usSequence, 00126 GetLastICMPHeader()->ucICMPType==ICMP_Time); 00127 } 00128 } 00129 00130 //Done 00131 return TRUE; 00132 } 00133 ERROR_HANDLER_RETURN("OnSocketReceive",TRUE) 00134 }
| BOOL CRealTimeTraceRouteSocket::OnSocketTimeout | ( | ) | [protected, virtual] |
Reimplemented from CPingSocket.
Definition at line 565 of file RealTimeTraceRouteSocket.cpp.
00566 { 00567 try 00568 { 00569 //Kill the timer 00570 KillTimer(); 00571 00572 //Is the trace done 00573 if (m_bTraceDone) 00574 return FALSE; 00575 00576 //Do we have threads ? 00577 if (GetResolvers()) 00578 { 00579 //We are partialy done 00580 m_bPartialDone=TRUE; 00581 00582 //Exit 00583 return FALSE; 00584 } 00585 00586 //We are partialy done 00587 m_bPartialDone=TRUE; 00588 00589 //Call the trace 00590 InvokeTraceDone(); 00591 00592 //Done 00593 return FALSE; 00594 } 00595 ERROR_HANDLER_RETURN("OnSocketTimeout",FALSE) 00596 }
| virtual BOOL CAsyncSocket::OnSocketWrite | ( | int | iErrorCode | ) | [protected, pure virtual, inherited] |
| bool CSpoofSocket::operator< | ( | const CSpoofSocket & | rSocket | ) | const [inherited] |
Definition at line 1601 of file SpoofSocket.cpp.
01602 { 01603 return m_aSpoofSocket<rSocket.m_aSpoofSocket; 01604 }
| bool CSpoofSocket::operator== | ( | const CSpoofSocket & | rSocket | ) | const [inherited] |
Definition at line 1596 of file SpoofSocket.cpp.
01597 { 01598 return m_aSpoofSocket==rSocket.m_aSpoofSocket; 01599 }
| BOOL CPingSocket::Ping | ( | IP | aDestinationAddress, | |
| DWORD | dwTimeout = 3000 | |||
| ) | [virtual, inherited] |
Reimplemented in CTraceRouteSocket.
Definition at line 157 of file PingSocket.cpp.
00159 { 00160 try 00161 { 00162 //Set some initial data 00163 m_ucTTL=0; 00164 m_aReplyingAddress=0; 00165 m_bTimeout=FALSE; 00166 m_dwTimeElapsed=0; 00167 m_iDataSize=0; 00168 m_dwTimeout=dwTimeout; 00169 00170 //What is the timeout 00171 if (dwTimeout) 00172 //Set the timeout 00173 SetTimeout(dwTimeout); 00174 00175 //Set ping timer 00176 m_dwLastTick=GetTickCount(); 00177 00178 //Set ping done 00179 m_bPingDone=FALSE; 00180 00181 if (!m_bSameID) 00182 //What is our ID 00183 m_usLastPingID=GetTickCount()*GetCurrentProcessId(); 00184 00185 //Send the ping 00186 return SendEcho(aDestinationAddress, 00187 FALSE, 00188 m_usLastPingID, 00189 m_usLastPingSequence, 00190 0)!=GetErrorCode(); 00191 } 00192 ERROR_HANDLER_RETURN("Ping",FALSE) 00193 }
| BOOL CPingSocket::Ping | ( | const std::string & | rDestinationAddress, | |
| DWORD | dwTimeout = 3000 | |||
| ) | [virtual, inherited] |
Definition at line 146 of file PingSocket.cpp.
00148 { 00149 try 00150 { 00151 return Ping(StringToLong(rDestinationAddress), 00152 dwTimeout); 00153 } 00154 ERROR_HANDLER_RETURN("Ping",FALSE) 00155 }
| void CPingSocket::PingDone | ( | BOOL | bTimeout | ) | [protected, virtual, inherited] |
| BOOL CICMPSocket::ProccessICMP | ( | const char * | pBuffer | ) | [protected, virtual, inherited] |
Definition at line 533 of file ICMPSocket.cpp.
00534 { 00535 try 00536 { 00537 //Here we proccess the input we received 00538 //Do we have previous data? 00539 if (m_pICMPReceiveData) 00540 { 00541 //Delete it 00542 delete [] m_pICMPReceiveData; 00543 m_pICMPReceiveData=NULL; 00544 } 00545 00546 //No user data 00547 m_usDataSize=0; 00548 00549 //Initialize members 00550 if (!m_pIPHeader) 00551 m_pIPHeader=new IpHeader; 00552 00553 if (!m_pICMPHeader) 00554 m_pICMPHeader=new ICMPHeader; 00555 00556 //Create an IP header 00557 LPIpHeader lpHead; 00558 lpHead=m_pIPHeader; 00559 00560 //Copy to buffer 00561 memcpy(lpHead, 00562 pBuffer, 00563 IpHeaderLength); 00564 00565 //Let's check for options 00566 unsigned char ucHeaderSize; 00567 ucHeaderSize=(lpHead->ucHeaderLength_Version & 15) << 2; 00568 00569 //Now check for total packet size 00570 unsigned short ucPacketSize; 00571 ucPacketSize=htons(lpHead->usTotalLength); 00572 00573 //Copy data to icmp 00574 memset(m_pICMPHeader, 00575 0, 00576 ICMPHeaderLength); 00577 00578 //How much to copy ? 00579 unsigned short ucCopy; 00580 ucCopy=ucPacketSize-ucHeaderSize; 00581 00582 //Save the datasize 00583 m_usDataSize=ucCopy; 00584 00585 if (ucCopy>ICMPHeaderLength) 00586 ucCopy=ICMPHeaderLength; 00587 00588 //Copy the ICMP header 00589 memcpy(m_pICMPHeader, 00590 pBuffer+ucHeaderSize, 00591 ucCopy); 00592 00593 //Now save the original IP 00594 if (!m_pICMPIPHeader) 00595 m_pICMPIPHeader=new IpHeader; 00596 00597 //Copy the data 00598 memcpy(m_pICMPIPHeader, 00599 pBuffer+ucHeaderSize+ICMP_DATA_SIZE, 00600 IpHeaderLength); 00601 00602 //Get this header size 00603 unsigned char ucNewHeaderSize; 00604 ucNewHeaderSize=(m_pICMPIPHeader->ucHeaderLength_Version & 15) << 2; 00605 00606 //Do we have ICMP buffer 00607 if (!(m_pICMPHeader->ucICMPType!=ICMP_Echo && 00608 m_pICMPHeader->ucICMPType!=ICMP_Echo_Reply && 00609 m_pICMPHeader->ucICMPType!=ICMP_Timestamp && 00610 m_pICMPHeader->ucICMPType!=ICMP_Timestamp_Reply && 00611 m_pICMPHeader->ucICMPType!=ICMP_Information && 00612 m_pICMPHeader->ucICMPType!=ICMP_Information_Reply && 00613 m_pICMPHeader->ucICMPType!=ICMP_Time)) 00614 { 00615 00616 //Copy rest of data 00617 if (!m_pICMPICMPHeader) 00618 m_pICMPICMPHeader=new ICMPHeader; 00619 00620 memcpy(m_pICMPICMPHeader, 00621 pBuffer+ucHeaderSize+ICMP_DATA_SIZE+ucNewHeaderSize, 00622 ICMP_DATA_SIZE); 00623 00624 //Reverse it 00625 ReverseHeader(m_pICMPICMPHeader); 00626 00627 //Do we have data to copy 00628 unsigned short usRemainingSize; 00629 usRemainingSize=ucHeaderSize+ 00630 ICMP_DATA_SIZE+ 00631 ucNewHeaderSize+ 00632 ICMP_DATA_SIZE; 00633 00634 //Anything left? 00635 if (usRemainingSize<ucPacketSize) 00636 { 00637 //Set the size 00638 m_usDataSize=ucPacketSize-usRemainingSize; 00639 00640 //Allocate some data 00641 m_pICMPReceiveData=new char[m_usDataSize]; 00642 00643 //Copy it 00644 memcpy(m_pICMPReceiveData, 00645 pBuffer+usRemainingSize, 00646 m_usDataSize); 00647 } 00648 } 00649 else 00650 { 00651 //Reset the ICMP 00652 if (m_pICMPICMPHeader) 00653 memset(m_pICMPICMPHeader, 00654 0, 00655 ICMPHeaderLength); 00656 00657 //Do we have data to copy 00658 unsigned short usRemainingSize; 00659 usRemainingSize=ucHeaderSize+ 00660 ICMP_DATA_SIZE+ 00661 ucNewHeaderSize; 00662 00663 //Anything left? 00664 if (usRemainingSize<ucPacketSize) 00665 { 00666 //Set the size 00667 m_usDataSize=ucPacketSize-usRemainingSize; 00668 00669 //Allocate some data 00670 m_pICMPReceiveData=new char[m_usDataSize]; 00671 00672 //Copy it 00673 memcpy(m_pICMPReceiveData, 00674 pBuffer+usRemainingSize, 00675 m_usDataSize); 00676 } 00677 } 00678 00679 //Now I need to reverse the header 00680 ReverseHeader(m_pICMPHeader); 00681 00682 //Done 00683 return TRUE; 00684 } 00685 ERROR_HANDLER_RETURN("ProccessICMP",FALSE) 00686 }
| BOOL CAsyncSocket::ReAsync | ( | ) | [virtual, inherited] |
Definition at line 782 of file AsyncSocket.cpp.
00783 { 00784 if (!m_bBlocking) 00785 return TRUE; 00786 00787 try 00788 { 00789 //Quit if not ok 00790 if (!CheckAsyncSocketValid()) 00791 return FALSE; 00792 00793 //First disable the events 00794 int iResult; 00795 iResult=WSAAsyncSelect(GetAsyncHandle(), 00796 GetWindowHandle(), 00797 m_iMsg, 00798 m_lEvent); 00799 00800 if (iResult) 00801 { 00802 //Report it 00803 SetLastError("ReAsync"); 00804 00805 //Exit 00806 return FALSE; 00807 } 00808 00809 //Set to async 00810 m_bBlocking=FALSE; 00811 00812 //And quit 00813 return TRUE; 00814 } 00815 ERROR_HANDLER_RETURN("ReAsync",FALSE) 00816 }
| BOOL CAsyncSocket::ReBlock | ( | ) | [virtual, inherited] |
Definition at line 718 of file AsyncSocket.cpp.
00719 { 00720 if (m_bBlocking) 00721 return TRUE; 00722 00723 try 00724 { 00725 //Quit if not ok 00726 if (!CheckAsyncSocketValid()) 00727 return FALSE; 00728 00729 if (Block()) 00730 //Set to reblock 00731 m_bBlocking=TRUE; 00732 00733 //And quit 00734 return TRUE; 00735 } 00736 ERROR_HANDLER_RETURN("ReBlock",FALSE) 00737 }
| int CSpoofSocket::Receive | ( | char * | pBuffer, | |
| unsigned long | ulBufferLength | |||
| ) | [virtual, inherited] |
Reimplemented in CTCPSocketAsync, and CUDPSocket.
Definition at line 1210 of file SpoofSocket.cpp.
01212 { 01213 try 01214 { 01215 if (!ValidSocket() || 01216 !pBuffer || 01217 !ulBufferLength) 01218 return GetErrorCode(); 01219 01220 //Receive data 01221 int iResult; 01222 01223 //Receive 01224 if (m_ucProtocol!=IPPROTO_TCP && 01225 !m_bSniffing) 01226 { 01227 //Get the remote address 01228 sockaddr saConnected; 01229 01230 int iTmp; 01231 iTmp=sizeof(saConnected); 01232 01233 //Accept it 01234 iResult=recvfrom(GetHandle(), 01235 pBuffer, 01236 ulBufferLength, 01237 NULL, 01238 &saConnected, 01239 &iTmp); 01240 01241 //If OK set it 01242 if (iResult!=GetErrorCode()) 01243 //Take the connected to data 01244 memcpy(&m_aConnectedTo, 01245 &saConnected, 01246 sizeof(saConnected)); 01247 } 01248 else 01249 //Do a regular receive 01250 iResult=recv(GetHandle(), 01251 pBuffer, 01252 ulBufferLength, 01253 NULL); 01254 01255 //Check if error 01256 if (iResult==GetErrorCode() && 01257 GetSystemLastError()!=WSAEWOULDBLOCK) 01258 //Error 01259 SetLastError("Receive"); 01260 01261 //Number of bytes received 01262 return iResult; 01263 } 01264 ERROR_HANDLER_RETURN("Receive",GetErrorCode()) 01265 }
| int CSpoofSocket::ReceiveFrom | ( | char * | pBuffer, | |
| unsigned long | ulBufferLength, | |||
| IP & | rIP, | |||
| unsigned short & | rSourcePort | |||
| ) | [protected, virtual, inherited] |
Definition at line 1140 of file SpoofSocket.cpp.
01144 { 01145 try 01146 { 01147 if (!ValidSocket() || 01148 !pBuffer || 01149 !ulBufferLength) 01150 return GetErrorCode(); 01151 01152 //Receive data 01153 int iResult; 01154 01155 //Receive 01156 if (m_ucProtocol!=IPPROTO_TCP && 01157 !m_bSniffing) 01158 { 01159 //Get the remote address 01160 sockaddr saConnected; 01161 01162 int iTmp; 01163 iTmp=sizeof(saConnected); 01164 01165 //Accept it 01166 iResult=recvfrom(GetHandle(), 01167 pBuffer, 01168 ulBufferLength, 01169 NULL, 01170 &saConnected, 01171 &iTmp); 01172 01173 //If OK set it 01174 if (iResult!=GetErrorCode()) 01175 { 01176 //Address 01177 rIP=((sockaddr_in*)&saConnected)->sin_addr.S_un.S_addr; 01178 01179 //Port 01180 rSourcePort=htons(((sockaddr_in*)&saConnected)->sin_port); 01181 01182 //Done 01183 return iResult; 01184 } 01185 else 01186 { 01187 //Error 01188 SetLastError("Receive"); 01189 01190 //Reset the data 01191 rIP=0; 01192 rSourcePort=0; 01193 01194 //Done 01195 return iResult; 01196 } 01197 } 01198 else 01199 { 01200 //Report it 01201 ReportError("Receive","Can't run on TCP socket!"); 01202 01203 //Exit 01204 return GetErrorCode(); 01205 } 01206 } 01207 ERROR_HANDLER_RETURN("Receive",GetErrorCode()) 01208 }
| void CSpoofBase::RegisterShutdown | ( | CSpoofBase * | pBase | ) | [protected, inherited] |
Definition at line 406 of file SpoofBase.cpp.
00407 { 00408 try 00409 { 00410 //Check if we already have a class 00411 if (m_pShutdownClass) 00412 delete m_pShutdownClass; 00413 00414 //Take it 00415 m_pShutdownClass=pBase; 00416 } 00417 ERROR_HANDLER("RegisterShutdown") 00418 }
| void CAsyncSocket::RemoveSocketFromList | ( | ) | [protected, inherited] |
Definition at line 303 of file AsyncSocket.cpp.
00304 { 00305 try 00306 { 00307 if (m_bList) 00308 if (m_pCSection) 00309 { 00310 //Enter the CS 00311 CCriticalAutoRelease aRelease(m_pCSection); 00312 00313 //Erase it 00314 m_aSocketMap.erase(GetSocketID()); 00315 } 00316 else 00317 ReportError("RemoveSocketFromList","Critical section not initialized"); 00318 } 00319 ERROR_HANDLER("RemoveSocketFromList") 00320 }
| 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 }
| long CSpoofSocket::ResolveDNS | ( | const std::string & | rAddress | ) | [static, inherited] |
Definition at line 1300 of file SpoofSocket.cpp.
01301 { 01302 try 01303 { 01304 //Resolve the DNS 01305 sockaddr_in aAddr; 01306 aAddr=InternalResolveDNS(rAddress.c_str()); 01307 01308 //Check if valid 01309 if (aAddr.sin_addr.S_un.S_addr==0) 01310 //Error 01311 return 0; 01312 else 01313 return aAddr.sin_addr.S_un.S_addr; 01314 } 01315 ERROR_HANDLER_STATIC_RETURN(CSpoofSocket_LOGNAME,"ResolveDNS",0) 01316 }
| int CSpoofSocket::Send | ( | const std::string & | rDestinationAddress, | |
| const char * | pBuffer, | |||
| unsigned long | ulBufferLength, | |||
| unsigned short | usDestinationPort = 0 | |||
| ) | [virtual, inherited] |
Definition at line 759 of file SpoofSocket.cpp.
00763 { 00764 try 00765 { 00766 //Quit if not ok 00767 if (!CheckSocketValid()) 00768 return GetErrorCode(); 00769 00770 return Send(inet_addr(rDestinationAddress.c_str()), 00771 pBuffer, 00772 ulBufferLength, 00773 usDestinationPort); 00774 } 00775 ERROR_HANDLER_RETURN("Send",GetErrorCode()) 00776 }
| int CSpoofSocket::Send | ( | IP | aDestinationAddress, | |
| const char * | pBuffer, | |||
| unsigned long | ulBufferLength, | |||
| unsigned short | usDestinationPort = 0 | |||
| ) | [virtual, inherited] |
Definition at line 604 of file SpoofSocket.cpp.
00608 { 00609 try 00610 { 00611 //Quit if not ok 00612 if (!CheckSocketValid()) 00613 return GetErrorCode(); 00614 00615 //Is it a valid size 00616 if (ulBufferLength && 00617 !pBuffer) 00618 return GetErrorCode(); 00619 00620 //Define the target address 00621 sockaddr_in aTargetAddress; 00622 memset(&aTargetAddress, 00623 0, 00624 sizeof(aTargetAddress)); 00625 00626 aTargetAddress.sin_family=AF_INET; 00627 aTargetAddress.sin_addr.s_addr=aDestinationAddress; 00628 aTargetAddress.sin_port=htons(usDestinationPort); 00629 00630 //packet send status ? 00631 int iResult; 00632 00633 //Only if allowing raw headers !! 00634 if (m_bRaw) 00635 { 00636 //Header length 00637 unsigned char ucHeaderLength; 00638 ucHeaderLength=IpHeaderLength; 00639 00640 //Do we have options? 00641 if (m_bOptions) 00642 ucHeaderLength+=m_pIPOptions->GetBufferLength(); 00643 00644 //First construct the packet 00645 LPIpHeader lpHead=ConstructIPHeader(m_ucProtocol, 00646 IpFragFlag_DONT_FRAG, 00647 m_ucTTL, 00648 (unsigned short)GetCurrentProcessId(), 00649 ucHeaderLength); 00650 00651 //Protect the header 00652 std::auto_ptr<IpHeader> pProtection(lpHead); 00653 00654 //Set the address 00655 SetIPHeaderAddress(lpHead, 00656 m_ulSourceAddress, 00657 aDestinationAddress); 00658 00659 //Now add some more options 00660 int iTotalLength; 00661 iTotalLength=ucHeaderLength+ulBufferLength; 00662 00663 //Set the header 00664 lpHead->usTotalLength=htons(iTotalLength); 00665 00666 //Need to construct a new packet 00667 char* pNewBuffer; 00668 pNewBuffer=new char[iTotalLength]; 00669 00670 //Protect the buffer 00671 CArray_ptr<char> pBufferProtection(pNewBuffer); 00672 00673 //Copy two buffers 00674 memcpy(pNewBuffer, 00675 lpHead, 00676 IpHeaderLength); 00677 00678 //Do we need to copy options ? 00679 if (m_bOptions) 00680 memcpy(pNewBuffer+IpHeaderLength, 00681 m_pIPOptions->GetBuffer(), 00682 m_pIPOptions->GetBufferLength()); 00683 00684 //Only if not null 00685 if (pBuffer) 00686 memcpy(pNewBuffer+ucHeaderLength, 00687 pBuffer, 00688 ulBufferLength); 00689 00690 //Calculate the checksum 00691 lpHead->usChecksum=CalculateChecksum((unsigned short*)pNewBuffer, 00692 ucHeaderLength); 00693 00694 //Alert everyone this is the final header 00695 FinalIPHeader(lpHead); 00696 00697 //Recopy the ip 00698 memcpy(pNewBuffer, 00699 lpHead, 00700 IpHeaderLength); 00701 00702 //Send the data 00703 iResult=sendto(GetHandle(), 00704 (const char*)pNewBuffer, 00705 iTotalLength, 00706 0, 00707 (sockaddr*)&aTargetAddress, 00708 sizeof(aTargetAddress)); 00709 00710 //Is all OK 00711 if (iResult==GetErrorCode() && 00712 GetSystemLastError()!=WSAEWOULDBLOCK) 00713 //Set the error 00714 SetLastError("Send - Raw"); 00715 } 00716 else 00717 { 00718 //Set to no error 00719 iResult=!GetErrorCode(); 00720 00721 //Insert options 00722 /*if (m_bOptions) 00723 iResult=setsockopt(GetHandle(), 00724 IPPROTO_IP, 00725 IP_OPTIONS, 00726 m_pIPOptions->GetBuffer(), 00727 m_pIPOptions->GetBufferLength()); 00728 else 00729 //No options 00730 iResult=setsockopt(GetHandle(), 00731 IPPROTO_IP, 00732 IP_OPTIONS, 00733 NULL, 00734 0);*/ 00735 00736 //Check if we had an error 00737 if (iResult!=GetErrorCode()) 00738 //Use regular send !!! 00739 iResult=sendto(GetHandle(), 00740 (const char*)pBuffer, 00741 ulBufferLength, 00742 0, 00743 (sockaddr*)&aTargetAddress, 00744 sizeof(aTargetAddress)); 00745 00746 //Is all OK? 00747 if (iResult==GetErrorCode() && 00748 GetSystemLastError()!=WSAEWOULDBLOCK) 00749 //Set the error 00750 SetLastError("Send"); 00751 } 00752 00753 //Done 00754 return iResult; 00755 } 00756 ERROR_HANDLER_RETURN("Send",GetErrorCode()) 00757 }
| BOOL CAsyncSocket::SendBlockedBuffer | ( | const CBlockedBuffer::CBlockedData & | rData | ) | [protected, virtual, inherited] |
| BOOL CICMPSocket::SendEcho | ( | IP | aDestinationAddress, | |
| BOOL | bReply, | |||
| unsigned short | usIdentifier, | |||
| unsigned short | usSequence, | |||
| unsigned long | ulData | |||
| ) | [inherited] |
Definition at line 347 of file ICMPSocket.cpp.
00352 { 00353 try 00354 { 00355 //Create the header 00356 LPICMPHeader lpHead; 00357 lpHead=ConstructICMP(); 00358 00359 if (!lpHead) 00360 { 00361 //Report it 00362 ReportError("SendEcho","Failed to construct ICMP header!"); 00363 00364 //Exit 00365 return FALSE; 00366 } 00367 00368 //Protect it 00369 std::auto_ptr<ICMPHeader> pProtection(lpHead); 00370 00371 //Check if echo or reply 00372 if (bReply) 00373 lpHead->ucICMPType=ICMP_Echo_Reply; 00374 else 00375 lpHead->ucICMPType=ICMP_Echo; 00376 00377 lpHead->ucICMPCode=0; 00378 lpHead->sICMP.sUS.us1=htons(usIdentifier); 00379 lpHead->sICMP.sUS.us2=htons(usSequence); 00380 lpHead->ulICMP_Originate_Timestamp=htonl(ulData); 00381 00382 //And the checksum 00383 lpHead->usICMPChecksum=CalculateChecksum((unsigned short*)lpHead,ICMPHeaderLength); 00384 00385 //Send it 00386 BOOL bSend; 00387 bSend=CSpoofSocket::Send(aDestinationAddress, 00388 (char*)lpHead, 00389 ICMPHeaderLength); 00390 00391 //Exit 00392 return bSend; 00393 } 00394 ERROR_HANDLER_RETURN("SendEcho",FALSE) 00395 }
| BOOL CICMPSocket::SendEcho | ( | const std::string & | rDestinationAddress, | |
| BOOL | bReply, | |||
| unsigned short | usIdentifier, | |||
| unsigned short | usSequence, | |||
| unsigned long | ulData | |||
| ) | [inherited] |
Definition at line 330 of file ICMPSocket.cpp.
00335 { 00336 try 00337 { 00338 return SendEcho(StringToLong(rDestinationAddress), 00339 bReply, 00340 usIdentifier, 00341 usSequence, 00342 ulData); 00343 } 00344 ERROR_HANDLER_RETURN("SendEcho",FALSE) 00345 }
| BOOL CICMPSocket::SendICMP | ( | LPICMPHeader | lpHead, | |
| IP | aDestinationAddress | |||
| ) | [protected, inherited] |
Definition at line 751 of file ICMPSocket.cpp.
00753 { 00754 try 00755 { 00756 //Our buffer to send 00757 char* pSendBuffer; 00758 00759 //Size of the buffer to send 00760 int iSendSize; 00761 iSendSize=ICMPHeaderLength; 00762 00763 //Do we have an external buffer ? 00764 if (!m_pSendBuffer) 00765 pSendBuffer=(char*)lpHead; 00766 else 00767 { 00768 iSendSize+=m_usBufferSendSize; 00769 pSendBuffer=new char[m_usBufferSendSize]; 00770 00771 //Copy the data 00772 memcpy(pSendBuffer, 00773 (char*)lpHead, 00774 ICMPHeaderLength); 00775 memcpy(pSendBuffer+ICMPHeaderLength, 00776 m_pSendBuffer, 00777 m_usBufferSendSize); 00778 } 00779 00780 //Send to modify before send 00781 FinalICMPHeader((LPICMPHeader)pSendBuffer); 00782 00783 //Send it 00784 int iResult; 00785 iResult=CSpoofSocket::Send(aDestinationAddress, 00786 pSendBuffer, 00787 iSendSize); 00788 00789 if (m_pSendBuffer) 00790 delete [] pSendBuffer; 00791 00792 //Done 00793 return iResult>0; 00794 } 00795 ERROR_HANDLER_RETURN("SendICMP",FALSE) 00796 }
| BOOL CICMPSocket::SendICMP | ( | LPICMPHeader | lpHead, | |
| const std::string & | rDestinationAddress | |||
| ) | [protected, inherited] |
Definition at line 740 of file ICMPSocket.cpp.
00742 { 00743 try 00744 { 00745 return SendICMP(lpHead, 00746 StringToLong(rDestinationAddress)); 00747 } 00748 ERROR_HANDLER_RETURN("SendICMP",FALSE) 00749 }
| BOOL CICMPSocket::SendInformation | ( | IP | aDestinationAddress, | |
| BOOL | bReply, | |||
| unsigned short | usIdentifier, | |||
| unsigned short | usSequence | |||
| ) | [inherited] |
Definition at line 486 of file ICMPSocket.cpp.
00490 { 00491 try 00492 { 00493 //Create the header 00494 LPICMPHeader lpHead; 00495 lpHead=ConstructICMP(); 00496 00497 if (!lpHead) 00498 { 00499 //Report it 00500 ReportError("SendInformation","Failed to construct ICMP header!"); 00501 00502 //Exit 00503 return FALSE; 00504 } 00505 00506 //Check if echo or reply 00507 if (bReply) 00508 lpHead->ucICMPType=ICMP_Information_Reply; 00509 else 00510 lpHead->ucICMPType=ICMP_Information; 00511 00512 lpHead->ucICMPCode=0; 00513 lpHead->sICMP.sUS.us1=htons(usIdentifier); 00514 lpHead->sICMP.sUS.us2=htons(usSequence); 00515 00516 //And the checksum 00517 //Using only first 8 bytes 00518 lpHead->usICMPChecksum=CalculateChecksum((unsigned short*)lpHead, 00519 ICMP_Information_SIZE); 00520 00521 //Send it 00522 BOOL bSend; 00523 bSend=SendICMP(lpHead, 00524 aDestinationAddress); 00525 00526 //Exit 00527 return bSend; 00528 } 00529 ERROR_HANDLER_RETURN("SendInformation",FALSE) 00530 }
| BOOL CICMPSocket::SendInformation | ( | const std::string & | rDestinationAddress, | |
| BOOL | bReply, | |||
| unsigned short | usIdentifier, | |||
| unsigned short | usSequence | |||
| ) | [inherited] |
Definition at line 471 of file ICMPSocket.cpp.
00475 { 00476 try 00477 { 00478 return SendInformation(StringToLong(rDestinationAddress), 00479 bReply, 00480 usIdentifier, 00481 usSequence); 00482 } 00483 ERROR_HANDLER_RETURN("SendInformation",FALSE) 00484 }
| BOOL CICMPSocket::SendParameter | ( | IP | aDestinationAddress, | |
| unsigned char | ucError | |||
| ) | [inherited] |
Definition at line 217 of file ICMPSocket.cpp.
00219 { 00220 try 00221 { 00222 //Construct the header 00223 LPICMPHeader lpHead; 00224 lpHead=ConstructICMP(); 00225 00226 if (!lpHead) 00227 { 00228 //Report it 00229 ReportError("SendParameter","Failed to construct ICMP header!"); 00230 00231 //Exit 00232 return FALSE; 00233 } 00234 00235 //Protect it 00236 std::auto_ptr<ICMPHeader> pProtection(lpHead); 00237 00238 //Set the values 00239 lpHead->ucICMPType=ICMP_Parameter; 00240 lpHead->ucICMPCode=ICMP_Parameter_ERROR; 00241 lpHead->sICMP.sUC.uc1=ucError; 00242 00243 //And the checksum 00244 lpHead->usICMPChecksum=CalculateChecksum((unsigned short*)lpHead,ICMPHeaderLength); 00245 00246 //Send it 00247 BOOL bSend; 00248 bSend=SendICMP(lpHead, 00249 aDestinationAddress); 00250 00251 //Done 00252 return bSend; 00253 } 00254 ERROR_HANDLER_RETURN("SendParameter",FALSE) 00255 }
| BOOL CICMPSocket::SendParameter | ( | const std::string & | rDestinationAddress, | |
| unsigned char | ucError | |||
| ) | [inherited] |
Definition at line 206 of file ICMPSocket.cpp.
00208 { 00209 try 00210 { 00211 return SendParameter(StringToLong(rDestinationAddress), 00212 ucError); 00213 } 00214 ERROR_HANDLER_RETURN("SendParameter",FALSE) 00215 }
| BOOL CICMPSocket::SendQuench | ( | IP | aDestinationAddress | ) | [inherited] |
Definition at line 266 of file ICMPSocket.cpp.
00267 { 00268 try 00269 { 00270 return Send(aDestinationAddress, 00271 ICMP_Quench, 00272 0); 00273 } 00274 ERROR_HANDLER_RETURN("SendQuench",FALSE) 00275 }
| BOOL CICMPSocket::SendQuench | ( | const std::string & | rDestinationAddress | ) | [inherited] |
Definition at line 257 of file ICMPSocket.cpp.
00258 { 00259 try 00260 { 00261 return SendQuench(StringToLong(rDestinationAddress)); 00262 } 00263 ERROR_HANDLER_RETURN("SendQuench",FALSE) 00264 }
| int CSpoofSocket::SendRawBuffer | ( | IP | aDestinationAddress, | |
| const char * | pBuffer, | |||
| unsigned long | ulBufferLength, | |||
| unsigned short | usDestinationPort | |||
| ) | [virtual, inherited] |
Definition at line 563 of file SpoofSocket.cpp.
00567 { 00568 try 00569 { 00570 //Quit if not ok 00571 //Make things the fastest 00572 if (m_aSpoofSocket==INVALID_SOCKET || 00573 !m_bRaw) 00574 return FALSE; 00575 00576 //Define the target address 00577 sockaddr_in m_TargetAddress; 00578 00579 m_TargetAddress.sin_family=AF_INET; 00580 m_TargetAddress.sin_addr.s_addr=aDestinationAddress; 00581 m_TargetAddress.sin_port=htons(usDestinationPort); 00582 memset(&m_TargetAddress.sin_zero,0,sizeof(m_TargetAddress.sin_zero)); 00583 00584 //And send the data 00585 //Send the data 00586 int iResult; 00587 iResult=sendto(GetHandle(), 00588 pBuffer, 00589 ulBufferLength, 00590 0, 00591 (sockaddr*)&m_TargetAddress, 00592 sizeof(m_TargetAddress)); 00593 00594 if (iResult==GetErrorCode()) 00595 //Set the error 00596 SetLastError("SendRawBuffer"); 00597 00598 //Done 00599 return iResult; 00600 } 00601 ERROR_HANDLER_RETURN("SendRawBuffer",GetErrorCode()) 00602 }
| BOOL CICMPSocket::SendRedirect | ( | IP | aDestinationAddress, | |
| unsigned char | ucType, | |||
| IP | aGatewayAddress | |||
| ) | [inherited] |
Definition at line 290 of file ICMPSocket.cpp.
00293 { 00294 try 00295 { 00296 LPICMPHeader lpHead; 00297 lpHead=ConstructICMP(); 00298 00299 if (!lpHead) 00300 { 00301 //Report it 00302 ReportError("SendRedirect","Failed to construct ICMP header!"); 00303 00304 //Exit 00305 return FALSE; 00306 } 00307 00308 //Protect it 00309 std::auto_ptr<ICMPHeader> pProtection(lpHead); 00310 00311 //Set the values 00312 lpHead->ucICMPType=ICMP_Redirect; 00313 lpHead->ucICMPCode=ucType; 00314 lpHead->sICMP.sUL=aGatewayAddress; 00315 00316 //And the checksum 00317 lpHead->usICMPChecksum=CalculateChecksum((unsigned short*)lpHead,ICMPHeaderLength); 00318 00319 //Send it 00320 BOOL bSend; 00321 bSend=SendICMP(lpHead, 00322 aDestinationAddress); 00323 00324 //Exit 00325 return bSend; 00326 } 00327 ERROR_HANDLER_RETURN("SendRedirect",FALSE) 00328 }
| BOOL CICMPSocket::SendRedirect | ( | const std::string & | rDestinationAddress, | |
| unsigned char | ucType, | |||
| const std::string & | rGatewayAddress | |||
| ) | [inherited] |
Definition at line 277 of file ICMPSocket.cpp.
00280 { 00281 try 00282 { 00283 return SendRedirect(StringToLong(rDestinationAddress), 00284 ucType, 00285 StringToLong(rGatewayAddress)); 00286 } 00287 ERROR_HANDLER_RETURN("SendRedirect",FALSE) 00288 }
| BOOL CICMPSocket::SendTime | ( | IP | aDestinationAddress, | |
| unsigned char | ucType | |||
| ) | [inherited] |
Definition at line 154 of file ICMPSocket.cpp.
00156 { 00157 try 00158 { 00159 return Send(aDestinationAddress, 00160 ICMP_Time, 00161 ucType); 00162 } 00163 ERROR_HANDLER_RETURN("SendTime",FALSE) 00164 }
| BOOL CICMPSocket::SendTime | ( | const std::string & | rDestinationAddress, | |
| unsigned char | ucType | |||
| ) | [inherited] |
Definition at line 143 of file ICMPSocket.cpp.
00145 { 00146 try 00147 { 00148 return SendTime(StringToLong(rDestinationAddress), 00149 ucType); 00150 } 00151 ERROR_HANDLER_RETURN("SendTime",FALSE) 00152 }
| BOOL CICMPSocket::SendTimestamp | ( | IP | aDestinationAddress, | |
| BOOL | bReply, | |||
| unsigned short | usIdentifier, | |||
| unsigned short | usSequence, | |||
| unsigned long | ulOriginateTimestamp, | |||
| unsigned long | ulReceiveTimestamp, | |||
| unsigned long | ulTransmitTimestamp | |||
| ) | [inherited] |
Definition at line 418 of file ICMPSocket.cpp.
00425 { 00426 try 00427 { 00428 //Create the header 00429 LPICMPHeader lpHead; 00430 lpHead=ConstructICMP(); 00431 00432 if (!lpHead) 00433 { 00434 //Report it 00435 ReportError("SendTimestamp","Failed to construct ICMP header!"); 00436 00437 //Exit 00438 return FALSE; 00439 } 00440 00441 //Protect it 00442 std::auto_ptr<ICMPHeader> pProtection(lpHead); 00443 00444 //Check if echo or reply 00445 if (bReply) 00446 lpHead->ucICMPType=ICMP_Timestamp_Reply; 00447 else 00448 lpHead->ucICMPType=ICMP_Timestamp; 00449 00450 lpHead->ucICMPCode=0; 00451 lpHead->sICMP.sUS.us1=htons(usIdentifier); 00452 lpHead->sICMP.sUS.us2=htons(usSequence); 00453 lpHead->ulICMP_Originate_Timestamp=htonl(ulOriginateTimestamp); 00454 lpHead->ulICMP_Receive_Timestamp=htonl(ulReceiveTimestamp); 00455 lpHead->ulICMP_Transmit_Timestamp=htonl(ulTransmitTimestamp); 00456 00457 //And the checksum 00458 lpHead->usICMPChecksum=CalculateChecksum((unsigned short*)lpHead,ICMPHeaderLength); 00459 00460 //Send it 00461 BOOL bSend; 00462 bSend=SendICMP(lpHead, 00463 aDestinationAddress); 00464 00465 //Exit 00466 return bSend; 00467 } 00468 ERROR_HANDLER_RETURN("SendTimestamp",FALSE) 00469 }
| BOOL CICMPSocket::SendTimestamp | ( | const std::string & | rDestinationAddress, | |
| BOOL | bReply, | |||
| unsigned short | usIdentifier, | |||
| unsigned short | usSequence, | |||
| unsigned long | ulOriginateTimestamp, | |||
| unsigned long | ulReceiveTimestamp, | |||
| unsigned long | ulTransmitTimestamp | |||
| ) | [inherited] |
Definition at line 397 of file ICMPSocket.cpp.
00404 { 00405 try 00406 { 00407 return SendTimestamp(StringToLong(rDestinationAddress), 00408 bReply, 00409 usIdentifier, 00410 usSequence, 00411 ulOriginateTimestamp, 00412 ulReceiveTimestamp, 00413 ulTransmitTimestamp); 00414 } 00415 ERROR_HANDLER_RETURN("SendTimestamp",FALSE) 00416 }
| BOOL CICMPSocket::SendUnreachable | ( | IP | aDestinationAddress, | |
| unsigned char | ucType | |||
| ) | [inherited] |
Definition at line 109 of file ICMPSocket.cpp.
00111 { 00112 try 00113 { 00114 return Send(aDestinationAddress, 00115 ICMP_Unreachable, 00116 ucType); 00117 } 00118 ERROR_HANDLER_RETURN("SendUnreachable",FALSE) 00119 }
| BOOL CICMPSocket::SendUnreachable | ( | const std::string & | rDestinationAddress, | |
| unsigned char | ucType | |||
| ) | [inherited] |
Definition at line 98 of file ICMPSocket.cpp.
00100 { 00101 try 00102 { 00103 return SendUnreachable(StringToLong(rDestinationAddress), 00104 ucType); 00105 } 00106 ERROR_HANDLER_RETURN("SendUnreachable",FALSE) 00107 }
| BOOL CICMPSocketAsync::SetAsync | ( | ) | [protected, virtual, inherited] |
Implements CAsyncSocket.
Definition at line 73 of file ICMPSocketAsync.cpp.
00074 { 00075 try 00076 { 00077 //Set event to read / write / close / oob 00078 int iResult; 00079 iResult=InternalWSAAsyncSelect(WM_SOCKET_GENERAL, 00080 FD_WRITE | FD_READ); 00081 00082 //Is it OK? 00083 if (iResult) 00084 { 00085 //Set socket error 00086 SetLastError("SetAsync"); 00087 00088 //Exit 00089 return FALSE; 00090 } 00091 00092 //Done 00093 return TRUE; 00094 } 00095 ERROR_HANDLER_RETURN("SetAsync",FALSE) 00096 }
| BOOL CSpoofSocket::SetBroadcast | ( | BOOL | bBroadcast | ) | [inherited] |
Definition at line 1522 of file SpoofSocket.cpp.
01523 { 01524 try 01525 { 01526 //Quit if not ok 01527 if (!CheckSocketValid()) 01528 return FALSE; 01529 01530 //Set broadcast option 01531 if(setsockopt(GetHandle(), 01532 SOL_SOCKET, 01533 SO_BROADCAST, 01534 (char*)&bBroadcast, 01535 sizeof(bBroadcast))==GetErrorCode()) 01536 { 01537 //Check for options error 01538 SetLastError("SetBroadcast"); 01539 01540 //Exit 01541 return FALSE; 01542 } 01543 01544 return TRUE; 01545 } 01546 ERROR_HANDLER_RETURN("SetBroadcast",FALSE) 01547 }
| void CSpoofSocket::SetConnectedTo | ( | const sockaddr_in & | rAddress | ) | [protected, inherited] |
| void CPingSocket::SetID | ( | unsigned short | usID | ) | [inherited] |
| void CAsyncSocket::SetInstance | ( | HINSTANCE | hInst | ) | [static, inherited] |
| void CSpoofSocket::SetIPHeaderAddress | ( | LPIpHeader | lpHead, | |
| IP | aSourceAddress, | |||
| IP | aDestinationAddress | |||
| ) | const [protected, virtual, inherited] |
Definition at line 791 of file SpoofSocket.cpp.
00794 { 00795 try 00796 { 00797 //We need to place the header 00798 //If source is NULL then we need to use default source 00799 if (!aSourceAddress || !aDestinationAddress) 00800 { 00801 //Report it 00802 ReportError("SetIPHeaderAddress","Recieved empty source or destination address!"); 00803 00804 //Exit 00805 return; 00806 } 00807 00808 //Place source address 00809 lpHead->ulSourceAddress=aSourceAddress; 00810 00811 //Place destination address 00812 lpHead->ulDestinationAddress=aDestinationAddress; 00813 00814 //Done 00815 } 00816 ERROR_HANDLER("SetIPHeaderAddress") 00817 }
| void CSpoofBase::SetLastError | ( | const std::string & | rMethod, | |
| int | iErrorCode | |||
| ) | const [protected, inherited] |
Definition at line 122 of file SpoofBase.cpp.
00124 { 00125 try 00126 { 00127 //First set the error 00128 m_iLastError=iErrorCode; 00129 00130 //Check if there is an error 00131 if (m_iLastError) 00132 ReportError(rMethod, 00133 m_iLastError); 00134 } 00135 ERROR_HANDLER("SetLastError") 00136 }
| void CSpoofBase::SetLastError | ( | const std::string & | rMethod | ) | const [protected, inherited] |
Definition at line 103 of file SpoofBase.cpp.
00104 { 00105 try 00106 { 00107 #ifdef WIN32 00108 //First set the error 00109 m_iLastError=WSAGetLastError(); 00110 #else 00111 m_iLastError=errno(); 00112 #endif 00113 00114 //Check if there is an error 00115 if (m_iLastError) 00116 ReportError(rMethod, 00117 m_iLastError); 00118 } 00119 ERROR_HANDLER("SetLastError") 00120 }
| void CErrorHandler::SetLocalLog | ( | CErrorLog * | pLog | ) | [inherited] |
| void CErrorHandler::SetLog | ( | CErrorLog * | pLog | ) | [static, inherited] |
| void CErrorHandler::SetName | ( | const std::string & | rName | ) | const [protected, inherited] |
| void CSpoofSocket::SetOptions | ( | BOOL | bOptions | ) | [inherited] |
Definition at line 1068 of file SpoofSocket.cpp.
01069 { 01070 try 01071 { 01072 //Do we want options, normaly not 01073 m_bOptions=bOptions; 01074 01075 //Do we have older options? 01076 if (m_pIPOptions) 01077 { 01078 delete m_pIPOptions; 01079 m_pIPOptions=NULL; 01080 } 01081 01082 //Do we need to reallocate the options 01083 if (bOptions) 01084 m_pIPOptions=new CIPOptions; 01085 } 01086 ERROR_HANDLER("SetOptions") 01087 }
| void CSpoofSocket::SetProtocol | ( | unsigned char | iProtocol | ) | [protected, inherited] |
| BOOL CSpoofSocket::SetReceiveTimeout | ( | unsigned long | ulMS | ) | [inherited] |
Definition at line 1569 of file SpoofSocket.cpp.
01570 { 01571 try 01572 { 01573 //Quit if not ok 01574 if (!CheckSocketValid()) 01575 return FALSE; 01576 01577 //Set it 01578 if(setsockopt(GetHandle(), 01579 SOL_SOCKET, 01580 SO_RCVTIMEO, 01581 (char*)&ulMS, 01582 sizeof(ulMS))==GetErrorCode()) 01583 { 01584 //Check for options error 01585 SetLastError("SetReceiveTimeout"); 01586 01587 //Exit 01588 return FALSE; 01589 } 01590 else 01591 return TRUE; 01592 } 01593 ERROR_HANDLER_RETURN("SetReceiveTimeout",FALSE) 01594 }
| void CRealTimeTraceRouteSocket::SetResolveStatus | ( | BOOL | bResolve | ) |
Definition at line 622 of file RealTimeTraceRouteSocket.cpp.
00623 { 00624 try 00625 { 00626 m_bResolveIPs=bResolve; 00627 } 00628 ERROR_HANDLER("SetResolveStatus") 00629 }
| void CICMPSocket::SetSendBuffer | ( | const char * | pBuffer, | |
| unsigned short | usSendSize | |||
| ) | [inherited] |
Definition at line 798 of file ICMPSocket.cpp.
00800 { 00801 //Set the buffer 00802 m_pSendBuffer=pBuffer; 00803 m_usBufferSendSize=usSendSize; 00804 }
| void CPingSocket::SetSequence | ( | unsigned short | usSequence | ) | [inherited] |
| void CSpoofSocket::SetSourceAddress | ( | const std::string & | rSourceAddress | ) | [virtual, inherited] |
Definition at line 984 of file SpoofSocket.cpp.
00985 { 00986 try 00987 { 00988 //Set the source address, in case we want to spoof it 00989 if (rSourceAddress.empty()) 00990 m_ulSourceAddress=0; 00991 else 00992 m_ulSourceAddress=inet_addr(rSourceAddress.c_str()); 00993 } 00994 ERROR_HANDLER("SetSourceAddress") 00995 }
| void CSpoofSocket::SetSourceAddress | ( | IP | aSourceAddress | ) | [virtual, inherited] |
| BOOL CAsyncSocket::SetSystemTimeout | ( | int | iMS | ) | [protected, inherited] |
Definition at line 1092 of file AsyncSocket.cpp.
01093 { 01094 try 01095 { 01096 //Do we have a timeout 01097 if (m_aTimerID.iTimerID) 01098 { 01099 //Report it 01100 ReportError("SetSystemTimeout","Please kill previous timer!"); 01101 01102 //Exit 01103 return FALSE; 01104 } 01105 01106 //Create the timer 01107 m_aTimerID=GetThreadManager()->RegisterTimeout(iMS, 01108 SystemTimerProc, 01109 this, 01110 TRUE, 01111 GetWindowHandle(), 01112 &m_aTimerID); 01113 01114 //Do we have it 01115 if (!m_aTimerID.iTimerID) 01116 { 01117 //Report it 01118 ReportError("SetSystemTimeout","Failed creating the timer!"); 01119 01120 //Exit 01121 return FALSE; 01122 } 01123 else 01124 return TRUE; 01125 } 01126 ERROR_HANDLER_RETURN("SetSystemTimeout",FALSE) 01127 }
| BOOL CAsyncSocket::SetTimeout | ( | int | iMs | ) | [inherited] |
Definition at line 322 of file AsyncSocket.cpp.
00323 { 00324 try 00325 { 00326 //Get the window handle 00327 HWND hWindowHandle; 00328 hWindowHandle=GetWindowHandle(); 00329 00330 if (!hWindowHandle) 00331 return FALSE; 00332 00333 //Set the timer 00334 m_bTimeout=SetTimer(hWindowHandle, 00335 GetAsyncHandle(), 00336 iMs, 00337 NULL); 00338 00339 return m_bTimeout; 00340 } 00341 ERROR_HANDLER_RETURN("SetTimeout",FALSE) 00342 }
| void CSpoofSocket::SetTTL | ( | unsigned char | ucTTL | ) | [inherited] |
Definition at line 1047 of file SpoofSocket.cpp.
01048 { 01049 try 01050 { 01051 //Quit if not ok 01052 if (!CheckSocketValid()) 01053 return; 01054 01055 if (m_bRaw) 01056 //Set the ttl 01057 m_ucTTL=ucTTL; 01058 else if(setsockopt(GetHandle(), 01059 IPPROTO_IP, 01060 IP_TTL, 01061 (const char*)&ucTTL, 01062 sizeof(ucTTL))) 01063 SetLastError("SetTTL"); 01064 } 01065 ERROR_HANDLER("SetTTL") 01066 }
| void CPingSocket::SetUseSameID | ( | BOOL | bSameID | ) | [inherited] |
| void CAsyncSocket::Shutdown | ( | ) | [static, inherited] |
Definition at line 371 of file AsyncSocket.cpp.
00372 { 00373 try 00374 { 00375 //Only if initialized 00376 if (!m_bInitialized) 00377 return; 00378 00379 if (!m_pCSection) 00380 { 00381 //Report it 00382 ReportStaticError(CAsyncSocket_Class,"Shutdown","Critical section not initialized"); 00383 00384 //Exit 00385 return; 00386 } 00387 00388 //Enter the CS 00389 CCriticalAutoRelease aRelease(m_pCSection); 00390 00391 //Indicate we're shutting down 00392 m_bShuttingDown=TRUE; 00393 00394 //Our vector of sockets 00395 typedef std::vector<CAsyncSocket*> SocketVector; 00396 SocketVector aVector; 00397 00398 //Clear the map 00399 SocketMap::iterator aIterator; 00400 aIterator=m_aSocketMap.begin(); 00401 00402 //While not end of the map 00403 while (aIterator!=m_aSocketMap.end()) 00404 { 00405 //Add the socket 00406 aVector.push_back(aIterator->second); 00407 00408 //Next data 00409 ++aIterator; 00410 } 00411 00412 //Exit the CS 00413 aRelease.Exit(); 00414 00415 //Iterate the vector 00416 while (!aVector.empty()) 00417 { 00418 //Get the socket 00419 CAsyncSocket* pSocket; 00420 pSocket=aVector.back(); 00421 00422 //Remove the socket 00423 aVector.pop_back(); 00424 00425 //Try to delete it 00426 try 00427 { 00428 delete pSocket; 00429 } 00430 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Shutdown - Deletion") 00431 } 00432 00433 //Wait for clean up 00434 Sleep(1000); 00435 00436 //Delete the thread manager 00437 if (m_pThreadManager) 00438 { 00439 delete m_pThreadManager; 00440 m_pThreadManager=NULL; 00441 } 00442 00443 //Remove the handlers 00444 RemoveHandlers(); 00445 00446 //Delete the CS 00447 delete m_pCSection; 00448 m_pCSection=NULL; 00449 } 00450 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Shutdown") 00451 }
| BOOL CSpoofSocket::Shutdown | ( | SocketShutdown | eHow | ) | [inherited] |
Definition at line 1355 of file SpoofSocket.cpp.
01356 { 01357 if (!CheckSocketValid()) 01358 return FALSE; 01359 01360 try 01361 { 01362 int iHow; 01363 01364 //Convert the how to a real flag 01365 if (eHow==ssReceive) 01366 iHow=SD_RECEIVE; 01367 else if (eHow==ssSend) 01368 iHow=SD_SEND; 01369 else 01370 iHow=SD_BOTH; 01371 01372 //Do it 01373 if (shutdown(GetHandle(),iHow)) 01374 { 01375 //Report it 01376 SetLastError("Shutdown"); 01377 01378 //Exit 01379 return FALSE; 01380 } 01381 01382 //Done 01383 return TRUE; 01384 } 01385 ERROR_HANDLER_RETURN("Shutdown",FALSE) 01386 }
| BOOL CSpoofBase::ShutdownSockets | ( | ) | [static, inherited] |
Definition at line 363 of file SpoofBase.cpp.
00364 { 00365 //Only if initialized 00366 if (!m_bInitialized) 00367 return TRUE; 00368 00369 try 00370 { 00371 //Do we have a thread? 00372 if (m_pThread) 00373 { 00374 //Delete it 00375 delete m_pThread; 00376 m_pThread=NULL; 00377 } 00378 00379 //Delete the CS 00380 delete m_pCSection; 00381 m_pCSection=NULL; 00382 00383 //Notify shutdown class 00384 if (m_pShutdownClass) 00385 { 00386 m_pShutdownClass->NotifyShutdown(); 00387 delete m_pShutdownClass; 00388 } 00389 00390 if (WSACleanup()==GetErrorCode()) 00391 return FALSE; 00392 00393 //Not initialized anymore 00394 m_bInitialized=FALSE; 00395 00396 //Done 00397 return TRUE; 00398 } 00399 ERROR_HANDLER_STATIC_RETURN(CSpoofBase_Class,"ShutdownSockets",FALSE) 00400 }
| void CAsyncSocket::SimpleMessageMap | ( | LPMapProc | pProc, | |
| BOOL | bStopWhenTRUE, | |||
| DWORD | dwSleep | |||
| ) | [static, inherited] |
Definition at line 1002 of file AsyncSocket.cpp.
01005 { 01006 try 01007 { 01008 //Check if we have the proc 01009 if (!pProc) 01010 { 01011 //Report it 01012 ReportStaticError(CAsyncSocket_Class,"SimpleMessageMap","Recieved null proc!"); 01013 01014 //Exit 01015 return; 01016 } 01017 01018 //If there is no message map, then receive won't work 01019 MSG msg; 01020 01021 //Set the message map to zeros 01022 memset(&msg, 01023 0, 01024 sizeof(msg)); 01025 01026 //Stop flag 01027 BOOL bStop; 01028 bStop=FALSE; 01029 01030 //Start the loop 01031 while (!bStop && 01032 (*pProc)()!=bStopWhenTRUE) 01033 { 01034 while (!(bStop=(*pProc)()==bStopWhenTRUE) && 01035 PeekMessage(&msg, 01036 NULL, 01037 0, 01038 0, 01039 PM_REMOVE)) 01040 { 01041 TranslateMessage(&msg); 01042 DispatchMessage(&msg); 01043 } 01044 01045 //Do we need to sleep? 01046 if (!bStop) 01047 //No messages 01048 Sleep(dwSleep); 01049 } 01050 } 01051 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SimpleMessageMap") 01052 }
| void CAsyncSocket::SimpleMessageMap | ( | DWORD | dwRunTimeMS | ) | [static, inherited] |
Definition at line 966 of file AsyncSocket.cpp.
00967 { 00968 try 00969 { 00970 //If there is no message map, then receive won't work 00971 MSG msg; 00972 00973 //Set the message map to zeros 00974 memset(&msg, 00975 0, 00976 sizeof(msg)); 00977 00978 //Start loop 00979 DWORD dwLoopStart; 00980 dwLoopStart=GetTickCount(); 00981 00982 //Until a key was hit 00983 while (GetTickCount()-dwLoopStart<dwRunTimeMS) 00984 { 00985 while (PeekMessage(&msg, 00986 NULL, 00987 0, 00988 0, 00989 PM_REMOVE)) 00990 { 00991 TranslateMessage(&msg); 00992 DispatchMessage(&msg); 00993 } 00994 00995 //Sleep so wont be hanged 00996 Sleep(1); 00997 } 00998 } 00999 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SimpleMessageMap") 01000 }
| void CAsyncSocket::SimpleMessageMap | ( | ) | [static, inherited] |
Definition at line 941 of file AsyncSocket.cpp.
00942 { 00943 try 00944 { 00945 //If there is no message map, then receive won't work 00946 MSG msg; 00947 00948 //Set the message map to zeros 00949 memset(&msg, 00950 0, 00951 sizeof(msg)); 00952 00953 while (GetMessage(&msg, 00954 NULL, 00955 0, 00956 0)) 00957 { 00958 //Dispatch the message 00959 TranslateMessage(&msg); 00960 DispatchMessage(&msg); 00961 } 00962 } 00963 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SimpleMessageMap") 00964 }
| char CAsyncSocket::SimpleMessageMapKey | ( | DWORD | dwSleep | ) | [static, inherited] |
Definition at line 1054 of file AsyncSocket.cpp.
01055 { 01056 try 01057 { 01058 //If there is no message map, then receive won't work 01059 MSG msg; 01060 01061 //Set the message map to zeros 01062 memset(&msg, 01063 0, 01064 sizeof(msg)); 01065 01066 //Until a key was hit 01067 while (!kbhit()) 01068 { 01069 while (!kbhit() && 01070 PeekMessage(&msg, 01071 NULL, 01072 0, 01073 0, 01074 PM_REMOVE)) 01075 { 01076 TranslateMessage(&msg); 01077 DispatchMessage(&msg); 01078 } 01079 01080 //Do we need to sleep 01081 if (!kbhit()) 01082 //Sleep so wont be hanged 01083 Sleep(dwSleep); 01084 } 01085 01086 //Return the char 01087 return getch(); 01088 } 01089 ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"SimpleMessageMapKey",0) 01090 }
| BOOL CSpoofSocket::Sniff | ( | BOOL | bSniff | ) | [virtual, inherited] |
Reimplemented in CSniffSocket.
Definition at line 1318 of file SpoofSocket.cpp.
01319 { 01320 //Start sniffing 01321 if (!ValidSocket()) 01322 return FALSE; 01323 01324 try 01325 { 01326 #ifdef WIN32 01327 unsigned long ulBytes; 01328 if (WSAIoctl(GetHandle(),SIO_RCVALL,&bSniff,sizeof(bSniff),NULL,0,&ulBytes,NULL,NULL)) 01329 { 01330 //Error 01331 SetLastError("Sniff"); 01332 01333 //Exit 01334 return FALSE; 01335 } 01336 01337 //Set sniffer status 01338 m_bSniffing=bSniff; 01339 01340 //Done 01341 return TRUE; 01342 #else 01343 return FALSE; 01344 #endif 01345 } 01346 ERROR_HANDLER_RETURN("Sniff",FALSE) 01347 }
| BOOL CAsyncSocket::SocketClosed | ( | int | iErrorCode | ) | [protected, virtual, inherited] |
Definition at line 921 of file AsyncSocket.cpp.
00922 { 00923 try 00924 { 00925 //Call user data 00926 return OnSocketClose(iErrorCode); 00927 } 00928 ERROR_HANDLER_RETURN("SocketClosed",FALSE) 00929 }
| void CAsyncSocket::SocketClosing | ( | ) | [protected, inherited] |
Definition at line 679 of file AsyncSocket.cpp.
00680 { 00681 try 00682 { 00683 //Are we valid 00684 if (m_bClosing || 00685 GetAsyncHandle()==INVALID_SOCKET) 00686 return; 00687 00688 //Indicate we are closing 00689 m_bClosing=TRUE; 00690 00691 //Do we have a regular timer 00692 if (m_bTimeout) 00693 KillTimer(); 00694 00695 //Do we have a system timer ? 00696 if (m_aTimerID.iTimerID) 00697 KillSystemTimer(); 00698 00699 //Kill all the messages 00700 m_iMsg=0; 00701 m_lEvent=0; 00702 00703 //Set it 00704 if (WSAAsyncSelect(GetAsyncHandle(), 00705 GetWindowHandle(), 00706 0, 00707 0)) 00708 SetLastError("SocketClosing"); 00709 } 00710 ERROR_HANDLER("SocketClosing") 00711 }
| BOOL CAsyncSocket::SocketConnected | ( | int | iErrorCode | ) | [protected, virtual, inherited] |
Definition at line 900 of file AsyncSocket.cpp.
00901 { 00902 try 00903 { 00904 //Did we have an error 00905 if (iErrorCode) 00906 return OnSocketConnect(iErrorCode); 00907 00908 //Save the connect value 00909 BOOL bConnectValue; 00910 bConnectValue=OnSocketConnect(0); 00911 00912 //Try to set it to async 00913 if (!SetAsync()) 00914 return FALSE; 00915 else 00916 return bConnectValue; 00917 } 00918 ERROR_HANDLER_RETURN("SocketConnected",FALSE) 00919 }
| void CAsyncSocket::SocketCreated | ( | ) | [protected, virtual, inherited] |
Definition at line 1272 of file AsyncSocket.cpp.
01273 { 01274 try 01275 { 01276 //No timer 01277 memset(&m_aTimerID, 01278 0, 01279 sizeof(m_aTimerID)); 01280 01281 //No delete timer 01282 memset(&m_aDeleteTimerID, 01283 0, 01284 sizeof(m_aDeleteTimerID)); 01285 01286 //Set values for new socket 01287 m_iSocketID=0; 01288 m_bBlocking=FALSE; 01289 m_bFreeze=FALSE; 01290 m_lEvent=0; 01291 m_hLocalWindowHandle=0; 01292 m_bList=FALSE; 01293 m_bClosing=FALSE; 01294 } 01295 ERROR_HANDLER("SocketCreated") 01296 }
| BOOL CAsyncSocket::SocketWrite | ( | int | iErrorCode | ) | [protected, virtual, inherited] |
Definition at line 931 of file AsyncSocket.cpp.
00932 { 00933 try 00934 { 00935 //Call user data 00936 return OnSocketWrite(iErrorCode); 00937 } 00938 ERROR_HANDLER_RETURN("SocketWrite",FALSE) 00939 }
| unsigned long CSpoofBase::StringToLong | ( | const std::string & | rAddress | ) | [static, inherited] |
| void CAsyncSocket::SystemTimeout | ( | ) | [protected, virtual, inherited] |
| void CRealTimeTraceRouteSocket::TraceData | ( | const TraceRouteData * | pData, | |
| BOOL | bResolved | |||
| ) | [protected, virtual] |
| void CRealTimeTraceRouteSocket::TraceDataForModify | ( | TraceRouteData * | pData, | |
| BOOL | bResolved | |||
| ) | [protected, virtual] |
| void CRealTimeTraceRouteSocket::TraceDone | ( | BOOL | bError | ) | [protected, virtual] |
| BOOL CRealTimeTraceRouteSocket::TraceRoute | ( | IP | aDestinationAddress, | |
| DWORD | dwTimeout | |||
| ) | [virtual] |
Definition at line 252 of file RealTimeTraceRouteSocket.cpp.
00254 { 00255 try 00256 { 00257 if (!m_bTraceDone || 00258 !m_bInitialized || 00259 m_bFinishing || 00260 m_bPartialDone) 00261 return FALSE; 00262 00263 //Trace not done 00264 m_bTraceDone=FALSE; 00265 m_bPartialDone=FALSE; 00266 m_bFinishing=FALSE; 00267 00268 //Save the address 00269 m_aTracedAddress=aDestinationAddress; 00270 00271 //Clear the data 00272 for (int iCounter=0;iCounter<=mhMaxHops;++iCounter) 00273 { 00274 //Clear the data 00275 m_aData[iCounter].aReplyingAddress=0; 00276 m_aData[iCounter].ucTTL=0; 00277 m_aData[iCounter].dwElapsedTime=0; 00278 m_aData[iCounter].pDNS=m_pManager; 00279 m_aData[iCounter].bResolved=FALSE; 00280 m_aData[iCounter].bTarget=FALSE; 00281 m_aData[iCounter].bFinal=FALSE; 00282 m_aData[iCounter].lpUserData=NULL; 00283 00284 //The CSection 00285 std::auto_ptr<CGenericCriticalSection> pProtection(COSManager::CreateCriticalSection()); 00286 00287 //Save it 00288 m_aData[iCounter].pCSection=pProtection; 00289 } 00290 00291 m_ucMaxHOP=0; 00292 m_ucMinHOP=mhMaxHops; 00293 00294 //Set the last hops data 00295 //Do we have DNS 00296 m_aData[mhMaxHops].bTarget=TRUE; 00297 00298 //No resolvers 00299 m_ulResolvers=0; 00300 00301 //We need our port start 00302 m_usPortStart=GetPortStart(); 00303 00304 //Send the pings 00305 for (int iPings=0;iPings<3;++iPings) 00306 for (int iCounter=1; 00307 iCounter<=mhMaxHops; 00308 ++iCounter) 00309 { 00310 //Set the TTL 00311 SetTTL(iCounter); 00312 00313 //Set the ID 00314 SetID(iCounter); 00315 00316 //Set the sequence 00317 SetSequence(m_usPortStart); 00318 00319 //And ping 00320 if (!Ping(aDestinationAddress, 00321 0)) 00322 { 00323 //Indicate we are done 00324 m_bTraceDone=TRUE; 00325 00326 //Call user 00327 TraceDone(TRUE); 00328 00329 //Exit 00330 return FALSE; 00331 } 00332 } 00333 00334 //Set the timeout 00335 SetTimeout(dwTimeout); 00336 00337 //Do we have DNS 00338 if (m_bResolveIPs) 00339 { 00340 //Set the resolvers 00341 AdjustResolvers(1); 00342 00343 //Create the data 00344 ResolveThreadData* pThreadData; 00345 pThreadData=new ResolveThreadData; 00346 00347 //Populate it 00348 pThreadData->pClass=this; 00349 pThreadData->pData=&m_aData[mhMaxHops]; 00350 00351 //DNS lookup for the host 00352 //Add the reverse DNS 00353 m_pManager->GetThreadManager()->SubmitJob(ResolveData,(LPVOID)pThreadData); 00354 } 00355 00356 //Done 00357 return TRUE; 00358 } 00359 ERROR_HANDLER_RETURN("TraceRoute",FALSE) 00360 }
| BOOL CRealTimeTraceRouteSocket::TraceRoute | ( | const std::string & | rDestinationAddress, | |
| DWORD | dwTimeout | |||
| ) | [virtual] |
Definition at line 241 of file RealTimeTraceRouteSocket.cpp.
00243 { 00244 try 00245 { 00246 return TraceRoute(StringToLong(rDestinationAddress), 00247 dwTimeout); 00248 } 00249 ERROR_HANDLER_RETURN("TraceRoute",FALSE) 00250 }
| BOOL CSpoofSocket::ValidAddress | ( | const std::string & | rAddress | ) | [static, inherited] |
Definition at line 1267 of file SpoofSocket.cpp.
01268 { 01269 try 01270 { 01271 return inet_addr(rAddress.c_str())!=INADDR_NONE; 01272 } 01273 ERROR_HANDLER_STATIC_RETURN(CSpoofSocket_LOGNAME,"ValidAddress",FALSE) 01274 }
| BOOL CSpoofSocket::ValidSocket | ( | ) | const [protected, inherited] |
| 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 }
Friends And Related Function Documentation
friend class CIPCrafter [friend, inherited] |
Definition at line 452 of file SpoofSocket.h.
The documentation for this class was generated from the following files: