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

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

模拟服务器

开发平台：

C/C++

SmartClient.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "SmartClient.h"
  4. #include "Macro.h"
  6. #include "KProtocolDef.h"
  7. #include "AccountLoginDef.h"
  8. #include "Buffer.h"
  10. #include "msg_define.h"
  11. #include "Macro.h"
  12. #include "../Engine/Src/KWin32.h"
  13. #include "../Engine/Src/KSG_MD5_String.h"
  14. #include "inoutmac.h"
  16. using OnlineGameLib::Win32::CPackager;
  18. using OnlineGameLib::Win32::CCriticalSection;
  19. using OnlineGameLib::Win32::CBuffer;
  21. OnlineGameLib::Win32::CLibrary CSmartClient::m_theRainbowLib( "rainbow.dll" );
  23. static const DWORD g_dwServerIdentify = 0xAEFC07B5;
  25. CSmartClient g_theSmartClient;
  27. CSmartClient::CSmartClient()
  28. : m_hWorkingThread( NULL )
  29. , m_pClient( NULL )
  30. , m_hwndContain( NULL )
  31. , m_nSvrPort( 0 )
  32. , m_theAllocator( 1024, 500 )
  33. {
  34. }
  36. CSmartClient::~CSmartClient()
  37. {
  38. if ( m_pClient )
  39. {
  40. m_pClient->Cleanup();
  41. }
  43. SAFE_RELEASE( m_pClient );
  44. }
  46. bool CSmartClient::Open( const char * const pAddressToConnectServer, 
  47. unsigned short usPortToConnectServer, 
  48. HWND hwndContain,
  49. const char *pName,
  50. const char *pPwd,
  51. bool bReLink /* true */ )
  52. {
  53. if ( !pName || !pPwd )
  54. {
  55. return false;
  56. }
  58. m_sUserName = pName;
  59. m_sUserPwd = pPwd;
  61. m_sSvrIP = pAddressToConnectServer;
  62. m_nSvrPort = usPortToConnectServer;
  64. m_hwndContain = hwndContain;
  66. /*
  67.  * m_bReLink == true ( default )
  68.  */
  69. m_bReLink = bReLink;
  71. m_ClientStatus = enumClientConnect;
  73. IClient* pClient = _Connect();
  74. if (pClient)
  75. {
  76. _Verify(pClient, false);
  77. SAFE_RELEASE(pClient);
  78. }
  80. bool ok = CreateConnectThread();
  82. return ok;
  83. }
  85. void CSmartClient::Close()
  86. {
  87. SetClientStatus(enumClientError); //停止线程
  88. }
  90. void __stdcall CSmartClient::EventNotify( LPVOID lpParam, 
  91. const unsigned long &ulnEventType )
  92. {
  93. CSmartClient *pThis = reinterpret_cast< CSmartClient * >( lpParam );
  95. ASSERT( pThis );
  97. try
  98. {
  99. pThis->_EventNotify( ulnEventType );
  100. }
  101. catch(...)
  102. {
  103. TRACE( "CSmartClient::EventNotify exception!" );
  104. }
  105. }
  107. void CSmartClient::_EventNotify( const unsigned long &ulnEventType )
  108. {
  109. switch( ulnEventType )
  110. {
  111. case enumServerConnectCreate:
  112. ::PostMessage( m_hwndContain, WM_SERVER_STATUS, ACCOUNTSERVER_NOTIFY, CONNECTED );
  113. break;
  115. case enumServerConnectClose:
  116. {
  117. ::PostMessage( m_hwndContain, WM_SERVER_STATUS, ACCOUNTSERVER_NOTIFY, DICONNECTED );
  118. SwitchToConnecting();
  119. }
  120. break;
  121. }
  122. }
  124. bool CSmartClient::CreateConnectThread()
  125. {
  126. /*
  127.  * Start a working thread
  128.  */
  129. DWORD dwThreadID = 0;
  131. m_hWorkingThread = ::CreateThread( NULL, 
  132. 0, 
  133. WorkingThreadFunction, 
  134. ( void * )this, 
  135. 0, 
  136. &dwThreadID );
  138. if ( m_hWorkingThread == INVALID_HANDLE_VALUE )
  139. {
  140. return false;
  141. }
  143. return true;
  144. }
  146. DWORD WINAPI CSmartClient::WorkingThreadFunction( void *pV )
  147. {
  148. CSmartClient *pThis = reinterpret_cast< CSmartClient * >( pV );
  150. ASSERT( pThis );
  151. IClient* pClient = NULL;
  153. try
  154. {
  155. while (!pThis->IsError())
  156. {
  157. if (pThis->IsConnecting())
  158. {
  159. if (pThis->m_pClient)
  160. {
  161. pThis->m_pClient->Cleanup();
  162. pThis->m_pClient = NULL;
  163. }
  164. SAFE_RELEASE( pClient );
  165. pClient = pThis->_Connect();
  166. }
  167. else if (pThis->IsVerifying())
  168. {
  169. pThis->_Verify(pClient, true);
  170. SAFE_RELEASE( pClient );
  171. }
  172. Sleep(10);
  173. }
  174. }
  175. catch(...)
  176. {
  177. ::MessageBox( NULL, "Run a working thread is failed!", "CSmartClient class", MB_OK );
  178. }
  179. ::PostMessage(pThis->m_hwndContain, WM_CLOSE, NULL, NULL);
  180. return 0;
  181. }
  183. IClient* CSmartClient::_Connect()
  184. {
  185. if ( !IsConnecting() )
  186. return NULL;
  188. #ifdef CONSOLE_DEBUG
  189. cprintf( "Begin connectn");
  190. #endif
  192. IClient *pClient = NULL;
  193. /*
  194.  * There is connectted the heaven by the rainbow
  195.  */
  197. pfnCreateClientInterface pClientFactroyFun = ( pfnCreateClientInterface )( m_theRainbowLib.GetProcAddress( _T( "CreateInterface" ) ) );
  198. IClientFactory *pClientFactory = NULL;
  200. if ( pClientFactroyFun && SUCCEEDED( pClientFactroyFun( IID_IClientFactory, reinterpret_cast< void ** >( &pClientFactory ) ) ) )
  201. {
  202. pClientFactory->SetEnvironment( 1024 * 1024 );
  204. pClientFactory->CreateClientInterface( IID_IESClient, reinterpret_cast< void ** >( &pClient ) );
  206. SAFE_RELEASE( pClientFactory );
  207. }
  209. if ( pClient )
  210. {
  211. pClient->Startup();
  213. pClient->RegisterMsgFilter( reinterpret_cast< void * >( this ), EventNotify );
  215. if ( FAILED( pClient->ConnectTo( m_sSvrIP.c_str(), m_nSvrPort ) ) )
  216. {
  217. pClient->Cleanup();
  219. SAFE_RELEASE( pClient );
  221. #ifdef CONSOLE_DEBUG
  222. cprintf( "Reconnect Failedn");
  223. #endif
  224. ::Sleep( 5000 );
  226. return NULL;
  227. }
  228. else
  229. {
  230. SetClientStatus(enumClientVerify);
  231. }
  232. }
  234. return pClient;
  235. }
  237. void CSmartClient::_Verify(IClient* pClient, bool bDisconnect)
  238. {
  239. if (!IsVerifying())
  240. return;
  242. if (pClient == NULL)
  243. return;
  245. #ifdef CONSOLE_DEBUG
  246. cprintf( "Begin verifyn");
  247. #endif
  249. /*
  250. * Send a login command
  251. */
  252. const size_t datalength = sizeof( KServerAccountUserLoginInfo ) + 1;
  254. BYTE *pData = new BYTE[datalength];
  256. KServerAccountUserLoginInfo serlogin;
  257. serlogin.Size = sizeof( KServerAccountUserLoginInfo );
  259. serlogin.Type = ServerAccountUserLoginInfo;
  260. serlogin.Version = ACCOUNT_CURRENT_VERSION;
  261. serlogin.Operate = g_dwServerIdentify;
  263. size_t lenTag, lenScr;
  265. lenTag = sizeof( serlogin.Account );
  266. lenScr = m_sUserName.size() + 1;
  268. lenTag = ( lenTag > lenScr ) ? lenScr : lenTag;
  270. memcpy( serlogin.Account, m_sUserName.c_str(), lenTag );
  271. serlogin.Account[lenTag - 1] = '';
  273. lenTag = sizeof( serlogin.Password );
  275. KSG_StringToMD5String(serlogin.Password, m_sUserPwd.c_str() /*szPassword*/);
  277. serlogin.Address = -1;
  279. // add by spe 2003/08/08
  280. gGetMacAndIPAddress(NULL, NULL, serlogin.MacAddress, &serlogin.Address);
  282. if ( bDisconnect )
  283. {
  284. *pData = c2s_gatewayverifyagain;
  285. }
  286. else
  287. {
  288. *pData = c2s_gatewayverify;
  289. }
  290. memcpy( pData + 1, &serlogin, sizeof( KServerAccountUserLoginInfo ) );
  292. pClient->SendPackToServer( ( const void * )pData, datalength );
  294. SAFE_DELETE_ARRAY( pData );
  296. /*
  297. * Wait for write back
  298. */
  299. while ( pClient )
  300. {
  301. if ( !IsVerifying() )
  302. {
  303. break; //因为正常的状态变化引起的退出
  304. }
  305. #ifdef CONSOLE_DEBUG
  306. cprintf( "Wait for verifyn");
  307. #endif
  309. size_t nLen = 0;
  311. const void *pData = pClient->GetPackFromServer( nLen );
  313. if ( !pData || 0 == nLen )
  314. {
  315. ::Sleep( 1 );
  317. continue;
  318. }
  320. BYTE cProtocol = CPackager::Peek( pData );
  322. switch ( cProtocol )
  323. {
  324. case s2c_gatewayverify:
  325. {
  326. KAccountUserReturn* pReturn = ( KAccountUserReturn * )( ( ( char * )pData ) + 1 );
  328. nLen--;
  329. if ( pReturn &&
  330. ( g_dwServerIdentify == pReturn->Operate ) && 
  331. ( nLen == sizeof( KAccountUserReturn ) ) )
  332. {
  333. if ( ACTION_SUCCESS == pReturn->nReturn )
  334. {
  335. ::PostMessage( m_hwndContain, WM_SERVER_LOGIN_SUCCESSFUL, 0L, 0L );
  336. pClient->QueryInterface( IID_IESClient, reinterpret_cast< void ** >( &m_pClient ) );
  338. if (SetClientStatus(enumClientNormal))
  339. {
  340. Send(NULL, 0);
  341. #ifdef CONSOLE_DEBUG
  342. cprintf( "Succeed verifyn");
  343. #endif
  345. }
  346. }
  347. else if ( E_ACCOUNT_OR_PASSWORD == pReturn->nReturn )
  348. {
  349. ::PostMessage( m_hwndContain, WM_SERVER_LOGIN_FAILED, enumUsrNamePswdErr, 0L );
  351. SetClientStatus(enumClientError);
  352. }
  353. else if ( E_ADDRESS_OR_PORT == pReturn->nReturn )
  354. {
  355. ::PostMessage( m_hwndContain, WM_SERVER_LOGIN_FAILED, enumIPPortErr, 0L );
  357. SetClientStatus(enumClientError);
  358. }
  359. else
  360. {
  361. ::PostMessage( m_hwndContain, WM_SERVER_LOGIN_FAILED, enumException, 0L );
  363. SetClientStatus(enumClientError);
  364. }
  366. }
  367. }
  368. break;
  370. default:
  372. ASSERT( FALSE );
  374. SetClientStatus(enumClientError);
  376. break;
  377. }
  378. }
  379. }
  381. bool CSmartClient::Send( const void * const pData, const size_t &datalength )
  382. {
  383. if (IsNormal())
  384. {
  385. if (m_pClient)
  386. {
  387. /*
  388.  * Send the histroy information to server
  389.  */
  390. {
  391. CCriticalSection::Owner locker( m_csHistroyList );
  393. stdList::iterator it;
  394. for ( it = m_theHistroyList.begin();
  395. it != m_theHistroyList.end();
  396. it ++ )
  397. {
  398. CBuffer *pBuffer = *it;
  400. if ( pBuffer )
  401. {
  402. m_pClient->SendPackToServer( 
  403. ( const void * )( pBuffer->GetBuffer() ), 
  404. pBuffer->GetUsed() );
  406. SAFE_RELEASE( pBuffer );
  407. }
  408. }
  410. m_theHistroyList.clear();
  411. }
  413. if (pData && datalength)
  414. m_pClient->SendPackToServer( pData, datalength );
  416. return true;
  417. }
  418. }
  419. else if (pData && datalength > 0)
  420. {
  421. /* Store data into buffer */
  422. CCriticalSection::Owner locker( m_csHistroyList );
  424. CBuffer *pBuffer = m_theAllocator.Allocate();
  426. ASSERT( pBuffer );
  428. pBuffer->AddData((BYTE*) pData, datalength );
  430. m_theHistroyList.push_back( pBuffer );
  431. }
  433. return false;
  434. }
  436. const void * CSmartClient::Recv( size_t &datalength )
  437. {
  438. if (IsNormal())
  439. {
  440. if ( m_pClient )
  441. {
  442. return m_pClient->GetPackFromServer( datalength );
  443. }
  444. }
  446. datalength = 0;
  447. return NULL;
  448. }
  450. bool CSmartClient::IsNormal()
  451. {
  452. CCriticalSection::Owner locker(m_csStatus);
  453. return (m_ClientStatus == enumClientNormal);
  454. }
  456. bool CSmartClient::IsConnecting()
  457. {
  458. CCriticalSection::Owner locker(m_csStatus);
  459. return (m_ClientStatus == enumClientConnect);
  460. }
  462. bool CSmartClient::IsVerifying()
  463. {
  464. CCriticalSection::Owner locker(m_csStatus);
  465. return (m_ClientStatus == enumClientVerify);
  466. }
  468. bool CSmartClient::IsError()
  469. {
  470. CCriticalSection::Owner locker(m_csStatus);
  471. return (m_ClientStatus == enumClientError);
  472. }
  474. void CSmartClient::SwitchToConnecting() //切换状态到重连,如有必要会停止重连线程
  475. {
  476. if (m_bReLink)
  477. SetClientStatus(enumClientConnect);
  478. else
  479. SetClientStatus(enumClientError); ; //停止线程
  480. }
  482. bool CSmartClient::SetClientStatus(enumClientStatus nNewS)
  483. {
  484. CCriticalSection::Owner locker(m_csStatus);
  486. if ( nNewS == enumClientError )
  487. {
  488. m_ClientStatus = nNewS;
  489. return true;
  490. }
  492. if (m_ClientStatus == enumClientNormal && nNewS == enumClientConnect)
  493. {
  494. m_ClientStatus = nNewS;
  495. return true;
  496. }
  498. if (m_ClientStatus == enumClientConnect &&
  499. (nNewS == enumClientConnect || nNewS == enumClientVerify)
  500. )
  501. {
  502. m_ClientStatus = nNewS;
  503. return true;
  504. }
  506. if (m_ClientStatus == enumClientVerify &&
  507. (nNewS == enumClientConnect || nNewS == enumClientNormal)
  508. )
  509. {
  510. m_ClientStatus = nNewS;
  511. return true;
  512. }
  514. return false;
  515. }