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

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

模拟服务器

开发平台：

C/C++

S3PDBSocketPool.cpp：源码内容
  1. //-----------------------------------------//
  2. //                                         //
  3. //  File : S3PDBSocketPool.cpp    //
  4. // Author : Yang Xiaodong            //
  5. // Modified : 8/26/2002                //
  6. //                                         //
  7. //-----------------------------------------//
  8. #include "S3PDBSocketPool.h"
  9. #include "regexpr2.h"
  11. using namespace std;
  12. using namespace regex;
  13. BOOL S3PDBSocketPool::m_bAccDBIsLocked = FALSE;
  15. static DWORD g_dwCount = 1; // Testing code
  17. static BOOL CALLBACK FreePoolData( DWORD data )
  18. {
  19. BOOL bRet = FALSE;
  20. S3PDBSocketPool::_LPDBSOCKETPOOLDATAPACKET lpData =
  21. ( S3PDBSocketPool::_LPDBSOCKETPOOLDATAPACKET )data;
  22. if ( NULL != lpData )
  23. {
  24. delete lpData;
  25. lpData = NULL;
  26. bRet = TRUE;
  27. }
  28. return bRet;
  29. }
  31. S3PDBSocketPool::S3PDBSocketPool():
  32. m_hProcessor( NULL ),
  33. m_dwProcessorThreadId( 0 ),
  34. m_piRunSignal( NULL ),
  35. m_hEnable( NULL ),
  36. m_Socket( INVALID_SOCKET )
  37. {
  38. m_piRunSignal = new int;
  39. *m_piRunSignal = 0;
  41. m_UDPs.NeedFreeData( FreePoolData );
  43. memset( &m_PoolParam, 0, sizeof( _DBSOCKETPOOLPARAM ) );
  44. }
  46. S3PDBSocketPool::~S3PDBSocketPool()
  47. {
  48. if ( NULL != m_piRunSignal )
  49. {
  50. delete m_piRunSignal;
  51. m_piRunSignal = NULL;
  52. }
  53. }
  55. static HANDLE g_hPoolMutex = NULL; // Testing code
  56. void S3PDBSocketPool::PushDataPacket(_LPDBSOCKETPOOLDATAPACKET lpData)
  57. {
  58. // Testing code
  59. //------>BEGIN
  60. if ( NULL == g_hPoolMutex )
  61. {
  62. g_hPoolMutex =
  63. KPICreateMutex( NULL, FALSE, "Socket pool's mutex" );
  64. }
  65. if ( NULL != g_hPoolMutex )
  66. {
  67. DWORD dwWaitResult;
  68. dwWaitResult =
  69. KPIWaitForSingleObject( g_hPoolMutex, INFINITE );
  70. if ( 1 == dwWaitResult )
  71. {
  72. __try
  73. {
  74. //<------END
  76. //m_UDPs.push_back( *lpData );
  77. _LPDBSOCKETPOOLDATAPACKET lpNewData = new _DBSOCKETPOOLDATAPACKET;
  78. if ( NULL != lpNewData )
  79. {
  80. *lpNewData = *lpData;
  81. m_UDPs.AddTail( ( DWORD )( lpNewData ) );
  82. if ( NULL != m_hEnable )
  83. {
  84. KPISetEvent( m_hEnable );
  85. }
  86. }
  88. // Testing code
  89. //------>BEGIN
  90. }
  91. __finally
  92. { 
  93.                 // Release ownership of the mutex object.
  94.                 if ( ! KPIReleaseMutex( g_hPoolMutex ) )
  95. { 
  96.                     // Deal with error.
  97.                 }
  98. }
  99. }
  100. }
  101. //<------END
  102. }
  104. BOOL S3PDBSocketPool::PopDataPacket( _DBSOCKETPOOLDATAPACKET& data )
  105. {
  106. BOOL bRet = FALSE;
  107. // Testing code
  108. //------>BEGIN
  109. if ( NULL == g_hPoolMutex )
  110. {
  111. g_hPoolMutex =
  112. KPICreateMutex( NULL, FALSE, "Socket pool's mutex" );
  113. }
  115. if ( NULL != g_hPoolMutex )
  116. {
  117. DWORD dwWaitResult;
  118. dwWaitResult =
  119. KPIWaitForSingleObject( g_hPoolMutex, INFINITE );
  120. if ( 1 == dwWaitResult )
  121. {
  122. __try
  123. {
  124. //<------END
  127. if ( !( m_UDPs.IsEmpty() ) )
  128. {
  129. DWORD headData = NULL;
  130. if ( TRUE == m_UDPs.GetHead( headData ) )
  131. {
  132. data = *( ( _LPDBSOCKETPOOLDATAPACKET )headData );
  133. m_UDPs.RemoveHead();
  134. }
  136. if ( ( m_UDPs.IsEmpty() )
  137. && ( NULL != m_hEnable ) )
  138. {
  139. KPIResetEvent( m_hEnable );
  140. }
  141. bRet = TRUE;
  142. }
  143. else if ( NULL != m_hEnable )
  144. {
  145. KPIResetEvent( m_hEnable );
  146. }
  148. // Testing code
  149. //------>BEGIN
  150. }
  151. __finally
  152. { 
  153.                 // Release ownership of the mutex object.
  154.                 if ( ! KPIReleaseMutex( g_hPoolMutex ) )
  155. { 
  156.                     // Deal with error.
  157.                 }
  158. }
  159. }
  160. }
  161. //<------END
  163. return bRet;
  164. }
  166. static DWORD WINAPI ProcessData( LPVOID lpParam )
  167. {
  168. DWORD dwRet = 0;
  169. if ( NULL == lpParam )
  170. {
  171. dwRet = 0;
  172. return dwRet;
  173. }
  174. S3PDBSocketPool::_LPDBSOCKETPOOLPARAM lpPoolParam =
  175. ( S3PDBSocketPool::_LPDBSOCKETPOOLPARAM )lpParam;
  176. if ( ( NULL == lpPoolParam->piRunSignal )
  177. || ( NULL == lpPoolParam->hEnableEvent )
  178. || ( NULL == lpPoolParam->pPool ) )
  179. {
  180. dwRet = 0;
  181. return dwRet;
  182. }
  184. S3PDBSocketPool* pPool = lpPoolParam->pPool;
  186. while ( 0 != *( lpPoolParam->piRunSignal ) )
  187. {
  188. DWORD dwResult =
  189. KPIWaitForSingleObject( lpPoolParam->hEnableEvent, INFINITE );
  190. if ( dwResult == 1 )
  191. {
  192. S3PDBSocketPool::_DBSOCKETPOOLDATAPACKET data;
  194. // Processes data
  195. //------>BEGIN
  196. if ( TRUE == pPool->PopDataPacket( data ) )
  197. {
  198. BOOL bResult = pPool->Process( &data );
  200. // Testing code
  201. //------>BEGIN
  202. if ( bResult )
  203. cout << "rn" << g_dwCount << " Successful";
  204. else
  205. cout << "rn" << g_dwCount << " Failed";
  206. g_dwCount++;
  207. //<------END
  208. }
  209. //<------END
  210. }
  211. }
  213. return dwRet;
  214. }
  216. HANDLE S3PDBSocketPool::Start()
  217. {
  218. HANDLE hRet = NULL;
  219. if ( ( NULL != m_hProcessor )
  220. || ( NULL == m_hEnable )
  221. || ( NULL == m_piRunSignal )
  222. || ( INVALID_SOCKET == m_Socket ) )
  223. {
  224. hRet = NULL;
  225. return hRet;
  226. }
  228. *m_piRunSignal = 1;
  230. m_PoolParam.hEnableEvent = m_hEnable;
  231. m_PoolParam.piRunSignal = m_piRunSignal;
  232. m_PoolParam.pPool = this;
  234. m_hProcessor =
  235. KPICreateThread( ProcessData, &m_PoolParam, &m_dwProcessorThreadId );
  237. hRet = m_hProcessor;
  239. return hRet;
  240. }
  242. BOOL S3PDBSocketPool::Stop()
  243. {
  244. BOOL bRet = FALSE;
  246. if ( ( NULL == m_hProcessor )
  247. || ( NULL == m_hEnable ) )
  248. {
  249. bRet = FALSE;
  250. return bRet;
  251. }
  253. *m_piRunSignal = 0;
  254. KPISetEvent( m_hEnable );
  256. DWORD dwResult = KPIWaitForSingleObject( m_hProcessor, 3000 );
  257. if ( 0 == dwResult )
  258. {
  259. bRet = FALSE;
  260. }
  261. else if ( 1 == dwResult )
  262. {
  263. bRet = TRUE;
  264. }
  265. else if ( 2 == dwResult ) // Time out.
  266. {
  267. if ( TRUE == KPITerminateThread( m_hProcessor, 0 ) )
  268. {
  269. bRet = TRUE;
  270. }
  271. else
  272. {
  273. bRet = FALSE;
  274. }
  275. }
  277. return bRet;
  278. }
  280. void S3PDBSocketPool::Init( SOCKET s, HANDLE hEnableEvent )
  281. {
  282. m_Socket = s;
  283. m_hEnable = hEnableEvent;
  284. }
  286. BOOL S3PDBSocketPool::ProMsgWhenLocked( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  287. {
  288. BOOL bRet = FALSE;
  289. if ( NULL != lpcParsedData )
  290. {
  291. IBYTE feedBuf[def_UDPSIZE];
  292. memset( feedBuf, 0, def_UDPSIZE );
  293. feedBuf[0] = LOGIN_R_TAG;
  294. DWORD dwSize = sizeof( KLoginAccountInfo );
  295. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  296. DWORD dwParam = LOGIN_R_LOGIN;
  298. if ( ( LOGIN_ACCOUNT_MAX_LEN + 2 + LOGIN_PASSWORD_MAX_LEN + 2 )
  299. == lpcParsedData->m_dwSize )
  300. {
  301. S3PAccount account;
  302. char szAccount[LOGIN_ACCOUNT_MAX_LEN+2];
  303. szAccount[LOGIN_ACCOUNT_MAX_LEN] = 0;
  304. char szPassword[LOGIN_PASSWORD_MAX_LEN+2];
  305. szPassword[LOGIN_PASSWORD_MAX_LEN] = 0;
  306. DWORD dwOffset = 0;
  307. memcpy( szAccount,
  308. lpcParsedData->m_lpData + dwOffset,
  309. LOGIN_ACCOUNT_MAX_LEN );
  310. dwOffset += LOGIN_ACCOUNT_MAX_LEN + 2;
  311. memcpy( szPassword,
  312. lpcParsedData->m_lpData + dwOffset,
  313. LOGIN_PASSWORD_MAX_LEN );
  314. dwOffset += LOGIN_PASSWORD_MAX_LEN + 2;
  316. dwParam |= LOGIN_R_ACCDBISLOCKED;
  318. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  319. memcpy( &feedBuf[1+sizeof( KLoginStructHead )],
  320. szAccount, LOGIN_ACCOUNT_MAX_LEN + 2 );
  321. memcpy( &feedBuf[1+sizeof( KLoginStructHead )+LOGIN_ACCOUNT_MAX_LEN+2],
  322. szPassword, LOGIN_PASSWORD_MAX_LEN + 2 );
  323. unsigned long ulSize = dwSize + 1;
  324. unsigned long ulEncodedSize;
  325. if ( TRUE == S3PDBSocketParser::Encode( feedBuf, ulSize, NULL, ulEncodedSize ) )
  326. {
  327. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  328. if ( NULL != pEncodedBuf )
  329. {
  330. S3PDBSocketParser::Encode( feedBuf, ulSize, pEncodedBuf, ulEncodedSize );
  331. bRet =
  332. SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  333. delete []pEncodedBuf;
  334. pEncodedBuf = NULL;
  335. }
  336. }
  337. }
  338. }
  339. return bRet;
  340. }
  342. BOOL S3PDBSocketPool::ProAddAccount( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  343. {
  344. assert( NULL != lpcParsedData );
  345. BOOL bRet = FALSE;
  347. IBYTE feedBuf[1+KLOGINSTRUCTHEADSIZE];
  348. feedBuf[0] = LOGIN_R_TAG;
  349. DWORD dwSize = KLOGINSTRUCTHEADSIZE;
  350. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  351. DWORD dwParam = LOGIN_R_NEWACCOUNT;
  353. if ( ( LOGIN_ACCOUNT_MAX_LEN + 2
  354. + LOGIN_PASSWORD_MAX_LEN + 2
  355. + LOGIN_REALNAME_MAX_LEN + 2 )
  356. == lpcParsedData->m_dwSize )
  357. {
  358. char szAccount[LOGIN_ACCOUNT_MAX_LEN+2];
  359. szAccount[LOGIN_ACCOUNT_MAX_LEN] = 0;
  360. char szPassword[LOGIN_PASSWORD_MAX_LEN+2];
  361. szPassword[LOGIN_PASSWORD_MAX_LEN] = 0;
  362. char szRealName[LOGIN_REALNAME_MAX_LEN+2];
  363. szRealName[LOGIN_REALNAME_MAX_LEN] = 0;
  364. DWORD dwOffset = 0;
  365. memcpy( szAccount,
  366. lpcParsedData->m_lpData + dwOffset,
  367. LOGIN_ACCOUNT_MAX_LEN + 2 );
  368. dwOffset += LOGIN_ACCOUNT_MAX_LEN + 2;
  369. memcpy( szPassword,
  370. lpcParsedData->m_lpData + dwOffset,
  371. LOGIN_PASSWORD_MAX_LEN + 2 );
  372. dwOffset += LOGIN_PASSWORD_MAX_LEN + 2;
  373. memcpy( szRealName,
  374. lpcParsedData->m_lpData + dwOffset,
  375. LOGIN_REALNAME_MAX_LEN + 2 );
  377. int iResult = S3PAccount::AddAccount( szAccount, szPassword, szRealName );
  379. switch ( iResult )
  380. {
  381. case 1:
  382. dwParam |= LOGIN_R_SUCCESS;
  383. break;
  384. case -4:
  385. dwParam |= LOGIN_R_ACCOUNT_EXIST;
  386. break;
  387. default:
  388. dwParam |= LOGIN_R_FAILED;
  389. break;
  390. }
  391. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  393. //bRet = SendUDP( dwTargetIP, iTargetPort, feedBuf, 1 + KLOGINSTRUCTHEADSIZE );
  394. unsigned long ulEncodedSize;
  395. if ( TRUE == S3PDBSocketParser::Encode( feedBuf,
  396. 1 + KLOGINSTRUCTHEADSIZE, NULL, ulEncodedSize ) )
  397. {
  398. IBYTE* pEncodedFeedBuf = new IBYTE[ulEncodedSize];
  399. if ( NULL != pEncodedFeedBuf )
  400. {
  401. S3PDBSocketParser::Encode( feedBuf, 1 + KLOGINSTRUCTHEADSIZE,
  402. pEncodedFeedBuf, ulEncodedSize );
  403. bRet =
  404. SendUDP( dwTargetIP, iTargetPort,
  405. pEncodedFeedBuf, ulEncodedSize );
  406. delete []pEncodedFeedBuf;
  407. pEncodedFeedBuf = NULL;
  408. }
  409. }
  410. }
  411. else
  412. {
  413. dwParam |= LOGIN_R_FAILED;
  414. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  415. bRet =
  416. SendUDP( dwTargetIP, iTargetPort, feedBuf, 1 + KLOGINSTRUCTHEADSIZE );
  417. }
  419. return bRet;
  420. }
  422. BOOL S3PDBSocketPool::ProLoginFromGame( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  423. {
  424. BOOL bRet = FALSE;
  425. if ( NULL != lpcParsedData )
  426. {
  427. IBYTE feedBuf[def_UDPSIZE];
  428. memset( feedBuf, 0, def_UDPSIZE );
  429. feedBuf[0] = LOGIN_R_TAG;
  430. DWORD dwSize = sizeof( KLoginAccountInfo );
  431. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  432. DWORD dwParam = LOGIN_R_LOGIN;
  434. if ( ( LOGIN_ACCOUNT_MAX_LEN + 2 + LOGIN_PASSWORD_MAX_LEN + 2 )
  435. == lpcParsedData->m_dwSize )
  436. {
  437. S3PAccount account;
  438. char szAccount[LOGIN_ACCOUNT_MAX_LEN+2];
  439. szAccount[LOGIN_ACCOUNT_MAX_LEN] = 0;
  440. char szPassword[LOGIN_PASSWORD_MAX_LEN+2];
  441. szPassword[LOGIN_PASSWORD_MAX_LEN] = 0;
  442. DWORD dwOffset = 0;
  443. memcpy( szAccount,
  444. lpcParsedData->m_lpData + dwOffset,
  445. LOGIN_ACCOUNT_MAX_LEN );
  446. dwOffset += LOGIN_ACCOUNT_MAX_LEN + 2;
  447. memcpy( szPassword,
  448. lpcParsedData->m_lpData + dwOffset,
  449. LOGIN_PASSWORD_MAX_LEN );
  450. dwOffset += LOGIN_PASSWORD_MAX_LEN + 2;
  451. int iResult = S3PAccount::Login( szAccount, szPassword );
  452. if ( 1 == iResult )
  453. {
  454. dwParam |= LOGIN_R_SUCCESS;
  455. }
  456. else if ( -4 == iResult )
  457. {
  458. dwParam |= LOGIN_R_NOTREGISTERED;
  459. }
  460. else
  461. {
  462. dwParam |= LOGIN_R_FAILED;
  463. }
  465. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  466. memcpy( &feedBuf[1+sizeof( KLoginStructHead )],
  467. szAccount, LOGIN_ACCOUNT_MAX_LEN + 2 );
  468. memcpy( &feedBuf[1+sizeof( KLoginStructHead )+LOGIN_ACCOUNT_MAX_LEN+2],
  469. szPassword, LOGIN_PASSWORD_MAX_LEN + 2 );
  470. unsigned long ulSize = dwSize + 1;
  471. unsigned long ulEncodedSize;
  472. if ( TRUE == S3PDBSocketParser::Encode( feedBuf, ulSize, NULL, ulEncodedSize ) )
  473. {
  474. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  475. if ( NULL != pEncodedBuf )
  476. {
  477. S3PDBSocketParser::Encode( feedBuf, ulSize, pEncodedBuf, ulEncodedSize );
  478. bRet =
  479. SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  480. delete []pEncodedBuf;
  481. pEncodedBuf = NULL;
  482. }
  483. }
  484. }
  485. }
  486. return bRet;
  487. }
  489. BOOL S3PDBSocketPool::ProLogoutFromGame( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  490. {
  491. assert( NULL != lpcParsedData );
  492. BOOL bRet = FALSE;
  494. IBYTE feedBuf[def_UDPSIZE];
  495. memset( feedBuf, 0, def_UDPSIZE );
  496. feedBuf[0] = LOGIN_R_TAG;
  497. DWORD dwSize = sizeof( KLoginAccountInfo );
  498. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  499. DWORD dwParam = LOGIN_R_LOGOUT;
  501. if ( ( LOGIN_ACCOUNT_MAX_LEN + 2 + LOGIN_PASSWORD_MAX_LEN + 2 + sizeof( DWORD ) )
  502. == lpcParsedData->m_dwSize )
  503. {
  504. S3PAccount account;
  506. char szAccount[LOGIN_ACCOUNT_MAX_LEN+2];
  507. szAccount[LOGIN_ACCOUNT_MAX_LEN] = 0;
  508. char szPassword[LOGIN_PASSWORD_MAX_LEN+2];
  509. szPassword[LOGIN_PASSWORD_MAX_LEN] = 0;
  510. DWORD dwGameID = 0;
  511. DWORD dwOffset = 0;
  512. memcpy( szAccount,
  513. lpcParsedData->m_lpData + dwOffset,
  514. LOGIN_ACCOUNT_MAX_LEN );
  515. dwOffset += LOGIN_ACCOUNT_MAX_LEN + 2;
  516. memcpy( szPassword,
  517. lpcParsedData->m_lpData + dwOffset,
  518. LOGIN_PASSWORD_MAX_LEN );
  519. dwOffset += LOGIN_PASSWORD_MAX_LEN + 2;
  520. memcpy( &dwGameID,
  521. lpcParsedData->m_lpData + dwOffset,
  522. sizeof( DWORD ) );
  523. dwOffset += sizeof( DWORD );
  525. int iResult = S3PAccount::Logout( szAccount, szPassword, dwGameID );
  526. switch ( iResult )
  527. {
  528. case 1:
  529. dwParam |= LOGIN_R_SUCCESS;
  530. break;
  531. default:
  532. dwParam |= LOGIN_R_FAILED;
  533. break;
  534. }
  535. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  536. memcpy( &feedBuf[1+sizeof( KLoginStructHead )],
  537. szAccount, LOGIN_ACCOUNT_MAX_LEN + 2 );
  538. memcpy( &feedBuf[1+sizeof( KLoginStructHead )+LOGIN_ACCOUNT_MAX_LEN+2],
  539. szPassword, LOGIN_PASSWORD_MAX_LEN + 2 );
  540. unsigned long ulSize = sizeof( KLoginAccountInfo ) + 1;
  541. unsigned long ulEncodedSize;
  542. if ( TRUE == S3PDBSocketParser::Encode( feedBuf, ulSize, NULL, ulEncodedSize ) )
  543. {
  544. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  545. if ( NULL != pEncodedBuf )
  546. {
  547. S3PDBSocketParser::Encode( feedBuf, ulSize, pEncodedBuf, ulEncodedSize );
  548. bRet =
  549. SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  550. delete []pEncodedBuf;
  551. pEncodedBuf = NULL;
  552. }
  553. }
  554. }
  555. return bRet;
  556. }
  558. BOOL S3PDBSocketPool::ProReportFromGame( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  559. {
  560. assert( NULL != lpcParsedData );
  561. BOOL bRet = FALSE;
  562. IBYTE feedBuf[def_UDPSIZE];
  563. memset( feedBuf, 0, def_UDPSIZE );
  564. feedBuf[0] = LOGIN_R_TAG;
  565. DWORD dwSize = sizeof( KLoginAccountInfo );
  566. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  567. DWORD dwParam = LOGIN_R_REPORT;
  569. if ( ( LOGIN_ACCOUNT_MAX_LEN + 2 + LOGIN_PASSWORD_MAX_LEN + 2 + sizeof( DWORD ) )
  570. == lpcParsedData->m_dwSize )
  571. {
  572. S3PAccount account;
  574. char szAccount[LOGIN_ACCOUNT_MAX_LEN+2];
  575. szAccount[LOGIN_ACCOUNT_MAX_LEN] = 0;
  576. char szPassword[LOGIN_PASSWORD_MAX_LEN+2];
  577. szPassword[LOGIN_PASSWORD_MAX_LEN] = 0; 
  578. DWORD dwGameID = 0;
  579. DWORD dwOffset = 0;
  580. memcpy( szAccount,
  581. lpcParsedData->m_lpData + dwOffset,
  582. LOGIN_ACCOUNT_MAX_LEN );
  583. dwOffset += LOGIN_ACCOUNT_MAX_LEN + 2;
  584. memcpy( szPassword,
  585. lpcParsedData->m_lpData + dwOffset,
  586. LOGIN_PASSWORD_MAX_LEN );
  587. dwOffset += LOGIN_PASSWORD_MAX_LEN + 2;
  588. memcpy( &dwGameID,
  589. &( lpcParsedData->m_lpData[LOGIN_ACCOUNT_MAX_LEN+LOGIN_PASSWORD_MAX_LEN] ),
  590. sizeof( DWORD ) );
  591. dwOffset += sizeof( DWORD );
  593. int iResult = S3PAccount::Report( szAccount, szPassword, dwGameID );
  594. switch ( iResult )
  595. {
  596. case 1:
  597. dwParam |= LOGIN_R_SUCCESS;
  598. break;
  599. case -3:
  600. dwParam |= LOGIN_R_BEDISCONNECTED;
  601. break;
  602. case -4:
  603. dwParam |= LOGIN_R_NOTREGISTERED;
  604. break;
  605. default:
  606. dwParam |= LOGIN_R_FAILED;
  607. break;
  608. }
  609. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  610. memcpy( &feedBuf[1+sizeof( KLoginStructHead )],
  611. szAccount, LOGIN_ACCOUNT_MAX_LEN + 2 );
  612. memcpy( &feedBuf[1+sizeof( KLoginStructHead )+LOGIN_ACCOUNT_MAX_LEN+2],
  613. szPassword, LOGIN_PASSWORD_MAX_LEN + 2 );
  614. unsigned long ulSize = sizeof( KLoginAccountInfo ) + 1;
  615. unsigned long ulEncodedSize;
  616. if ( TRUE == S3PDBSocketParser::Encode( feedBuf, ulSize, NULL, ulEncodedSize ) )
  617. {
  618. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  619. if ( NULL != pEncodedBuf )
  620. {
  621. S3PDBSocketParser::Encode( feedBuf, ulSize, pEncodedBuf, ulEncodedSize );
  622. bRet =
  623. SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  624. delete []pEncodedBuf;
  625. pEncodedBuf = NULL;
  626. }
  627. }
  628. }
  629. return bRet;
  630. }
  632. BOOL S3PDBSocketPool::ProQueryGameserverList( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  633. {
  634. BOOL bRet = FALSE;
  635. if ( NULL != lpcParsedData )
  636. {
  637. IBYTE feedBuf[def_UDPSIZE*10];
  638. memset( feedBuf, 0, def_UDPSIZE * 10 );
  639. feedBuf[0] = LOGIN_R_TAG;
  640. DWORD dwSize = sizeof( KLoginAccountInfo );
  641. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  642. DWORD dwParam = LOGIN_R_LOGIN;
  644. if ( ( LOGIN_ACCOUNT_MAX_LEN + 2 + LOGIN_PASSWORD_MAX_LEN + 2 )
  645. == lpcParsedData->m_dwSize )
  646. {
  647. char szAccount[LOGIN_ACCOUNT_MAX_LEN + 2 ];
  648. szAccount[LOGIN_ACCOUNT_MAX_LEN] = 0;
  649. char szPassword[LOGIN_PASSWORD_MAX_LEN+1];
  650. szPassword[LOGIN_PASSWORD_MAX_LEN] = 0; 
  651. memcpy( szAccount,
  652. lpcParsedData->m_lpData,
  653. LOGIN_ACCOUNT_MAX_LEN );
  654. memcpy( szPassword,
  655. &( lpcParsedData->m_lpData[LOGIN_ACCOUNT_MAX_LEN] ),
  656. LOGIN_PASSWORD_MAX_LEN );
  657. S3PAccount account;
  658. DWORD dwSizeTemp = 0;
  659. IBYTE* pFeedBuf = feedBuf;
  660. IBYTE* pLastFeedBuf = NULL;
  661. int iResult =
  662. account.QueryGameserverList( szAccount, szPassword, NULL, dwSizeTemp );
  663. BOOL bFixedMemory = TRUE;
  664. if ( 1 == iResult )
  665. {
  666. pFeedBuf = new IBYTE[dwSizeTemp+dwSize+1];
  667. if ( NULL != pFeedBuf )
  668. {
  669. memcpy( pFeedBuf, feedBuf, dwSize + 1 );
  670. dwSize += dwSizeTemp;
  671. memcpy( &( pFeedBuf[1] ), &dwSize, sizeof( DWORD ) );
  672. account.QueryGameserverList( szAccount, szPassword,
  673. &( pFeedBuf[dwSize+1] ), dwSizeTemp );
  674. bFixedMemory = FALSE;
  675. }
  676. else
  677. {
  678. pFeedBuf = feedBuf;
  679. dwParam |= LOGIN_R_FAILED;
  680. }
  681. }
  682. else
  683. {
  684. dwParam |= LOGIN_R_FAILED;
  685. }
  687. memcpy( &pFeedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  688. memcpy( &pFeedBuf[1+sizeof( KLoginStructHead )],
  689. szAccount, LOGIN_ACCOUNT_MAX_LEN + 2 );
  690. memcpy( &pFeedBuf[1+sizeof( KLoginStructHead )+LOGIN_ACCOUNT_MAX_LEN+2],
  691. szPassword, LOGIN_PASSWORD_MAX_LEN + 2 );
  692. unsigned long ulSize = dwSize + 1;
  693. unsigned long ulEncodedSize;
  694. if ( TRUE == S3PDBSocketParser::Encode( feedBuf, ulSize, NULL, ulEncodedSize ) )
  695. {
  696. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  697. if ( NULL != pEncodedBuf )
  698. {
  699. S3PDBSocketParser::Encode( feedBuf, ulSize, pEncodedBuf, ulEncodedSize );
  700. bRet =
  701. SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  702. delete []pEncodedBuf;
  703. pEncodedBuf = NULL;
  704. }
  705. }
  707. if ( ( !bFixedMemory ) && ( NULL != pFeedBuf ) )
  708. {
  709. delete []pFeedBuf;
  710. pFeedBuf = NULL;
  711. }
  712. }
  713. }
  714. return bRet;
  715. }
  717. BOOL S3PDBSocketPool::ProBeginGame( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  718. {
  719. BOOL bRet = FALSE;
  720. if ( NULL != lpcParsedData )
  721. {
  722. IBYTE feedBuf[def_UDPSIZE];
  723. memset( feedBuf, 0, def_UDPSIZE );
  724. feedBuf[0] = LOGIN_R_TAG;
  725. DWORD dwSize = sizeof( KLoginAccountInfo );
  726. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  727. DWORD dwParam = LOGIN_R_BEGINGAME;
  729. if ( ( LOGIN_ACCOUNT_MAX_LEN + 2 + LOGIN_PASSWORD_MAX_LEN + 2 + sizeof( DWORD ) )
  730. == lpcParsedData->m_dwSize )
  731. {
  732. S3PAccount account;
  733. char szAccount[LOGIN_ACCOUNT_MAX_LEN+2];
  734. szAccount[LOGIN_ACCOUNT_MAX_LEN] = 0;
  735. char szPassword[LOGIN_PASSWORD_MAX_LEN+2];
  736. szPassword[LOGIN_PASSWORD_MAX_LEN] = 0;
  737. DWORD dwGameID = 0;
  738. DWORD dwOffset = 0;
  739. memcpy( szAccount,
  740. lpcParsedData->m_lpData + dwOffset,
  741. LOGIN_ACCOUNT_MAX_LEN );
  742. dwOffset += LOGIN_ACCOUNT_MAX_LEN + 2;
  743. memcpy( szPassword,
  744. lpcParsedData->m_lpData + dwOffset,
  745. LOGIN_PASSWORD_MAX_LEN );
  746. dwOffset += LOGIN_PASSWORD_MAX_LEN + 2;
  747. memcpy( &dwGameID,
  748. lpcParsedData->m_lpData + dwOffset,
  749. sizeof( DWORD ) );
  750. dwOffset += sizeof( DWORD );
  752. int iResult = S3PAccount::Login( szAccount, szPassword, dwGameID );
  753. if ( 1 == iResult )
  754. {
  755. dwParam |= LOGIN_R_SUCCESS;
  756. }
  757. else if ( -4 == iResult )
  758. {
  759. dwParam |= LOGIN_R_NOTREGISTERED;
  760. }
  761. else
  762. {
  763. dwParam |= LOGIN_R_FAILED;
  764. }
  766. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  767. memcpy( &feedBuf[1+sizeof( KLoginStructHead )],
  768. szAccount, LOGIN_ACCOUNT_MAX_LEN + 2 );
  769. memcpy( &feedBuf[1+sizeof( KLoginStructHead )+LOGIN_ACCOUNT_MAX_LEN+2],
  770. szPassword, LOGIN_PASSWORD_MAX_LEN + 2 );
  771. unsigned long ulSize = dwSize + 1;
  772. unsigned long ulEncodedSize;
  773. if ( TRUE == S3PDBSocketParser::Encode( feedBuf, ulSize, NULL, ulEncodedSize ) )
  774. {
  775. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  776. if ( NULL != pEncodedBuf )
  777. {
  778. S3PDBSocketParser::Encode( feedBuf, ulSize, pEncodedBuf, ulEncodedSize );
  779. bRet =
  780. SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  781. delete []pEncodedBuf;
  782. pEncodedBuf = NULL;
  783. }
  784. }
  785. }
  786. }
  787. return bRet;
  788. }
  790. BOOL S3PDBSocketPool::ProDBLogin( DWORD dwTargetIP, INT iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  791. {
  792. BOOL bRet = FALSE;
  793. if ( NULL != lpcParsedData )
  794. {
  795. if ( ( sizeof( GUID ) + sizeof( _DBLOGINSTRUCT ) - sizeof( KLoginStructHead ) )
  796. == lpcParsedData->m_dwSize )
  797. {
  798. char szUserName[def_DBUSERNAME_MAX_LEN+1];
  799. szUserName[def_DBUSERNAME_MAX_LEN] = 0;
  800. char szPassword[def_DBPASSWORD_MAX_LEN+1];
  801. szPassword[def_DBPASSWORD_MAX_LEN] = 0;
  802. struct sockaddr_in targetAddr;
  803. targetAddr.sin_family = AF_INET;
  804. targetAddr.sin_addr.s_addr = dwTargetIP;
  805. targetAddr.sin_port = htons( ( short )iTargetPort );
  806. GUID msgID;
  807. memcpy( szUserName,
  808. lpcParsedData->m_lpData,
  809. def_DBUSERNAME_MAX_LEN );
  810. memcpy( szPassword,
  811. &( lpcParsedData->m_lpData[def_DBUSERNAME_MAX_LEN] ),
  812. def_DBPASSWORD_MAX_LEN );
  813. memcpy( &msgID,
  814. &( lpcParsedData->m_lpData[def_DBUSERNAME_MAX_LEN + def_DBPASSWORD_MAX_LEN] ),
  815. sizeof( GUID ) );
  816. char* lpszTargetIP = inet_ntoa( targetAddr.sin_addr );
  817. IBYTE feedBuf[def_UDPSIZE];
  818. feedBuf[0] = LOGIN_R_TAG;
  819. DWORD dwSize = sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  820. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  821. memcpy( &feedBuf[1+sizeof( DWORD )*2],
  822. &szUserName, def_DBUSERNAME_MAX_LEN );
  823. memcpy( &feedBuf[1+sizeof( DWORD )*2+def_DBUSERNAME_MAX_LEN],
  824. &szPassword, def_DBPASSWORD_MAX_LEN );
  825. memcpy( &feedBuf[1+sizeof( _DBLOGINSTRUCT )], &msgID, sizeof( GUID ) );
  826. DWORD dwParam = DBLOGIN_R_LOGIN;
  828. int iResult =
  829. S3PAccount::DBLogin( szUserName, szPassword, lpszTargetIP );
  830. if ( 1 == iResult ) // Successful
  831. {
  832. dwParam |= DBLOGIN_R_SUCCESS;
  833. }
  834. else if ( -4 == iResult ) // User has logged in
  835. {
  836. dwParam |= DBLOGIN_R_HASLOGGEDIN;
  837. }
  838. else // Failed to logged in
  839. {
  840. dwParam |= DBLOGIN_R_FAILED;
  841. }
  842. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  843. unsigned long ulFeedSize = 1 + sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  844. unsigned long ulEncodedSize;
  845. if ( TRUE ==
  846. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, NULL, ulEncodedSize ) )
  847. {
  848. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  849. if ( NULL != pEncodedBuf )
  850. {
  851. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, pEncodedBuf, ulEncodedSize );
  852. bRet = SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  853. delete []pEncodedBuf;
  854. pEncodedBuf = NULL;
  855. }
  856. }
  857. }
  858. else
  859. {
  860. // No operation here
  861. }
  862. }
  863. return bRet;
  864. }
  866. BOOL S3PDBSocketPool::ProDBLogout( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  867. {
  868. BOOL bRet = FALSE;
  869. if ( NULL != lpcParsedData )
  870. {
  871. if ( ( sizeof( GUID ) + sizeof( _DBLOGINSTRUCT ) - sizeof( KLoginStructHead ) )
  872. == lpcParsedData->m_dwSize )
  873. {
  874. char szUserName[def_DBUSERNAME_MAX_LEN+1];
  875. szUserName[def_DBUSERNAME_MAX_LEN] = 0;
  876. char szPassword[def_DBPASSWORD_MAX_LEN+1];
  877. szPassword[def_DBPASSWORD_MAX_LEN] = 0;
  878. GUID msgID;
  879. memcpy( szUserName,
  880. lpcParsedData->m_lpData,
  881. def_DBUSERNAME_MAX_LEN );
  882. memcpy( szPassword,
  883. &( lpcParsedData->m_lpData[def_DBUSERNAME_MAX_LEN] ),
  884. def_DBPASSWORD_MAX_LEN );
  885. memcpy( &msgID,
  886. &( lpcParsedData->m_lpData[def_DBUSERNAME_MAX_LEN + def_DBPASSWORD_MAX_LEN] ),
  887. sizeof( GUID ) );
  888. IBYTE feedBuf[def_UDPSIZE];
  889. feedBuf[0] = LOGIN_R_TAG;
  890. DWORD dwSize = sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  891. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  892. memcpy( &feedBuf[1+sizeof( DWORD )*2],
  893. &szUserName, def_DBUSERNAME_MAX_LEN );
  894. memcpy( &feedBuf[1+sizeof( DWORD )*2+def_DBUSERNAME_MAX_LEN],
  895. &szPassword, def_DBPASSWORD_MAX_LEN );
  896. memcpy( &feedBuf[1+sizeof( _DBLOGINSTRUCT )], &msgID, sizeof( GUID ) );
  897. DWORD dwParam = DBLOGIN_R_LOGOUT;
  899. int iResult =
  900. S3PAccount::DBLogout( szUserName, szPassword );
  901. if ( 1 == iResult ) // Successful
  902. {
  903. dwParam |= DBLOGIN_R_SUCCESS;
  904. }
  905. else // Failed to logged out
  906. {
  907. dwParam |= DBLOGIN_R_FAILED;
  908. }
  909. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  910. unsigned long ulFeedSize = 1 + sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  911. unsigned long ulEncodedSize;
  912. if ( TRUE ==
  913. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, NULL, ulEncodedSize ) )
  914. {
  915. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  916. if ( NULL != pEncodedBuf )
  917. {
  918. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, pEncodedBuf, ulEncodedSize );
  919. bRet = SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  920. delete []pEncodedBuf;
  921. pEncodedBuf = NULL;
  922. }
  923. }
  924. }
  925. else
  926. {
  927. // No operation here
  928. }
  929. }
  930. return bRet;
  931. }
  933. BOOL S3PDBSocketPool::ProDBQueryUserList( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  934. {
  935. BOOL bRet = FALSE;
  936. if ( NULL != lpcParsedData )
  937. {
  938. if ( ( sizeof( GUID ) + sizeof( _DBLOGINSTRUCT ) - sizeof( KLoginStructHead ) )
  939. == lpcParsedData->m_dwSize )
  940. {
  941. char szUserName[def_DBUSERNAME_MAX_LEN+1];
  942. szUserName[def_DBUSERNAME_MAX_LEN] = 0;
  943. char szPassword[def_DBPASSWORD_MAX_LEN+1];
  944. szPassword[def_DBPASSWORD_MAX_LEN] = 0;
  945. GUID msgID;
  946. memcpy( szUserName,
  947. lpcParsedData->m_lpData,
  948. def_DBUSERNAME_MAX_LEN );
  949. memcpy( szPassword,
  950. &( lpcParsedData->m_lpData[def_DBUSERNAME_MAX_LEN] ),
  951. def_DBPASSWORD_MAX_LEN );
  952. memcpy( &msgID,
  953. &( lpcParsedData->m_lpData[def_DBUSERNAME_MAX_LEN + def_DBPASSWORD_MAX_LEN] ),
  954. sizeof( GUID ) );
  956. IBYTE feedBuf[def_UDPSIZE];
  957. IBYTE* pLastFeedBuf = NULL;
  958. feedBuf[0] = LOGIN_R_TAG;
  959. DWORD dwSize = sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  960. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  961. memcpy( &feedBuf[1+sizeof( DWORD )*2],
  962. &szUserName, def_DBUSERNAME_MAX_LEN );
  963. memcpy( &feedBuf[1+sizeof( DWORD )*2+def_DBUSERNAME_MAX_LEN],
  964. &szPassword, def_DBPASSWORD_MAX_LEN );
  965. memcpy( &feedBuf[1+sizeof( _DBLOGINSTRUCT )], &msgID, sizeof( GUID ) );
  966. DWORD dwParam = DBLOGIN_R_QUERYUSERLIST;
  967. DWORD dwUserListSize = 0;
  968. int iResult =
  969. S3PAccount::DBQueryUserList( szUserName,
  970. szPassword, NULL, dwUserListSize );
  971. BOOL bFeedBufIsFixed = TRUE;
  972. if ( 1 == iResult )
  973. {
  974. if ( 0 == dwUserListSize )
  975. {
  976. pLastFeedBuf = feedBuf;
  977. dwParam |= DBLOGIN_R_SUCCESS;
  978. }
  979. else
  980. {
  981. pLastFeedBuf =
  982. new IBYTE[1+sizeof( _DBLOGINSTRUCT )+sizeof( GUID )+dwUserListSize];
  983. if ( NULL != pLastFeedBuf )
  984. {
  985. bFeedBufIsFixed = FALSE;
  986. dwSize += dwUserListSize;
  987. memcpy( pLastFeedBuf, feedBuf, 1 + sizeof( _DBLOGINSTRUCT ) + sizeof( GUID ) );
  988. memcpy( &pLastFeedBuf[1], &dwSize, sizeof( DWORD ) );
  989. dwParam |= DBLOGIN_R_SUCCESS;
  990. S3PAccount::DBQueryUserList( szUserName, szPassword,
  991. &( pLastFeedBuf[1+sizeof( _DBLOGINSTRUCT )+sizeof( GUID )] ),
  992. dwUserListSize );
  993. }
  994. else
  995. {
  996. pLastFeedBuf = feedBuf;
  997. dwParam |= DBLOGIN_R_FAILED;
  998. }
  999. }
  1000. }
  1001. else
  1002. {
  1003. pLastFeedBuf = feedBuf;
  1004. dwParam |= DBLOGIN_R_FAILED;
  1005. }
  1006. memcpy( &pLastFeedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  1008. unsigned long ulFeedSize =
  1009. 1 + sizeof( _DBLOGINSTRUCT ) + sizeof( GUID ) + dwUserListSize;
  1010. unsigned long ulEncodedSize;
  1011. if ( TRUE ==
  1012. S3PDBSocketParser::Encode( pLastFeedBuf, ulFeedSize, NULL, ulEncodedSize ) )
  1013. {
  1014. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  1015. if ( NULL != pEncodedBuf )
  1016. {
  1017. S3PDBSocketParser::Encode( pLastFeedBuf, ulFeedSize, pEncodedBuf, ulEncodedSize );
  1018. bRet = SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  1019. delete []pEncodedBuf;
  1020. pEncodedBuf = NULL;
  1021. }
  1022. }
  1023. if ( !bFeedBufIsFixed )
  1024. {
  1025. delete []pLastFeedBuf;
  1026. pLastFeedBuf = NULL;
  1027. }
  1028. }
  1029. }
  1030. return bRet;
  1031. }
  1033. BOOL S3PDBSocketPool::ProDBLock( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  1034. {
  1035. BOOL bRet = FALSE;
  1036. if ( NULL != lpcParsedData )
  1037. {
  1038. if ( ( sizeof( GUID ) + sizeof( _DBLOGINSTRUCT ) - sizeof( KLoginStructHead ) )
  1039. == lpcParsedData->m_dwSize )
  1040. {
  1041. char szUserName[def_DBUSERNAME_MAX_LEN+1];
  1042. szUserName[def_DBUSERNAME_MAX_LEN] = 0;
  1043. char szPassword[def_DBPASSWORD_MAX_LEN+1];
  1044. szPassword[def_DBPASSWORD_MAX_LEN] = 0;
  1045. GUID msgID;
  1046. memcpy( szUserName,
  1047. lpcParsedData->m_lpData,
  1048. def_DBUSERNAME_MAX_LEN );
  1049. memcpy( szPassword,
  1050. &( lpcParsedData->m_lpData[def_DBUSERNAME_MAX_LEN] ),
  1051. def_DBPASSWORD_MAX_LEN );
  1052. memcpy( &msgID,
  1053. &( lpcParsedData->m_lpData[def_DBUSERNAME_MAX_LEN + def_DBPASSWORD_MAX_LEN] ),
  1054. sizeof( GUID ) );
  1055. IBYTE feedBuf[def_UDPSIZE];
  1056. feedBuf[0] = LOGIN_R_TAG;
  1057. DWORD dwSize = sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  1058. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  1059. memcpy( &feedBuf[1+sizeof( DWORD )*2],
  1060. &szUserName, def_DBUSERNAME_MAX_LEN );
  1061. memcpy( &feedBuf[1+sizeof( DWORD )*2+def_DBUSERNAME_MAX_LEN],
  1062. &szPassword, def_DBPASSWORD_MAX_LEN );
  1063. memcpy( &feedBuf[1+sizeof( _DBLOGINSTRUCT )], &msgID, sizeof( GUID ) );
  1064. DWORD dwParam = DBLOGIN_R_LOCKDATABASE;
  1066. int iResult =
  1067. S3PAccount::DBLock( szUserName, szPassword );
  1068. if ( 1 == iResult ) // Successful
  1069. {
  1070. m_bAccDBIsLocked = TRUE;
  1071. dwParam |= DBLOGIN_R_SUCCESS;
  1072. }
  1073. else // Failed to lock account database
  1074. {
  1075. dwParam |= DBLOGIN_R_FAILED;
  1076. }
  1077. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  1078. unsigned long ulFeedSize = 1 + sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  1079. unsigned long ulEncodedSize;
  1080. if ( TRUE ==
  1081. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, NULL, ulEncodedSize ) )
  1082. {
  1083. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  1084. if ( NULL != pEncodedBuf )
  1085. {
  1086. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, pEncodedBuf, ulEncodedSize );
  1087. bRet = SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  1088. delete []pEncodedBuf;
  1089. pEncodedBuf = NULL;
  1090. }
  1091. }
  1092. }
  1093. else
  1094. {
  1095. // No operation here
  1096. }
  1097. }
  1098. return bRet;
  1099. }
  1101. BOOL S3PDBSocketPool::ProDBActivate( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  1102. {
  1103. BOOL bRet = FALSE;
  1104. if ( NULL != lpcParsedData )
  1105. {
  1106. if ( ( sizeof( GUID ) + sizeof( _DBLOGINSTRUCT ) - sizeof( KLoginStructHead ) )
  1107. == lpcParsedData->m_dwSize )
  1108. {
  1109. char szUserName[def_DBUSERNAME_MAX_LEN+1];
  1110. szUserName[def_DBUSERNAME_MAX_LEN] = 0;
  1111. char szPassword[def_DBPASSWORD_MAX_LEN+1];
  1112. szPassword[def_DBPASSWORD_MAX_LEN] = 0;
  1113. GUID msgID;
  1114. memcpy( szUserName,
  1115. lpcParsedData->m_lpData,
  1116. def_DBUSERNAME_MAX_LEN );
  1117. memcpy( szPassword,
  1118. &( lpcParsedData->m_lpData[def_DBUSERNAME_MAX_LEN] ),
  1119. def_DBPASSWORD_MAX_LEN );
  1120. memcpy( &msgID,
  1121. &( lpcParsedData->m_lpData[def_DBUSERNAME_MAX_LEN + def_DBPASSWORD_MAX_LEN] ),
  1122. sizeof( GUID ) );
  1123. IBYTE feedBuf[def_UDPSIZE];
  1124. feedBuf[0] = LOGIN_R_TAG;
  1125. DWORD dwSize = sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  1126. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  1127. memcpy( &feedBuf[1+sizeof( DWORD )*2],
  1128. &szUserName, def_DBUSERNAME_MAX_LEN );
  1129. memcpy( &feedBuf[1+sizeof( DWORD )*2+def_DBUSERNAME_MAX_LEN],
  1130. &szPassword, def_DBPASSWORD_MAX_LEN );
  1131. memcpy( &feedBuf[1+sizeof( _DBLOGINSTRUCT )], &msgID, sizeof( GUID ) );
  1132. DWORD dwParam = DBLOGIN_R_ACTIVATEDATABASE;
  1134. int iResult =
  1135. S3PAccount::DBActivate( szUserName, szPassword );
  1136. if ( 1 == iResult ) // Successful
  1137. {
  1138. m_bAccDBIsLocked = TRUE;
  1139. dwParam |= DBLOGIN_R_SUCCESS;
  1140. }
  1141. else // Failed to activate account database
  1142. {
  1143. dwParam |= DBLOGIN_R_FAILED;
  1144. }
  1145. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  1146. unsigned long ulFeedSize = 1 + sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  1147. unsigned long ulEncodedSize;
  1148. if ( TRUE ==
  1149. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, NULL, ulEncodedSize ) )
  1150. {
  1151. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  1152. if ( NULL != pEncodedBuf )
  1153. {
  1154. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, pEncodedBuf, ulEncodedSize );
  1155. bRet = SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  1156. delete []pEncodedBuf;
  1157. pEncodedBuf = NULL;
  1158. }
  1159. }
  1160. }
  1161. else
  1162. {
  1163. // No operation here
  1164. }
  1165. }
  1166. return bRet;
  1167. }
  1169. BOOL S3PDBSocketPool::ProDBAddUser( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  1170. {
  1171. BOOL bRet = FALSE;
  1172. if ( NULL != lpcParsedData )
  1173. {
  1174. if ( ( sizeof( GUID ) + sizeof( _DBLOGINSTRUCT )
  1175.  + def_DBUSERNAME_MAX_LEN + def_DBPASSWORD_MAX_LEN
  1176.  + sizeof( short int )
  1177.  - sizeof( KLoginStructHead ) )
  1178. == lpcParsedData->m_dwSize )
  1179. {
  1180. char szUserName[def_DBUSERNAME_MAX_LEN+2];
  1181. szUserName[def_DBUSERNAME_MAX_LEN] = 0;
  1182. char szPassword[def_DBPASSWORD_MAX_LEN+2];
  1183. szPassword[def_DBPASSWORD_MAX_LEN] = 0;
  1184. char szNewUserName[def_DBUSERNAME_MAX_LEN+2];
  1185. szNewUserName[def_DBUSERNAME_MAX_LEN] = 0;
  1186. char szNewUserPassword[def_DBPASSWORD_MAX_LEN+2];
  1187. szNewUserPassword[def_DBPASSWORD_MAX_LEN] = 0;
  1188. short int siNewUserPriority = 0;
  1189. GUID msgID;
  1190. DWORD dwOffset = 0;
  1191. memcpy( szUserName,
  1192. lpcParsedData->m_lpData,
  1193. def_DBUSERNAME_MAX_LEN );
  1194. dwOffset += def_DBUSERNAME_MAX_LEN;
  1195. memcpy( szPassword,
  1196. lpcParsedData->m_lpData + dwOffset,
  1197. def_DBPASSWORD_MAX_LEN );
  1198. dwOffset += def_DBPASSWORD_MAX_LEN;
  1199. memcpy( szNewUserName,
  1200. lpcParsedData->m_lpData + dwOffset,
  1201. def_DBUSERNAME_MAX_LEN );
  1202. dwOffset += def_DBUSERNAME_MAX_LEN;
  1203. memcpy( szNewUserPassword,
  1204. lpcParsedData->m_lpData + dwOffset,
  1205. def_DBPASSWORD_MAX_LEN );
  1206. dwOffset += def_DBPASSWORD_MAX_LEN;
  1207. memcpy( &siNewUserPriority,
  1208. lpcParsedData->m_lpData + dwOffset,
  1209. sizeof( short int ) );
  1210. dwOffset += sizeof( short int );
  1211. memcpy( &msgID,
  1212. lpcParsedData->m_lpData + dwOffset,
  1213. sizeof( GUID ) );
  1214. IBYTE feedBuf[def_UDPSIZE];
  1215. feedBuf[0] = LOGIN_R_TAG;
  1216. DWORD dwSize = sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  1217. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  1218. memcpy( &feedBuf[1+sizeof( DWORD )*2],
  1219. &szUserName, def_DBUSERNAME_MAX_LEN );
  1220. memcpy( &feedBuf[1+sizeof( DWORD )*2+def_DBUSERNAME_MAX_LEN],
  1221. &szPassword, def_DBPASSWORD_MAX_LEN );
  1222. memcpy( &feedBuf[1+sizeof( _DBLOGINSTRUCT )], &msgID, sizeof( GUID ) );
  1223. DWORD dwParam = DBLOGIN_R_ADDDBUSER;
  1225. int iResult =
  1226. S3PAccount::DBAddUser( szUserName, szPassword,
  1227. szNewUserName, szNewUserPassword, siNewUserPriority );
  1228. if ( 1 == iResult ) // Successful
  1229. {
  1230. dwParam |= DBLOGIN_R_SUCCESS;
  1231. }
  1232. else if ( -6 == iResult )
  1233. {
  1234. dwParam |= DBLOGIN_R_HASNOENOUGHPRIORITY;
  1235. }
  1236. else if ( -7 == iResult )
  1237. {
  1238. dwParam |= DBLOGIN_R_USERHASEXISTED;
  1239. }
  1240. else // Failed to activate account database
  1241. {
  1242. dwParam |= DBLOGIN_R_FAILED;
  1243. }
  1244. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  1245. unsigned long ulFeedSize = 1 + sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  1246. unsigned long ulEncodedSize;
  1247. if ( TRUE ==
  1248. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, NULL, ulEncodedSize ) )
  1249. {
  1250. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  1251. if ( NULL != pEncodedBuf )
  1252. {
  1253. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, pEncodedBuf, ulEncodedSize );
  1254. bRet = SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  1255. delete []pEncodedBuf;
  1256. pEncodedBuf = NULL;
  1257. }
  1258. }
  1259. }
  1260. else
  1261. {
  1262. // No operation here
  1263. }
  1264. }
  1265. return bRet;
  1266. }
  1268. BOOL S3PDBSocketPool::ProDBDeleteUser( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  1269. {
  1270. BOOL bRet = FALSE;
  1271. if ( NULL != lpcParsedData )
  1272. {
  1273. if ( ( sizeof( GUID ) + sizeof( _DBLOGINSTRUCT )
  1274.  + def_DBUSERNAME_MAX_LEN
  1275.  - sizeof( KLoginStructHead ) )
  1276. == lpcParsedData->m_dwSize )
  1277. {
  1278. char szUserName[def_DBUSERNAME_MAX_LEN+2];
  1279. szUserName[def_DBUSERNAME_MAX_LEN] = 0;
  1280. char szPassword[def_DBPASSWORD_MAX_LEN+2];
  1281. szPassword[def_DBPASSWORD_MAX_LEN] = 0;
  1282. char szSelUserName[def_DBUSERNAME_MAX_LEN+2];
  1283. szSelUserName[def_DBUSERNAME_MAX_LEN] = 0;
  1284. GUID msgID;
  1285. DWORD dwOffset = 0;
  1286. memcpy( szUserName,
  1287. lpcParsedData->m_lpData,
  1288. def_DBUSERNAME_MAX_LEN );
  1289. dwOffset += def_DBUSERNAME_MAX_LEN;
  1290. memcpy( szPassword,
  1291. lpcParsedData->m_lpData + dwOffset,
  1292. def_DBPASSWORD_MAX_LEN );
  1293. dwOffset += def_DBPASSWORD_MAX_LEN;
  1294. memcpy( szSelUserName,
  1295. lpcParsedData->m_lpData + dwOffset,
  1296. def_DBUSERNAME_MAX_LEN );
  1297. dwOffset += def_DBUSERNAME_MAX_LEN;
  1298. memcpy( &msgID,
  1299. lpcParsedData->m_lpData + dwOffset,
  1300. sizeof( GUID ) );
  1301. IBYTE feedBuf[def_UDPSIZE];
  1302. feedBuf[0] = LOGIN_R_TAG;
  1303. DWORD dwSize = sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  1304. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  1305. memcpy( &feedBuf[1+sizeof( DWORD )*2],
  1306. &szUserName, def_DBUSERNAME_MAX_LEN );
  1307. memcpy( &feedBuf[1+sizeof( DWORD )*2+def_DBUSERNAME_MAX_LEN],
  1308. &szPassword, def_DBPASSWORD_MAX_LEN );
  1309. memcpy( &feedBuf[1+sizeof( _DBLOGINSTRUCT )], &msgID, sizeof( GUID ) );
  1310. DWORD dwParam = DBLOGIN_R_DELDBUSER;
  1311. int iResult =
  1312. S3PAccount::DBDeleteUser( szUserName, szPassword, szSelUserName );
  1313. if ( 1 == iResult ) // Successful
  1314. {
  1315. dwParam |= DBLOGIN_R_SUCCESS;
  1316. }
  1317. else if ( -4 == iResult )
  1318. {
  1319. dwParam |= DBLOGIN_R_HASNOENOUGHPRIORITY;
  1320. }
  1321. else // Failed to activate account database
  1322. {
  1323. dwParam |= DBLOGIN_R_FAILED;
  1324. }
  1325. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  1326. unsigned long ulFeedSize = 1 + sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  1327. unsigned long ulEncodedSize;
  1328. if ( TRUE ==
  1329. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, NULL, ulEncodedSize ) )
  1330. {
  1331. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  1332. if ( NULL != pEncodedBuf )
  1333. {
  1334. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, pEncodedBuf, ulEncodedSize );
  1335. bRet = SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  1336. delete []pEncodedBuf;
  1337. pEncodedBuf = NULL;
  1338. }
  1339. }
  1340. }
  1341. else
  1342. {
  1343. // No operation here
  1344. }
  1345. }
  1346. return bRet;
  1347. }
  1349. BOOL S3PDBSocketPool::ProDBCreateAccount( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  1350. {
  1351. BOOL bRet = FALSE;
  1352. if ( NULL != lpcParsedData )
  1353. {
  1354. if ( ( sizeof( GUID ) + sizeof( _DBLOGINSTRUCT )
  1355.  + LOGIN_REALNAME_MAX_LEN
  1356.  + LOGIN_PASSWORD_MAX_LEN
  1357.  + LOGIN_ACCOUNT_MAX_LEN
  1358.  - sizeof( KLoginStructHead ) )
  1359. == lpcParsedData->m_dwSize )
  1360. {
  1361. char szUserName[def_DBUSERNAME_MAX_LEN+2];
  1362. szUserName[def_DBUSERNAME_MAX_LEN] = 0;
  1363. char szPassword[def_DBPASSWORD_MAX_LEN+2];
  1364. szPassword[def_DBPASSWORD_MAX_LEN] = 0;
  1365. char szAccRealName[LOGIN_REALNAME_MAX_LEN+2];
  1366. szAccRealName[LOGIN_REALNAME_MAX_LEN] = 0;
  1367. char szAccPassword[LOGIN_PASSWORD_MAX_LEN+2];
  1368. szAccPassword[LOGIN_PASSWORD_MAX_LEN] = 0;
  1369. char szAccName[LOGIN_ACCOUNT_MAX_LEN+2];
  1370. szAccName[LOGIN_ACCOUNT_MAX_LEN] = 0;
  1371. GUID msgID;
  1372. DWORD dwOffset = 0;
  1373. memcpy( szUserName,
  1374. lpcParsedData->m_lpData,
  1375. def_DBUSERNAME_MAX_LEN );
  1376. dwOffset += def_DBUSERNAME_MAX_LEN;
  1377. memcpy( szPassword,
  1378. lpcParsedData->m_lpData + dwOffset,
  1379. def_DBPASSWORD_MAX_LEN );
  1380. dwOffset += def_DBPASSWORD_MAX_LEN;
  1381. memcpy( szAccRealName,
  1382. lpcParsedData->m_lpData + dwOffset,
  1383. LOGIN_REALNAME_MAX_LEN );
  1384. dwOffset += LOGIN_REALNAME_MAX_LEN;
  1385. memcpy( szAccPassword,
  1386. lpcParsedData->m_lpData + dwOffset,
  1387. LOGIN_PASSWORD_MAX_LEN );
  1388. dwOffset += LOGIN_PASSWORD_MAX_LEN;
  1389. memcpy( szAccName,
  1390. lpcParsedData->m_lpData + dwOffset,
  1391. LOGIN_ACCOUNT_MAX_LEN );
  1392. dwOffset += LOGIN_ACCOUNT_MAX_LEN;
  1393. memcpy( &msgID,
  1394. lpcParsedData->m_lpData + dwOffset,
  1395. sizeof( GUID ) );
  1396. IBYTE feedBuf[def_UDPSIZE];
  1397. feedBuf[0] = LOGIN_R_TAG;
  1398. DWORD dwSize = sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  1399. memcpy( &feedBuf[1], &dwSize, sizeof( DWORD ) );
  1400. memcpy( &feedBuf[1+sizeof( DWORD )*2],
  1401. &szUserName, def_DBUSERNAME_MAX_LEN );
  1402. memcpy( &feedBuf[1+sizeof( DWORD )*2+def_DBUSERNAME_MAX_LEN],
  1403. &szPassword, def_DBPASSWORD_MAX_LEN );
  1404. memcpy( &feedBuf[1+sizeof( _DBLOGINSTRUCT )], &msgID, sizeof( GUID ) );
  1405. DWORD dwParam = DBLOGIN_R_CREATEACCOUNT;
  1406. int iResult =
  1407. S3PAccount::DBCreateAccount( szUserName, szPassword,
  1408. szAccRealName, szAccPassword, szAccName );
  1409. if ( 1 == iResult )
  1410. {
  1411. dwParam |= DBLOGIN_R_SUCCESS;
  1412. }
  1413. else if ( -6 == iResult )
  1414. {
  1415. dwParam |= DBLOGIN_R_HASNOENOUGHPRIORITY;
  1416. }
  1417. else
  1418. {
  1419. dwParam |= DBLOGIN_R_FAILED;
  1420. }
  1421. memcpy( &feedBuf[1+sizeof( DWORD )], &dwParam, sizeof( DWORD ) );
  1422. unsigned long ulFeedSize = 1 + sizeof( _DBLOGINSTRUCT ) + sizeof( GUID );
  1423. unsigned long ulEncodedSize;
  1424. if ( TRUE ==
  1425. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, NULL, ulEncodedSize ) )
  1426. {
  1427. IBYTE* pEncodedBuf = new IBYTE[ulEncodedSize];
  1428. if ( NULL != pEncodedBuf )
  1429. {
  1430. S3PDBSocketParser::Encode( feedBuf, ulFeedSize, pEncodedBuf, ulEncodedSize );
  1431. bRet = SendUDP( dwTargetIP, iTargetPort, pEncodedBuf, ulEncodedSize );
  1432. delete []pEncodedBuf;
  1433. pEncodedBuf = NULL;
  1434. }
  1435. }
  1436. }
  1437. else
  1438. {
  1439. // No operation here
  1440. }
  1441. }
  1442. return bRet;
  1443. }
  1445. BOOL S3PDBSocketPool::Distribute( DWORD dwTargetIP, int iTargetPort, _LPCPARSEDDATAPACKET lpcParsedData )
  1446. {
  1447. assert( NULL != lpcParsedData );
  1448. BOOL bRet = FALSE;
  1450. switch( lpcParsedData->m_dwParam )
  1451. {
  1452. case LOGIN_A_LOGIN:
  1453. if ( m_bAccDBIsLocked )
  1454. bRet = ProMsgWhenLocked( dwTargetIP, iTargetPort, lpcParsedData );
  1455. else
  1456. bRet = ProLoginFromGame( dwTargetIP, iTargetPort, lpcParsedData );
  1457. break;
  1458. case LOGIN_A_NEWACCOUNT:
  1459. if ( m_bAccDBIsLocked )
  1460. bRet = ProMsgWhenLocked( dwTargetIP, iTargetPort, lpcParsedData );
  1461. else
  1462. bRet = ProAddAccount( dwTargetIP, iTargetPort, lpcParsedData );
  1463. break;
  1464. case LOGIN_A_REPORT:
  1465. if ( m_bAccDBIsLocked )
  1466. bRet = ProMsgWhenLocked( dwTargetIP, iTargetPort, lpcParsedData );
  1467. else
  1468. bRet = ProReportFromGame( dwTargetIP, iTargetPort, lpcParsedData );
  1469. break;
  1470. case LOGIN_A_LOGOUT:
  1471. if ( m_bAccDBIsLocked )
  1472. bRet = ProMsgWhenLocked( dwTargetIP, iTargetPort, lpcParsedData );
  1473. else
  1474. bRet = ProLogoutFromGame( dwTargetIP, iTargetPort, lpcParsedData );
  1475. break;
  1476. case LOGIN_A_SERVERLIST:
  1477. if ( m_bAccDBIsLocked )
  1478. bRet = ProMsgWhenLocked( dwTargetIP, iTargetPort, lpcParsedData );
  1479. else
  1480. bRet = ProQueryGameserverList( dwTargetIP, iTargetPort, lpcParsedData );
  1481. bRet = FALSE;
  1482. break;
  1483. case LOGIN_A_BEGINGAME:
  1484. if ( m_bAccDBIsLocked )
  1485. bRet = ProMsgWhenLocked( dwTargetIP, iTargetPort, lpcParsedData );
  1486. else
  1487. bRet = ProBeginGame( dwTargetIP, iTargetPort, lpcParsedData );
  1488. bRet = FALSE;
  1489. break;
  1490. case DBLOGIN_A_LOGIN:
  1491. bRet = ProDBLogin( dwTargetIP, iTargetPort, lpcParsedData );
  1492. break;
  1493. case DBLOGIN_A_LOGOUT:
  1494. bRet = ProDBLogout( dwTargetIP, iTargetPort, lpcParsedData );
  1495. break;
  1496. case DBLOGIN_A_QUERYUSERLIST:
  1497. bRet = ProDBQueryUserList( dwTargetIP, iTargetPort, lpcParsedData );
  1498. break;
  1499. case DBLOGIN_A_LOCKDATABASE:
  1500. bRet = ProDBLock( dwTargetIP, iTargetPort, lpcParsedData );
  1501. break;
  1502. case DBLOGIN_A_ACTIVATEDATABASE:
  1503. bRet = ProDBActivate( dwTargetIP, iTargetPort, lpcParsedData );
  1504. break;
  1505. case DBLOGIN_A_ADDDBUSER:
  1506. bRet = ProDBAddUser( dwTargetIP, iTargetPort, lpcParsedData );
  1507. break;
  1508. case DBLOGIN_A_DELDBUSER:
  1509. bRet = ProDBDeleteUser( dwTargetIP, iTargetPort, lpcParsedData );
  1510. break;
  1511. case DBLOGIN_A_CREATEACCOUNT:
  1512. bRet = ProDBCreateAccount( dwTargetIP, iTargetPort, lpcParsedData );
  1513. break;
  1514. default:
  1515. break;
  1516. }
  1518. return bRet;
  1519. }
  1521. BOOL S3PDBSocketPool::Process( _LPDBSOCKETPOOLDATAPACKET lpData )
  1522. {
  1523. BOOL bRet = FALSE;
  1524. if ( NULL != lpData )
  1525. {
  1526. DWORD dwTargetIP = lpData->dwFromIP;
  1527. int iTargetPort = lpData->iFromPort;
  1529. S3PDBSocketParser parser;
  1530. if ( TRUE == parser.Parse( lpData->dataBuf, lpData->dwSize ) )
  1531. {
  1532. bRet = Distribute( dwTargetIP, iTargetPort, &parser );
  1533. }
  1534. }
  1535. return bRet;
  1536. }
  1538. BOOL S3PDBSocketPool::SendUDP( DWORD dwTargetIP, int iTargetPort, IBYTE* pBuf, DWORD dwSize )
  1539. {
  1540. BOOL bRet = FALSE;
  1542. SOCKADDR_IN targetAddr;
  1543. targetAddr.sin_family = AF_INET;
  1544. targetAddr.sin_port = htons( ( short )( iTargetPort ) );
  1545. targetAddr.sin_addr.s_addr = dwTargetIP;
  1546. int iResult = sendto( m_Socket,
  1547. pBuf,
  1548. dwSize,
  1549. 0,
  1550. ( SOCKADDR* )( &targetAddr ),
  1551. sizeof( targetAddr ) );
  1552. if ( SOCKET_ERROR == iResult )
  1553. {
  1554. bRet = FALSE;
  1555. }
  1556. else
  1557. {
  1558. bRet = TRUE;
  1559. }
  1561. return bRet;
  1562. }
  1564. BOOL S3PDBSocketPool::SendError( DWORD dwTargetIP, int iTargetPort )
  1565. {
  1566. BOOL bRet = FALSE;
  1567. IBYTE sendBuf[KLOGINSTRUCTHEADSIZE+1];
  1568. sendBuf[0] = LOGIN_R_TAG;
  1569. DWORD dwSize = KLOGINSTRUCTHEADSIZE;
  1570. DWORD dwParam = LOGIN_R_FAILED;
  1571. memcpy( &( sendBuf[1] ), &dwSize, sizeof( DWORD ) );
  1572. memcpy( &( sendBuf[1+sizeof( DWORD )] ), &dwParam, sizeof( DWORD ) );
  1574. bRet = SendUDP( dwTargetIP, iTargetPort, sendBuf, KLOGINSTRUCTHEADSIZE + 1 );
  1576. return bRet;
  1577. }