CSniffSocket Class Reference#include <SniffSocket.h>
Inheritance diagram for CSniffSocket:
![]()
Collaboration diagram for CSniffSocket:
![]()
Detailed DescriptionDefinition at line 48 of file SniffSocket.h. Member Typedef Documentation
Definition at line 93 of file AsyncSocket.h.
Member Enumeration Documentation
Definition at line 83 of file AsyncSocket.h. 00084 { 00085 aeReceive=1, 00086 aeSend=2, 00087 aeOOB=4, 00088 aeClose=8 00089 } AsyncEvents;
Definition at line 53 of file ErrorHandler.h. 00054 { 00055 lpDebug, 00056 lpMessage, 00057 lpCritical, 00058 lpError 00059 } LogPriority;
Definition at line 444 of file SpoofSocket.h. 00445 { 00446 ssReceive, 00447 ssSend, 00448 ssBoth 00449 } SocketShutdown;
Constructor & Destructor Documentation
Definition at line 51 of file SniffSocket.cpp. 00051 : CSpoofSocket(TRUE), 00052 CAsyncSocket() 00053 { 00054 try 00055 { 00056 //Set our name 00057 SetName(CSniffSocket_Class); 00058 } 00059 ERROR_HANDLER("CSniffSocket") 00060 }
Definition at line 62 of file SniffSocket.cpp. 00063 { 00064 try 00065 { 00066 RemoveSocketFromList(); 00067 } 00068 ERROR_HANDLER("~CSniffSocket") 00069 }
Member Function Documentation
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
Reimplemented in CICMPSocketAsync, CTCPSocket, CTCPSocketAsync, and CUDPSocketAsync. Definition at line 945 of file SpoofSocket.cpp. 00946 { 00947 try 00948 { 00949 //Close the socket 00950 //Quit if not ok 00951 if (!ValidSocket()) 00952 return FALSE; 00953 00954 //Close it 00955 if (closesocket(GetHandle())==GetErrorCode()) 00956 { 00957 //Error in closing ? 00958 SetLastError("Close"); 00959 00960 //Exit 00961 return FALSE; 00962 } 00963 00964 //Set the socket to invalid 00965 m_aSpoofSocket=INVALID_SOCKET; 00966 00967 //Done 00968 return TRUE; 00969 } 00970 ERROR_HANDLER_RETURN("Close",FALSE) 00971 }
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 }
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 }
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 }
Definition at line 87 of file SniffSocket.cpp. 00088 { 00089 try 00090 { 00091 //Try to create as regular IP socket 00092 SetProtocol(IPPROTO_IP); 00093 if (CSpoofSocket::Create(IPPROTO_IP)) 00094 { 00095 //OK, we can use this socket 00096 AddSocketToList(); 00097 00098 //Done 00099 return TRUE; 00100 } 00101 else 00102 return FALSE; 00103 } 00104 ERROR_HANDLER_RETURN("Create",FALSE) 00105 }
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 }
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 }
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 }
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 }
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 }
Reimplemented in CICMPCrafter, CTCPCrafter, and CUDPCrafter. Definition at line 1393 of file SpoofSocket.cpp.
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 }
Implements CAsyncSocket. Definition at line 107 of file SniffSocket.cpp. 00108 { 00109 return GetHandle(); 00110 }
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 }
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 }
Definition at line 1180 of file AsyncSocket.cpp. 01181 { 01182 return m_aTimerID.iTimerID!=0; 01183 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
Implemented in CSocketPoolSocket, CWhoisSocket, and KomodiaDNS::CDNSTCPSocket.
Implemented in CSocketPoolSocket, CUDPSocketAsync, CWhoisSocket, and KomodiaDNS::CDNSTCPSocket.
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 }
Implemented in CICMPSocketAsync, CPingSocket, CWhoisSocket, KomodiaDNS::CDNSTCPSocket, and KomodiaDNS::CDNSUDPSocket.
Implemented in CPingSocket, CRealTimeTraceRouteSocket, and CWhoisSocket.
Definition at line 1601 of file SpoofSocket.cpp. 01602 { 01603 return m_aSpoofSocket<rSocket.m_aSpoofSocket; 01604 }
Definition at line 1596 of file SpoofSocket.cpp. 01597 { 01598 return m_aSpoofSocket==rSocket.m_aSpoofSocket; 01599 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
Reimplemented from CSpoofSocket. Definition at line 71 of file SniffSocket.cpp. 00072 { 00073 try 00074 { 00075 //Try to move to sniff mode 00076 if (CSpoofSocket::Sniff(bSniff)) 00077 return !WSAAsyncSelect(GetHandle(), 00078 GetWindowHandle(), 00079 WM_SOCKET_GENERAL, 00080 FD_READ); 00081 else 00082 return FALSE; 00083 } 00084 ERROR_HANDLER_RETURN("Sniff",FALSE) 00085 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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
Definition at line 452 of file SpoofSocket.h.
Member Data Documentation
Definition at line 124 of file SpoofBase.h.
The documentation for this class was generated from the following files: |