开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
ServerStage.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：20k
源码类别：

模拟服务器

开发平台：

C/C++

ServerStage.cpp：源码内容
  1. #include "ServerStage.h"
  3. #include "IOCPServerException.h"
  4. #include "IOCPServerUtils.h"
  5. #include "IOCPServerManualResetEvent.h"
  6. #include "IOCPServerWin32Exception.h"
  7. #include "IOCPServerSocket.h"
  9. #include "ProtocolProtocol.h"
  11. /*
  12.  * Using directives
  13.  */
  14. using OnlineGameLib::Win32::CWin32Exception;
  15. using OnlineGameLib::Win32::CSocket;
  17. using OnlineGameLib::Win32::_tstring;
  18. using OnlineGameLib::Win32::CException;
  19. using OnlineGameLib::Win32::Output;
  20. using OnlineGameLib::Win32::GetTimeStamp;
  21. using OnlineGameLib::Win32::OutPutInfo;
  22. using OnlineGameLib::Win32::ToString;
  23. using OnlineGameLib::Win32::CCriticalSection;
  24. using OnlineGameLib::Win32::DumpData;
  25. using OnlineGameLib::Win32::Trace2File;
  27. /*
  28.  * Global variable
  29.  */
  31. //[ for trace
  32. #ifdef  NETWORK_DEBUG
  33. //{
  34. static DWORD gsc_dwPackID = 0;
  35. //}
  36. #endif
  37. //]
  39. /*
  40.  * Get server interface
  41.  */
  42. STDAPI QueryServerInterface
  43. (
  44. REFIID riid,
  45. void **ppv
  46. )
  47. {
  48. HRESULT hr = E_NOINTERFACE;
  50. if ( IID_IIOCPServer == riid )
  51. {
  52. CClientManager *pObject = new CClientManager( MAX_BUFFER_KEEPINPOOL, EXTEND_BUFFER_SIZE );
  54. *ppv = reinterpret_cast< void * > ( dynamic_cast< IServer * >( pObject ) );
  56. if ( *ppv )
  57. {
  58. reinterpret_cast< IUnknown * >( *ppv )->AddRef();
  60. hr = S_OK;
  61. }
  62. }
  64. if ( FAILED( hr ) )
  65. {
  66. *ppv = NULL;
  67. }
  69. return ( HRESULT )( hr );
  70. }
  72. /*
  73.  * CGameServerWorkerThread implement
  74.  */
  75. CGameServerWorkerThread::CGameServerWorkerThread(
  76. OnlineGameLib::Win32::CIOCompletionPort &iocp,
  77. CClientManager &refClientManager)
  78.    : OnlineGameLib::Win32::CSocketServer::WorkerThread(iocp)
  79.    , m_refClientManager(refClientManager)
  80. {
  81. }
  83. CGameServerWorkerThread::~CGameServerWorkerThread()
  84. {
  85. }
  87. void CGameServerWorkerThread::OnBeginProcessing()
  88. {
  89. // Output( _T("OnBeginProcessing") );
  90. }
  92. void CGameServerWorkerThread::ReadCompleted(
  93. OnlineGameLib::Win32::CSocketServer::Socket *pSocket,
  94. OnlineGameLib::Win32::CIOBuffer *pBuffer)
  95. {
  96. try
  97. {
  98. unsigned long ulnID = pSocket->GetUserData();
  100. const BYTE *pPackData = pBuffer->GetBuffer();
  101. const size_t used = pBuffer->GetUsed();
  103. m_refClientManager.RecvFromClient( ulnID, reinterpret_cast<const char*>( pPackData ), used );
  105. pBuffer->Empty();
  107. pSocket->Read( pBuffer );
  108. }
  109. catch( const CException &e )
  110. {
  111. Output( _T("ReadCompleted - Exception - ") + e.GetWhere() + _T(" - ") + e.GetMessage() );
  113. pSocket->Shutdown();
  114. }
  115. catch(...)
  116. {
  117. Output( _T("ReadCompleted - Unexpected exception") );
  119. pSocket->Shutdown();
  120. }
  121. }
  123. void CGameServerWorkerThread::OnEndProcessing()
  124. {
  125. // Output( _T("OnEndProcessing") );
  126. }
  128. void CGameServerWorkerThread::OnError( const OnlineGameLib::Win32::_tstring &message )
  129. {
  130. Output( _T("OnError - ") + message );
  131. }
  133. CGameServer::CGameServer(
  134. CClientManager &refClientManager,    
  135. unsigned long addressToListenOn,
  136. unsigned short portToListenOn,
  137. size_t maxFreeSockets,
  138. size_t maxFreeBuffers,
  139. size_t bufferSize /* = 1024 */,
  140. size_t numThreads /* = 0 */)
  141.    : OnlineGameLib::Win32::CSocketServer(addressToListenOn, portToListenOn, maxFreeSockets, maxFreeBuffers, bufferSize, numThreads)
  142.    , m_refClientManager( refClientManager )
  143. {
  144. }
  146. CGameServer::CGameServer(
  147. CClientManager &refClientManager,
  148. size_t maxFreeSockets,
  149. size_t maxFreeBuffers,
  150. size_t bufferSize /* = 1024 */,
  151. size_t numThreads /* = 0 */)
  152.    : OnlineGameLib::Win32::CSocketServer(maxFreeSockets, maxFreeBuffers, bufferSize, numThreads)
  153.    , m_refClientManager( refClientManager )
  154. {
  155. }
  158. CGameServer::~CGameServer()
  159. {
  160. /*
  161.  * If we want to be informed of any buffers or sockets being destroyed at destruction 
  162.  * time then we need to release these resources now, whilst we, the derived class,
  163.  * still exists. Once our destructor exits and the base destructor takes over we wont 
  164.  * get any more notifications...
  165.  */
  167. try
  168. {
  169. ReleaseSockets();
  170. ReleaseBuffers();
  171. }
  172. catch(...)
  173. {
  174. }
  175. }
  177. SOCKET CGameServer::CreateListeningSocket( unsigned long address, unsigned short port )
  178. {
  179. SOCKET s = ::WSASocket( AF_INET, SOCK_STREAM, IPPROTO_IP, NULL, 0, WSA_FLAG_OVERLAPPED );
  181. if ( INVALID_SOCKET == s )
  182. {
  183. throw CWin32Exception( _T("CSocket::CreateListeningSocket()"), ::WSAGetLastError() );
  184. }
  186. CSocket listeningSocket( s );
  188. CSocket::InternetAddress localAddress( address, port );
  190. listeningSocket.Bind( localAddress );
  192. listeningSocket.Listen( 5 );
  194. return listeningSocket.Detatch();
  195. }
  197. OnlineGameLib::Win32::CSocketServer::WorkerThread *CGameServer::CreateWorkerThread( 
  198. OnlineGameLib::Win32::CIOCompletionPort &iocp )
  199. {
  200. Output( _T("CreateWorkerThread") );
  202. return new CGameServerWorkerThread( iocp, m_refClientManager );
  203. }
  205. void CGameServer::OnStartAcceptingConnections()
  206. {
  207. Output( _T("OnStartAcceptingConnections") );
  208. }
  210. void CGameServer::OnStopAcceptingConnections()
  211. {
  212. Output( _T("OnStopAcceptingConnections") );
  213. }
  214.       
  215. void CGameServer::OnShutdownInitiated()
  216. {
  217. Output( _T("OnShutdownInitiated") );
  218. }
  219.       
  220. void CGameServer::OnShutdownComplete()
  221. {
  222. Output( _T("OnShutdownComplete") );
  223. }
  225. void CGameServer::OnConnectionEstablished(
  226. OnlineGameLib::Win32::CSocketServer::Socket *pSocket, 
  227. OnlineGameLib::Win32::CIOBuffer * pAddress )
  228. {
  229. Output( _T("OnConnectionEstablished") );
  231. /*
  232.  * Add Client
  233.  */
  234. m_refClientManager.AddClient( pSocket );
  236. pSocket->Read();
  237. }
  239. void CGameServer::OnConnectionClosed( 
  240. OnlineGameLib::Win32::CSocketServer::Socket * pSocket )
  241. {
  242. /*
  243.  * Delete client
  244.  */
  245. m_refClientManager.DelClient( pSocket );
  247. Output( _T("OnConnectionClosed") );
  248. }
  250. void CGameServer::OnConnectionCreated()
  251. {
  252. Output( _T("OnConnectionCreated") );
  253. }
  255. void CGameServer::OnConnectionDestroyed()
  256. {
  257. Output( _T("OnConnectionDestroyed") );
  258. }
  260. void CGameServer::OnError( const OnlineGameLib::Win32::_tstring &message )
  261. {
  262. Output( _T("OnError - ") + message );
  263. }
  265. void CGameServer::PreWrite( 
  266. OnlineGameLib::Win32::CSocketServer::Socket *pSocket, 
  267. OnlineGameLib::Win32::CIOBuffer *pBuffer, 
  268. const char *pData, 
  269. size_t dataLength )
  270. {
  271. /*
  272.  * TODO : You can change protocol that it is used to split package
  273.  */
  274. if ( pBuffer && dataLength > 0 )
  275. {
  276. PACK_HEADER ph = {0};
  278. ph.cPackBeginFlag = PACK_BEGIN_FLAG;
  279. ph.cPackEndFlag = PACK_END_FLAG;
  281. ph.wDataLen = dataLength;
  282. ph.wCRCData = MAKE_CRC_DATE( PACK_BEGIN_FLAG, PACK_END_FLAG, dataLength );
  284. pBuffer->AddData( reinterpret_cast<const char *>( &ph ), PACK_HEADER_LEN );
  285. }
  286. }
  288. STDMETHODIMP CClientManager::Startup()
  289. {
  290. HRESULT hr = E_FAIL;
  292. try
  293. {
  294. m_theGameServer.Start();
  296. hr = S_OK;
  297. }
  298. catch( const CException &e )
  299. {
  300. Output( _T("CClientManager::Startup Exception: ") + e.GetWhere() + _T(" - ") + e.GetMessage() );
  301. }
  302. catch(...)
  303. {
  304. Output( _T("CClientManager::Startup - Unexpected exception") );
  305. }
  307. return hr;
  308. }
  310. STDMETHODIMP CClientManager::Cleanup()
  311. {
  312. HRESULT hr = E_FAIL;
  314. try
  315. {
  316. m_theGameServer.StopAcceptingConnections();
  318. m_theGameServer.WaitForShutdownToComplete();
  320. hr = S_OK;
  321. }
  322. catch( const CException &e )
  323. {
  324. Output( _T("CClientManager::Cleanup Exception: ") + e.GetWhere() + _T(" - ") + e.GetMessage() );
  325. }
  326. catch(...)
  327. {
  328. Output( _T("CClientManager::Cleanup - Unexpected exception") );
  329. }
  331. return hr;
  332. }
  334. STDMETHODIMP CClientManager::OpenService(
  335. const unsigned long &ulnAddressToListenOn,
  336. const unsigned short &usnPortToListenOn )
  337. {
  338. HRESULT hr = E_FAIL;
  340. try
  341. {
  342. m_theGameServer.Open( ulnAddressToListenOn, usnPortToListenOn );
  344. m_theGameServer.StartAcceptingConnections();
  346. hr = S_OK;
  347. }
  348. catch( const CException &e )
  349. {
  350. Output( _T("CClientManager::OpenService Exception: ") + e.GetWhere() + _T(" - ") + e.GetMessage() );
  351. }
  352. catch(...)
  353. {
  354. Output( _T("CClientManager::OpenService - Unexpected exception") );
  355. }
  357. return hr;
  358. }
  360. STDMETHODIMP CClientManager::CloseService()
  361. {
  362. HRESULT hr = E_FAIL;
  364. try
  365. {
  366. m_theGameServer.StopAcceptingConnections();
  368. hr = S_OK;
  369. }
  370. catch( const CException &e )
  371. {
  372. Output( _T("CClientManager::CloseService Exception: ") + e.GetWhere() + _T(" - ") + e.GetMessage() );
  373. }
  374. catch(...)
  375. {
  376. Output( _T("CClientManager::CloseService - Unexpected exception") );
  377. }
  379. return hr;
  380. }
  382. STDMETHODIMP CClientManager::RegisterMsgFilter( CALLBACK_SERVER_EVENT pfnEventNotify )
  383. {
  384. m_pfnCallBackServerEvent = pfnEventNotify;
  386. return S_OK;
  387. }
  389. STDMETHODIMP CClientManager::PreparePackSink( )
  390. {
  391. // CCriticalSection::Owner lock( m_csSystemAction );
  393. return S_OK;
  394. }
  396. STDMETHODIMP CClientManager::PackDataToClient(
  397. const unsigned long &ulnClientID,
  398. const void * const pData,
  399. const size_t &datalength )
  400. {
  401. HRESULT hr = E_FAIL;
  403. if ( ulnClientID >= 0 && ulnClientID < MAX_CLIENT_CANBELINKED )
  404. {
  405. OnlineGameLib::Win32::CSocketServer::Socket *pSocket = 
  406. m_clientContext[ulnClientID].pSocket;
  408. if ( pSocket )
  409. {
  410. CCriticalSection::Owner locker( m_clientContext[ulnClientID].csWriteAction );
  412. try
  413. {
  414. m_clientContext[ulnClientID].pWriteBuffer->AddData( static_cast<const char * const>( pData ), datalength );
  416. hr = S_OK;
  417. }
  418. catch( const CException &e )
  419. {
  420. Output( _T("CClientManager::PackDataToClient Exception: ") + e.GetWhere() + _T(" - ") + e.GetMessage() );
  422. pSocket->Shutdown();
  423. }
  424. catch(...)
  425. {
  426. Output( _T("CClientManager::PackDataToClient - Unexpected exception") );
  428. pSocket->Shutdown();
  429. }
  430. }
  431. }
  433. return hr;
  434. }
  436. STDMETHODIMP CClientManager::SendPackToClient( )
  437. {
  438. CCriticalSection::Owner lock( m_csSystemAction );
  440. HRESULT hr = E_FAIL;
  442. for ( std_LIST::iterator i = m_usedClientStack.begin(); i != m_usedClientStack.end(); i ++ )
  443. {
  444. int nID = *i;
  446. CCriticalSection::Owner locker( m_clientContext[nID].csWriteAction );
  448. const BYTE * pPackData = m_clientContext[nID].pWriteBuffer->GetBuffer();
  449. const size_t used = m_clientContext[nID].pWriteBuffer->GetUsed();
  451. if ( used > 0 )
  452. {
  453. //[
  454. #ifdef  NETWORK_DEBUG
  455. //{
  456. static const DWORD sc_dwFlag = 0xABCD0000; // End of stream
  457. static const int sc_nFlagLen = sizeof(DWORD) * 2;
  459. DWORD dwEOSFlag[2];
  460. dwEOSFlag[0] = gsc_dwPackID ++;
  461. dwEOSFlag[1] = sc_dwFlag | ( 0xFFFF & used );
  463. m_clientContext[nID].pWriteBuffer->AddData( reinterpret_cast<const char *>( &dwEOSFlag ), sc_nFlagLen );
  465. m_clientContext[nID].pSocket->Write( reinterpret_cast<const char *>( pPackData ), used + sc_nFlagLen );
  467. /* #undef NETWORK_DEBUG_TRACE2FILE
  468. #ifdef NETWORK_DEBUG_TRACE2FILE
  469. //{
  470. Trace2File( _T("Package[ID:") + ToString( gsc_dwPackID - 1 ) + _T("]n") + DumpData( pPackData, used, 50 ) );
  471. //}
  472. #else
  473. //{
  474. Output( _T("NO.[ID:") +
  475. ToString( gsc_dwPackID - 1 ) +
  476. _T("]Pack - Len:") +
  477. ToString( used )
  478. );
  479. //}
  480. #endif // NETWORK_DEBUG_TRACE_MININFO
  481. */
  482. //}
  483. #else // NETWORK_DEBUG
  484. //{
  485. m_clientContext[nID].pSocket->Write( reinterpret_cast<const char *>( pPackData ), used );
  486. //}
  487. #endif  // NETWORK_DEBUG
  488. //]
  490. /* Output(
  491. _T("ID:") + 
  492. ToString(nID) + 
  493. _T(" - Package[length:") + 
  494. ToString( used ) + 
  495. _T("]n") + 
  496. DumpData( pPackData, used, 50 ) 
  497. );
  498. */
  499. }
  501. m_clientContext[nID].pWriteBuffer->Empty();
  503. hr = S_OK;
  504. }
  506. return hr;
  507. }
  509. STDMETHODIMP_( const void * ) CClientManager::GetPackFromClient(
  510. const unsigned long &ulnClientID,
  511. size_t &datalength )
  512. {
  513. if ( ulnClientID >= 0 && ulnClientID < MAX_CLIENT_CANBELINKED )
  514. {
  515. OnlineGameLib::Win32::CSocketServer::Socket *pSocket = 
  516. m_clientContext[ulnClientID].pSocket;
  517. if ( pSocket )
  518. {
  519. CCriticalSection::Owner locker( m_clientContext[ulnClientID].csReadAction );
  521. m_clientContext[ulnClientID].pReadBuffer->Empty();
  523. m_clientContext[ulnClientID].pRecvBuffer = ProcessDataStream(
  524. ulnClientID,
  525. m_clientContext[ulnClientID].pRecvBuffer );
  527. const BYTE *pPackData = m_clientContext[ulnClientID].pReadBuffer->GetBuffer();
  528. datalength = m_clientContext[ulnClientID].pReadBuffer->GetUsed();
  529.  
  530. return reinterpret_cast<const char*>( pPackData );
  531. }
  532. }
  534. datalength = 0;
  536. return NULL;
  537. }
  539. STDMETHODIMP CClientManager::ShutdownClient( const unsigned long &ulnClientID )
  540. {
  541. CCriticalSection::Owner lock( m_csSystemAction );
  543. if ( ulnClientID >= 0 && ulnClientID < MAX_CLIENT_CANBELINKED )
  544. {
  545. OnlineGameLib::Win32::CSocketServer::Socket *pSocket = 
  546. m_clientContext[ulnClientID].pSocket;
  548. if ( pSocket )
  549. {
  550. pSocket->Close();
  551. pSocket = NULL;
  553. m_clientContext[ulnClientID].pReadBuffer->Empty();
  554. m_clientContext[ulnClientID].pRecvBuffer->Empty();
  556. m_clientContext[ulnClientID].pWriteBuffer->Empty();
  557. }
  558. }
  560. return S_OK;
  561. }
  563. STDMETHODIMP_( size_t ) CClientManager::GetClientCount( )
  564. {
  565. CCriticalSection::Owner lock( m_csSystemAction );
  567. return m_usedClientStack.size();
  568. }
  570. STDMETHODIMP CClientManager::QueryInterface( REFIID riid, void** ppv )
  571. {
  572. /*
  573.  * By definition all COM objects support the IUnknown interface
  574.  */
  575. if( riid == IID_IUnknown )
  576. {
  577. AddRef();
  579. *ppv = dynamic_cast< IUnknown * >( this );
  580. }
  581. else if ( riid == IID_IIOCPServer )
  582. {
  583. AddRef();
  585. *ppv = dynamic_cast< IServer * >( this );
  586. }
  587. else
  588. {
  589. *ppv = NULL;
  591. return E_NOINTERFACE;
  592. }
  594. return S_OK;
  595. }
  596.     
  597. STDMETHODIMP_(ULONG) CClientManager::AddRef()
  598. {
  599. return InterlockedIncrement( &m_lRefCount );
  600. }
  602. STDMETHODIMP_(ULONG) CClientManager::Release()
  603. {
  604. if ( InterlockedDecrement( &m_lRefCount ) > 0 )
  605. {
  606. return m_lRefCount;
  607. }
  609. delete this;
  610. return 0L;
  611. }
  613. CClientManager::CClientManager( size_t maxFreeBuffers, size_t bufferSize /*1024*/ )
  614. : OnlineGameLib::Win32::CIOBuffer::Allocator( bufferSize, maxFreeBuffers )
  615. , m_lRefCount( 0L )
  616. , m_theGameServer( *this, MAX_SOCKET_KEEPINPOOL, MAX_BUFFER_KEEPINPOOL, EXTEND_BUFFER_SIZE )
  617. , m_pfnCallBackServerEvent( NULL )
  618. {
  619. int i=0;
  621. for ( i=0; i<MAX_CLIENT_CANBELINKED; i++ )
  622. {
  623. m_freeClientStack.push( i );
  624. }
  626. for ( i=0; i<MAX_CLIENT_CANBELINKED; i++ )
  627. {
  628. m_clientContext[i].pSocket = NULL;
  630. m_clientContext[i].pRecvBuffer = Allocate();
  631. m_clientContext[i].pReadBuffer = Allocate();
  633. m_clientContext[i].pWriteBuffer = Allocate();
  634. }
  636. }
  638. CClientManager::~CClientManager()
  639. {
  640. CCriticalSection::Owner lock( m_csSystemAction );
  642. /*
  643.      * Repeat until stack is empty
  644.  */
  645. while ( !m_freeClientStack.empty() )
  646. {
  647. m_freeClientStack.pop();
  648. }
  650. m_usedClientStack.erase( m_usedClientStack.begin(), m_usedClientStack.end() );
  652. for ( int i=0; i<MAX_CLIENT_CANBELINKED; i++ )
  653. {
  654. m_clientContext[i].pReadBuffer->Release();
  655. m_clientContext[i].pRecvBuffer->Release();
  657. m_clientContext[i].pWriteBuffer->Release();
  658. }
  660. try
  661. {
  662. Flush();
  663. }
  664. catch(...)
  665. {
  666. /*
  667.  * Some error was found, what are you doing now?
  668.  */
  669. }
  670. }
  672. unsigned long CClientManager::AddClient( 
  673. OnlineGameLib::Win32::CSocketServer::Socket *pSocket )
  674. {
  675. CCriticalSection::Owner lock( m_csSystemAction );
  677. unsigned long index = -1;
  679. if ( !m_freeClientStack.empty() && pSocket )
  680. {
  681. /*
  682.  * Get ID from the free table
  683.  */
  684. index = m_freeClientStack.top();
  685. m_freeClientStack.pop();
  687. /*
  688.  * Set ID into the used table
  689.  */
  690. m_usedClientStack.push_back( index );
  692. /*
  693.  * Store information
  694.  */
  695. pSocket->SetUserData( index );
  696. m_clientContext[index].pSocket = pSocket;
  698. if ( m_pfnCallBackServerEvent )
  699. {
  700. m_pfnCallBackServerEvent( index, CLIENT_CONNECT_CREATE );
  701. }
  703. Output( GetTimeStamp() + _T("Add a client [ID:") + 
  704. ToString( index ) + _T( "] current total is " ) +
  705. ToString( m_usedClientStack.size() )
  706. );
  707. }
  709. return index;
  710. }
  712. unsigned long CClientManager::DelClient(
  713. OnlineGameLib::Win32::CSocketServer::Socket *pSocket )
  714. {
  715. CCriticalSection::Owner lock( m_csSystemAction );
  717. unsigned long index = -1;
  719. if ( !m_usedClientStack.empty() && pSocket )
  720. {
  721. index = pSocket->GetUserData();
  722. m_clientContext[index].pSocket = NULL;
  724. m_clientContext[index].pReadBuffer->Empty();
  725. m_clientContext[index].pRecvBuffer->Empty();
  726. m_clientContext[index].pWriteBuffer->Empty();
  728. /*
  729.  * Call back ID into the free table
  730.  */
  731. m_freeClientStack.push( index );
  733. /*
  734.  * Erase ID from the used table
  735.  */
  736. m_usedClientStack.remove( index );
  738. if ( m_pfnCallBackServerEvent )
  739. {
  740. m_pfnCallBackServerEvent( index, CLIENT_CONNECT_CLOSE );
  741. }
  743. Output( GetTimeStamp() + _T("Del a client [ID:") + 
  744. ToString( index ) + _T( "] current total is " ) + 
  745. ToString( m_usedClientStack.size() ) );
  746. }
  748. return index;
  749. }
  751. void CClientManager::RecvFromClient(
  752.    const unsigned long &ulnID,
  753.    const char *pData,
  754.    size_t dataLength )
  755. {
  756. if ( ulnID >= 0 && ulnID < MAX_CLIENT_CANBELINKED )
  757. {
  758. OnlineGameLib::Win32::CSocketServer::Socket *pSocket = 
  759. m_clientContext[ulnID].pSocket;
  761. if ( pSocket )
  762. {
  763. CCriticalSection::Owner locker( m_clientContext[ulnID].csReadAction );
  765. m_clientContext[ulnID].pRecvBuffer->AddData( pData, dataLength );
  766. }
  767. }
  768. }
  770. void CClientManager::ProcessCommand(
  771.    const unsigned long &ulnID,
  772.    const OnlineGameLib::Win32::CIOBuffer *pBuffer) const
  773. {
  774. const BYTE *pPackData = pBuffer->GetBuffer();
  775. const size_t used = pBuffer->GetUsed();
  777. bool ok = false;
  779. WORD wDataLen = 0;
  780. PACK_HEADER ph = {0};
  782. if ( used > PACK_HEADER_LEN )
  783. {
  784. memcpy( &ph, pPackData, PACK_HEADER_LEN );
  786. wDataLen = ph.wDataLen;
  788. ok = true;
  789. }
  791. if ( ok )
  792. {
  793. const BYTE *pData = pPackData + PACK_HEADER_LEN;
  794. const size_t datalength = wDataLen;
  796. /*
  797.  * TODO : Process data receive from client
  798.  */
  800. //Output( _T("Get a package[length:") + ToString( wDataLen ) + _T("]n") + DumpData( pData, datalength, 50 ) );
  802. m_clientContext[ulnID].pReadBuffer->AddData( pData, datalength );
  803. }
  804. else
  805. {
  806. Output( "found error and close this socket!" );
  808. m_clientContext[ulnID].pSocket->Close();
  809. }
  810. }
  812. size_t CClientManager::GetMinimumMessageSize() const
  813. {
  814. /*
  815.  * The smallest possible package we accept is pack-header
  816.  * once we have this many bytes we can start with try and work out
  817.  * what we have...
  818.  */
  820. return PACK_HEADER_LEN;
  821. }
  823. size_t CClientManager::GetMessageSize(
  824. const OnlineGameLib::Win32::CIOBuffer *pBuffer ) const
  825. {
  826. const BYTE *pData = pBuffer->GetBuffer();
  827. const size_t used = pBuffer->GetUsed();
  829. PACK_HEADER ph = {0};
  831. /*
  832.  * First, verify the flag of a message
  833.  */
  834. if ( used > PACK_HEADER_LEN )
  835. {
  836. memcpy( &ph, pData, PACK_HEADER_LEN );
  838. if ( PACK_BEGIN_FLAG == ph.cPackBeginFlag && 
  839.  PACK_END_FLAG == ph.cPackEndFlag )
  840. {
  841. WORD wCRC = MAKE_CRC_DATE( PACK_BEGIN_FLAG, PACK_END_FLAG, ph.wDataLen );
  843. if ( ph.wCRCData == wCRC )
  844. {
  845. return ph.wDataLen + PACK_HEADER_LEN;
  846. }
  847. }
  848. }
  850. return 0;
  851. }
  853. OnlineGameLib::Win32::CIOBuffer *CClientManager::ProcessDataStream(
  854. const unsigned long &ulnID,
  855. OnlineGameLib::Win32::CIOBuffer *pBuffer) const
  856. {
  857. const size_t used = pBuffer->GetUsed();
  859. if ( used >= GetMinimumMessageSize() )
  860. {
  861. const size_t messageSize = GetMessageSize( pBuffer );
  863. if ( messageSize == 0 )
  864. {
  865. /*
  866.  * havent got a complete message yet.
  868.  * we null terminate our messages in the buffer, so we need to reserve
  869.  * a byte of the buffer for this purpose...
  870.  */
  872. if ( used == ( pBuffer->GetSize() - 1 ) )
  873. {
  874. Output( _T("Too much data!") );
  876. /*
  877.  * Write this message and then shutdown the sending side of the socket.
  878.  */
  879. Output( "found error and close this socket!" );
  881. m_clientContext[ulnID].pSocket->Close();
  883. /*
  884.  * throw the rubbish away
  885.  */
  886. pBuffer->Empty();
  887. }
  888. }
  889. else if ( used == messageSize )
  890. {
  891. Output( _T("Got a complete message and begin to process it") );
  892. /*
  893.  * we have a whole, distinct, message
  894.  */
  895. ProcessCommand( ulnID, pBuffer );
  897. pBuffer->Empty();
  898. }
  899. else if ( used > messageSize )
  900. {
  901. Output( _T("Got message plus extra data") );
  902. /*
  903.  * we have a message, plus some more data
  904.  * 
  905.  * allocate a new buffer, copy the extra data into it and try again...
  906.  */
  907. OnlineGameLib::Win32::CIOBuffer *pMessage = 
  908. pBuffer->SplitBuffer( messageSize );
  910. ProcessCommand( ulnID, pMessage );
  912. pMessage->Release();
  914. }
  915. }
  917. /*
  918.  * Reissue a read into the same buffer to collect more data
  919.  */
  920. return pBuffer;
  921. }