00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036 #include "stdafx.h"
00037 #include "AsyncSocket.h"
00038
00039 #include "ErrorHandlerMacros.h"
00040
00041 #include "OSManager.h"
00042 #include "GenericCriticalSection.h"
00043
00044 #include <conio.h>
00045
00046 #include <vector>
00047
00048 #ifdef _MEMORY_DEBUG
00049 #define new DEBUG_NEW
00050 #define malloc DEBUG_MALLOC
00051 static char THIS_FILE[] = __FILE__;
00052 #endif
00053
00054 KOMODIA_NAMESPACE_START
00055
00056
00057
00058 BOOL CAsyncSocket::m_bWindow=FALSE;
00059
00060
00061 HINSTANCE CAsyncSocket::m_hInstance=0;
00062
00063
00064 BOOL CAsyncSocket::m_bInitialized=0;
00065
00066
00067 CAsyncSocket::SocketMap CAsyncSocket::m_aSocketMap;
00068
00069
00070 CSocketThreadManager* CAsyncSocket::m_pThreadManager=NULL;
00071
00072
00073 BOOL CAsyncSocket::m_bShuttingDown=FALSE;
00074
00075
00076 CGenericCriticalSection* CAsyncSocket::m_pCSection=NULL;
00077
00078 CAsyncSocket::CAsyncSocket() : CSpoofBase(),
00079 m_bList(FALSE),
00080 m_bTimeout(FALSE),
00081 m_pLocalThreadManager(NULL),
00082 m_hLocalWindowHandle(0),
00083 m_bFreeze(FALSE),
00084 m_bBlocking(FALSE),
00085 m_iMsg(0),
00086 m_lEvent(0),
00087 m_iSocketID(0),
00088 m_pBlockedBuffer(NULL),
00089 m_bClosing(FALSE),
00090 m_ucEvents(0)
00091 {
00092 try
00093 {
00094
00095 Initialize();
00096
00097
00098 SocketCreated();
00099 }
00100 ERROR_HANDLER("CAsyncSocket")
00101 }
00102
00103 CAsyncSocket::~CAsyncSocket()
00104 {
00105 try
00106 {
00107
00108
00109 if (m_aTimerID.iTimerID)
00110 m_pThreadManager->RemoveTimeout(m_aTimerID);
00111
00112 if (m_aDeleteTimerID.iTimerID)
00113 m_pThreadManager->RemoveTimeout(m_aDeleteTimerID);
00114
00115
00116 if (GetThreadManager())
00117
00118 GetThreadManager()->DecreaseSocketCount(GetWindowHandle(),m_bFreeze);
00119
00120
00121 delete m_pBlockedBuffer;
00122 }
00123 ERROR_HANDLER("~CAsyncSocket")
00124 }
00125
00126 BOOL CAsyncSocket::SetHandlers()
00127 {
00128 try
00129 {
00130
00131 if (!m_bWindow)
00132 if (!RegisterWindow())
00133 {
00134
00135 ReportStaticError(CAsyncSocket_Class,"SetHandlers","Error registering the window, please check API error!");
00136
00137
00138 return FALSE;
00139 }
00140 else
00141
00142 m_bWindow=TRUE;
00143
00144
00145 if (!m_pThreadManager)
00146 {
00147
00148 int iThreads;
00149 if (CSpoofBase::IsMultiThreaded())
00150 iThreads=CSpoofBase::GetNumberOfThreads();
00151 else
00152 iThreads=1;
00153
00154
00155 m_pThreadManager=new CSocketThreadManager(m_hInstance);
00156 if (!m_pThreadManager->Initialize(iThreads,
00157 CAsyncSocket_Class))
00158 {
00159
00160 ReportStaticError(CAsyncSocket_Class,"SetHandlers","Failed to initialize the thread manager!");
00161
00162
00163 delete m_pThreadManager;
00164 m_pThreadManager=NULL;
00165
00166
00167 return FALSE;
00168 }
00169 }
00170
00171
00172
00173 return TRUE;
00174 }
00175 ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"CAsyncSocket",FALSE)
00176 }
00177
00178 HINSTANCE CAsyncSocket::GetInstance()
00179 {
00180
00181 return m_hInstance;
00182 }
00183
00184 void CAsyncSocket::AddSocketToList()
00185 {
00186 try
00187 {
00188
00189 AllocateHandle();
00190
00191
00192 if (m_pCSection)
00193 {
00194
00195 CCriticalAutoRelease aRelease(m_pCSection);
00196
00197
00198 m_iSocketID=GetAsyncHandle();
00199 m_aSocketMap.insert(SocketMap::value_type(m_iSocketID,this));
00200
00201
00202 m_bList=TRUE;
00203 }
00204 else
00205 ReportError("AddSocketToList","Critical section not initialized");
00206 }
00207 ERROR_HANDLER("AddSocketToList")
00208 }
00209
00210 int CAsyncSocket::GetSocketID()const
00211 {
00212 return m_iSocketID;
00213 }
00214
00215 CAsyncSocket* CAsyncSocket::GetSocketByID(int iSockID)
00216 {
00217 try
00218 {
00219
00220 if (m_pCSection)
00221 {
00222
00223 CCriticalAutoRelease aRelease(m_pCSection);
00224
00225
00226 SocketMap::iterator aTheIterator;
00227 aTheIterator=m_aSocketMap.find(iSockID);
00228
00229
00230 if (aTheIterator!=m_aSocketMap.end())
00231 return aTheIterator->second;
00232 else
00233 return NULL;
00234 }
00235 else
00236 {
00237
00238 ReportStaticError(CAsyncSocket_Class,"GetSocketByID",NULL);
00239
00240
00241 return NULL;
00242 }
00243 }
00244 ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"GetSocketByID",NULL)
00245 }
00246
00247 BOOL CAsyncSocket::RegisterWindow()
00248 {
00249 try
00250 {
00251 WNDCLASS wc;
00252
00253
00254
00255
00256 wc.style = 0;
00257 wc.lpfnWndProc = (WNDPROC)SocketMessageHandler;
00258
00259 wc.cbClsExtra = 0;
00260 wc.cbWndExtra = 0;
00261 wc.hIcon = NULL;
00262 wc.hInstance = GetInstance();
00263 wc.hCursor = NULL;
00264 wc.hbrBackground = NULL;
00265 wc.lpszMenuName = NULL;
00266 wc.lpszClassName = CAsyncSocket_Class ;
00267
00268
00269
00270 return (RegisterClass(&wc));
00271 }
00272 ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"RegisterWindow",FALSE)
00273 }
00274
00275 void CAsyncSocket::SetInstance(HINSTANCE hInst)
00276 {
00277 m_hInstance=hInst;
00278 }
00279
00280 BOOL CAsyncSocket::RemoveHandlers()
00281 {
00282 try
00283 {
00284
00285 if (m_bWindow)
00286 if (!UnregisterClass(CAsyncSocket_Class,GetInstance()))
00287 return FALSE;
00288
00289 m_bWindow=FALSE;
00290
00291
00292 return TRUE;
00293 }
00294 ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"RemoveHandlers",FALSE)
00295 }
00296
00297 HWND CAsyncSocket::GetWindowHandle()const
00298 {
00299
00300 return m_hLocalWindowHandle;
00301 }
00302
00303 void CAsyncSocket::RemoveSocketFromList()
00304 {
00305 try
00306 {
00307 if (m_bList)
00308 if (m_pCSection)
00309 {
00310
00311 CCriticalAutoRelease aRelease(m_pCSection);
00312
00313
00314 m_aSocketMap.erase(GetSocketID());
00315 }
00316 else
00317 ReportError("RemoveSocketFromList","Critical section not initialized");
00318 }
00319 ERROR_HANDLER("RemoveSocketFromList")
00320 }
00321
00322 BOOL CAsyncSocket::SetTimeout(int iMs)
00323 {
00324 try
00325 {
00326
00327 HWND hWindowHandle;
00328 hWindowHandle=GetWindowHandle();
00329
00330 if (!hWindowHandle)
00331 return FALSE;
00332
00333
00334 m_bTimeout=SetTimer(hWindowHandle,
00335 GetAsyncHandle(),
00336 iMs,
00337 NULL);
00338
00339 return m_bTimeout;
00340 }
00341 ERROR_HANDLER_RETURN("SetTimeout",FALSE)
00342 }
00343
00344 BOOL CAsyncSocket::KillTimer()
00345 {
00346 try
00347 {
00348 HWND hWindowHandle;
00349 hWindowHandle=GetWindowHandle();
00350
00351 if (!hWindowHandle ||
00352 !m_bTimeout)
00353 return FALSE;
00354
00355
00356 m_bTimeout=FALSE;
00357
00358 BOOL bResult;
00359 bResult=::KillTimer(hWindowHandle,
00360 GetAsyncHandle());
00361
00362 if (!bResult)
00363
00364 ReportError("KillTimer");
00365
00366 return bResult;
00367 }
00368 ERROR_HANDLER_RETURN("KillTimer",FALSE)
00369 }
00370
00371 void CAsyncSocket::Shutdown()
00372 {
00373 try
00374 {
00375
00376 if (!m_bInitialized)
00377 return;
00378
00379 if (!m_pCSection)
00380 {
00381
00382 ReportStaticError(CAsyncSocket_Class,"Shutdown","Critical section not initialized");
00383
00384
00385 return;
00386 }
00387
00388
00389 CCriticalAutoRelease aRelease(m_pCSection);
00390
00391
00392 m_bShuttingDown=TRUE;
00393
00394
00395 typedef std::vector<CAsyncSocket*> SocketVector;
00396 SocketVector aVector;
00397
00398
00399 SocketMap::iterator aIterator;
00400 aIterator=m_aSocketMap.begin();
00401
00402
00403 while (aIterator!=m_aSocketMap.end())
00404 {
00405
00406 aVector.push_back(aIterator->second);
00407
00408
00409 ++aIterator;
00410 }
00411
00412
00413 aRelease.Exit();
00414
00415
00416 while (!aVector.empty())
00417 {
00418
00419 CAsyncSocket* pSocket;
00420 pSocket=aVector.back();
00421
00422
00423 aVector.pop_back();
00424
00425
00426 try
00427 {
00428 delete pSocket;
00429 }
00430 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Shutdown - Deletion")
00431 }
00432
00433
00434 Sleep(1000);
00435
00436
00437 if (m_pThreadManager)
00438 {
00439 delete m_pThreadManager;
00440 m_pThreadManager=NULL;
00441 }
00442
00443
00444 RemoveHandlers();
00445
00446
00447 delete m_pCSection;
00448 m_pCSection=NULL;
00449 }
00450 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Shutdown")
00451 }
00452
00453 CAsyncSocket::CAsyncShutdown::CAsyncShutdown() : CSpoofBase()
00454 {
00455 try
00456 {
00457
00458 SetName(CAsyncShutdown_Class);
00459
00460
00461 RegisterShutdown(this);
00462 }
00463 ERROR_HANDLER("CAsyncShutdown")
00464 }
00465
00466 CAsyncSocket::CAsyncShutdown::~CAsyncShutdown()
00467 {
00468 }
00469
00470 void CAsyncSocket::CAsyncShutdown::NotifyShutdown()
00471 {
00472 try
00473 {
00474
00475 CAsyncSocket::Shutdown();
00476 }
00477 ERROR_HANDLER("NotifyShutdown")
00478 }
00479
00480 BOOL CAsyncSocket::IsTimeout() const
00481 {
00482 return m_bTimeout;
00483 }
00484
00485 void CAsyncSocket::Initialize()
00486 {
00487 try
00488 {
00489
00490 if (!m_bInitialized &&
00491 CSpoofBase::IsInitialized())
00492 {
00493
00494 m_pCSection=COSManager::CreateCriticalSection();
00495
00496
00497 if (!SetHandlers())
00498 {
00499
00500 ReportStaticError(CAsyncSocket_Class,"CAsyncSocket","Failed to init handlers!");
00501
00502
00503 return;
00504 }
00505
00506
00507 CAsyncShutdown* pShutdown;
00508 pShutdown=new CAsyncShutdown;
00509
00510
00511 m_bInitialized=TRUE;
00512 }
00513 }
00514 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Initialize")
00515 }
00516
00517
00518 LRESULT CALLBACK CAsyncSocket::SocketMessageHandler(HWND hwnd,
00519 UINT uMsg,
00520 WPARAM wParam,
00521 LPARAM lParam)
00522 {
00523 if (m_bShuttingDown)
00524 return TRUE;
00525
00526 try
00527 {
00528
00529 CAsyncSocket* pSocket;
00530 pSocket=GetSocketByID((int)wParam);
00531
00532
00533 BOOL bIgnore;
00534 if (pSocket &&
00535 pSocket->IsClosing() &&
00536 uMsg!=WM_SOCKET_DELETE)
00537 bIgnore=TRUE;
00538 else
00539 bIgnore=FALSE;
00540
00541
00542 try
00543 {
00544 if (pSocket &&
00545 !bIgnore)
00546
00547 switch (uMsg)
00548 {
00549 case WM_SOCKET_FORCED:
00550 return pSocket->OnSocketReceive(0);
00551 break;
00552 case WM_SOCKET_GENERAL:
00553 if (WSAGETSELECTEVENT(lParam)==FD_READ)
00554 return pSocket->OnSocketReceive(WSAGETSELECTERROR(lParam));
00555 else if (WSAGETSELECTEVENT(lParam)==FD_WRITE)
00556 return pSocket->SocketWrite(WSAGETSELECTERROR(lParam));
00557 else if (WSAGETSELECTEVENT(lParam)==FD_OOB)
00558 return pSocket->OnSocketOOB(WSAGETSELECTERROR(lParam));
00559 else if (WSAGETSELECTEVENT(lParam)==FD_CLOSE)
00560 return pSocket->SocketClosed(WSAGETSELECTERROR(lParam));
00561 break;
00562 case WM_SOCKET_CONNECT:
00563 if (WSAGETSELECTEVENT(lParam)==FD_CONNECT)
00564 return pSocket->SocketConnected(WSAGETSELECTERROR(lParam));
00565 break;
00566 case WM_SOCKET_ACCEPT:
00567 if (WSAGETSELECTEVENT(lParam)==FD_ACCEPT)
00568 return pSocket->OnSocketAccept(WSAGETSELECTERROR(lParam));
00569 break;
00570 case WM_TIMER:
00571
00572 if (pSocket->HasTimeout())
00573
00574 return pSocket->OnSocketTimeout();
00575 else
00576 {
00577
00578 ReportStaticError("CAsyncSocket_Class","Timeout from previous socket!");
00579
00580
00581 return FALSE;
00582 }
00583 case WM_SOCKET_DELETE:
00584
00585 pSocket->OnSocketDelete();
00586
00587
00588 return TRUE;
00589 default:
00590 return (int)(DefWindowProc(hwnd,
00591 uMsg,
00592 wParam,
00593 lParam));
00594 }
00595 else
00596 return (int)(DefWindowProc(hwnd,
00597 uMsg,
00598 wParam,
00599 lParam));
00600 }
00601 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SocketMessageHandler - Proc")
00602
00603
00604 return TRUE;
00605 }
00606 ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"SocketMessageHandler",TRUE)
00607 }
00608
00609 CSocketThreadManager* CAsyncSocket::GetThreadManager() const
00610 {
00611 if (!m_pLocalThreadManager)
00612 return m_pThreadManager;
00613 else
00614 return m_pLocalThreadManager;
00615 }
00616
00617 void CAsyncSocket::AllocateHandle()
00618 {
00619 try
00620 {
00621 m_hLocalWindowHandle=GetThreadManager()->GetWindowHandle();
00622 }
00623 ERROR_HANDLER("AllocateHandle")
00624 }
00625
00626 void CAsyncSocket::DeAllocateHandle()
00627 {
00628 }
00629
00630 BOOL CAsyncSocket::DisableAsync()
00631 {
00632 try
00633 {
00634
00635 if (!CheckAsyncSocketValid())
00636 return FALSE;
00637
00638
00639 int iResult;
00640
00641 iResult=WSAAsyncSelect(GetAsyncHandle(),
00642 GetWindowHandle(),
00643 0,
00644 0);
00645 if (iResult)
00646 {
00647
00648 SetLastError("DisableAsync");
00649
00650
00651 return FALSE;
00652 }
00653
00654 return TRUE;
00655 }
00656 ERROR_HANDLER_RETURN("DisableAsync",FALSE)
00657 }
00658
00659 BOOL CAsyncSocket::CheckAsyncSocketValid() const
00660 {
00661 try
00662 {
00663
00664 if (GetAsyncHandle()==INVALID_SOCKET)
00665 {
00666
00667 ReportError("CheckAsyncSocketValid","Operation made on non existant socket!");
00668
00669
00670 return FALSE;
00671 }
00672
00673
00674 return TRUE;
00675 }
00676 ERROR_HANDLER_RETURN("CheckAsyncSocketValid",FALSE)
00677 }
00678
00679 void CAsyncSocket::SocketClosing()
00680 {
00681 try
00682 {
00683
00684 if (m_bClosing ||
00685 GetAsyncHandle()==INVALID_SOCKET)
00686 return;
00687
00688
00689 m_bClosing=TRUE;
00690
00691
00692 if (m_bTimeout)
00693 KillTimer();
00694
00695
00696 if (m_aTimerID.iTimerID)
00697 KillSystemTimer();
00698
00699
00700 m_iMsg=0;
00701 m_lEvent=0;
00702
00703
00704 if (WSAAsyncSelect(GetAsyncHandle(),
00705 GetWindowHandle(),
00706 0,
00707 0))
00708 SetLastError("SocketClosing");
00709 }
00710 ERROR_HANDLER("SocketClosing")
00711 }
00712
00713 void CAsyncSocket::FreezeThread()
00714 {
00715 m_bFreeze=TRUE;
00716 }
00717
00718 BOOL CAsyncSocket::ReBlock()
00719 {
00720 if (m_bBlocking)
00721 return TRUE;
00722
00723 try
00724 {
00725
00726 if (!CheckAsyncSocketValid())
00727 return FALSE;
00728
00729 if (Block())
00730
00731 m_bBlocking=TRUE;
00732
00733
00734 return TRUE;
00735 }
00736 ERROR_HANDLER_RETURN("ReBlock",FALSE)
00737 }
00738
00739 int CAsyncSocket::InternalWSAAsyncSelect(unsigned int wMsg, long lEvent)
00740 {
00741 try
00742 {
00743
00744 m_iMsg=wMsg;
00745 m_lEvent=lEvent;
00746
00747
00748 typedef struct _MsgPair
00749 {
00750 unsigned int uiMsg;
00751 AsyncEvents aEvents;
00752 } MsgPair;
00753
00754
00755 static const int iMaxEvents=4;
00756
00757
00758 static const MsgPair aMsgPair[iMaxEvents]={{FD_READ,aeReceive},
00759 {FD_WRITE,aeSend},
00760 {FD_OOB,aeOOB},
00761 {FD_CLOSE,aeClose}};
00762
00763
00764 for (int iCounter=0;iCounter<iMaxEvents;++iCounter)
00765 if ((m_lEvent & aMsgPair[iCounter].uiMsg) &&
00766 (m_ucEvents & ((unsigned char)aMsgPair[iCounter].aEvents)))
00767
00768 m_lEvent^=aMsgPair[iCounter].uiMsg;
00769
00770 if (m_bBlocking)
00771 return 0;
00772 else
00773
00774 return WSAAsyncSelect(GetAsyncHandle(),
00775 GetWindowHandle(),
00776 wMsg,
00777 lEvent);
00778 }
00779 ERROR_HANDLER_RETURN("InternalWSAAsyncSelect",GetErrorCode())
00780 }
00781
00782 BOOL CAsyncSocket::ReAsync()
00783 {
00784 if (!m_bBlocking)
00785 return TRUE;
00786
00787 try
00788 {
00789
00790 if (!CheckAsyncSocketValid())
00791 return FALSE;
00792
00793
00794 int iResult;
00795 iResult=WSAAsyncSelect(GetAsyncHandle(),
00796 GetWindowHandle(),
00797 m_iMsg,
00798 m_lEvent);
00799
00800 if (iResult)
00801 {
00802
00803 SetLastError("ReAsync");
00804
00805
00806 return FALSE;
00807 }
00808
00809
00810 m_bBlocking=FALSE;
00811
00812
00813 return TRUE;
00814 }
00815 ERROR_HANDLER_RETURN("ReAsync",FALSE)
00816 }
00817
00818 BOOL CAsyncSocket::Block()
00819 {
00820 try
00821 {
00822
00823 int iResult;
00824 iResult=WSAAsyncSelect(GetAsyncHandle(),
00825 GetWindowHandle(),
00826 0,
00827 0);
00828
00829 if (iResult)
00830 {
00831
00832 SetLastError("Block");
00833
00834
00835 return FALSE;
00836 }
00837
00838 unsigned long ulBlocking;
00839 ulBlocking=0;
00840
00841
00842 iResult=ioctlsocket(GetAsyncHandle(),
00843 FIONBIO,
00844 &ulBlocking);
00845
00846 if (iResult)
00847 {
00848
00849 SetLastError("Block");
00850
00851
00852 return FALSE;
00853 }
00854
00855 return TRUE;
00856 }
00857 ERROR_HANDLER_RETURN("Block",FALSE)
00858 }
00859
00860 BOOL CAsyncSocket::IsBlocking() const
00861 {
00862 return m_bBlocking;
00863 }
00864
00865 void CAsyncSocket::AllowBlockedBuffer(BOOL bAllow)
00866 {
00867 try
00868 {
00869
00870 if (bAllow &&
00871 !m_pBlockedBuffer)
00872 m_pBlockedBuffer=new CBlockedBuffer(this);
00873 else if (!bAllow &&
00874 m_pBlockedBuffer)
00875 {
00876
00877 delete m_pBlockedBuffer;
00878 m_pBlockedBuffer=NULL;
00879 }
00880 }
00881 ERROR_HANDLER("AllowBlockedBuffer")
00882 }
00883
00884 CBlockedBuffer* CAsyncSocket::GetBlockedBuffer()const
00885 {
00886 return m_pBlockedBuffer;
00887 }
00888
00889 BOOL CAsyncSocket::SendBlockedBuffer(const CBlockedBuffer::CBlockedData& rData)
00890 {
00891
00892 return FALSE;
00893 }
00894
00895 CSocketThreadManager* CAsyncSocket::GetSocketThreadManager()
00896 {
00897 return m_pThreadManager;
00898 }
00899
00900 BOOL CAsyncSocket::SocketConnected(int iErrorCode)
00901 {
00902 try
00903 {
00904
00905 if (iErrorCode)
00906 return OnSocketConnect(iErrorCode);
00907
00908
00909 BOOL bConnectValue;
00910 bConnectValue=OnSocketConnect(0);
00911
00912
00913 if (!SetAsync())
00914 return FALSE;
00915 else
00916 return bConnectValue;
00917 }
00918 ERROR_HANDLER_RETURN("SocketConnected",FALSE)
00919 }
00920
00921 BOOL CAsyncSocket::SocketClosed(int iErrorCode)
00922 {
00923 try
00924 {
00925
00926 return OnSocketClose(iErrorCode);
00927 }
00928 ERROR_HANDLER_RETURN("SocketClosed",FALSE)
00929 }
00930
00931 BOOL CAsyncSocket::SocketWrite(int iErrorCode)
00932 {
00933 try
00934 {
00935
00936 return OnSocketWrite(iErrorCode);
00937 }
00938 ERROR_HANDLER_RETURN("SocketWrite",FALSE)
00939 }
00940
00941 void CAsyncSocket::SimpleMessageMap()
00942 {
00943 try
00944 {
00945
00946 MSG msg;
00947
00948
00949 memset(&msg,
00950 0,
00951 sizeof(msg));
00952
00953 while (GetMessage(&msg,
00954 NULL,
00955 0,
00956 0))
00957 {
00958
00959 TranslateMessage(&msg);
00960 DispatchMessage(&msg);
00961 }
00962 }
00963 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SimpleMessageMap")
00964 }
00965
00966 void CAsyncSocket::SimpleMessageMap(DWORD dwRunTimeMS)
00967 {
00968 try
00969 {
00970
00971 MSG msg;
00972
00973
00974 memset(&msg,
00975 0,
00976 sizeof(msg));
00977
00978
00979 DWORD dwLoopStart;
00980 dwLoopStart=GetTickCount();
00981
00982
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
00996 Sleep(1);
00997 }
00998 }
00999 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SimpleMessageMap")
01000 }
01001
01002 void CAsyncSocket::SimpleMessageMap(LPMapProc pProc,
01003 BOOL bStopWhenTRUE,
01004 DWORD dwSleep)
01005 {
01006 try
01007 {
01008
01009 if (!pProc)
01010 {
01011
01012 ReportStaticError(CAsyncSocket_Class,"SimpleMessageMap","Recieved null proc!");
01013
01014
01015 return;
01016 }
01017
01018
01019 MSG msg;
01020
01021
01022 memset(&msg,
01023 0,
01024 sizeof(msg));
01025
01026
01027 BOOL bStop;
01028 bStop=FALSE;
01029
01030
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
01046 if (!bStop)
01047
01048 Sleep(dwSleep);
01049 }
01050 }
01051 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SimpleMessageMap")
01052 }
01053
01054 char CAsyncSocket::SimpleMessageMapKey(DWORD dwSleep)
01055 {
01056 try
01057 {
01058
01059 MSG msg;
01060
01061
01062 memset(&msg,
01063 0,
01064 sizeof(msg));
01065
01066
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
01081 if (!kbhit())
01082
01083 Sleep(dwSleep);
01084 }
01085
01086
01087 return getch();
01088 }
01089 ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"SimpleMessageMapKey",0)
01090 }
01091
01092 BOOL CAsyncSocket::SetSystemTimeout(int iMS)
01093 {
01094 try
01095 {
01096
01097 if (m_aTimerID.iTimerID)
01098 {
01099
01100 ReportError("SetSystemTimeout","Please kill previous timer!");
01101
01102
01103 return FALSE;
01104 }
01105
01106
01107 m_aTimerID=GetThreadManager()->RegisterTimeout(iMS,
01108 SystemTimerProc,
01109 this,
01110 TRUE,
01111 GetWindowHandle(),
01112 &m_aTimerID);
01113
01114
01115 if (!m_aTimerID.iTimerID)
01116 {
01117
01118 ReportError("SetSystemTimeout","Failed creating the timer!");
01119
01120
01121 return FALSE;
01122 }
01123 else
01124 return TRUE;
01125 }
01126 ERROR_HANDLER_RETURN("SetSystemTimeout",FALSE)
01127 }
01128
01129 BOOL CAsyncSocket::KillSystemTimer()
01130 {
01131 try
01132 {
01133
01134 if (!m_aTimerID.iTimerID)
01135 return TRUE;
01136
01137 return GetThreadManager()->RemoveTimeout(m_aTimerID);
01138 }
01139 ERROR_HANDLER_RETURN("KillSystemTimer",FALSE)
01140 }
01141
01142 void CAsyncSocket::SystemTimeout()
01143 {
01144
01145 }
01146
01147 void CAsyncSocket::SystemTimerProc(LPVOID lpData)
01148 {
01149 try
01150 {
01151
01152 CAsyncSocket* pClass;
01153 pClass=(CAsyncSocket*)lpData;
01154
01155
01156 memset(&pClass->m_aTimerID,
01157 0,
01158 sizeof(pClass->m_aTimerID));
01159
01160
01161 pClass->SystemTimeout();
01162 }
01163 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SystemTimerProc")
01164 }
01165
01166 void CAsyncSocket::DeleteTimerProc(LPVOID lpData)
01167 {
01168 try
01169 {
01170
01171 CAsyncSocket* pClass;
01172 pClass=(CAsyncSocket*)lpData;
01173
01174
01175 pClass->DeleteSocketFromThread();
01176 }
01177 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"SystemTimerProc")
01178 }
01179
01180 BOOL CAsyncSocket::HasSystemTimer()const
01181 {
01182 return m_aTimerID.iTimerID!=0;
01183 }
01184
01185 void CAsyncSocket::OnSocketDelete()
01186 {
01187 try
01188 {
01189
01190 delete this;
01191 }
01192 ERROR_HANDLER_STATIC(CAsyncSocket_Class,"OnSocketDelete")
01193 }
01194
01195 void CAsyncSocket::ForceReceiveEvent()
01196 {
01197 try
01198 {
01199
01200
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 }
01211
01212 void CAsyncSocket::DeleteSocketFromThread()
01213 {
01214 try
01215 {
01216
01217 SocketClosing();
01218
01219
01220
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 }
01231
01232 void CAsyncSocket::DeleteSocketFromThread(DWORD dwTimeToWait)
01233 {
01234 try
01235 {
01236 if (!dwTimeToWait)
01237 DeleteSocketFromThread();
01238 else
01239 {
01240
01241 SocketClosing();
01242
01243
01244
01245 if (!m_bList)
01246 OnSocketDelete();
01247 else
01248 {
01249
01250 m_aDeleteTimerID=m_pThreadManager->RegisterTimeout(dwTimeToWait,
01251 DeleteTimerProc,
01252 (LPVOID)this,
01253 TRUE,
01254 GetWindowHandle(),
01255 &m_aDeleteTimerID);
01256
01257
01258 if (!m_aDeleteTimerID.iTimerID)
01259 {
01260
01261 ReportError("DeleteSocketFromThread","Failed to create timeout!");
01262
01263
01264 DeleteSocketFromThread();
01265 }
01266 }
01267 }
01268 }
01269 ERROR_HANDLER("OnSocketDelete")
01270 }
01271
01272 void CAsyncSocket::SocketCreated()
01273 {
01274 try
01275 {
01276
01277 memset(&m_aTimerID,
01278 0,
01279 sizeof(m_aTimerID));
01280
01281
01282 memset(&m_aDeleteTimerID,
01283 0,
01284 sizeof(m_aDeleteTimerID));
01285
01286
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 }
01297
01298 BOOL CAsyncSocket::IsClosing()const
01299 {
01300 return m_bClosing;
01301 }
01302
01303 void CAsyncSocket::DisableEvents(unsigned char ucEvents)
01304 {
01305 try
01306 {
01307
01308 m_ucEvents=ucEvents;
01309 }
01310 ERROR_HANDLER("DisableEvents")
01311 }
01312
01313 BOOL CAsyncSocket::HasTimeout()const
01314 {
01315 return m_bTimeout;
01316 }
01317
01318 KOMODIA_NAMESPACE_END